@camstack/addon-post-analysis 1.2.621 → 1.2.623

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as MediaFileKindEnum, $i as isDeviceScopedCap, $n as cosineSimilarity$1, $r as projectSubjectPath, $t as OpsLogEntrySchema, A as DeclaredDevices, Ai as systemEventFilterApplies, An as activateAlarmProfile, Ar as isEventOwnerType, At as NcAlarmSensorsInputSchema, B as FULL_IMAGE_BBOX, Bi as evaluateSensorEdge, Bn as applySecureOnArmEdit, Br as kebabToCamel, Bt as NcRuleUpdateInputSchema, C as ClearTrackRelationResultSchema, Ci as subKindsOf, Cn as TimelapseRulePatchSchema, Cr as isAlertEpisodeSeverity, Ct as NC_SNOOZE_MAX_MINUTES, D as DEFAULT_TIMELAPSE_PREVIEW_TEXT, Di as syncActiveAlarmProfileSettings, Dn as TrackRelationSchema, Dr as isDetectionMacroClass, Dt as NC_TEMPLATE_VARS, E as DEFAULT_EVENT_COLOR, Ei as summarizeReview, En as TrackRelationKindSchema, Er as isDefaultAlarmProfileId, Et as NC_TAXONOMY, F as EVENT_DENSITY_BATCH_MAX, Fi as vectorDimFromBase64, Fn as alertEpisodeKind, Fr as isRootSuppliableStepId, Ft as NcRuleActionSchema, G as ListTrackRelationsResultSchema, Gi as CamProfileSchema, Gn as buildEventKindDescriptor, Gr as normalizeNcMediaPolicy, Gt as NcSnoozeSuppressedSchema, H as LABEL_SUPPLY_MACRO, Hi as DeviceType, Hn as assertTimelapseCadences, Hr as mayWriteToLocation, Ht as NcSharedSequenceSchema, I as EVENT_KIND_BY_CAP, Ii as viewerLinkBaseOf, In as alertEpisodePayload, Ir as isScheduleActive, It as NcRuleInputSchema, J as MAX_BIRTH_DECISION_RECORDS, Ji as createEvent, Jn as calendarEventLocalSpan, Jr as parseAlertEpisodePayload, Jt as NcTaxonomySchema, K as LockStateSchema, Ki as RECORD_MAX_DATA_BYTES, Kn as buildSubjectPath, Kr as notificationRulesCapability, Kt as NcStateSummarySectionIdSchema, L as EVENT_OWNER_TYPES, Li as zoneAnalyticsCapability, Ln as applyBlockingEdit, Lr as isSystemDelivery, Lt as NcRulePatchSchema, M as EMBEDDING_MODEL_FAILED, Mi as systemEventSummarySplitOf, Mn as alarmDeviceSecureOnArm, Mr as isLabelSupplyStepId, Mt as NcAlarmSettingsPatchSchema, N as EMBEDDING_REQUIREMENTS_FAILED, Ni as templateCarriesSummary, Nn as alarmPanelCapability, Nr as isMediaOwnerType, Nt as NcConditionDescriptorSchema, O as DETECTION_MACRO_CLASSES, Oi as systemEventDeliveryProblems, On as TrackSideSchema, Or as isDrawableSubjectPath, Ot as NcAlarmConfigSchema, P as EMBEDDING_REQUIREMENTS_UNAVAILABLE, Pi as templateVarsFor, Pn as alertEpisodeId, Pr as isRetiredClearKey, Pt as NcConditionsSchema, Q as MOTION_CLOSE_AFTER_MS, Qi as hydrateSchema, Qn as coreBlockIdFromAddonId, Qr as plateGalleryCapability, Qt as OPS_LOG_DEFAULT_LIMIT, R as EXPORT_DENSE_MAX_RANGES, Ri as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, Rn as applyModeDelaysEdits, Rr as isSystemEventSummaryRule, Rt as NcRuleSchema, S as ClearTrackRelationInputSchema, Si as storageOccupancyCapability, Sn as TimelapseRuleInputSchema, Sr as isAlertEpisodeOpen, St as NC_SENSOR_TRANSITION_KINDS, T as DEFAULT_DETAIL_CROP_CONVENTION, Ti as subjectPathSvgPoints, Tn as TrackPuritySchema, Tr as isAudioClassName, Tt as NC_TANK_SYSTEM_EVENT_KINDS, U as LabelAttributionSchema, Ui as errMsg, Un as audioMetricsCapability, Ur as memoizePinnedFfmpeg, Ut as NcSnoozeInputSchema, V as FailureCounters, Vi as isSourceCap, Vn as armRemovalReconcile, Vr as linkedStepOf, Vt as NcScheduleSchema, W as ListTrackRelationsInputSchema, Wi as BaseAddon, Wn as audioModeOf, Wr as ncMediaPolicyError, Wt as NcSnoozeSchema, X as MAX_TRACK_PURITIES, Xi as defineCustomActions, Xn as cloneAlarmSettings, Xr as pickFaceRescoreIntervalMinutes, Xt as NcTemplatePreviewSchema, Y as MAX_BIRTH_LATENCY_PROXY_MS, Yi as customAction, Yn as classifyRetrainReview, Yt as NcTemplatePreviewInputSchema, Z as MAX_TRACK_RELATIONS, Zi as defineRecordKinds, Zn as consumableLowPercentOf, Zr as pipelineAnalyticsCapability, Zt as NcTemplateVarDescriptorSchema, _ as BIRTH_DECISION_DEFAULT_LIMIT, _a as tuple, _i as sceneMonitorCapability, _n as SetTrackPurityInputSchema, _r as faceGalleryCapability, _t as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, a as CLIP_EMBEDDING_STEP_ID, aa as array, ai as resolveLocationMode, an as RetrainOriginSchema, ar as describeSystemEventDeliveryProblem, at as NC_ALARM_NOTIFY_FIELDS, b as BucketAccumulator, ba as EventCategory, bi as servedTemplateVars, bn as TIMELAPSE_DENSE_FLOOR_SEC, br as gifFromMp4Args, bt as NC_GROUPING_MAX_SEC, c as readClusterModelPinStrict, ca as literal, ci as resolveNcMediaImage, cn as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, ct as NC_AUDIO_CONFIRM_HITS_DEFAULT, d as APPEARANCE_BLOCKS, da as object, di as rootSupplyServes, dn as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, dt as NC_CLIP_PRE_ROLL_DEFAULT_SEC, ea as nodePin, ei as readDeviceStateFrom, er as createAlarmProfile, et as MotionTriggeredBySchema, f as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, fa as partialRecord, fi as ruleAutoTriggersAlarm, fn as SCENE_DEFAULT_QUIET_SECONDS, ft as NC_CLIP_RETENTION_MAX_SEC, g as ArchivedDebugNoteSchema, ga as templateLiteral, gi as ruleKindOf, gn as SceneMonitorSchema, gr as evictionPolicyOfLocation, gt as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, h as AlarmArmModeSchema, ha as string, hi as ruleGroupingApplies, hn as SCENE_RESET_RECAPTURES, hr as eventKindLabel, ht as NC_CONFIRM_DEFAULT_TIMEOUT_MS, ia as _enum, ii as resolveClipSearchMinScore, in as RetrainDismissedSchema, ir as deriveRecordingMode, it as NC_ALARM_DELAY_MAX_SEC, j as DetectionSourceSchema, ji as systemEventSummaryScheduleOf, jn as addonWidgetsSourceCapability, jr as isKnownTemplateVar, jt as NcAlarmSensorsSchema, k as DETECTION_PIPELINE_CAP_NAME, ki as systemEventFamilyProblems, kn as TrackSourceSchema, kr as isEventKindLabelKey, kt as NcAlarmPostTriggeredActionSchema, l as resolveClusterModelPin, la as looseObject, ln as SCENE_DEFAULT_ANCHOR_THRESHOLD, lt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, m as AUDIO_MACRO_LABELS, ma as strictObject, mi as ruleDeviceCompatCapQueries, mn as SCENE_DIVERGED, mr as ensureAlarmProfiles, mt as NC_CONFIRM_DEFAULT_MAX_IMAGE_PX, na as sleep$1, ni as readTimelapseGeneratedAt, nn as RECORDING_SOURCE_CAMSTACK_ADDON, nr as deriveDetailCropRect, nt as NC_ALARM_DEFAULT_TRIGGERED_DURATION_SEC, o as CLUSTER_MODEL_OWNER_ADDON_ID, oa as boolean, oi as resolveModeDelays, on as RetrainStatusSchema, or as describeSystemEventFamilyProblem, ot as NC_ALARM_SYSTEM_EVENT_KINDS, p as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, pa as record, pi as ruleBelongsToAlarm$1, pn as SCENE_DEFAULT_UNCOVERED_POLICY, pr as encodeVectorBase64, pt as NC_CONDITION_CATALOG, q as MAX_ARCHIVED_DEBUG_NOTES, qi as RECORD_QUERY_MAX, qn as buildViewerLink, qr as occupancyScope, qt as NcSystemEventKindSchema, ra as ZodObject, ri as renameAlarmProfile, rn as RebuildObjectEmbeddingsRefusalSchema, rr as derivePostTriggeredAction, rt as NC_ALARM_DELAY_FIELDS, s as FACE_EMBEDDING_STEP_ID, sa as discriminatedUnion, si as resolveModeNotifyPolicy, sn as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, sr as deviceRemovalHookCapability, st as NC_ALARM_TRIGGERED_MAX_SEC, t as BUILTIN_CLIP_MODELS, ti as readMotionTriggeredBy, tn as RECORDING_EXPORT_MAX_READ_BYTES, tr as deleteAlarmProfile, tt as NC_ALARM_DEFAULT_PROFILE_ID, u as APPEARANCE_BIN_COUNT, ua as number, ui as retrainRevisionConflictMessage, un as SCENE_DEFAULT_CHECK_INTERVAL_SEC, ur as embeddingRefusalOf, ut as NC_CLIP_POST_ROLL_DEFAULT_SEC, v as BaseDevice, va as union, vi as secureActuationFor, vn as SetTrackPurityResultSchema, vr as failureContributionCapability, vt as NC_DEFAULT_SNOOZE_MINUTES, w as CoverStateSchema, wi as subjectPathSampleFromBox, wn as TimelapseRuleSchema, wr as isAppLinkBase, wt as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, x as COCO_TO_MACRO, xi as startMoverUnderClearance, xn as TRACK_RELATIONS_DEFAULT_LIMIT, xr as isAlarmControllableCap, xt as NC_GROUPING_MIN_SEC, y as BirthDecisionRecordSchema, ya as unknown, yi as sensorRaisedOf, yn as SetTrackRelationInputSchema, yr as gifDeriveSpeed, yt as NC_GROUPING_DEFAULT_SEC, z as FIRST_LEVEL_MACRO_CLASSES, zi as canonicalHash, zn as applyNonBlockingEdit, zr as isVectorIndexDimConflict, zt as NcRuleTargetSchema } from "../clip-model-registry-BBzoIoKO.mjs";
+import { $ as MediaFileKindEnum, $i as defineCustomActions, $n as cosineSimilarity$1, $r as plateGalleryCapability, $t as OpsLogEntrySchema, A as DeclaredDevices, Ai as systemEventFamilyProblems, An as activateAlarmProfile, Ar as isEventKindLabelKey, At as NcAlarmSensorsInputSchema, B as FULL_IMAGE_BBOX, Bi as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, Bn as applySecureOnArmEdit, Br as isVectorIndexDimConflict, Bt as NcRuleUpdateInputSchema, C as ClearTrackRelationResultSchema, Ca as EventCategory, Ci as storageOccupancyCapability, Cn as TimelapseRulePatchSchema, Cr as isAlertEpisodeOpen, Ct as NC_SNOOZE_MAX_MINUTES, D as DEFAULT_TIMELAPSE_PREVIEW_TEXT, Di as summarizeReview, Dn as TrackRelationSchema, Dr as isDefaultAlarmProfileId, Dt as NC_TEMPLATE_VARS, E as DEFAULT_EVENT_COLOR, Ei as subjectPathSvgPoints, En as TrackRelationKindSchema, Er as isAudioClassName, Et as NC_TAXONOMY, F as EVENT_DENSITY_BATCH_MAX, Fi as templateVarsFor, Fn as alertEpisodeKind, Fr as isRetiredClearKey, Ft as NcRuleActionSchema, G as ListTrackRelationsResultSchema, Gi as errMsg, Gn as buildEventKindDescriptor, Gr as ncMediaPolicyError, Gt as NcSnoozeSuppressedSchema, H as LABEL_SUPPLY_MACRO, Hi as evaluateSensorEdge, Hn as assertTimelapseCadences, Hr as linkedStepOf, Ht as NcSharedSequenceSchema, I as EVENT_KIND_BY_CAP, Ii as vectorDimFromBase64, In as alertEpisodePayload, Ir as isRootSuppliableStepId, It as NcRuleInputSchema, J as MAX_BIRTH_DECISION_RECORDS, Ji as InvalidRecordError, Jn as calendarEventLocalSpan, Jr as occupancyScope, Jt as NcTaxonomySchema, K as LockStateSchema, Ki as BaseAddon, Kn as buildSubjectPath, Kr as normalizeNcMediaPolicy, Kt as NcStateSummarySectionIdSchema, L as EVENT_OWNER_TYPES, Li as viewerLinkBaseOf, Ln as applyBlockingEdit, Lr as isScheduleActive, Lt as NcRulePatchSchema, M as EMBEDDING_MODEL_FAILED, Mi as systemEventSummaryScheduleOf, Mn as alarmDeviceSecureOnArm, Mr as isKnownTemplateVar, Mt as NcAlarmSettingsPatchSchema, N as EMBEDDING_REQUIREMENTS_FAILED, Ni as systemEventSummarySplitOf, Nn as alarmPanelCapability, Nr as isLabelSupplyStepId, Nt as NcConditionDescriptorSchema, O as DETECTION_MACRO_CLASSES, Oi as syncActiveAlarmProfileSettings, On as TrackSideSchema, Or as isDetectionMacroClass, Ot as NcAlarmConfigSchema, P as EMBEDDING_REQUIREMENTS_UNAVAILABLE, Pi as templateCarriesSummary, Pn as alertEpisodeId, Pr as isMediaOwnerType, Pt as NcConditionsSchema, Q as MOTION_CLOSE_AFTER_MS, Qi as customAction, Qn as coreBlockIdFromAddonId, Qr as pipelineAnalyticsCapability, Qt as OPS_LOG_DEFAULT_LIMIT, R as EXPORT_DENSE_MAX_RANGES, Ri as withSystemEventClasses, Rn as applyModeDelaysEdits, Rr as isSystemDelivery, Rt as NcRuleSchema, S as ClearTrackRelationInputSchema, Sa as unknown, Si as startMoverUnderClearance, Sn as TimelapseRuleInputSchema, Sr as isAlarmControllableCap, St as NC_SENSOR_TRANSITION_KINDS, T as DEFAULT_DETAIL_CROP_CONVENTION, Ti as subjectPathSampleFromBox, Tn as TrackPuritySchema, Tr as isAppLinkBase, Tt as NC_TANK_SYSTEM_EVENT_KINDS, U as LabelAttributionSchema, Ui as isSourceCap, Un as audioMetricsCapability, Ur as mayWriteToLocation, Ut as NcSnoozeInputSchema, V as FailureCounters, Vi as canonicalHash, Vn as armRemovalReconcile, Vr as kebabToCamel, Vt as NcScheduleSchema, W as ListTrackRelationsInputSchema, Wi as DeviceType, Wn as audioModeOf, Wr as memoizePinnedFfmpeg, Wt as NcSnoozeSchema, X as MAX_TRACK_PURITIES, Xi as RECORD_QUERY_MAX, Xn as cloneAlarmSettings, Xt as NcTemplatePreviewSchema, Y as MAX_BIRTH_LATENCY_PROXY_MS, Yi as RECORD_MAX_DATA_BYTES, Yn as classifyRetrainReview, Yr as parseAlertEpisodePayload, Yt as NcTemplatePreviewInputSchema, Z as MAX_TRACK_RELATIONS, Zi as createEvent, Zn as consumableLowPercentOf, Zr as pickFaceRescoreIntervalMinutes, Zt as NcTemplateVarDescriptorSchema, _ as BIRTH_DECISION_DEFAULT_LIMIT, _a as strictObject, _i as ruleKindOf, _n as SetTrackPurityInputSchema, _r as evictionPolicyOfLocation, _t as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, a as CLIP_EMBEDDING_STEP_ID, aa as sleep$1, ai as resolveClipSearchMinScore, an as RetrainOriginSchema, ar as describeSystemEventDeliveryProblem, at as NC_ALARM_NOTIFY_FIELDS, b as BucketAccumulator, ba as tuple, bi as sensorRaisedOf, bn as TIMELAPSE_DENSE_FLOOR_SEC, br as gifDeriveSpeed, bt as NC_GROUPING_MAX_SEC, c as readClusterModelPinStrict, ca as array, ci as resolveModeNotifyPolicy, cn as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, cr as deviceRemovalHookCapability, ct as NC_AUDIO_CONFIRM_HITS_DEFAULT, d as APPEARANCE_BLOCKS, da as literal, di as retrainRevisionConflictMessage, dn as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, dr as embeddingRefusalOf, dt as NC_CLIP_PRE_ROLL_DEFAULT_SEC, ea as defineRecordKinds, ei as projectSubjectPath, er as createAlarmProfile, et as MotionTriggeredBySchema, f as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, fa as looseObject, fi as rootSupplyServes, fn as SCENE_DEFAULT_QUIET_SECONDS, ft as NC_CLIP_RETENTION_MAX_SEC, g as ArchivedDebugNoteSchema, ga as record, gi as ruleGroupingApplies, gn as SceneMonitorSchema, gr as eventKindLabel, gt as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, h as AlarmArmModeSchema, ha as partialRecord, hi as ruleDeviceCompatCapQueries, hn as SCENE_RESET_RECAPTURES, hr as ensureAlarmProfiles, ht as NC_CONFIRM_DEFAULT_TIMEOUT_MS, ii as renameAlarmProfile, in as RetrainDismissedSchema, ir as deriveRecordingMode, it as NC_ALARM_DELAY_MAX_SEC, j as DetectionSourceSchema, ji as systemEventFilterApplies, jn as addonWidgetsSourceCapability, jr as isEventOwnerType, jt as NcAlarmSensorsSchema, k as DETECTION_PIPELINE_CAP_NAME, ki as systemEventDeliveryProblems, kn as TrackSourceSchema, kr as isDrawableSubjectPath, kt as NcAlarmPostTriggeredActionSchema, l as resolveClusterModelPin, la as boolean, li as resolveNcMediaImage, ln as SCENE_DEFAULT_ANCHOR_THRESHOLD, lt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, m as AUDIO_MACRO_LABELS, ma as object, mi as ruleBelongsToAlarm$1, mn as SCENE_DIVERGED, mr as encodeVectorBase64, mt as NC_CONFIRM_DEFAULT_MAX_IMAGE_PX, na as isDeviceScopedCap, ni as readMotionTriggeredBy, nn as RECORDING_SOURCE_CAMSTACK_ADDON, nr as deriveDetailCropRect, nt as NC_ALARM_DEFAULT_TRIGGERED_DURATION_SEC, o as CLUSTER_MODEL_OWNER_ADDON_ID, oa as ZodObject, oi as resolveLocationMode, on as RetrainStatusSchema, or as describeSystemEventFamilyProblem, ot as NC_ALARM_SYSTEM_EVENT_KINDS, p as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, pa as number, pi as ruleAutoTriggersAlarm, pn as SCENE_DEFAULT_UNCOVERED_POLICY, pt as NC_CONDITION_CATALOG, q as MAX_ARCHIVED_DEBUG_NOTES, qi as CamProfileSchema, qn as buildViewerLink, qr as notificationRulesCapability, qt as NcSystemEventKindSchema, ra as nodePin, ri as readTimelapseGeneratedAt, rn as RebuildObjectEmbeddingsRefusalSchema, rr as derivePostTriggeredAction, rt as NC_ALARM_DELAY_FIELDS, s as FACE_EMBEDDING_STEP_ID, sa as _enum, si as resolveModeDelays, sn as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, sr as deviceAttentionKind, st as NC_ALARM_TRIGGERED_MAX_SEC, t as BUILTIN_CLIP_MODELS, ta as hydrateSchema, ti as readDeviceStateFrom, tn as RECORDING_EXPORT_MAX_READ_BYTES, tr as deleteAlarmProfile, tt as NC_ALARM_DEFAULT_PROFILE_ID, u as APPEARANCE_BIN_COUNT, ua as discriminatedUnion, un as SCENE_DEFAULT_CHECK_INTERVAL_SEC, ut as NC_CLIP_POST_ROLL_DEFAULT_SEC, v as BaseDevice, va as string, vi as sceneMonitorCapability, vn as SetTrackPurityResultSchema, vr as faceGalleryCapability, vt as NC_DEFAULT_SNOOZE_MINUTES, w as CoverStateSchema, wi as subKindsOf, wn as TimelapseRuleSchema, wr as isAlertEpisodeSeverity, wt as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, x as COCO_TO_MACRO, xa as union, xi as servedTemplateVars, xn as TRACK_RELATIONS_DEFAULT_LIMIT, xr as gifFromMp4Args, xt as NC_GROUPING_MIN_SEC, y as BirthDecisionRecordSchema, ya as templateLiteral, yi as secureActuationFor, yn as SetTrackRelationInputSchema, yr as failureContributionCapability, yt as NC_GROUPING_DEFAULT_SEC, z as FIRST_LEVEL_MACRO_CLASSES, zi as zoneAnalyticsCapability, zn as applyNonBlockingEdit, zr as isSystemEventSummaryRule, zt as NcRuleTargetSchema } from "../clip-model-registry-C58fyELd.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs$1 from "node:fs";
 import { createWriteStream, promises } from "node:fs";
@@ -5394,40 +5394,118 @@ async function notificationLinkEndpoints(api, logger) {
 */
 var NC_TRACKS_AT_INSTANT_LIMIT = 25;
 /**
-* Every source track with a position within `toleranceMs` of `timestamp`, its
-* nearest box normalised, deduplicated by track id (a live copy and a
-* persisted copy of one track are one track). Pure.
+* How far outside its own life a track may still be drawn: one detection tick.
+*
+* The box TOLERANCE (`toleranceMs`, 750 ms) is about how sparse a trail is —
+* a live track keeps a position every few frames — and it must never stretch
+* a LIFE. A track born after the frame was not on it: on 2026-10-22 the
+* tracker split a dog on camera 615 and the second piece, born 676 ms after
+* the key frame, was drawn at its first box as a second box on the dog. One
+* tick (~110–150 ms at that camera's detection rate, rounded up) absorbs the
+* gap between a frame and the detection that confirmed it, and nothing more.
+*/
+var NC_TRACK_LIFE_SLACK_MS = 200;
+/**
+* A position this close to the instant is drawn as it is: one detection tick,
+* the same notion as {@link NC_TRACK_LIFE_SLACK_MS}. Anything farther is a
+* position of a MOVED subject, so it is either interpolated (a position on
+* each side inside the tolerance) or the track is left out — never drawn at a
+* later place than it was at the picture's instant.
+*/
+var NC_BOX_EXACT_MS = NC_TRACK_LIFE_SLACK_MS;
+/** The box at `timestamp`: a near position as is, else the bracketing pair interpolated. */
+function boxAt(positions, timestamp, toleranceMs) {
+	let nearest = null;
+	let before = null;
+	let after = null;
+	for (const p of positions) {
+		const d = p.timestamp - timestamp;
+		if (nearest === null || Math.abs(d) < Math.abs(nearest.timestamp - timestamp)) nearest = p;
+		if (d <= 0 && (before === null || p.timestamp > before.timestamp)) before = p;
+		if (d >= 0 && (after === null || p.timestamp < after.timestamp)) after = p;
+	}
+	if (nearest === null) return null;
+	const dt = nearest.timestamp - timestamp;
+	if (Math.abs(dt) <= NC_BOX_EXACT_MS) return {
+		bbox: nearest.bbox,
+		score: nearest.score,
+		dtMs: dt,
+		interpolated: false
+	};
+	if (before === null || after === null || timestamp - before.timestamp > toleranceMs || after.timestamp - timestamp > toleranceMs) return null;
+	const span = after.timestamp - before.timestamp;
+	const f = span === 0 ? 0 : (timestamp - before.timestamp) / span;
+	const lerp = (a, b) => a + (b - a) * f;
+	return {
+		bbox: {
+			x: lerp(before.bbox.x, after.bbox.x),
+			y: lerp(before.bbox.y, after.bbox.y),
+			w: lerp(before.bbox.w, after.bbox.w),
+			h: lerp(before.bbox.h, after.bbox.h)
+		},
+		score: nearest.score,
+		dtMs: dt,
+		interpolated: true
+	};
+}
+/**
+* Every source track ALIVE at `timestamp` (± {@link NC_TRACK_LIFE_SLACK_MS})
+* with a box AT that instant: a trail position within {@link NC_BOX_EXACT_MS},
+* else the linear interpolation of the positions bracketing it (each within
+* `toleranceMs`). A track with neither is not drawn — `onDrop` names it.
+* Deduplicated by track id (a live copy and a persisted copy are one track).
+* Pure.
 */
-function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims) {
+function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims, onDrop) {
 	const out = /* @__PURE__ */ new Map();
 	for (const track of sources) {
 		if (out.has(track.trackId)) continue;
-		if (track.firstSeen > timestamp + toleranceMs || track.lastSeen < timestamp - toleranceMs) continue;
+		if (track.firstSeen > timestamp + NC_TRACK_LIFE_SLACK_MS || track.lastSeen < timestamp - NC_TRACK_LIFE_SLACK_MS) {
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "outside-life"
+			});
+			continue;
+		}
 		const w = track.frameWidth ?? fallbackDims?.w ?? 0;
 		const h = track.frameHeight ?? fallbackDims?.h ?? 0;
-		if (w <= 0 || h <= 0) continue;
-		let best = null;
-		let bestDelta = Number.POSITIVE_INFINITY;
-		for (const p of track.positions) {
-			const delta = Math.abs(p.timestamp - timestamp);
-			if (delta < bestDelta) {
-				bestDelta = delta;
-				best = p;
-			}
+		if (w <= 0 || h <= 0) {
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "no-frame-dims"
+			});
+			continue;
+		}
+		const at = boxAt(track.positions, timestamp, toleranceMs);
+		if (at === null) {
+			const nearestDtMs = track.positions.reduce((best, p) => {
+				const d = p.timestamp - timestamp;
+				return best === void 0 || Math.abs(d) < Math.abs(best) ? d : best;
+			}, void 0);
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "no-position-near-instant",
+				...nearestDtMs !== void 0 ? { nearestDtMs } : {}
+			});
+			continue;
 		}
-		if (best === null || bestDelta > toleranceMs) continue;
 		const label = track.subLabel ?? track.label;
 		out.set(track.trackId, {
 			trackId: track.trackId,
 			className: track.className,
 			...label !== void 0 && label !== track.className ? { label } : {},
-			...best.score !== void 0 ? { confidence: best.score } : {},
+			...at.score !== void 0 ? { confidence: at.score } : {},
 			bbox: {
-				x: best.bbox.x / w,
-				y: best.bbox.y / h,
-				w: best.bbox.w / w,
-				h: best.bbox.h / h
-			}
+				x: at.bbox.x / w,
+				y: at.bbox.y / h,
+				w: at.bbox.w / w,
+				h: at.bbox.h / h
+			},
+			dtMs: at.dtMs,
+			interpolated: at.interpolated
 		});
 	}
 	return [...out.values()];
@@ -19329,11 +19407,16 @@ var DebugNoteArchiveStore = class {
 };
 //#endregion
 //#region src/pipeline-analytics/store/event-ledger-collection.ts
+/**
+* One event ledger (motion, audio, sensor, faces, plates …) over its
+* `ctx.records` kind. Every node has `ctx.records`, so there is no other path.
+*/
 /** Matches {@link EventStore.LEDGER_PAGE_SIZE} — kept local to avoid a circular import. */
 var LEDGER_PAGE_SIZE = 500;
 var EventLedgerCollection = class EventLedgerCollection {
 	collection;
 	kind;
+	records;
 	autoIntegerId;
 	legacyAtField;
 	deviceIdMode;
@@ -19349,6 +19432,7 @@ var EventLedgerCollection = class EventLedgerCollection {
 		this.logger = deps.logger;
 		this.deriveBody = deps.deriveBody;
 		this.indexFields = deps.definition.declaration.indexes.map((i) => i.fields);
+		this.records = deps.records;
 		const handle = deps.records.kind(deps.definition);
 		this.kind = handle;
 	}
@@ -19367,6 +19451,31 @@ var EventLedgerCollection = class EventLedgerCollection {
 		}
 		await this.kind.put(put);
 	}
+	/**
+	* `upsertRow` as an op of {@link EventLedgerCollection.transact}. A row that
+	* cannot be mapped THROWS here: inside a transaction a silently skipped write
+	* would let the rest of the call commit without it.
+	*/
+	async txUpsert(id, value) {
+		const put = this.buildRecordPut(id, value);
+		if (put === null) throw new InvalidRecordError(`${this.collection}/${id}: the record could not be mapped`);
+		return this.kind.txPut(put);
+	}
+	/** `update` as an op of {@link EventLedgerCollection.transact}. */
+	txUpdate(id, patch) {
+		return this.kind.txPatch(id, this.derived(patch, "patch"));
+	}
+	/** `deleteKey` as an op of {@link EventLedgerCollection.transact}. */
+	txDelete(id) {
+		return this.kind.txDelete(id);
+	}
+	/**
+	* Run ops (built by the `tx*` methods of ledgers whose kinds share a
+	* `transactFamily`) in ONE transaction: all land or none does.
+	*/
+	transact(ops) {
+		return this.records.transact(ops);
+	}
 	async insert(record) {
 		const idNum = this.autoIntegerId ? await this.kind.allocateId() : null;
 		const id = idNum !== null ? String(idNum) : typeof record["id"] === "string" ? record["id"] : null;
@@ -20443,8 +20552,8 @@ var FACE_REF_COLUMNS = ["deviceId"];
 * D312) a predicate that silently matched nothing. The faces ledger therefore derives a
 * boolean `recognized` from every write that touches `recognizedIdentityId`
 * (`face-recognized.ts`), and the views are plain ranges over the `recognized_ts` /
-* `assigned_recognized_ts` indexes. A row written before the field existed lacks it until
-* `scripts/hub/backfill-faces-recognized.ts` has run.
+* `assigned_recognized_ts` indexes. Rows written before the field existed were
+* backfilled offline on the operator hubs on 2026-10-22 (the one-shot script is deleted).
 *
 * `assigned` is `BOOLEAN NOT NULL`; the backend serialises `false` to `0` at
 * the bind (`serializeColumnValue`) and decodes `0` back to `false` on read, so
@@ -22308,8 +22417,9 @@ var RetrainAnnotationStore = class {
 	* The old rows' deletion, the new rows, the frame's `dismissed` set and its
 	* bumped `revision` run under a per-frame commit lock, guarded by
 	* `commit.fromRevision`: a concurrent save in this process leaves one winner
-	* and one `conflict` — never a blend. The steps are separate records writes,
-	* so a crash between them is NOT rolled back.
+	* and one `conflict` — never a blend. The deletion, the new rows and the frame
+	* row are ONE records `transact` (the four retrain kinds share a family): a
+	* failure leaves the frame exactly as it was.
 	*
 	* Returns the persisted rows so the caller renders ids it can address.
 	*/
@@ -22426,21 +22536,14 @@ var RetrainAnnotationStore = class {
 		}
 		return stamped;
 	}
-	/** Remove every annotation of a frame — the operator un-selecting it. */
-	async deleteForFrame(mediaKey) {
-		const rows = await this.listByFrame(mediaKey);
-		for (const row of rows) try {
-			await this.annotations.deleteKey(row.id);
-		} catch (err) {
-			this.logger.warn("retrain annotation delete failed", {
-				tags: { deviceId: row.deviceId },
-				meta: {
-					annotationId: row.id,
-					error: String(err)
-				}
-			});
-		}
-		return rows.length;
+	/**
+	* The delete ops of every annotation of a frame, for ONE transaction with
+	* the frame row and its memberships (RetrainService.removeFrame). A failed
+	* read THROWS: "no annotations" must never be the answer to an unreadable
+	* store, because the frame row would then be deleted over live boxes.
+	*/
+	async deleteOpsForFrame(mediaKey) {
+		return (await this.annotations.query({ where: { mediaKey } })).map((row) => this.annotations.txDelete(row.id));
 	}
 	async replaceForFrameOnRecords(mediaKey, rows, commit, nextRevision) {
 		const frame = await this.frames.get(mediaKey);
@@ -22453,12 +22556,14 @@ var RetrainAnnotationStore = class {
 			kind: "conflict",
 			currentRevision
 		};
-		await this.annotations.deleteWhere({ where: { mediaKey } });
-		for (const row of rows) await this.annotations.upsertRow(row.id, this.toRecord(row));
-		await this.frames.update(mediaKey, {
+		const ops = [];
+		for (const existing of await this.annotations.query({ where: { mediaKey } })) ops.push(this.annotations.txDelete(existing.id));
+		for (const row of rows) ops.push(await this.annotations.txUpsert(row.id, this.toRecord(row)));
+		ops.push(await this.frames.txUpdate(mediaKey, {
 			revision: nextRevision,
 			...commit.dismissed !== void 0 ? { dismissed: [...commit.dismissed] } : {}
-		});
+		}));
+		await this.frames.transact(ops);
 		return {
 			kind: "saved",
 			rows,
@@ -22476,8 +22581,10 @@ var RetrainAnnotationStore = class {
 			kind: "conflict",
 			currentRevision
 		};
-		for (const row of eligible) await this.annotations.update(row.id, { origin: origins.get(row.id) ?? null });
-		await this.frames.update(mediaKey, { revision: nextRevision });
+		const ops = [];
+		for (const row of eligible) ops.push(await this.annotations.txUpdate(row.id, { origin: origins.get(row.id) ?? null }));
+		ops.push(await this.frames.txUpdate(mediaKey, { revision: nextRevision }));
+		await this.frames.transact(ops);
 		return {
 			kind: "updated",
 			updated: eligible.length,
@@ -22648,16 +22755,16 @@ var RetrainCollectionStore = class {
 			}, counts.get(input.id) ?? 0)
 		};
 	}
-	/** Remove the collection and its memberships — members first, so a crash
-	*  never leaves memberships pointing at a name that no longer exists. */
+	/** Remove the collection and its memberships in ONE transaction: a failure
+	*  leaves the collection with all its members, never memberships pointing at
+	*  a name that no longer exists, nor a collection that silently lost some. */
 	async delete(id) {
 		if (await this.readRow(id) === null) return {
 			deleted: false,
 			memberFrameIds: []
 		};
 		const members = await this.memberships.query({ where: { collectionId: id } });
-		for (const m of members) await this.memberships.deleteKey(m.id);
-		await this.collections.deleteKey(id);
+		await this.collections.transact([...members.map((m) => this.memberships.txDelete(m.id)), this.collections.txDelete(id)]);
 		this.logger.info("retrain collection deleted", { meta: {
 			collectionId: id,
 			members: members.length
@@ -22686,11 +22793,29 @@ var RetrainCollectionStore = class {
 		await this.memberships.deleteKey(key);
 		return true;
 	}
-	/** Remove a frame from EVERY collection — the frame itself is leaving. */
-	async forgetFrame(frameId) {
-		const rows = await this.membershipRows({ frameId });
-		for (const r of rows) await this.memberships.deleteKey(r.id);
-		return rows.length;
+	/**
+	* The delete ops of every membership of a frame, for ONE transaction with
+	* the frame row and its annotations (RetrainService.removeFrame). A failed
+	* read THROWS: the frame row must not be deleted over memberships nobody
+	* could list.
+	*/
+	async forgetFrameOps(frameId) {
+		return (await this.memberships.query({ where: { frameId } })).map((r) => this.memberships.txDelete(r.id));
+	}
+	/**
+	* The op that adds a frame to a collection, for ONE transaction with the
+	* frame's own row (a still stored from the recording). `null` when it is
+	* already a member: there is nothing to write.
+	*/
+	async addFrameOp(input) {
+		const key = membershipKey(input.collectionId, input.frameId);
+		if (await this.memberships.get(key) !== null) return null;
+		return this.memberships.txUpsert(key, {
+			collectionId: input.collectionId,
+			frameId: input.frameId,
+			deviceId: input.deviceId,
+			addedAt: this.now()
+		});
 	}
 	/** The frames of a collection, in the order they were added. */
 	async listFrameIds(collectionId) {
@@ -23282,7 +23407,7 @@ var RetrainFrameStore = class {
 	* returned untouched; the blob lands before the row; a refusal is named.
 	* `capturedAt` IS the instant — the camera saw this frame then.
 	*/
-	async storeRecordingStill(input) {
+	async storeRecordingStill(input, withRow = []) {
 		const frameId = recordingFrameId(input.deviceId, input.epochMs);
 		const existing = await this.get(frameId);
 		if (existing !== null) return {
@@ -23329,7 +23454,7 @@ var RetrainFrameStore = class {
 				relativePath: path,
 				data: input.bytes
 			});
-			await this.ledger.upsertRow(frameId, {
+			const row = await this.ledger.txUpsert(frameId, {
 				deviceId: frame.deviceId,
 				trackId: "",
 				sourceMediaId: 0,
@@ -23346,6 +23471,7 @@ var RetrainFrameStore = class {
 				origin: "recording",
 				epochMs: input.epochMs
 			});
+			await this.ledger.transact([row, ...withRow]);
 		};
 		try {
 			if (this.writeGate) await this.writeGate.run(persist);
@@ -23399,22 +23525,33 @@ var RetrainFrameStore = class {
 	/**
 	* Drop a copy and its blob — the operator un-selecting a frame.
 	*
-	* The caller must have removed the frame's annotations first; this store does
-	* not cascade, because a store that deletes rows in another table on a
-	* best-effort write is how a half-deleted annotation set happens.
+	* The ROW goes first, in one transaction with `withRow` (the frame's
+	* annotations and collection memberships, which the caller builds): a failure
+	* leaves the frame, its boxes and its memberships all in place, and throws.
+	* The blob goes after: if that fails the row is already gone and the bytes
+	* are reclaimable junk, logged, never a row pointing at missing media.
 	*/
-	async deleteFrame(frame) {
+	async deleteFrame(frame, withRow = []) {
 		const remove = async () => {
+			try {
+				await this.ledger.transact([...withRow, this.ledger.txDelete(frame.frameId)]);
+			} catch (err) {
+				this.logger.error("retrain frame delete failed; nothing was removed", {
+					tags: { deviceId: frame.deviceId },
+					meta: {
+						frameId: frame.frameId,
+						error: String(err)
+					}
+				});
+				throw err;
+			}
 			try {
 				await this.storage.delete({
 					location: frame.locationId ?? LEGACY_RETRAIN_MEDIA_LOCATION,
 					relativePath: framePath(frame)
 				});
-			} catch {}
-			try {
-				await this.ledger.deleteKey(frame.frameId);
 			} catch (err) {
-				this.logger.warn("RetrainFrameStore.deleteFrame row delete failed", {
+				this.logger.warn("retrain frame removed but its blob could not be deleted", {
 					tags: { deviceId: frame.deviceId },
 					meta: {
 						frameId: frame.frameId,
@@ -28392,7 +28529,9 @@ function incomingFromSystemEvent(event, lookup) {
 			const blindForMs = numberField(data, "blindForMs");
 			if (deviceId === void 0 || blindForMs === void 0) return null;
 			const identity = lookup(deviceId);
-			const minutes = Math.max(1, Math.round(blindForMs / 6e4));
+			const motionMs = numberField(data, "motionMs") ?? blindForMs;
+			const sessions = numberField(data, "sessions") ?? 1;
+			const minutes = Math.max(1, Math.round(motionMs / 6e4));
 			return systemSubject({
 				facts,
 				kind: "detection-blind",
@@ -28401,13 +28540,39 @@ function incomingFromSystemEvent(event, lookup) {
 				bodyKey: "system.detection-blind.body",
 				textParams: {
 					...deviceTextParams(deviceId, identity),
-					minutes: String(minutes)
+					minutes: String(minutes),
+					sessions: String(sessions)
 				},
 				textCount: minutes,
 				deviceId,
 				...identity !== void 0 ? { deviceType: identity.type } : {}
 			});
 		}
+		case "pipeline.motion-noisy":
+		case "pipeline.motion-calm": {
+			const deviceId = numberField(data, "deviceId");
+			const dutyPct = numberField(data, "dutyPct");
+			const sessions = numberField(data, "sessions");
+			const windowMs = numberField(data, "windowMs");
+			if (deviceId === void 0 || dutyPct === void 0 || sessions === void 0 || windowMs === void 0) return null;
+			const noisy = event.category === "pipeline.motion-noisy";
+			const identity = lookup(deviceId);
+			return systemSubject({
+				facts,
+				kind: noisy ? "motion-noisy" : "motion-calm",
+				subject: `motion-noise:${deviceId}`,
+				titleKey: noisy ? "system.motion-noisy.title" : "system.motion-calm.title",
+				bodyKey: noisy ? "system.motion-noisy.body" : "system.motion-calm.body",
+				textParams: {
+					...deviceTextParams(deviceId, identity),
+					minutes: String(Math.max(1, Math.round(windowMs / 6e4))),
+					duty: String(dutyPct),
+					sessions: String(sessions)
+				},
+				deviceId,
+				...identity !== void 0 ? { deviceType: identity.type } : {}
+			});
+		}
 		case "recording.health.stalled": {
 			const deviceId = numberField(data, "deviceId");
 			const idleMs = numberField(data, "idleMs");
@@ -28489,6 +28654,33 @@ function incomingFromSystemEvent(event, lookup) {
 				...nodeId !== void 0 ? { nodeId } : {}
 			});
 		}
+		case "notification.rule-broken":
+		case "notification.rule-repaired": {
+			const ruleId = stringField(data, "ruleId");
+			if (ruleId === void 0) return null;
+			const broken = event.category === "notification.rule-broken";
+			const kind = broken ? "rule-broken" : "rule-repaired";
+			const ruleName = stringField(data, "ruleName") ?? ruleId;
+			const reason = stringField(data, "reason") ?? "unknown";
+			const ids = data["offendingIds"];
+			const offendingIds = Array.isArray(ids) ? ids.filter((id) => typeof id === "string").join(", ") : "";
+			return systemSubject({
+				facts,
+				kind,
+				subject: `rule-health:${ruleId}`,
+				titleKey: `system.${kind}.title`,
+				bodyKey: broken ? `system.rule-broken.body.${reason}` : "system.rule-repaired.body",
+				textParams: broken ? {
+					ruleId,
+					ruleName,
+					brokenReason: reason,
+					offendingIds
+				} : {
+					ruleId,
+					ruleName
+				}
+			});
+		}
 		case "update.available": return incomingFromUpdateAvailable(facts, data);
 		case "addon.updated": {
 			const update = parseAddonUpdateComplete(data);
@@ -28498,7 +28690,7 @@ function incomingFromSystemEvent(event, lookup) {
 		case "system.restarting": return incomingFromNodeRestarting(facts, data);
 		case "recording.export.completed": return incomingFromExportCompleted(facts, data);
 		case "backup.run-completed": return incomingFromBackupCompleted(facts, data);
-		case "alert.episode": return incomingFromAlertEpisode(facts);
+		case "alert.episode": return incomingFromAlertEpisode(facts, lookup);
 		default: return null;
 	}
 }
@@ -28514,9 +28706,11 @@ function incomingFromSystemEvent(event, lookup) {
 * Whether an edge is notified at all (once per episode, reconciled from the
 * alerts store) is decided before this point, by `NcAlertEpisodeLedger`.
 */
-function incomingFromAlertEpisode(facts) {
+function incomingFromAlertEpisode(facts, lookup) {
 	const payload = parseAlertEpisodePayload(facts.data);
 	if (payload === null) return null;
+	const attention = incomingFromDeviceAttention(facts, payload, lookup);
+	if (attention !== null) return attention;
 	const kind = alertEpisodeKind(payload.severity, payload.phase);
 	if (kind === null) return null;
 	return systemSubject({
@@ -28537,6 +28731,38 @@ function incomingFromAlertEpisode(facts) {
 		...payload.nodeId !== void 0 ? { nodeId: payload.nodeId } : {}
 	});
 }
+/**
+* A CRITICAL alert whose source is a DEVICE (D911) is announced in the devices
+* family — `device-attention-required` / `-resolved`, carrying the device id so
+* a rule's device filters apply — and NOT as `alert-critical`, so one alert
+* never notifies twice through two families. A device source whose id is not a
+* device id falls through to the generic alert kinds.
+*/
+function incomingFromDeviceAttention(facts, payload, lookup) {
+	if (payload.sourceType !== "device" || payload.sourceId === void 0) return null;
+	const kind = deviceAttentionKind(payload.severity, payload.phase);
+	if (kind === null) return null;
+	const deviceId = Number(payload.sourceId);
+	if (!Number.isInteger(deviceId)) return null;
+	const identity = lookup?.(deviceId);
+	return systemSubject({
+		facts,
+		kind,
+		subject: `alert:${payload.episodeId}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body`,
+		textParams: {
+			...deviceTextParams(deviceId, identity),
+			title: payload.title,
+			message: payload.message,
+			category: payload.category,
+			actionUrl: payload.actionUrl ?? ""
+		},
+		deviceId,
+		...identity !== void 0 ? { deviceType: identity.type } : {},
+		...payload.nodeId !== void 0 ? { nodeId: payload.nodeId } : {}
+	});
+}
 /** The shells whose update has its own sentence. Anything else gets the plain
 *  one: a body that names a shell nobody observed is worse than a vague body. */
 var WRAPPER_BODY_KINDS = new Set([
@@ -30494,8 +30720,8 @@ var en_default = {
 	"occupancy.body": "{{scope}} {{op}} ({{count}}/{{capacity}})",
 	"occupancy.op.occupied": "occupied",
 	"occupancy.op.free": "free",
-	"system.device-online.title": "Online — {{deviceName}}",
-	"system.device-online.body": "Device {{deviceName}} is online",
+	"system.device-online.title": "Back online — {{deviceName}}",
+	"system.device-online.body": "Device {{deviceName}} is back online",
 	"system.device-offline.title": "Offline — {{deviceName}}",
 	"system.device-offline.body": "Device {{deviceName}} is offline",
 	"system.device-disabled.title": "Switched off — {{deviceName}}",
@@ -30508,14 +30734,14 @@ var en_default = {
 	"system.device-battery-normal.title": "Battery back to normal — {{deviceName}}",
 	"system.device-battery-normal.body": "{{deviceName}} is back to {{percentage}}% battery",
 	"system.device-battery-normal.body.binary": "{{deviceName}} no longer reports a low battery",
-	"system.stream-online.title": "Stream online — {{deviceName}}",
-	"system.stream-online.body": "Stream for camera {{deviceName}} is online",
-	"system.stream-online.body.profiled": "{{profile}} stream for camera {{deviceName}} is online",
+	"system.stream-online.title": "Stream back online — {{deviceName}}",
+	"system.stream-online.body": "Stream for camera {{deviceName}} is back online",
+	"system.stream-online.body.profiled": "{{profile}} stream for camera {{deviceName}} is back online",
 	"system.stream-offline.title": "Stream offline — {{deviceName}}",
 	"system.stream-offline.body": "Stream for camera {{deviceName}} is offline",
 	"system.stream-offline.body.profiled": "{{profile}} stream for camera {{deviceName}} is offline",
-	"system.node-online.title": "Node online — {{nodeName}}",
-	"system.node-online.body.agent": "Agent {{nodeName}} is online",
+	"system.node-online.title": "Node back online — {{nodeName}}",
+	"system.node-online.body.agent": "Agent {{nodeName}} is back online",
 	"system.node-online.body.agent.after": "Agent {{nodeName}} is back online after {{offlineFor}} offline",
 	"system.node-offline.title": "Node offline — {{nodeName}}",
 	"system.node-offline.body.agent": "Agent {{nodeName}} is offline",
@@ -30527,18 +30753,26 @@ var en_default = {
 	"system.addon-crash-loop.body": "The {{addons}} addon on node {{nodeId}} crashed {{count}} times in a row and will NOT be restarted. Everything it provides is offline until it is repaired.",
 	"system.detection-blind.title": "Detecting nothing — {{deviceName}}",
 	"system.detection-blind.body": {
-		"one": "Camera {{deviceName}} has been analysed for {{minutes}} minute with no detection at all",
-		"other": "Camera {{deviceName}} has been analysed for {{minutes}} minutes with no detection at all"
+		"one": "Camera {{deviceName}} moved for {{minutes}} minute over {{sessions}} sessions and the detector produced nothing at all, not even a weak candidate",
+		"other": "Camera {{deviceName}} moved for {{minutes}} minutes over {{sessions}} sessions and the detector produced nothing at all, not even a weak candidate"
 	},
+	"system.motion-noisy.title": "Constant motion, no subject — {{deviceName}}",
+	"system.motion-noisy.body": "Camera {{deviceName}} has been in motion {{duty}}% of the last {{minutes}} minutes ({{sessions}} sessions) without a single detection. The detector is fine — tune this camera's motion zones or sensitivity.",
+	"system.motion-calm.title": "Motion calm again — {{deviceName}}",
+	"system.motion-calm.body": "Camera {{deviceName}} is no longer in constant motion ({{duty}}% of the last {{minutes}} minutes, {{sessions}} sessions)",
 	"system.recording-stalled.title": "Recording stalled — {{deviceName}}",
 	"system.recording-stalled.body": {
 		"one": "Camera {{deviceName}} has not written a recording segment for {{minutes}} minute",
 		"other": "Camera {{deviceName}} has not written a recording segment for {{minutes}} minutes"
 	},
-	"system.recording-healthy.title": "Recording healthy — {{deviceName}}",
+	"system.recording-healthy.title": "Recording again — {{deviceName}}",
 	"system.recording-healthy.body": "Camera {{deviceName}} is writing recording segments again",
 	"system.recording-degraded.title": "Recording degraded — {{deviceName}}",
 	"system.recording-degraded.body": "Camera {{deviceName}} exhausted its writer restart budget ({{message}})",
+	"system.device-attention-required.title": "{{title}}",
+	"system.device-attention-required.body": "{{message}}",
+	"system.device-attention-resolved.title": "Resolved: {{title}}",
+	"system.device-attention-resolved.body": "{{deviceName}} no longer needs attention",
 	"system.storage-location-low.title": "Storage low — {{locationName}}",
 	"system.storage-location-low.body": "Location {{locationName}} is down to {{freePercent}}% free ({{reason}})",
 	"system.storage-location-critical.title": "Storage critical — {{locationName}}",
@@ -30796,7 +31030,13 @@ var en_default = {
 	"calendar-events.line.timed": "• {{when}} {{title}}{{where}}",
 	"calendar-events.line.allDay": "• All day {{title}}{{where}}",
 	"calendar-events.where": " @ {{location}}",
-	"calendar-events.more": "…and {{count}} more"
+	"calendar-events.more": "…and {{count}} more",
+	"system.rule-broken.title": "Notification rule broken — {{ruleName}}",
+	"system.rule-broken.body.unparseable": "The rule \"{{ruleName}}\" cannot be loaded and sends nothing. Open it and save it again.",
+	"system.rule-broken.body.device-deleted": "The rule \"{{ruleName}}\" still names a deleted device ({{offendingIds}}) and was switched off. Pick the device again.",
+	"system.rule-broken.body.target-deleted": "The rule \"{{ruleName}}\" still sends to a deleted destination ({{offendingIds}}) and was switched off. Pick a destination again.",
+	"system.rule-repaired.title": "Notification rule works again — {{ruleName}}",
+	"system.rule-repaired.body": "The rule \"{{ruleName}}\" loads and names nothing deleted any more."
 };
 //#endregion
 //#region src/notification-center/texts/it.json
@@ -30881,8 +31121,8 @@ var it_default = {
 	"occupancy.body": "{{scope}} {{op}} ({{count}}/{{capacity}})",
 	"occupancy.op.occupied": "occupata",
 	"occupancy.op.free": "libera",
-	"system.device-online.title": "Online — {{deviceName}}",
-	"system.device-online.body": "Il dispositivo {{deviceName}} è online",
+	"system.device-online.title": "Di nuovo online — {{deviceName}}",
+	"system.device-online.body": "Il dispositivo {{deviceName}} è di nuovo online",
 	"system.device-offline.title": "Offline — {{deviceName}}",
 	"system.device-offline.body": "Il dispositivo {{deviceName}} è offline",
 	"system.device-disabled.title": "Spento — {{deviceName}}",
@@ -30895,14 +31135,14 @@ var it_default = {
 	"system.device-battery-normal.title": "Batteria rientrata — {{deviceName}}",
 	"system.device-battery-normal.body": "{{deviceName}} è risalito al {{percentage}}% di batteria",
 	"system.device-battery-normal.body.binary": "{{deviceName}} non segnala più la batteria scarica",
-	"system.stream-online.title": "Stream online — {{deviceName}}",
-	"system.stream-online.body": "Lo stream della camera {{deviceName}} è online",
-	"system.stream-online.body.profiled": "Lo stream {{profile}} della camera {{deviceName}} è online",
+	"system.stream-online.title": "Stream di nuovo online — {{deviceName}}",
+	"system.stream-online.body": "Lo stream della camera {{deviceName}} è di nuovo online",
+	"system.stream-online.body.profiled": "Lo stream {{profile}} della camera {{deviceName}} è di nuovo online",
 	"system.stream-offline.title": "Stream offline — {{deviceName}}",
 	"system.stream-offline.body": "Lo stream della camera {{deviceName}} è offline",
 	"system.stream-offline.body.profiled": "Lo stream {{profile}} della camera {{deviceName}} è offline",
-	"system.node-online.title": "Nodo online — {{nodeName}}",
-	"system.node-online.body.agent": "L'agent {{nodeName}} è online",
+	"system.node-online.title": "Nodo di nuovo online — {{nodeName}}",
+	"system.node-online.body.agent": "L'agent {{nodeName}} è di nuovo online",
 	"system.node-online.body.agent.after": "L'agent {{nodeName}} è di nuovo online dopo {{offlineFor}} offline",
 	"system.node-offline.title": "Nodo offline — {{nodeName}}",
 	"system.node-offline.body.agent": "L'agent {{nodeName}} è offline",
@@ -30917,10 +31157,14 @@ var it_default = {
 		"one": "La camera {{deviceName}} non scrive un segmento da {{minutes}} minuto",
 		"other": "La camera {{deviceName}} non scrive un segmento da {{minutes}} minuti"
 	},
-	"system.recording-healthy.title": "Registrazione ok — {{deviceName}}",
+	"system.recording-healthy.title": "Registra di nuovo — {{deviceName}}",
 	"system.recording-healthy.body": "La camera {{deviceName}} scrive di nuovo i segmenti",
 	"system.recording-degraded.title": "Registrazione degradata — {{deviceName}}",
 	"system.recording-degraded.body": "La camera {{deviceName}} ha esaurito i riavvii del writer ({{message}})",
+	"system.device-attention-required.title": "{{title}}",
+	"system.device-attention-required.body": "{{message}}",
+	"system.device-attention-resolved.title": "Risolto: {{title}}",
+	"system.device-attention-resolved.body": "{{deviceName}} non richiede più intervento",
 	"system.storage-location-low.title": "Storage basso — {{locationName}}",
 	"system.storage-location-low.body": "La location {{locationName}} è al {{freePercent}}% libero ({{reason}})",
 	"system.storage-location-critical.title": "Storage critico — {{locationName}}",
@@ -30929,9 +31173,13 @@ var it_default = {
 	"system.storage-location-ok.body": "La location {{locationName}} ha recuperato spazio libero",
 	"system.detection-blind.title": "Senza detection — {{deviceName}}",
 	"system.detection-blind.body": {
-		"one": "La camera {{deviceName}} è analizzata da {{minutes}} minuto senza alcun rilevamento",
-		"other": "La camera {{deviceName}} è analizzata da {{minutes}} minuti senza alcun rilevamento"
+		"one": "La camera {{deviceName}} ha avuto movimento per {{minutes}} minuto in {{sessions}} sessioni e il detector non ha prodotto nulla, nemmeno un candidato debole",
+		"other": "La camera {{deviceName}} ha avuto movimento per {{minutes}} minuti in {{sessions}} sessioni e il detector non ha prodotto nulla, nemmeno un candidato debole"
 	},
+	"system.motion-noisy.title": "Movimento continuo senza soggetto — {{deviceName}}",
+	"system.motion-noisy.body": "La camera {{deviceName}} è stata in movimento il {{duty}}% degli ultimi {{minutes}} minuti ({{sessions}} sessioni) senza alcun rilevamento. Il detector funziona — regola le zone di movimento o la sensibilità di questa camera.",
+	"system.motion-calm.title": "Movimento di nuovo calmo — {{deviceName}}",
+	"system.motion-calm.body": "La camera {{deviceName}} non è più in movimento continuo ({{duty}}% degli ultimi {{minutes}} minuti, {{sessions}} sessioni)",
 	"system.addon-update-available.title": {
 		"one": "{{count}} aggiornamento addon disponibile",
 		"other": "{{count}} aggiornamenti addon disponibili"
@@ -31183,7 +31431,13 @@ var it_default = {
 	"calendar-events.line.timed": "• {{when}} {{title}}{{where}}",
 	"calendar-events.line.allDay": "• Tutto il giorno {{title}}{{where}}",
 	"calendar-events.where": " @ {{location}}",
-	"calendar-events.more": "…e altri {{count}}"
+	"calendar-events.more": "…e altri {{count}}",
+	"system.rule-broken.title": "Regola di notifica rotta — {{ruleName}}",
+	"system.rule-broken.body.unparseable": "La regola \"{{ruleName}}\" non si carica e non invia nulla. Aprila e salvala di nuovo.",
+	"system.rule-broken.body.device-deleted": "La regola \"{{ruleName}}\" usa ancora un dispositivo eliminato ({{offendingIds}}) ed è stata disattivata. Scegli di nuovo il dispositivo.",
+	"system.rule-broken.body.target-deleted": "La regola \"{{ruleName}}\" invia ancora a una destinazione eliminata ({{offendingIds}}) ed è stata disattivata. Scegli di nuovo una destinazione.",
+	"system.rule-repaired.title": "Regola di notifica di nuovo funzionante — {{ruleName}}",
+	"system.rule-repaired.body": "La regola \"{{ruleName}}\" si carica e non usa più nulla di eliminato."
 };
 //#endregion
 //#region src/notification-center/text-catalog.ts
@@ -33454,6 +33708,10 @@ function systemEventKeys(kind) {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body.cleanWater`
 	};
+	if (kind === "rule-broken") return {
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body.device-deleted`
+	};
 	return {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body`
@@ -33481,6 +33739,7 @@ function systemEventSubject(kind, scope) {
 	if (kind === "node-online" || kind === "node-offline") return `node:${scope.nodeId ?? "hub"}`;
 	if (kind === "node-inference-unavailable") return `node-inference:${scope.nodeId ?? "hub"}`;
 	if (kind === "detection-blind") return `detection-blind:${scope.deviceId ?? 0}`;
+	if (kind === "motion-noisy" || kind === "motion-calm") return `motion-noise:${scope.deviceId ?? 0}`;
 	if (kind === "addon-crash-loop") return `addon-crash:${scope.nodeId ?? "hub"}:${TEST_CRASHED_RUNNER}`;
 	if (kind === "addon-update-available" || kind === "server-update-available") return `package:${scope.packageName ?? "@camstack/server"}`;
 	if (kind === "wrapper-update-available") return `wrapper:${scope.nodeId ?? "hub"}`;
@@ -33626,6 +33885,8 @@ function planRuleTest(input) {
 					seconds: "30",
 					devices: "cuda:0",
 					minutes: "15",
+					duty: "55",
+					sessions: "96",
 					addons: TEST_CRASHED_RUNNER,
 					list: "@camstack/addon-pipeline 1.0.1 (current 1.0.0)",
 					nodes: "hub",
@@ -39694,6 +39955,99 @@ var NcRecordedCutMemo = class {
 	}
 };
 //#endregion
+//#region src/notification-center/notification-label-layout.ts
+/**
+* Where each box's caption goes on a notification picture — pure geometry,
+* rects in, placements out (D897 follow-up, 2026-10-22).
+*
+* A caption drawn INSIDE its box used to cover the subject whole on a small
+* box, and a caption next to a crowd landed on a neighbour's box. The rule:
+*
+*  1. Try, in order: OUTSIDE above the box (inside the picture), OUTSIDE below
+*     it, then INSIDE its top edge — the last only when the box is big enough
+*     that the plate is a thin band of it: plate height ≤
+*     {@link NC_LABEL_INSIDE_MAX_HEIGHT_FRACTION} of the box height and plate
+*     width ≤ the box width. A fifth of the height leaves the head and torso of
+*     an upright person, or most of a vehicle, visible; anything taller is the
+*     caption hiding what it names.
+*  2. A candidate is refused when its plate intersects ANY other box drawn on
+*     the picture, or a plate already placed.
+*  3. The subject is placed first; the other tracks follow by score, highest
+*     first, so a crowd never costs the subject its caption.
+*  4. The font never shrinks to make a plate fit: no fitting candidate means
+*     no caption for that box. A box without its caption still carries its
+*     outline and colour.
+*
+* Coordinates are the picture's own pixels, whatever it is (a scene or a crop).
+*/
+/** The inside placement is allowed only when the plate is at most this fraction of the box height. */
+var NC_LABEL_INSIDE_MAX_HEIGHT_FRACTION = .2;
+/** A caption is never drawn smaller than this, in output pixels. */
+var NC_LABEL_MIN_FONT_PX = 14;
+/** The dark plate a caption sits on, for this text at this font size. */
+function labelPlateSize(label, fontSize) {
+	return {
+		w: Math.round(label.length * fontSize * .62 + fontSize * .8),
+		h: Math.round(fontSize * 1.35)
+	};
+}
+/** Positive-area overlap; rectangles that only touch do not intersect. */
+function intersects(a, b) {
+	return a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
+}
+function captionOrder(boxes) {
+	const rank = (b) => b.role === "subject" ? 0 : 1;
+	return boxes.map((_, i) => i).sort((i, j) => {
+		const a = boxes[i];
+		const b = boxes[j];
+		if (a === void 0 || b === void 0) return 0;
+		return rank(a) - rank(b) || (b.score ?? 0) - (a.score ?? 0) || i - j;
+	});
+}
+function candidates(box, plate, width, height) {
+	if (plate.w > width) return [];
+	const x = Math.min(box.x, Math.max(0, width - plate.w));
+	const out = [];
+	if (box.y - plate.h >= 0) out.push({
+		x,
+		y: box.y - plate.h,
+		...plate,
+		where: "above"
+	});
+	if (box.y + box.h + plate.h <= height) out.push({
+		x,
+		y: box.y + box.h,
+		...plate,
+		where: "below"
+	});
+	if (plate.h <= box.h * NC_LABEL_INSIDE_MAX_HEIGHT_FRACTION && plate.w <= box.w) out.push({
+		x,
+		y: box.y,
+		...plate,
+		where: "inside"
+	});
+	return out;
+}
+/** Place every caption by the rule above. */
+function layoutBoxLabels(input) {
+	const { width, height, boxes } = input;
+	const fontSize = Math.max(NC_LABEL_MIN_FONT_PX, input.fontSize);
+	const placements = /* @__PURE__ */ new Map();
+	let dropped = 0;
+	for (const i of captionOrder(boxes)) {
+		const box = boxes[i];
+		if (box === void 0 || box.label.length === 0) continue;
+		const chosen = candidates(box, labelPlateSize(box.label, fontSize), width, height).find((c) => !boxes.some((other, j) => j !== i && intersects(c, other)) && ![...placements.values()].some((p) => intersects(c, p)));
+		if (chosen === void 0) dropped += 1;
+		else placements.set(i, chosen);
+	}
+	return {
+		placements: boxes.map((_, i) => placements.get(i) ?? null),
+		placed: placements.size,
+		dropped
+	};
+}
+//#endregion
 //#region src/notification-center/trigger-zone-still.ts
 /**
 * How far a candidate's instant may sit from the nearest trail point before the
@@ -39816,6 +40170,15 @@ var NC_IMAGE_OTHER_COLOR = "#f2f2f2";
 var NC_IMAGE_ZONE_COLOR = "#29b6f6";
 /** Two tracks whose boxes overlap this much at one instant are the same subject (a fused id). */
 var SAME_SUBJECT_IOU = .8;
+/**
+* A box of the SUBJECT'S CLASS overlapping the subject this much at one
+* instant is the subject itself — an unfused piece L2 has not joined yet
+* (D683 fuses 10–20 s later; a push leaves ~6 s after the trigger). The
+* detector's per-class NMS (`NMS_IOU_DEFAULT` 0.45) keeps one of two
+* same-class boxes above 0.45 in a frame, so two REAL subjects of one class
+* cannot overlap past it; 0.5 leaves a margin over that.
+*/
+var NC_IMAGE_SAME_CLASS_SUBJECT_IOU = .5;
 var JPEG_QUALITY = 85;
 /** The caption of a box: class (or label) and confidence — "dog 87%". Language-free. */
 function imageLabelText(name, confidence) {
@@ -39848,15 +40211,21 @@ function toPixels(box, width, height) {
 		h: Math.max(1, Math.min(Math.round(box.h * height), height - y))
 	};
 }
+/** {@link notificationOverlay}'s SVG alone. */
+function notificationOverlaySvg(input) {
+	return notificationOverlay(input).svg;
+}
 /**
-* The SVG drawn over a scene picture of `width` × `height`. The subject is
-* drawn LAST so a crowd never hides it. Captions sit on a dark plate above
-* the box (inside it when the box touches the top edge), white text.
+* The SVG drawn over a picture of `width` × `height`. The subject is drawn
+* LAST so a crowd never hides it. Captions sit on a dark plate, white text,
+* where `layoutBoxLabels` puts them — outside above, outside below, inside a
+* box only when it covers a thin band of it, never on another box or caption,
+* and nowhere at all rather than over the subject.
 */
-function notificationOverlaySvg(input) {
+function notificationOverlay(input) {
 	const { width, height } = input;
 	const strokes = overlayStrokes(width, height);
-	const fontSize = Math.max(14, Math.round(height / 36));
+	const fontSize = Math.max(NC_LABEL_MIN_FONT_PX, Math.round(height / 36));
 	const parts = [];
 	for (const zone of input.zones) {
 		if (zone.length < 3) continue;
@@ -39868,19 +40237,29 @@ function notificationOverlaySvg(input) {
 		parts.push(`<polyline data-role="subject-path" points="${subjectPathSvgPoints(run, width, height)}" fill="none" stroke="${NC_IMAGE_SUBJECT_COLOR}" stroke-width="${String(strokes.subject)}" stroke-linejoin="round" stroke-linecap="round" stroke-opacity="0.9"/>`);
 	}
 	const ordered = [...input.boxes.filter((b) => b.role === "other"), ...input.boxes.filter((b) => b.role === "subject")];
-	for (const box of ordered) {
+	const layout = layoutBoxLabels({
+		width,
+		height,
+		fontSize,
+		boxes: ordered
+	});
+	const plates = [];
+	ordered.forEach((box, i) => {
 		const subject = box.role === "subject";
 		const color = subject ? NC_IMAGE_SUBJECT_COLOR : NC_IMAGE_OTHER_COLOR;
 		const stroke = subject ? strokes.subject : strokes.other;
 		parts.push(`<rect data-role="${box.role}" x="${String(box.x)}" y="${String(box.y)}" width="${String(box.w)}" height="${String(box.h)}" fill="none" stroke="${color}" stroke-width="${String(stroke)}"/>`);
-		if (box.label.length === 0) continue;
-		const plateH = Math.round(fontSize * 1.35);
-		const plateW = Math.round(box.label.length * fontSize * .62 + fontSize * .8);
-		const plateY = box.y - plateH >= 0 ? box.y - plateH : box.y;
-		const plateX = Math.min(box.x, Math.max(0, width - plateW));
-		parts.push(`<rect data-role="${box.role}-plate" x="${String(plateX)}" y="${String(plateY)}" width="${String(plateW)}" height="${String(plateH)}" fill="#000000" fill-opacity="0.72" stroke="${color}" stroke-width="${String(subject ? 2 : 1)}"/>`, `<text data-role="${box.role}-label" x="${String(plateX + Math.round(fontSize * .4))}" y="${String(plateY + Math.round(plateH * .75))}" font-family="DejaVu Sans, Helvetica, Arial, sans-serif" font-size="${String(fontSize)}" font-weight="${subject ? "700" : "400"}" fill="#ffffff">${escapeXml$2(box.label)}</text>`);
-	}
-	return `<svg xmlns="http://www.w3.org/2000/svg" width="${String(width)}" height="${String(height)}">${parts.join("")}</svg>`;
+		const plate = layout.placements[i];
+		if (plate === null || plate === void 0) return;
+		plates.push(`<rect data-role="${box.role}-plate" x="${String(plate.x)}" y="${String(plate.y)}" width="${String(plate.w)}" height="${String(plate.h)}" fill="#000000" fill-opacity="0.72" stroke="${color}" stroke-width="${String(subject ? 2 : 1)}"/>`, `<text data-role="${box.role}-label" x="${String(plate.x + Math.round(fontSize * .4))}" y="${String(plate.y + Math.round(plate.h * .75))}" font-family="DejaVu Sans, Helvetica, Arial, sans-serif" font-size="${String(fontSize)}" font-weight="${subject ? "700" : "400"}" fill="#ffffff">${escapeXml$2(box.label)}</text>`);
+	});
+	return {
+		svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${String(width)}" height="${String(height)}">${[...parts, ...plates].join("")}</svg>`,
+		labels: {
+			placed: layout.placed,
+			dropped: layout.dropped
+		}
+	};
 }
 /** The pixel rectangle a `crop` cuts from a `width` × `height` frame, or null when too small. */
 function subjectCropRect(box, width, height) {
@@ -39910,11 +40289,18 @@ function iou$4(a, b) {
 }
 /**
 * The tracks to draw thin: every track at the instant except the subject —
-* the same id, or a box that is the subject's (a fused id reads under its
-* survivor's name).
-*/
-function otherTracks(tracks, subjectTrackId, subjectBox) {
-	return tracks.filter((t) => t.trackId !== subjectTrackId && (subjectBox === null || iou$4(t.bbox, subjectBox) < SAME_SUBJECT_IOU));
+* the same id, a box that is the subject's (a fused id reads under its
+* survivor's name), or a box of the subject's class over it past what NMS
+* lets two real subjects share (an unfused piece of the same subject).
+*/
+function otherTracks(tracks, subjectTrackId, subjectBox, subjectClassName) {
+	return tracks.filter((t) => {
+		if (t.trackId === subjectTrackId) return false;
+		if (subjectBox === null) return true;
+		const overlap = iou$4(t.bbox, subjectBox);
+		if (overlap >= SAME_SUBJECT_IOU) return false;
+		return !(t.className === subjectClassName && overlap >= NC_IMAGE_SAME_CLASS_SUBJECT_IOU);
+	});
 }
 /**
 * What picture a ROW asks for. A row written since D897 carries `mediaImage`;
@@ -39931,9 +40317,15 @@ function payloadImageMode(payload) {
 	if (payload.media === "keyFrame") return "clean";
 	return "crop";
 }
-/** The zone ids a row's picture outlines: the zones that fired it, when it asked. */
+/**
+* The zone ids a row's picture outlines: the zone(s) THIS event triggered,
+* when it asked — never every zone the rule lists (a dog in Uscio drew Aiuola
+* too). A row that asked but froze no `matchedZoneIds` (written before the
+* field) draws none: an outline of a zone the subject never entered is a
+* picture that lies about its own reason.
+*/
 function payloadZoneOverlayIds(payload) {
-	if (payload.mediaShowTriggerZone === true) return payload.triggerZoneIds ?? [];
+	if (payload.mediaShowTriggerZone === true) return payload.matchedZoneIds ?? [];
 	if (payload.mediaImage === void 0) return payload.mediaZoneIds ?? [];
 	return [];
 }
@@ -40022,7 +40414,8 @@ async function renderNotificationImage(req) {
 	const boxes = req.mode === "scene-boxes" ? [...req.others.map((o) => ({
 		...toPixels(o, outW, outH),
 		role: "other",
-		label: o.label
+		label: o.label,
+		...o.confidence !== void 0 ? { score: o.confidence } : {}
 	})), ...req.subject !== null ? [{
 		...toPixels(req.subject, outW, outH),
 		role: "subject",
@@ -40040,16 +40433,18 @@ async function renderNotificationImage(req) {
 		height: outH,
 		fit: "fill"
 	});
+	let labels;
 	if (boxes.length > 0 || zones.length > 0 || paths.length > 0) {
-		const svg = notificationOverlaySvg({
+		const overlay = notificationOverlay({
 			width: outW,
 			height: outH,
 			boxes,
 			zones,
 			paths
 		});
+		if (boxes.length > 0) labels = overlay.labels;
 		pipeline = pipeline.composite([{
-			input: Buffer.from(svg),
+			input: Buffer.from(overlay.svg),
 			top: 0,
 			left: 0
 		}]);
@@ -40059,7 +40454,8 @@ async function renderNotificationImage(req) {
 	return {
 		bytes: toArrayBufferBytes(out),
 		name: `${rendered}.jpg`,
-		rendered
+		rendered,
+		...labels !== void 0 ? { labels } : {}
 	};
 }
 var NcNotificationImageStage = class {
@@ -40133,10 +40529,29 @@ var NcNotificationImageStage = class {
 			...subjectBox,
 			label: imageLabelText(payload.subject.label ?? payload.subject.className, payload.subject.confidence)
 		} : null;
-		const others = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox).map((t) => ({
+		const othersDrawn = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox, payload.subject.className) : [];
+		if (mode === "scene-boxes") this.deps.logger.info("scene-boxes: other boxes drawn", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: entry.ruleId,
+				recordId: entry.recordId,
+				instant: source.timestamp,
+				drawn: othersDrawn.map((t) => `${t.trackId}/${t.className}/dt=${t.dtMs ?? "?"}ms/${t.interpolated === true ? "interpolated" : "exact"}`).join(",")
+			}
+		});
+		const others = mode === "scene-boxes" ? othersDrawn.map((t) => ({
 			...t.bbox,
-			label: imageLabelText(t.label ?? t.className, t.confidence)
+			label: imageLabelText(t.label ?? t.className, t.confidence),
+			...t.confidence !== void 0 ? { confidence: t.confidence } : {}
 		})) : [];
+		if (mode !== "crop" && input.withSubject && payload.mediaShowTriggerZone === true && payload.matchedZoneIds === void 0) this.deps.logger.info("trigger zone not drawn — the row never froze which zone fired", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: entry.ruleId,
+				recordId: entry.recordId,
+				ruleZoneIds: (payload.triggerZoneIds ?? []).join(",")
+			}
+		});
 		const zones = mode === "crop" || zoneIds.length === 0 ? [] : await this.zonePolygons(camera, zoneIds);
 		try {
 			const image = await this.render({
@@ -40149,6 +40564,7 @@ var NcNotificationImageStage = class {
 			});
 			const reason = image.rendered === mode ? void 0 : mode === "crop" ? "no-subject-box" : "no-tracks-at-instant";
 			if (reason !== void 0) this.reportFallback(input, mode, reason);
+			if (image.labels !== void 0) this.reportLabels(input, image.labels);
 			return reason !== void 0 ? {
 				...image,
 				reason
@@ -40197,6 +40613,19 @@ var NcNotificationImageStage = class {
 			}
 		});
 	}
+	/** ONE line per rendered picture: how many captions it carries and how many had no clear spot. */
+	reportLabels(input, labels) {
+		const camera = input.camera === "composite" ? input.entry.payload.subject.deviceId : input.camera;
+		this.deps.logger.debug("notification picture captions laid out", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: input.entry.ruleId,
+				recordId: input.entry.recordId,
+				placed: labels.placed,
+				dropped: labels.dropped
+			}
+		});
+	}
 	/** The subject's trail, read once per render for its box AND its path. */
 	async subjectTrail(camera, trackId) {
 		const read = this.deps.getSubjectTrail;
@@ -46890,6 +47319,27 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
+* Incident 2026-10-22: a row stored with `groupingSec: 0` failed `NcRuleSchema` (min
+* {@link NC_GROUPING_MIN_SEC}) and the WHOLE rule was skipped as malformed on every load — a
+* system-event rule on which a window cannot even apply vanished from the engine and from
+* `listRules`. A non-positive (or non-numeric) window only ever meant "no window": dropped. A
+* positive one outside the range is clamped. One bad optional field never costs the rule.
+*/
+function repairStoredGroupingSec(value) {
+	if (value === void 0) return { kind: "unchanged" };
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return {
+		kind: "repaired",
+		from: value,
+		to: null
+	};
+	const clamped = clampGroupingSec(value);
+	return clamped === value ? { kind: "unchanged" } : {
+		kind: "repaired",
+		from: value,
+		to: clamped
+	};
+}
+/**
 * Project a RAW stored rule value (`data['rule']`, before any Zod parse). A value that is not
 * an object, or has no string `delivery`, is returned untouched: the schema parse that follows
 * rejects it exactly as before, and a projection must never be what decides a row is valid.
@@ -46897,9 +47347,12 @@ function isRecord(value) {
 function projectRawStoredRule(raw) {
 	if (!isRecord(raw) || typeof raw["delivery"] !== "string") return {
 		candidate: raw,
-		projection: { kind: "unchanged" }
+		projection: { kind: "unchanged" },
+		groupingRepair: { kind: "unchanged" }
 	};
-	const groupingSec = raw["groupingSec"];
+	const groupingRepair = repairStoredGroupingSec(raw["groupingSec"]);
+	const repaired = withRepairedGrouping(raw, groupingRepair);
+	const groupingSec = repaired["groupingSec"];
 	const projection = projectRetiredRuleFields({
 		delivery: raw["delivery"],
 		conditions: isRecord(raw["conditions"]) ? raw["conditions"] : {},
@@ -46908,15 +47361,25 @@ function projectRawStoredRule(raw) {
 		...typeof groupingSec === "number" ? { groupingSec } : {}
 	});
 	if (projection.kind === "unchanged" || projection.groupingSec === void 0) return {
-		candidate: raw,
-		projection
+		candidate: repaired,
+		projection,
+		groupingRepair
 	};
 	return {
 		candidate: {
-			...raw,
+			...repaired,
 			groupingSec: projection.groupingSec
 		},
-		projection
+		projection,
+		groupingRepair
+	};
+}
+function withRepairedGrouping(raw, repair) {
+	if (repair.kind === "unchanged") return raw;
+	const { groupingSec: _dropped, ...rest } = raw;
+	return repair.to === null ? rest : {
+		...rest,
+		groupingSec: repair.to
 	};
 }
 /**
@@ -46969,16 +47432,44 @@ var LOAD_LIMIT = 1e4;
 * Parse a raw body object (as returned from storage — may contain retired keys)
 * into an `NcRule` applying the legacy field projection.
 */
-function bodyToRule(id, raw, onProjection) {
-	const { candidate, projection } = projectRawStoredRule(raw);
+function bodyToRule(id, raw, onProjection, onGroupingRepair) {
+	const parsed = parseStoredRule(id, raw, onProjection, onGroupingRepair);
+	return parsed.ok ? parsed.rule : null;
+}
+function parseStoredRule(id, raw, onProjection, onGroupingRepair, onClassWidening) {
+	const { candidate, projection, groupingRepair } = projectRawStoredRule(raw);
 	const parsed = NcRuleSchema.safeParse({
 		...candidate,
 		id
 	});
-	if (!parsed.success) return null;
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		return {
+			ok: false,
+			reason: issue === void 0 ? "invalid" : `${issue.path.join(".") || "(root)"}: ${issue.message}`
+		};
+	}
 	if (projection.kind === "projected") onProjection?.(id, projection);
-	return withNormalizedMedia(parsed.data);
+	if (groupingRepair.kind === "repaired") onGroupingRepair?.(id, groupingRepair);
+	const media = withNormalizedMedia(parsed.data);
+	const rule = withSystemEventClasses(media);
+	if (rule !== media) onClassWidening?.(id, media, rule);
+	return {
+		ok: true,
+		rule
+	};
+}
+/**
+* D906: what a rule is stored as — its media policy folded (D897) and, on an
+* INSTANT system rule, every paired class it touches completed with both
+* edges. Applied on every WRITE; the load applies the same through
+* {@link parseStoredRule}, which also says once that it widened a rule.
+*/
+function normalizeStoredRule(rule) {
+	return withSystemEventClasses(withNormalizedMedia(rule));
 }
+/** At most this many skipped rows are NAMED in the WARN line; the count is always whole. */
+var SKIPPED_ROWS_NAMED_MAX = 10;
 /**
 * D897: the rule with its media policy in the stored shape — `image` set, the
 * legacy `attach` / `frame` / `zoneCrop` folded into it. Applied on LOAD (a read
@@ -47055,6 +47546,8 @@ var NcRuleStore = class NcRuleStore {
 	now;
 	newId;
 	identityIdsByName;
+	/** Rows the last successful {@link load} skipped; `null` before one succeeded. */
+	skipped = null;
 	/** Has a {@link load} ever completed? See the note there. */
 	loaded = false;
 	/** Legacy detection rules naming sounds already reported (D690) — once each. */
@@ -47066,6 +47559,10 @@ var NcRuleStore = class NcRuleStore {
 	pendingProjections = /* @__PURE__ */ new Map();
 	/** Rules whose projection was already logged in this process (D692 §9) — once each. */
 	projectionLogged = /* @__PURE__ */ new Set();
+	/** Rules whose out-of-range `groupingSec` repair was already logged — once each. */
+	groupingRepairLogged = /* @__PURE__ */ new Set();
+	/** Rules whose class widening (D906) was already logged — once each. */
+	classWideningLogged = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.logger = deps.logger;
 		this.now = deps.now ?? (() => Date.now());
@@ -47100,20 +47597,29 @@ var NcRuleStore = class NcRuleStore {
 		try {
 			const { records } = await this.kind.query({ limit: LOAD_LIMIT });
 			const next = /* @__PURE__ */ new Map();
-			let skipped = 0;
+			const skippedRows = [];
 			for (const row of records) {
-				const rule = bodyToRule(row.id, row.data, (ruleId, projection) => {
+				const parsed = parseStoredRule(row.id, row.data, (ruleId, projection) => {
 					this.pendingProjections.set(ruleId, projection);
-				});
-				if (rule === null) {
-					skipped += 1;
+				}, (ruleId, repair) => this.logGroupingRepair(ruleId, repair), (ruleId, before, after) => this.logClassWidening(ruleId, before, after));
+				if (!parsed.ok) {
+					const name = row.data["name"];
+					skippedRows.push({
+						ruleId: row.id,
+						name: typeof name === "string" ? name : null,
+						reason: parsed.reason
+					});
 					continue;
 				}
-				next.set(row.id, rule);
+				next.set(row.id, parsed.rule);
 			}
 			this.byId.clear();
 			for (const [id, rule] of next) this.byId.set(id, rule);
-			if (skipped > 0) this.logger.warn("notification rule rows skipped as malformed", { meta: { skipped } });
+			this.skipped = skippedRows;
+			if (skippedRows.length > 0) this.logger.warn("notification rule rows skipped as malformed", { meta: {
+				skipped: skippedRows.length,
+				rows: skippedRows.slice(0, SKIPPED_ROWS_NAMED_MAX)
+			} });
 			this.loaded = true;
 		} catch (err) {
 			this.logger.warn("notification rules load failed — keeping rules already in memory", { meta: {
@@ -47125,6 +47631,27 @@ var NcRuleStore = class NcRuleStore {
 		for (const id of warnLegacyAudioClassRules([...this.byId.values()], this.audioClassWarned, this.logger)) this.audioClassWarned.add(id);
 		this.logger.debug("notification rules loaded", { meta: { rules: this.byId.size } });
 	}
+	/** Say, once per process per rule, that an instant rule was read as its whole class (D906). */
+	logClassWidening(ruleId, before, after) {
+		if (this.classWideningLogged.has(ruleId)) return;
+		this.classWideningLogged.add(ruleId);
+		const had = new Set(before.conditions.systemEvent?.kinds ?? []);
+		this.logger.info("instant system rule read as its whole event class — both edges", { meta: {
+			ruleId,
+			rule: after.name,
+			added: (after.conditions.systemEvent?.kinds ?? []).filter((kind) => !had.has(kind))
+		} });
+	}
+	/** Say, once per process per rule, that an out-of-range stored `groupingSec` was repaired. */
+	logGroupingRepair(ruleId, repair) {
+		if (this.groupingRepairLogged.has(ruleId)) return;
+		this.groupingRepairLogged.add(ruleId);
+		this.logger.warn("rule carries an out-of-range groupingSec — repaired on read", { meta: {
+			ruleId,
+			from: repair.from,
+			to: repair.to
+		} });
+	}
 	/** Log, once per process per rule, what `bodyToRule` projected from a retired field. */
 	logPendingProjections() {
 		for (const [ruleId, projection] of this.pendingProjections) {
@@ -47193,6 +47720,13 @@ var NcRuleStore = class NcRuleStore {
 	* camera's ring) must ask this first: before the first load the empty list
 	* is not a fact, and a failed load leaves whatever was already mirrored.
 	*/
+	/**
+	* The rows the last SUCCESSFUL load could not parse — `null` until one has
+	* succeeded, so "not read yet" never reads as "nothing broken" (D315).
+	*/
+	skippedRows() {
+		return this.skipped;
+	}
 	isLoaded() {
 		return this.loaded;
 	}
@@ -47222,7 +47756,7 @@ var NcRuleStore = class NcRuleStore {
 	/** Create a new rule. `createdBy` is the SERVER-injected caller userId. */
 	async create(input, createdBy) {
 		const now = this.now();
-		const rule = withNormalizedMedia({
+		const rule = normalizeStoredRule({
 			...input,
 			id: this.newId(),
 			createdBy,
@@ -47267,7 +47801,7 @@ var NcRuleStore = class NcRuleStore {
 			createdAt: existing.createdAt,
 			updatedAt: this.now()
 		};
-		const updated = withNormalizedMedia(NcRuleSchema.parse(candidate));
+		const updated = normalizeStoredRule(NcRuleSchema.parse(candidate));
 		await this.write(updated);
 		return updated;
 	}
@@ -47307,7 +47841,7 @@ var NcRuleStore = class NcRuleStore {
 			id: ruleId
 		} : candidate);
 		if (!parsed.success) return existing;
-		const next = withNormalizedMedia(parsed.data);
+		const next = normalizeStoredRule(parsed.data);
 		const { id: _omit, ...data } = next;
 		await this.kind.put({
 			id: ruleId,
@@ -53336,6 +53870,104 @@ var NcZoneOwnershipCache = class {
 	}
 };
 //#endregion
+//#region src/notification-center/rule-health.ts
+var EMPTY_SNAPSHOT = {
+	timelapse: [],
+	summary: [],
+	alarm: null,
+	mutedDeviceIds: []
+};
+function fingerprintOf(reasons) {
+	return reasons.map((r) => `${r.code}:${[...r.ids].sort().join(",")}`).join("|");
+}
+/** The deleted subjects a rule still names, from the prune's `kept*` records. */
+function deletedReasons(rule, prunes) {
+	const snapshot = {
+		...EMPTY_SNAPSHOT,
+		rules: [rule]
+	};
+	const devices = referencedDeviceIds(snapshot);
+	const targets = referencedTargetIds(snapshot);
+	const deadDevices = /* @__PURE__ */ new Set();
+	const deadTargets = /* @__PURE__ */ new Set();
+	for (const p of prunes) {
+		if (p.kind !== "rule" || p.ruleId !== rule.id) continue;
+		if (p.outcome !== "kept" && p.outcome !== "kept-disabled") continue;
+		if (p.subjectKind === "device" && devices.has(Number(p.subject))) deadDevices.add(p.subject);
+		if (p.subjectKind === "target" && targets.has(p.subject)) deadTargets.add(p.subject);
+	}
+	const reasons = [];
+	if (deadDevices.size > 0) reasons.push({
+		code: "device-deleted",
+		ids: [...deadDevices].sort()
+	});
+	if (deadTargets.size > 0) reasons.push({
+		code: "target-deleted",
+		ids: [...deadTargets].sort()
+	});
+	return reasons;
+}
+var NcRuleHealthMonitor = class {
+	verdicts = /* @__PURE__ */ new Map();
+	/** Judge every rule once; return the edges to announce. */
+	evaluate(inputs) {
+		const next = /* @__PURE__ */ new Map();
+		const seen = /* @__PURE__ */ new Set();
+		if (inputs.skipped !== null) for (const row of inputs.skipped) {
+			seen.add(row.ruleId);
+			const unparseable = {
+				code: "unparseable",
+				ids: [],
+				detail: row.reason
+			};
+			next.set(row.ruleId, this.verdict(row.name, unparseable, []));
+		}
+		if (inputs.rules !== null) for (const rule of inputs.rules) {
+			seen.add(rule.id);
+			const previous = this.verdicts.get(rule.id);
+			const deleted = inputs.prunes !== null ? deletedReasons(rule, inputs.prunes) : previous?.deleted ?? [];
+			const unparseable = inputs.skipped !== null ? null : previous?.unparseable ?? null;
+			next.set(rule.id, this.verdict(rule.name, unparseable, deleted));
+		}
+		const edges = [];
+		const answeredAll = inputs.rules !== null && inputs.skipped !== null;
+		for (const [ruleId, previous] of this.verdicts) {
+			if (seen.has(ruleId)) continue;
+			if (!answeredAll) next.set(ruleId, previous);
+		}
+		for (const [ruleId, verdict] of next) {
+			const previous = this.verdicts.get(ruleId);
+			const reasons = reasonsOf(verdict);
+			if (reasons.length > 0) {
+				if (previous?.fingerprint !== verdict.fingerprint) edges.push({
+					kind: "broken",
+					ruleId,
+					ruleName: verdict.name,
+					reasons
+				});
+			} else if (previous !== void 0 && reasonsOf(previous).length > 0) edges.push({
+				kind: "repaired",
+				ruleId,
+				ruleName: verdict.name
+			});
+		}
+		this.verdicts.clear();
+		for (const [ruleId, verdict] of next) if (reasonsOf(verdict).length > 0) this.verdicts.set(ruleId, verdict);
+		return edges;
+	}
+	verdict(name, unparseable, deleted) {
+		return {
+			name,
+			unparseable,
+			deleted,
+			fingerprint: fingerprintOf([...unparseable !== null ? [unparseable] : [], ...deleted])
+		};
+	}
+};
+function reasonsOf(verdict) {
+	return [...verdict.unparseable !== null ? [verdict.unparseable] : [], ...verdict.deleted];
+}
+//#endregion
 //#region src/notification-center/index.ts
 /**
 * NotificationCenter — the P1 core of the Notification Center (spec
@@ -53402,7 +54034,7 @@ var NC_ALARM_ANNOUNCE_RULE_ID = "nc-alarm-announce";
 * media (the SOURCE rule of a combined alarm row), and a zone overlay is
 * frozen only when the rule asked for one AND fired on a zone.
 */
-function mediaPolicyFields(mediaRule, cropZoneIds) {
+function mediaPolicyFields(mediaRule, cropZoneIds, matchedZoneIds) {
 	const media = effectiveMediaPolicyForRule(mediaRule);
 	const image = media.image ?? "crop";
 	return {
@@ -53411,6 +54043,7 @@ function mediaPolicyFields(mediaRule, cropZoneIds) {
 		...media.showTriggerZone === true && cropZoneIds !== void 0 && cropZoneIds.length > 0 ? { mediaShowTriggerZone: true } : {},
 		...media.showSubjectPath === true && image !== "none" ? { mediaShowSubjectPath: true } : {},
 		...cropZoneIds !== void 0 ? { triggerZoneIds: [...cropZoneIds] } : {},
+		...matchedZoneIds !== void 0 ? { matchedZoneIds: [...matchedZoneIds] } : {},
 		...media.profile !== void 0 ? { mediaProfile: media.profile } : {},
 		...media.gif === true ? { mediaGif: true } : {},
 		...media.clip === true ? { mediaClip: true } : {},
@@ -53916,6 +54549,21 @@ function groupOrderInput(fate, triggerZoneIds) {
 * condition's ids, else an occupancy rule's one zone. A grouped member freezes the same
 * ids a plain row of the rule would.
 */
+/**
+* The zones of `cropZoneIds` this subject actually triggered — what the zone
+* condition saw (membership plus the crossed zone, `zonesVisitedBy`), on the
+* rule whose media the row carries. On a combined alarm row the subject is the
+* alarm, so the source match's frozen zones answer. An occupancy rule's one
+* zone is the zone the count edge is ABOUT, so it is its own trigger.
+*/
+function matchedTriggerZoneIds(mediaRule, cropZoneIds, subject) {
+	if (cropZoneIds === void 0) return void 0;
+	if (mediaRule.conditions.zones === void 0) return [...cropZoneIds];
+	const alarmSource = subject.systemEvent?.alarmSource;
+	const visited = new Set(alarmSource !== void 0 ? alarmSource.zones ?? [] : subject.zones);
+	if (alarmSource === void 0 && subject.crossing !== void 0) visited.add(subject.crossing.zoneId);
+	return cropZoneIds.filter((id) => visited.has(id));
+}
 function ruleCropZoneIds(rule) {
 	if (rule.conditions.zones !== void 0) return rule.conditions.zones.ids;
 	const zoneId = rule.conditions.occupancy?.zoneId;
@@ -54069,6 +54717,8 @@ var NotificationCenter = class {
 	* evaluating one.
 	*/
 	pruneLedger;
+	/** D905: which rules cannot work, announced once per distinct reason. */
+	ruleHealth = new NcRuleHealthMonitor();
 	/** The prune itself — see `device-prune-runner.ts`. */
 	pruner;
 	/**
@@ -57498,7 +58148,7 @@ var NotificationCenter = class {
 		const subject = incoming.subject;
 		const alarmSource = subject.systemEvent?.alarmSource;
 		const sourceRule = alarmSource !== void 0 ? this.rules.get(alarmSource.ruleId) : null;
-		const media = sourceRule !== null ? mediaPolicyFields(sourceRule, ruleCropZoneIds(sourceRule)) : { media: "none" };
+		const media = sourceRule !== null ? mediaPolicyFields(sourceRule, ruleCropZoneIds(sourceRule), matchedTriggerZoneIds(sourceRule, ruleCropZoneIds(sourceRule), subject)) : { media: "none" };
 		const mediaDeviceId = alarmSource?.deviceId ?? panel.deviceId;
 		const entries = targets.map((targetId) => ({
 			ruleId: NC_ALARM_ANNOUNCE_RULE_ID,
@@ -58704,6 +59354,7 @@ var NotificationCenter = class {
 		const renderedZones = notificationZones(rule, subject);
 		const confirm = frozenConfirmPolicy(rule, isSystemEvent);
 		const cropZoneIds = ruleCropZoneIds(mediaRule);
+		const matchedZoneIds = matchedTriggerZoneIds(mediaRule, cropZoneIds, subject);
 		const allTargets = [...rule.targets, ...userTargets.filter((t) => !direct.has(t.targetId))];
 		const linkedOwners = !noMedia && subject.linkedStills !== void 0 ? linkedMediaOwners(subject.linkedStills, linkedCameraMode(mediaRule.media)) : void 0;
 		const groupV2 = extras?.groupV2 ?? (subject.systemEvent !== void 0 && !noMedia ? alarmIncidentGroup(subject.systemEvent, subject.timestamp) : void 0);
@@ -58714,7 +59365,7 @@ var NotificationCenter = class {
 				...origin === "synthetic" ? { synthetic: true } : {},
 				priority: rule.priority,
 				...rule.template !== void 0 ? { template: rule.template } : {},
-				...noMedia ? { media: "none" } : mediaPolicyFields(mediaRule, cropZoneIds),
+				...noMedia ? { media: "none" } : mediaPolicyFields(mediaRule, cropZoneIds, matchedZoneIds),
 				...confirm !== void 0 ? {
 					confirm,
 					...cooldown !== void 0 ? { cooldown } : {},
@@ -59359,6 +60010,51 @@ var NotificationCenter = class {
 		if (!this.pruneLedger.isLoaded()) await this.pruneLedger.load();
 		await this.pruner.reconcileDevices();
 		await this.pruner.reconcileTargets();
+		this.announceRuleHealth();
+	}
+	/**
+	* D905 — say which rules cannot work: a row the load skipped, or a rule still
+	* naming a device / target the prune confirmed deleted. One edge per rule per
+	* distinct set of reasons; a reading that did not answer changes nothing.
+	*/
+	announceRuleHealth() {
+		const edges = this.ruleHealth.evaluate({
+			rules: this.rules.isLoaded() ? this.rules.list() : null,
+			skipped: this.rules.skippedRows(),
+			prunes: this.pruneLedger.isLoaded() ? this.pruner.listPrunes() : null
+		});
+		for (const edge of edges) {
+			const source = {
+				type: "addon",
+				id: "notification-center"
+			};
+			if (edge.kind === "broken") {
+				const [first] = edge.reasons;
+				if (first === void 0) continue;
+				const offendingIds = [...new Set(edge.reasons.flatMap((r) => r.ids))];
+				this.logger.warn("notification rule cannot work — announced", { meta: {
+					ruleId: edge.ruleId,
+					rule: edge.ruleName,
+					reasons: edge.reasons
+				} });
+				this.deps.emitBusEvent?.(createEvent(EventCategory.NotificationRuleBroken, source, {
+					ruleId: edge.ruleId,
+					ruleName: edge.ruleName,
+					reason: first.code,
+					reasons: edge.reasons,
+					offendingIds
+				}));
+			} else {
+				this.logger.info("notification rule works again — announced", { meta: {
+					ruleId: edge.ruleId,
+					rule: edge.ruleName
+				} });
+				this.deps.emitBusEvent?.(createEvent(EventCategory.NotificationRuleRepaired, source, {
+					ruleId: edge.ruleId,
+					ruleName: edge.ruleName
+				}));
+			}
+		}
 	}
 	/**
 	* `DeviceUnregistered` — a device was DELETED (only `removeDevice` emits it,
@@ -87156,7 +87852,12 @@ var RetrainCollectionService = class {
 				reason: "unknown-collection"
 			};
 		}
-		const stored = await this.storeStill(input.deviceId, input.epochMs);
+		const membershipOp = await this.deps.collections.addFrameOp({
+			collectionId: input.collectionId,
+			frameId: recordingFrameId(input.deviceId, input.epochMs),
+			deviceId: input.deviceId
+		});
+		const stored = await this.storeStill(input.deviceId, input.epochMs, membershipOp === null ? [] : [membershipOp]);
 		if (stored.kind === "refused") {
 			this.deps.logger.info("retrain collection add refused", {
 				tags,
@@ -87168,7 +87869,7 @@ var RetrainCollectionService = class {
 			});
 			return stored;
 		}
-		await this.deps.collections.addFrame({
+		if (stored.reused) await this.deps.collections.addFrame({
 			collectionId: input.collectionId,
 			frameId: stored.frame.frameId,
 			deviceId: input.deviceId
@@ -87233,7 +87934,7 @@ var RetrainCollectionService = class {
 		const ids = await this.deps.collections.listFrameIds(input.collectionId);
 		return this.deps.retrain.toWireFrames(await this.deps.frames.getMany(ids));
 	}
-	async storeStill(deviceId, epochMs) {
+	async storeStill(deviceId, epochMs, withRow) {
 		const existing = await this.deps.frames.get(recordingFrameId(deviceId, epochMs));
 		if (existing !== null) return {
 			kind: "stored",
@@ -87253,7 +87954,7 @@ var RetrainCollectionService = class {
 			deviceId,
 			epochMs,
 			bytes: still.jpeg
-		});
+		}, withRow);
 		return stored.kind === "copied" ? {
 			kind: "stored",
 			frame: stored.frame,
@@ -89576,9 +90277,9 @@ var RetrainService = class {
 			...this.frameUrls(updated.frameId)
 		};
 	}
-	/** Un-select: annotations first, then the copy. Never the other way round —
-	*  an annotation whose frame is gone is unopenable and unfixable. The frame's
-	*  collection memberships go with it. */
+	/** Un-select: the frame row, its annotations and its collection memberships
+	*  leave in one transaction (an annotation whose frame is gone is unopenable
+	*  and unfixable, so they never part); the blob is deleted after the row. */
 	async deselectFrame(input) {
 		const frame = await this.deps.frames.get(input.frameId);
 		if (frame === null) {
@@ -89597,11 +90298,16 @@ var RetrainService = class {
 			removedAnnotations: await this.removeFrame(frame)
 		};
 	}
-	/** Remove a frame from the dataset: annotations, memberships, then the copy. */
+	/**
+	* Remove a frame from the dataset. The frame row, its annotations and its
+	* collection memberships leave in ONE transaction (a failure removes nothing
+	* and throws); the blob is deleted after the row, never before.
+	*/
 	async removeFrame(frame) {
-		const removedAnnotations = await this.deps.annotations.deleteForFrame(frame.frameId);
-		await this.deps.memberships?.forgetFrame(frame.frameId);
-		await this.deps.frames.deleteFrame(frame);
+		const annotationOps = await this.deps.annotations.deleteOpsForFrame(frame.frameId);
+		const membershipOps = await this.deps.memberships?.forgetFrameOps(frame.frameId) ?? [];
+		await this.deps.frames.deleteFrame(frame, [...annotationOps, ...membershipOps]);
+		const removedAnnotations = annotationOps.length;
 		this.deps.logger.info("retrain frame removed from the dataset", {
 			tags: { deviceId: frame.deviceId },
 			meta: {
@@ -89795,7 +90501,8 @@ var RetrainService = class {
 	* The guarded replace. A caller that names the revision it saw gets exactly
 	* one attempt: a different current revision is a conflict, never a retry —
 	* the point is that it must look again. A caller that names none asked for
-	* last-write-wins, so a race lost between our read and the transaction is
+	* last-write-wins, so a race lost between our revision read and the records
+	* `transact` that commits the save (a per-frame lock serialises the two) is
 	* retried on the fresh revision, a bounded number of times.
 	*/
 	async replaceGuarded(frame, input, drafts, dismissed) {
@@ -103422,12 +104129,16 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	EventCategory.WorkerOffline,
 	EventCategory.PipelineNodeInferenceUnavailable,
 	EventCategory.PipelineDetectionBlind,
+	EventCategory.PipelineMotionNoisy,
+	EventCategory.PipelineMotionCalm,
 	EventCategory.RecordingHealthStalled,
 	EventCategory.RecordingHealthOk,
 	EventCategory.RecordingHealthDegraded,
 	EventCategory.StorageLocationLow,
 	EventCategory.StorageLocationCritical,
 	EventCategory.StorageLocationOk,
+	EventCategory.NotificationRuleBroken,
+	EventCategory.NotificationRuleRepaired,
 	EventCategory.AddonRunnerFailed,
 	EventCategory.AddonStarted,
 	EventCategory.AddonRestarted,
@@ -106438,6 +107149,18 @@ Object.freeze({
 				"empty"
 			]
 		},
+		{
+			"path": "filterCleaningDue",
+			"valueType": "boolean"
+		},
+		{
+			"path": "machineCareDue",
+			"valueType": "boolean"
+		},
+		{
+			"path": "machineCareRemainingRuns",
+			"valueType": "number"
+		},
 		{
 			"path": "halfLoad",
 			"valueType": "boolean"
@@ -115458,6 +116181,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				nodeAddons: (nodeId) => api.nodes.getNodeAddons.query({ nodeId })
 			},
 			readAlerts: () => api.alerts.list.query({ limit: 5e3 }),
+			emitBusEvent: (event) => this.ctx.eventBus.emit(event),
 			getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }),
 			recognitionOutlook: ({ deviceId, trackId, className, labelKind, now }) => recognitionOutlook({
 				className,
@@ -115731,7 +116455,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 						since: timestamp - toleranceMs,
 						limit: NC_TRACKS_AT_INSTANT_LIMIT
 					});
-					return tracksAtInstant([...live, ...persisted.tracks], timestamp, toleranceMs, this.lastFrameDimsByDevice.get(deviceId));
+					return tracksAtInstant([...live, ...persisted.tracks], timestamp, toleranceMs, this.lastFrameDimsByDevice.get(deviceId), (drop) => this.ctx.logger.info("scene-boxes: other track not drawn", {
+						tags: { deviceId },
+						meta: {
+							trackId: drop.trackId,
+							className: drop.className,
+							reason: drop.reason,
+							instant: timestamp,
+							...drop.nearestDtMs !== void 0 ? { nearestDtMs: drop.nearestDtMs } : {}
+						}
+					}));
 				},
 				getDeviceName,
 				getDeviceLocation,