@camstack/addon-post-analysis 1.2.607 → 1.2.608

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as MediaFileKindEnum, $i as record, $n as deleteAlarmProfile, $t as NcTemplateVarDescriptorSchema, A as DeclaredDevices, Ai as errMsg, An as TrackSideSchema, Ar as isRootSuppliableStepId, At as NcAlarmSensorsInputSchema, B as FULL_IMAGE_BBOX, Bi as nodePin, Bn as armRemovalReconcile, Br as occupancyScope, Bt as NcRuleSchema, C as ClearTrackRelationResultSchema, Ci as viewerLinkBaseOf, Cn as TRACK_RELATIONS_DEFAULT_LIMIT, Cr as isDetectionMacroClass, Ct as NC_SNOOZE_MAX_MINUTES, D as DEFAULT_TIMELAPSE_PREVIEW_TEXT, Di as evaluateSensorEdge, Dn as TrackPuritySchema, Dr as isLabelSupplyStepId, Dt as NC_TEMPLATE_VARS, E as DEFAULT_EVENT_COLOR, Ei as canonicalHash, En as TimelapseRuleSchema, Er as isKnownTemplateVar, Et as NC_TAXONOMY, F as EVENT_DENSITY_BATCH_MAX, Fi as customAction, Fn as alarmPanelCapability, Fr as kebabToCamel, Ft as NcLegacyRuleActionSequenceSchema, G as ListTrackRelationsResultSchema, Gi as array, Gn as buildViewerLink, Gr as readDeviceStateFrom, Gt as NcSnoozeInputSchema, H as LABEL_SUPPLY_MACRO, Hi as sleep$1, Hn as audioMetricsCapability, Hr as pickFaceRescoreIntervalMinutes, Ht as NcRuleUpdateInputSchema, I as EVENT_KIND_BY_CAP, Ii as defineCustomActions, In as applyBlockingEdit, Ir as linkedStepOf, It as NcRuleActionSchema, J as MAX_BIRTH_DECISION_RECORDS, Ji as literal, Jn as cloneAlarmSettings, Jr as renameAlarmProfile, Jt as NcStateSummarySectionIdSchema, K as LockStateSchema, Ki as boolean, Kn as calendarEventLocalSpan, Kr as readMotionTriggeredBy, Kt as NcSnoozeSchema, L as EVENT_OWNER_TYPES, Li as defineRecordKinds, Ln as applyModeDelaysEdits, Lr as mayWriteToLocation, Lt as NcRuleActionsSchema, M as EMBEDDING_MODEL_FAILED, Mi as CamProfileSchema, Mn as activateAlarmProfile, Mr as isSystemDelivery, Mt as NcAlarmSettingsPatchSchema, N as EMBEDDING_REQUIREMENTS_FAILED, Ni as RECORD_MAX_DATA_BYTES, Nn as addonWidgetsSourceCapability, Nr as isSystemEventSummaryRule, Nt as NcConditionDescriptorSchema, O as DETECTION_MACRO_CLASSES, Oi as isSourceCap, On as TrackRelationKindSchema, Or as isMediaOwnerType, Ot as NcAlarmConfigSchema, P as EMBEDDING_REQUIREMENTS_UNAVAILABLE, Pi as createEvent, Pn as alarmDeviceSecureOnArm, Pr as isVectorIndexDimConflict, Pt as NcConditionsSchema, Q as MOTION_CLOSE_AFTER_MS, Qi as partialRecord, Qn as createAlarmProfile, Qr as resolveModeNotifyPolicy, Qt as NcTemplatePreviewSchema, R as EXPORT_DENSE_MAX_RANGES, Ri as hydrateSchema, Rn as applyNonBlockingEdit, Rr as memoizePinnedFfmpeg, Rt as NcRuleInputSchema, S as ClearTrackRelationInputSchema, Si as vectorDimFromBase64, Sn as TIMELAPSE_DENSE_FLOOR_SEC, Sr as isDefaultAlarmProfileId, St as NC_SENSOR_TRANSITION_KINDS, T as DEFAULT_DETAIL_CROP_CONVENTION, Ti as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, Tn as TimelapseRulePatchSchema, Tr as isEventOwnerType, Tt as NC_TANK_SYSTEM_EVENT_KINDS, U as LabelAttributionSchema, Ui as ZodObject, Un as audioModeOf, Ur as pipelineAnalyticsCapability, Ut as NcScheduleSchema, V as FailureCounters, Vn as assertTimelapseCadences, Vt as NcRuleTargetSchema, W as ListTrackRelationsInputSchema, Wi as _enum, Wn as buildEventKindDescriptor, Wr as plateGalleryCapability, Wt as NcSharedSequenceSchema, X as MAX_TRACK_PURITIES, Xi as number, Xn as coreBlockIdFromAddonId, Xr as resolveLocationMode, Xt as NcTaxonomySchema, Y as MAX_BIRTH_LATENCY_PROXY_MS, Yi as looseObject, Yn as consumableLowPercentOf, Yr as resolveClipSearchMinScore, Yt as NcSystemEventKindSchema, Z as MAX_TRACK_RELATIONS, Zi as object, Zn as cosineSimilarity$1, Zr as resolveModeDelays, Zt as NcTemplatePreviewInputSchema, _ as BIRTH_DECISION_DEFAULT_LIMIT, _i as systemEventFilterApplies, _n as SCENE_RESET_RECAPTURES, _r as gifDeriveSpeed, _t as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, a as CLIP_EMBEDDING_STEP_ID, aa as unknown, ai as ruleGroupingApplies, an as RebuildObjectEmbeddingsRefusalSchema, ar as deviceRemovalHookCapability, at as NC_ALARM_NOTIFY_FIELDS, b as BucketAccumulator, bi as templateCarriesSummary, bn as SetTrackPurityResultSchema, br as isAppLinkBase, bt as NC_GROUPING_MAX_SEC, c as readClusterModelPinStrict, ci as secureActuationFor, cn as RetrainStatusSchema, cr as embeddingRefusalOf, ct as NC_AUDIO_CONFIRM_HITS_DEFAULT, d as APPEARANCE_BLOCKS, di as storageOccupancyCapability, dn as SCENE_DEFAULT_ANCHOR_THRESHOLD, dr as encodeVectorBase64, dt as NC_CLIP_PRE_ROLL_DEFAULT_SEC, ea as strictObject, ei as retrainRevisionConflictMessage, en as OPS_LOG_DEFAULT_LIMIT, er as deriveDetailCropRect, et as MotionTriggeredBySchema, f as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, fi as subKindsOf, fn as SCENE_DEFAULT_CHECK_INTERVAL_SEC, fr as ensureAlarmProfiles, ft as NC_CLIP_RETENTION_MAX_SEC, g as ArchivedDebugNoteSchema, gi as systemEventFamilyProblems, gn as SCENE_DIVERGED, gr as failureContributionCapability, gt as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, h as AlarmArmModeSchema, hi as systemEventDeliveryProblems, hn as SCENE_DEFAULT_UNCOVERED_POLICY, hr as faceGalleryCapability, ht as NC_CONFIRM_DEFAULT_TIMEOUT_MS, ia as union, ii as ruleDeviceCompatCapQueries, in as RECORDING_SOURCE_CAMSTACK_ADDON, ir as describeSystemEventFamilyProblem, it as NC_ALARM_DELAY_MAX_SEC, j as DetectionSourceSchema, ji as BaseAddon, jn as TrackSourceSchema, jr as isScheduleActive, jt as NcAlarmSensorsSchema, k as DETECTION_PIPELINE_CAP_NAME, ki as DeviceType, kn as TrackRelationSchema, kr as isRetiredClearKey, kt as NcAlarmPostTriggeredActionSchema, l as resolveClusterModelPin, li as sensorRaisedOf, ln as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, lt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, m as AUDIO_MACRO_LABELS, mi as syncActiveAlarmProfileSettings, mn as SCENE_DEFAULT_QUIET_SECONDS, mr as evictionPolicyOfLocation, mt as NC_CONFIRM_DEFAULT_MAX_IMAGE_PX, na as templateLiteral, ni as ruleAutoTriggersAlarm, nr as deriveRecordingMode, nt as NC_ALARM_DEFAULT_TRIGGERED_DURATION_SEC, o as CLUSTER_MODEL_OWNER_ADDON_ID, oa as EventCategory, oi as ruleKindOf, on as RetrainDismissedSchema, ot as NC_ALARM_SYSTEM_EVENT_KINDS, p as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, pi as summarizeReview, pn as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, pr as eventKindLabel, pt as NC_CONDITION_CATALOG, q as MAX_ARCHIVED_DEBUG_NOTES, qi as discriminatedUnion, qn as classifyRetrainReview, qr as readTimelapseGeneratedAt, qt as NcSnoozeSuppressedSchema, ra as tuple, ri as ruleBelongsToAlarm$1, rn as RECORDING_EXPORT_MAX_READ_BYTES, rr as describeSystemEventDeliveryProblem, rt as NC_ALARM_DELAY_FIELDS, s as FACE_EMBEDDING_STEP_ID, si as sceneMonitorCapability, sn as RetrainOriginSchema, st as NC_ALARM_TRIGGERED_MAX_SEC, t as BUILTIN_CLIP_MODELS, ta as string, ti as rootSupplyServes, tn as OpsLogEntrySchema, tr as derivePostTriggeredAction, tt as NC_ALARM_DEFAULT_PROFILE_ID, u as APPEARANCE_BIN_COUNT, ui as servedTemplateVars, un as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, ut as NC_CLIP_POST_ROLL_DEFAULT_SEC, v as BaseDevice, vi as systemEventSummaryScheduleOf, vn as SceneMonitorSchema, vr as gifFromMp4Args, vt as NC_DEFAULT_SNOOZE_MINUTES, w as CoverStateSchema, wi as zoneAnalyticsCapability, wn as TimelapseRuleInputSchema, wr as isEventKindLabelKey, wt as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, x as COCO_TO_MACRO, xi as templateVarsFor, xn as SetTrackRelationInputSchema, xr as isAudioClassName, xt as NC_GROUPING_MIN_SEC, y as BirthDecisionRecordSchema, yi as systemEventSummarySplitOf, yn as SetTrackPurityInputSchema, yr as isAlarmControllableCap, yt as NC_GROUPING_DEFAULT_SEC, z as FIRST_LEVEL_MACRO_CLASSES, zi as isDeviceScopedCap, zn as applySecureOnArmEdit, zr as notificationRulesCapability, zt as NcRulePatchSchema } from "../clip-model-registry-CTfe5v5_.mjs";
+import { $ as MediaFileKindEnum, $i as boolean, $n as coreBlockIdFromAddonId, $r as readTimelapseGeneratedAt, $t as NcTemplateVarDescriptorSchema, A as DeclaredDevices, Ai as viewerLinkBaseOf, An as TrackSideSchema, Ar as isEventOwnerType, At as NcAlarmSensorsInputSchema, B as FULL_IMAGE_BBOX, Bi as RECORD_MAX_DATA_BYTES, Bn as applyModeDelaysEdits, Br as kebabToCamel, Bt as NcRuleSchema, C as ClearTrackRelationResultSchema, Ci as systemEventFamilyProblems, Cn as TRACK_RELATIONS_DEFAULT_LIMIT, Cr as isAlertEpisodeOpen, Ct as NC_SNOOZE_MAX_MINUTES, D as DEFAULT_TIMELAPSE_PREVIEW_TEXT, Di as templateCarriesSummary, Dn as TrackPuritySchema, Dr as isDefaultAlarmProfileId, Dt as NC_TEMPLATE_VARS, E as DEFAULT_EVENT_COLOR, Ei as systemEventSummarySplitOf, En as TimelapseRuleSchema, Er as isAudioClassName, Et as NC_TAXONOMY, F as EVENT_DENSITY_BATCH_MAX, Fi as isSourceCap, Fn as alarmPanelCapability, Fr as isRootSuppliableStepId, Ft as NcLegacyRuleActionSequenceSchema, G as ListTrackRelationsResultSchema, Gi as hydrateSchema, Gn as audioMetricsCapability, Gr as occupancyScope, Gt as NcSnoozeInputSchema, H as LABEL_SUPPLY_MACRO, Hi as customAction, Hn as applySecureOnArmEdit, Hr as mayWriteToLocation, Ht as NcRuleUpdateInputSchema, I as EVENT_KIND_BY_CAP, Ii as DeviceType, In as alertEpisodeId, Ir as isScheduleActive, It as NcRuleActionSchema, J as MAX_BIRTH_DECISION_RECORDS, Jn as buildViewerLink, Jr as pickFaceRescoreIntervalMinutes, Jt as NcStateSummarySectionIdSchema, K as LockStateSchema, Ki as isDeviceScopedCap, Kn as audioModeOf, Kr as parseAlertEpisodePayload, Kt as NcSnoozeSchema, L as EVENT_OWNER_TYPES, Li as errMsg, Ln as alertEpisodeKind, Lr as isSystemDelivery, Lt as NcRuleActionsSchema, M as EMBEDDING_MODEL_FAILED, Mi as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, Mn as activateAlarmProfile, Mr as isLabelSupplyStepId, Mt as NcAlarmSettingsPatchSchema, N as EMBEDDING_REQUIREMENTS_FAILED, Ni as canonicalHash, Nn as addonWidgetsSourceCapability, Nr as isMediaOwnerType, Nt as NcConditionDescriptorSchema, O as DETECTION_MACRO_CLASSES, Oi as templateVarsFor, On as TrackRelationKindSchema, Or as isDetectionMacroClass, Ot as NcAlarmConfigSchema, P as EMBEDDING_REQUIREMENTS_UNAVAILABLE, Pi as evaluateSensorEdge, Pn as alarmDeviceSecureOnArm, Pr as isRetiredClearKey, Pt as NcConditionsSchema, Q as MOTION_CLOSE_AFTER_MS, Qi as array, Qn as consumableLowPercentOf, Qr as readMotionTriggeredBy, Qt as NcTemplatePreviewSchema, R as EXPORT_DENSE_MAX_RANGES, Ri as BaseAddon, Rn as alertEpisodePayload, Rr as isSystemEventSummaryRule, Rt as NcRuleInputSchema, S as ClearTrackRelationInputSchema, Si as systemEventDeliveryProblems, Sn as TIMELAPSE_DENSE_FLOOR_SEC, Sr as isAlarmControllableCap, St as NC_SENSOR_TRANSITION_KINDS, T as DEFAULT_DETAIL_CROP_CONVENTION, Ti as systemEventSummaryScheduleOf, Tn as TimelapseRulePatchSchema, Tr as isAppLinkBase, Tt as NC_TANK_SYSTEM_EVENT_KINDS, U as LabelAttributionSchema, Ui as defineCustomActions, Un as armRemovalReconcile, Ur as memoizePinnedFfmpeg, Ut as NcScheduleSchema, V as FailureCounters, Vi as createEvent, Vn as applyNonBlockingEdit, Vr as linkedStepOf, Vt as NcRuleTargetSchema, W as ListTrackRelationsInputSchema, Wi as defineRecordKinds, Wn as assertTimelapseCadences, Wr as notificationRulesCapability, Wt as NcSharedSequenceSchema, X as MAX_TRACK_PURITIES, Xi as ZodObject, Xn as classifyRetrainReview, Xr as plateGalleryCapability, Xt as NcTaxonomySchema, Y as MAX_BIRTH_LATENCY_PROXY_MS, Yi as sleep$1, Yn as calendarEventLocalSpan, Yr as pipelineAnalyticsCapability, Yt as NcSystemEventKindSchema, Z as MAX_TRACK_RELATIONS, Zi as _enum, Zn as cloneAlarmSettings, Zr as readDeviceStateFrom, Zt as NcTemplatePreviewInputSchema, _ as BIRTH_DECISION_DEFAULT_LIMIT, _i as startMoverUnderClearance, _n as SCENE_RESET_RECAPTURES, _r as evictionPolicyOfLocation, _t as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, a as CLIP_EMBEDDING_STEP_ID, aa as partialRecord, an as RebuildObjectEmbeddingsRefusalSchema, ar as deriveRecordingMode, at as NC_ALARM_NOTIFY_FIELDS, b as BucketAccumulator, bi as summarizeReview, bn as SetTrackPurityResultSchema, br as gifDeriveSpeed, bt as NC_GROUPING_MAX_SEC, c as readClusterModelPinStrict, ca as string, ci as ruleAutoTriggersAlarm, cn as RetrainStatusSchema, cr as deviceRemovalHookCapability, ct as NC_AUDIO_CONFIRM_HITS_DEFAULT, d as APPEARANCE_BLOCKS, da as union, di as ruleGroupingApplies, dn as SCENE_DEFAULT_ANCHOR_THRESHOLD, dr as embeddingRefusalOf, dt as NC_CLIP_PRE_ROLL_DEFAULT_SEC, ea as discriminatedUnion, ei as renameAlarmProfile, en as OPS_LOG_DEFAULT_LIMIT, er as cosineSimilarity$1, et as MotionTriggeredBySchema, f as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, fa as unknown, fi as ruleKindOf, fn as SCENE_DEFAULT_CHECK_INTERVAL_SEC, ft as NC_CLIP_RETENTION_MAX_SEC, g as ArchivedDebugNoteSchema, gi as servedTemplateVars, gn as SCENE_DIVERGED, gr as eventKindLabel, gt as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, h as AlarmArmModeSchema, hi as sensorRaisedOf, hn as SCENE_DEFAULT_UNCOVERED_POLICY, hr as ensureAlarmProfiles, ht as NC_CONFIRM_DEFAULT_TIMEOUT_MS, ia as object, ii as resolveModeNotifyPolicy, in as RECORDING_SOURCE_CAMSTACK_ADDON, ir as derivePostTriggeredAction, it as NC_ALARM_DELAY_MAX_SEC, j as DetectionSourceSchema, ji as zoneAnalyticsCapability, jn as TrackSourceSchema, jr as isKnownTemplateVar, jt as NcAlarmSensorsSchema, k as DETECTION_PIPELINE_CAP_NAME, ki as vectorDimFromBase64, kn as TrackRelationSchema, kr as isEventKindLabelKey, kt as NcAlarmPostTriggeredActionSchema, l as resolveClusterModelPin, la as templateLiteral, li as ruleBelongsToAlarm$1, ln as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, lt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, m as AUDIO_MACRO_LABELS, mi as secureActuationFor, mn as SCENE_DEFAULT_QUIET_SECONDS, mr as encodeVectorBase64, mt as NC_CONFIRM_DEFAULT_MAX_IMAGE_PX, na as looseObject, ni as resolveLocationMode, nr as deleteAlarmProfile, nt as NC_ALARM_DEFAULT_TRIGGERED_DURATION_SEC, o as CLUSTER_MODEL_OWNER_ADDON_ID, oa as record, oi as retrainRevisionConflictMessage, on as RetrainDismissedSchema, or as describeSystemEventDeliveryProblem, ot as NC_ALARM_SYSTEM_EVENT_KINDS, p as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, pa as EventCategory, pi as sceneMonitorCapability, pn as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, pt as NC_CONDITION_CATALOG, q as MAX_ARCHIVED_DEBUG_NOTES, qi as nodePin, qn as buildEventKindDescriptor, qt as NcSnoozeSuppressedSchema, ra as number, ri as resolveModeDelays, rn as RECORDING_EXPORT_MAX_READ_BYTES, rr as deriveDetailCropRect, rt as NC_ALARM_DELAY_FIELDS, s as FACE_EMBEDDING_STEP_ID, sa as strictObject, si as rootSupplyServes, sn as RetrainOriginSchema, sr as describeSystemEventFamilyProblem, st as NC_ALARM_TRIGGERED_MAX_SEC, t as BUILTIN_CLIP_MODELS, ta as literal, ti as resolveClipSearchMinScore, tn as OpsLogEntrySchema, tr as createAlarmProfile, tt as NC_ALARM_DEFAULT_PROFILE_ID, u as APPEARANCE_BIN_COUNT, ua as tuple, ui as ruleDeviceCompatCapQueries, un as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, ut as NC_CLIP_POST_ROLL_DEFAULT_SEC, v as BaseDevice, vi as storageOccupancyCapability, vn as SceneMonitorSchema, vr as faceGalleryCapability, vt as NC_DEFAULT_SNOOZE_MINUTES, w as CoverStateSchema, wi as systemEventFilterApplies, wn as TimelapseRuleInputSchema, wr as isAlertEpisodeSeverity, wt as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, x as COCO_TO_MACRO, xi as syncActiveAlarmProfileSettings, xn as SetTrackRelationInputSchema, xr as gifFromMp4Args, xt as NC_GROUPING_MIN_SEC, y as BirthDecisionRecordSchema, yi as subKindsOf, yn as SetTrackPurityInputSchema, yr as failureContributionCapability, yt as NC_GROUPING_DEFAULT_SEC, z as FIRST_LEVEL_MACRO_CLASSES, zi as CamProfileSchema, zn as applyBlockingEdit, zr as isVectorIndexDimConflict, zt as NcRulePatchSchema } from "../clip-model-registry-BItfTZEx.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs$1 from "node:fs";
 import { createWriteStream, promises } from "node:fs";
@@ -10273,6 +10273,7 @@ var NC_SYSTEM_STATE_LEGACY = "notification-center:system-state";
 var NC_OCCUPANCY_LEGACY = "notification-center:occupancy";
 var NC_DEVICE_PRUNES_LEGACY = "notification-center:device-prunes";
 var NC_STATE_SUMMARY_STAMPS_LEGACY = "notification-center:state-summary-stamps";
+var NC_ALERT_EPISODES_LEGACY = "notification-center:alert-episodes";
 var NC_META_LEGACY = "notification-center:meta";
 var NC_SNOOZES_LEGACY = "notification-center:snoozes";
 var NC_SNOOZE_SUPPRESSED_LEGACY = "notification-center:snooze-suppressed";
@@ -10293,6 +10294,7 @@ var ncDurableRecordKinds = defineRecordKinds({
 	liveness: ledger(NC_LIVENESS_LEGACY, "a liveness state TRANSITION the centre accepted (seed or flip); a no-flip writes nothing"),
 	"device-alerts": ledger(NC_DEVICE_ALERTS_LEGACY, "a sustained device alert episode the centre confirmed or cleared"),
 	"system-state": ledger(NC_SYSTEM_STATE_LEGACY, "a system-state subject flip the state summary accepted"),
+	"alert-episodes": ledger(NC_ALERT_EPISODES_LEGACY, "an alert episode the centre notified (critical or error); its resolution deletes the row"),
 	occupancy: ledger(NC_OCCUPANCY_LEGACY, "a confirmed occupancy level write-through after the watcher decided an edge"),
 	"device-prunes": ledger(NC_DEVICE_PRUNES_LEGACY, "one row recording what a deleted-device prune removed"),
 	"state-summary-stamps": ledger(NC_STATE_SUMMARY_STAMPS_LEGACY, "digest delivery stamps per rule kind"),
@@ -10312,6 +10314,7 @@ var NC_PHASE3_RECORD_BACKED_LEGACY_COLLECTIONS = [
 	NC_LIVENESS_LEGACY,
 	NC_DEVICE_ALERTS_LEGACY,
 	NC_SYSTEM_STATE_LEGACY,
+	NC_ALERT_EPISODES_LEGACY,
 	NC_OCCUPANCY_LEGACY,
 	NC_DEVICE_PRUNES_LEGACY,
 	NC_STATE_SUMMARY_STAMPS_LEGACY,
@@ -10733,6 +10736,120 @@ var NcAlertStore = class {
 	}
 };
 //#endregion
+//#region src/notification-center/alert-episode-ledger.ts
+/**
+* @durable class=ledger owner=notification-center
+*   write="an alert episode the centre notified (alert-critical / alert-error); its resolution deletes the row"
+*   retention="a row lives while its episode is open. A row whose alert was pruned by the alert centre's own retention is dropped after NC_ALERT_EPISODE_MAX_AGE_MS by the reconcile, never on absence alone (D49)."
+*/
+var NC_ALERT_EPISODES_COLLECTION = "notification-center:alert-episodes";
+var NC_ALERT_EPISODES_COLUMNS = [
+	{
+		name: "episodeId",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	(
+	/** The kind that was notified: `alert-critical` or `alert-error`. */
+	{
+		name: "kind",
+		type: "TEXT",
+		notNull: true
+	}),
+	{
+		name: "alertId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "since",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+/** Longer than the alert centre's maximum retention (365 days). */
+var NC_ALERT_EPISODE_MAX_AGE_MS = 400 * 24 * 60 * 60 * 1e3;
+function isEpisodeKind(value) {
+	return value === "alert-critical" || value === "alert-error";
+}
+var NC_ALERT_EPISODES_SPEC = {
+	collection: NC_ALERT_EPISODES_COLLECTION,
+	columns: NC_ALERT_EPISODES_COLUMNS,
+	writeMode: "write-behind",
+	keyOf: (row) => row.episodeId,
+	toValue: (row) => ({
+		kind: row.kind,
+		alertId: row.alertId,
+		since: row.since
+	}),
+	fromRecord: (key, data) => {
+		const kind = data["kind"];
+		const alertId = data["alertId"];
+		const since = data["since"];
+		if (!isEpisodeKind(kind) || typeof alertId !== "string" || typeof since !== "number") return null;
+		return {
+			episodeId: key,
+			kind,
+			alertId,
+			since
+		};
+	}
+};
+NC_ALERT_EPISODES_SPEC.fromRecord, NC_ALERT_EPISODES_SPEC.toValue;
+var NcAlertEpisodeLedger = class {
+	ledger;
+	constructor(deps) {
+		this.ledger = new DurableLedger({
+			spec: NC_ALERT_EPISODES_SPEC,
+			kind: resolveDurableKind(NC_ALERT_EPISODES_SPEC, ncDurableRecordKinds["alert-episodes"], deps),
+			logger: deps.logger
+		});
+	}
+	static declare(store) {
+		return declareDurableSpecLegacy(store, NC_ALERT_EPISODES_SPEC);
+	}
+	async load() {
+		return (await this.ledger.load()).length;
+	}
+	/** Has a load READ the store once? Until then the mirror is not the truth. */
+	hasAnswered() {
+		return this.ledger.hasAnswered();
+	}
+	has(episodeId) {
+		return this.ledger.has(episodeId);
+	}
+	snapshot() {
+		return this.ledger.snapshot();
+	}
+	/**
+	* Judge one announced edge and advance the ledger. Synchronous: the verdict
+	* is a function of the mirror (D49); the durable write trails it.
+	*/
+	admit(edge, now) {
+		const held = this.ledger.get(edge.episodeId);
+		if (edge.phase === "raised") {
+			if (edge.kind !== "alert-critical" && edge.kind !== "alert-error") return "duplicate";
+			if (held !== void 0 && (held.kind === "alert-critical" || edge.kind === "alert-error")) return "duplicate";
+			this.ledger.put({
+				episodeId: edge.episodeId,
+				kind: edge.kind,
+				alertId: edge.alertId,
+				since: held?.since ?? now
+			});
+			return "notify";
+		}
+		if (held === void 0) return "unknown-episode";
+		this.ledger.forget(edge.episodeId);
+		return held.kind === "alert-critical" && edge.kind === "alert-critical-resolved" ? "notify" : "closed-silently";
+	}
+	/** Drop rows older than the alert centre could still hold the alert. */
+	async pruneOlderThan(cutoffMs) {
+		const keep = new Set(this.ledger.snapshot().filter((row) => row.since >= cutoffMs).map((row) => row.episodeId));
+		return this.ledger.pruneExcept(keep);
+	}
+};
+//#endregion
 //#region src/notification-center/device-prune-ledger.ts
 /**
 * @durable class=ledger owner=notification-center
@@ -16018,6 +16135,34 @@ function bestMatchingKindPreference(signal, ownerKind) {
 }
 //#endregion
 //#region src/notification-center/event-intake.ts
+/**
+* The notification path's INTAKE SEAM — one event in, no knowledge of who
+* produced it.
+*
+* Why this file exists at all: until now every producer reached the centre
+* through its own record-shaped door (`onObjectEventPersisted(ObjectEvent)`,
+* `onSensorEventPersisted(SensorEvent)`, …). The doors did nothing but build a
+* subject and schedule an evaluation, yet their SIGNATURES made the notification
+* path look like a function of the pipeline's row types — so "notify about this"
+* was not expressible without first having a persisted row to hand.
+*
+* The split this file draws is between PRODUCING an event and CONSUMING one:
+*
+*   - The producer owns persistence. The tracker persists its tracks, the sensor
+*     ingest persists its rows, and a synthetic producer (the rule tester)
+*     persists NOTHING. Whether a row exists is the producer's business and
+*     never the consumer's.
+*   - The consumer owns match → media → delivery. It receives an
+*     {@link NcIncomingEvent} and cannot tell which producer built it, because
+*     the only thing the matcher can read is `subject`, and `subject` carries no
+*     provenance beyond the detection `source` a real record would carry anyway.
+*
+* {@link NcIncomingEvent.origin} exists for LOGS, and for the outbox row's
+* marker. It is deliberately NOT part of `NcRuleSubject`: a condition cannot
+* reach it, so no rule can be authored that behaves differently for a test. That
+* is the property the tester is worth nothing without — a test that takes a
+* different branch is a test of the branch, not of the rule.
+*/
 /** Object-event insert (movement-state transitions + zone crossings). */
 function incomingFromObjectEvent(event) {
 	return {
@@ -16861,9 +17006,45 @@ 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);
 		default: return null;
 	}
 }
+/**
+* An alert episode edge (`alert-critical`, `alert-error`, `alert-critical-resolved`).
+*
+* The WORDS are the alert's own: the alert centre composed the title and the
+* message when it opened the alert, and a rule's template may reword them with
+* `{{title}}`, `{{message}}`, `{{severity}}`, `{{category}}`, `{{source}}`,
+* `{{node}}` and `{{actionUrl}}`. The subject is the EPISODE, so the dedup slot
+* of a new episode is never the one a previous, resolved, episode held.
+*
+* 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) {
+	const payload = parseAlertEpisodePayload(facts.data);
+	if (payload === null) return null;
+	const kind = alertEpisodeKind(payload.severity, payload.phase);
+	if (kind === null) return null;
+	return systemSubject({
+		facts,
+		kind,
+		subject: `alert:${payload.episodeId}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body`,
+		textParams: {
+			title: payload.title,
+			message: payload.message,
+			severity: payload.severity,
+			category: payload.category,
+			source: payload.sourceId ?? "",
+			nodeId: payload.nodeId ?? "",
+			actionUrl: payload.actionUrl ?? ""
+		},
+		...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([
@@ -19346,6 +19527,7 @@ async function declareNcPhase3SettingsStoreLegacyCollections(store) {
 async function declareNcPhase3RecordBackedLegacyCollections(store) {
 	await OccupancyStore.declare(store);
 	await NcLivenessLedger.declare(store);
+	await NcAlertEpisodeLedger.declare(store);
 	await NcAlertStore.declare(store);
 	await NcStateSummaryService.declare(store);
 	await NcSnoozeStore.declare(store);
@@ -32855,6 +33037,12 @@ var en_default = {
 	"system.backup-completed.title": "Backup completed",
 	"system.backup-completed.body": "Backup saved to {{destinationsOk}} of {{destinationsTotal}} destinations ({{sizeMB}} MB)",
 	"system.backup-completed.body.partial": "Backup saved to {{destinationsOk}} of {{destinationsTotal}} destinations — {{destinationsFailed}} failed",
+	"system.alert-critical.title": "{{title}}",
+	"system.alert-critical.body": "{{message}}",
+	"system.alert-error.title": "{{title}}",
+	"system.alert-error.body": "{{message}}",
+	"system.alert-critical-resolved.title": "Resolved: {{title}}",
+	"system.alert-critical-resolved.body": "{{message}}",
 	"system.device-consumable-low.title": "Consumable low — {{deviceName}}",
 	"system.device-consumable-low.body": "{{item}} on {{deviceName}} is at {{percentage}}%",
 	"system.device-consumable-low.body.unmeasured": "{{item}} on {{deviceName}} needs replacing",
@@ -33235,6 +33423,12 @@ var it_default = {
 	"system.backup-completed.title": "Backup completato",
 	"system.backup-completed.body": "Backup salvato su {{destinationsOk}} destinazioni su {{destinationsTotal}} ({{sizeMB}} MB)",
 	"system.backup-completed.body.partial": "Backup salvato su {{destinationsOk}} destinazioni su {{destinationsTotal}} — {{destinationsFailed}} fallite",
+	"system.alert-critical.title": "{{title}}",
+	"system.alert-critical.body": "{{message}}",
+	"system.alert-error.title": "{{title}}",
+	"system.alert-error.body": "{{message}}",
+	"system.alert-critical-resolved.title": "Risolto: {{title}}",
+	"system.alert-critical-resolved.body": "{{message}}",
 	"system.device-consumable-low.title": "Consumabile basso — {{deviceName}}",
 	"system.device-consumable-low.body": "{{item}} su {{deviceName}} è al {{percentage}}%",
 	"system.device-consumable-low.body.unmeasured": "{{item}} su {{deviceName}} va sostituito",
@@ -35210,6 +35404,7 @@ function systemEventSubject(kind, scope) {
 	if (kind === "node-updating") return `node-updating:${scope.nodeId ?? "hub"}:1.0.1`;
 	if (kind === "export-completed") return `export:${scope.deviceId ?? 0}`;
 	if (kind === "backup-completed") return "backup:test";
+	if (kind.startsWith("alert-")) return "alert:test";
 	return `alarm:${scope.deviceId ?? 0}`;
 }
 /**
@@ -35350,7 +35545,12 @@ function planRuleTest(input) {
 					nodes: "hub",
 					fromVersion: "1.0.0",
 					toVersion: "1.0.1",
-					title: "Export",
+					title: systemEventKind.startsWith("alert-") ? "Recording location full" : "Export",
+					message: "No free space left on the recording location",
+					severity: systemEventKind === "alert-error" ? "error" : "critical",
+					category: "recorder.placement",
+					source: "recorder",
+					actionUrl: "/system/addons",
 					count: "1"
 				},
 				...systemScope.deviceId !== void 0 ? { deviceId: systemScope.deviceId } : {},
@@ -51921,6 +52121,10 @@ function groupedAlarmPhaseKey(ruleId, trackId) {
 var NO_MATCH_REPORT_INTERVAL_MS = 6e4;
 var DEFAULT_DRAIN_INTERVAL_MS = 2e3;
 var DEFAULT_RULE_RELOAD_INTERVAL_MS = 3e4;
+/** How often open critical/error alerts are reconciled against the notified episodes. */
+var NC_ALERT_RECONCILE_INTERVAL_MS = 5 * 6e4;
+/** The most alerts one reconcile reads (the alert centre's own ceiling). */
+var NC_ALERT_RECONCILE_LIMIT = 5e3;
 var DEFAULT_RECONCILE_WINDOW_MS = 15 * 6e4;
 /** Overlap subtracted from the watermark on boot (idempotent, cheap). */
 var RECONCILE_OVERLAP_MS = 6e4;
@@ -52493,6 +52697,15 @@ var NotificationCenter = class {
 	* seeds, only a real flip notifies.
 	*/
 	liveness;
+	/**
+	* Which alert episodes were already notified (`alert-episode-ledger.ts`): the
+	* alert centre sends nothing of its own, so this is what makes its bus
+	* announcements and the reconcile from the alerts store safe to run together.
+	*/
+	alertEpisodes;
+	/** The boot load of {@link alertEpisodes} has been ATTEMPTED (bus edges before it are the reconcile's). */
+	alertEpisodesLoaded = false;
+	alertReconcileTimer = null;
 	/** Batches `addon.updated` (version-bearing) into one notification per 30 s. */
 	addonUpdates;
 	/** Trailing 5 min hold-off for camera liveness flaps (plugin restart). */
@@ -53194,6 +53407,10 @@ var NotificationCenter = class {
 			...durableStore,
 			logger: this.logger.child("liveness")
 		});
+		this.alertEpisodes = new NcAlertEpisodeLedger({
+			...durableStore,
+			logger: this.logger.child("alert-episodes")
+		});
 		this.addonUpdates = new AddonUpdateCoalescer((updates) => {
 			const incoming = incomingFromAddonUpdates({
 				eventId: `addon-updated:${updates.map((u) => u.packageName).join(",")}`,
@@ -53590,6 +53807,10 @@ var NotificationCenter = class {
 		this.reloadTimer = setInterval(() => {
 			this.reloadRules();
 		}, this.deps.ruleReloadIntervalMs ?? DEFAULT_RULE_RELOAD_INTERVAL_MS);
+		this.alertReconcileTimer = setInterval(() => {
+			this.reconcileAlertEpisodes();
+		}, this.deps.alertReconcileIntervalMs ?? NC_ALERT_RECONCILE_INTERVAL_MS);
+		this.alertReconcileTimer.unref?.();
 		const timelapseScheduler = this.timelapseScheduler;
 		if (timelapseScheduler !== null) await timed("timelapseProducer", () => timelapseScheduler.start()).catch((err) => {
 			this.logger.warn("timelapse producer did not start", { meta: { error: String(err) } });
@@ -53705,6 +53926,7 @@ var NotificationCenter = class {
 			await this.deviceDirectory.refresh();
 		})) return;
 		if (!await phase("liveness", () => this.hydrateLiveness())) return;
+		if (!await phase("alertEpisodes", () => this.hydrateAlertEpisodes())) return;
 		if (!await phase("deviceAlerts", async () => {
 			const rows = await this.alertStore.load();
 			this.logger.info("device alert ledger reseeded", { meta: { rows } });
@@ -53747,6 +53969,10 @@ var NotificationCenter = class {
 			clearInterval(this.reloadTimer);
 			this.reloadTimer = null;
 		}
+		if (this.alertReconcileTimer !== null) {
+			clearInterval(this.alertReconcileTimer);
+			this.alertReconcileTimer = null;
+		}
 		this.timelapseScheduler?.stop();
 		this.summaryProducer?.stop();
 		await this.closeGroupedWindowsOnStop();
@@ -54758,6 +54984,10 @@ var NotificationCenter = class {
 			return;
 		}
 		this.stateSummary.observeRawEvent(event.category, event.data, this.now(), event.source.nodeId);
+		if (event.category === "alert.episode") {
+			if (this.alertEpisodesLoaded) this.admitAlertEpisode(event, "bus");
+			return;
+		}
 		if (event.category === "addon.started" || event.category === "addon.restarted") return;
 		if (event.category === "pipeline.camera-assigned") return;
 		const battery = batterySliceOf(event);
@@ -54791,10 +55021,6 @@ var NotificationCenter = class {
 		const system = incoming.subject.systemEvent;
 		if (system !== void 0) this.stateSummary.observeSystem(system, this.now());
 		if (system !== void 0) this.updateLandings.observe(system, this.now());
-		if (system !== void 0 && system.kind === "addon-crash-loop") {
-			this.logger.debug("addon-crash-loop is pushed by the hub alert centre, not by a rule", { meta: { subject: system.subject } });
-			return;
-		}
 		const observation = system !== void 0 ? ledgeredLiveness(system) : null;
 		if (observation !== null) {
 			const previous = this.liveness.stateOf(observation.subject);
@@ -57446,6 +57672,89 @@ var NotificationCenter = class {
 		await this.occupancyStore.pruneExcept(this.activeOccupancyKeys());
 	}
 	/**
+	* One edge of an alert episode, from the bus or from the reconcile. The
+	* ledger decides whether it is news; only news reaches the rules.
+	*/
+	admitAlertEpisode(event, via) {
+		const payload = parseAlertEpisodePayload(event.data);
+		if (payload === null) {
+			this.logger.warn("alert episode event with an unreadable payload ignored", { meta: {
+				via,
+				eventId: event.id
+			} });
+			return false;
+		}
+		const verdict = this.alertEpisodes.admit({
+			kind: alertEpisodeKind(payload.severity, payload.phase),
+			phase: payload.phase,
+			episodeId: payload.episodeId,
+			alertId: payload.alertId
+		}, this.now());
+		const meta = {
+			via,
+			alertId: payload.alertId,
+			episodeId: payload.episodeId,
+			phase: payload.phase,
+			severity: payload.severity,
+			verdict
+		};
+		if (verdict !== "notify") {
+			this.logger.debug("alert episode edge not notified", { meta });
+			return false;
+		}
+		const incoming = incomingFromSystemEvent(event, this.deviceDirectory.lookup());
+		if (incoming === null) return false;
+		this.logger.info("alert episode notified to the rules", { meta });
+		this.consumeEvent(incoming);
+		return true;
+	}
+	async hydrateAlertEpisodes() {
+		try {
+			const rows = await this.alertEpisodes.load();
+			this.logger.info("alert episode ledger reseeded", { meta: { rows } });
+		} finally {
+			this.alertEpisodesLoaded = true;
+		}
+		await this.reconcileAlertEpisodes();
+	}
+	/**
+	* The alerts store against the notified episodes (D11, D49): every OPEN
+	* critical/error alert not yet notified is notified, and every notified
+	* episode whose alert is CLOSED gets its resolution. Never runs on a ledger
+	* the store has not answered — an empty, unread mirror would re-notify every
+	* open alert — and never reads absence as closure: an alert that is not in
+	* the answer is left alone (rows age out by {@link NC_ALERT_EPISODE_MAX_AGE_MS}).
+	*/
+	async reconcileAlertEpisodes() {
+		const read = this.deps.readAlerts;
+		if (read === void 0 || !this.evaluationActive || !this.alertEpisodes.hasAnswered()) return;
+		let alerts;
+		try {
+			alerts = await read();
+		} catch (err) {
+			this.logger.warn("alert episode reconcile could not read the alerts", { meta: { error: errMsg(err) } });
+			return;
+		}
+		let notified = 0;
+		for (const alert of alerts) {
+			const episodeId = alertEpisodeId(alert);
+			const open = isAlertEpisodeOpen(alert.status);
+			if (open && !isAlertEpisodeSeverity(alert.severity)) continue;
+			if (!open && !this.alertEpisodes.has(episodeId)) continue;
+			const phase = open ? "raised" : "resolved";
+			if (this.admitAlertEpisode(createEvent(EventCategory.AlertEpisode, {
+				type: "addon",
+				id: "notification-center"
+			}, alertEpisodePayload(alert, phase, this.now())), "reconcile")) notified += 1;
+		}
+		const pruned = alerts.length < NC_ALERT_RECONCILE_LIMIT ? await this.alertEpisodes.pruneOlderThan(this.now() - NC_ALERT_EPISODE_MAX_AGE_MS) : 0;
+		if (notified > 0 || pruned > 0) this.logger.info("alert episodes reconciled", { meta: {
+			alerts: alerts.length,
+			notified,
+			pruned
+		} });
+	}
+	/**
 	* Boot reseed of the durable liveness ledger.
 	*
 	* The count is said OUT LOUD at info, because it is the one line that
@@ -94546,6 +94855,62 @@ function pickWritableMediaLocation(locations, stickyId) {
 	return writable.toSorted((a, b) => b.headroomBytes - a.headroomBytes || a.id.localeCompare(b.id))[0]?.id ?? null;
 }
 //#endregion
+//#region src/pipeline-analytics/event-media-write-location.ts
+var EventMediaWriteLocator = class {
+	deps;
+	cached = null;
+	/**
+	* The last location actually picked. Survives {@link invalidate}, so a ring
+	* keeps writing where it was writing while that stays writable — the
+	* stickiness the class default used to provide (D383).
+	*/
+	lastPick = null;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Drop the cached pick: the next write re-reads the location set. */
+	invalidate() {
+		this.cached = null;
+	}
+	async resolve(logger, deviceId) {
+		if (this.cached !== null) return this.cached;
+		let locations;
+		try {
+			locations = await this.deps.list();
+		} catch (err) {
+			logger.debug("pipeline-analytics: eventMedia location list unavailable — writing through the default ref", { meta: { error: errMsg(err) } });
+			this.cached = DEFAULT_MEDIA_LOCATION;
+			return DEFAULT_MEDIA_LOCATION;
+		}
+		const picked = pickWritableMediaLocation(locations.map((l) => ({
+			id: l.id,
+			mode: resolveLocationMode(l),
+			headroomBytes: l.capacity?.availableBytes ?? 0
+		})), this.lastPick ?? void 0);
+		if (picked === null) {
+			const seen = locations.length > 0 ? locations.map((l) => l.id).join(", ") : "(none registered)";
+			logger.error("pipeline-analytics: no writable eventMedia storage location — refusing the write instead of failing far downstream as a filesystem error", {
+				tags: { deviceId },
+				meta: { locationsSeen: seen }
+			});
+			throw new Error(`no writable eventMedia storage location (seen: ${seen})`);
+		}
+		this.cached = picked;
+		this.lastPick = picked;
+		return picked;
+	}
+};
+/**
+* Ring the locator from the location-set doorbell. `onRing` lets the caller drop
+* its other location-derived caches in the same breath.
+*/
+function subscribeEventMediaWriteLocator(eventBus, locator, onRing) {
+	return eventBus.subscribe({ category: EventCategory.StorageLocationsChanged }, () => {
+		locator.invalidate();
+		onRing();
+	});
+}
+//#endregion
 //#region src/pipeline-analytics/media-relocate-engine.ts
 /**
 * Event-media relocation engine (entity-routing spec, Phase 4) — the
@@ -104539,7 +104904,8 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	EventCategory.SystemRestartCompleted,
 	EventCategory.SystemRestarting,
 	EventCategory.RecordingExportCompleted,
-	EventCategory.BackupRunCompleted
+	EventCategory.BackupRunCompleted,
+	EventCategory.AlertEpisode
 ];
 /**
 * Install the addon's bus subscriptions. Identical set + relative order to the
@@ -107427,6 +107793,15 @@ Object.freeze({
 		"valueType": "boolean"
 	}],
 	"dishwasher": [
+		{
+			"path": "availability",
+			"valueType": "enum",
+			"enumValues": [
+				"available",
+				"offline",
+				"description-missing"
+			]
+		},
 		{
 			"path": "state",
 			"valueType": "enum",
@@ -107439,12 +107814,35 @@ Object.freeze({
 				"unavailable"
 			]
 		},
+		{
+			"path": "operationState",
+			"valueType": "enum",
+			"enumValues": [
+				"Inactive",
+				"Ready",
+				"DelayedStart",
+				"Run",
+				"Pause",
+				"ActionRequired",
+				"Finished",
+				"Error",
+				"Aborting"
+			]
+		},
 		{
 			"path": "program",
 			"valueType": "string"
 		},
 		{
-			"path": "remainingMinutes",
+			"path": "selectedProgram",
+			"valueType": "string"
+		},
+		{
+			"path": "remainingSeconds",
+			"valueType": "number"
+		},
+		{
+			"path": "delayedStartSeconds",
 			"valueType": "number"
 		},
 		{
@@ -107455,14 +107853,30 @@ Object.freeze({
 			"path": "doorOpen",
 			"valueType": "boolean"
 		},
+		{
+			"path": "doorLocked",
+			"valueType": "boolean"
+		},
 		{
 			"path": "remoteStartAllowed",
 			"valueType": "boolean"
 		},
+		{
+			"path": "remoteControlActive",
+			"valueType": "boolean"
+		},
+		{
+			"path": "localControlActive",
+			"valueType": "boolean"
+		},
 		{
 			"path": "powerOn",
 			"valueType": "boolean"
 		},
+		{
+			"path": "powerState",
+			"valueType": "string"
+		},
 		{
 			"path": "saltLevel",
 			"valueType": "enum",
@@ -113784,20 +114198,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	mediaRelocate = null;
 	mediaLocationStorage = null;
 	/**
-	* Cached pick for NEW `eventMedia` writes (`pickWritableMediaLocation`).
-	* Resolved once, never per blob (no-RPC-per-blob, same discipline as
-	* `mediaLocationStorage`'s own root cache) — dropped together with it by
-	* `refreshStorageLocationsForMigration`, since a location's `readOnly` /
-	* `enabled` flags only change via operator reconfig.
-	*/
-	eventMediaWriteLocationCache = null;
-	/**
-	* The last location this process actually picked for an `eventMedia` write.
-	* Survives the cache invalidation a migration performs, so a refresh keeps
-	* writing where it was writing while that stays writable — the stickiness the
-	* class default used to provide before it was deleted (D383).
+	* Where NEW `eventMedia` writes land. Its pick is cached per location-set
+	* generation and dropped by the `StorageLocationsChanged` doorbell (D387) and
+	* by `refreshStorageLocationsForMigration`, so a mode change or a repoint takes
+	* effect without a restart.
 	*/
-	lastEventMediaWritePick = null;
+	eventMediaWriteLocator = null;
+	eventMediaLocationDoorbellUnsub = null;
 	mediaWriteGate = new MediaWriteGate();
 	storageMigrationLeaseId = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
@@ -115837,33 +116244,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	}
 	/** One line per process: this repeats on every occupancy refresh otherwise. */
 	mediaOccupancyUnattributedLogged = false;
-	async resolveEventMediaWriteLocation(api, logger, deviceId) {
-		const cached = this.eventMediaWriteLocationCache;
-		if (cached !== null) return cached;
-		let locations;
-		try {
-			locations = await api.storage.listLocations.query({ type: DEFAULT_MEDIA_LOCATION });
-		} catch (err) {
-			logger.debug("pipeline-analytics: eventMedia location list unavailable — writing through the default ref", { meta: { error: errMsg(err) } });
-			this.eventMediaWriteLocationCache = DEFAULT_MEDIA_LOCATION;
-			return DEFAULT_MEDIA_LOCATION;
-		}
-		const picked = pickWritableMediaLocation(locations.map((l) => ({
-			id: l.id,
-			mode: resolveLocationMode(l),
-			headroomBytes: l.capacity?.availableBytes ?? 0
-		})), this.lastEventMediaWritePick ?? void 0);
-		if (picked === null) {
-			const seen = locations.length > 0 ? locations.map((l) => l.id).join(", ") : "(none registered)";
-			logger.error("pipeline-analytics: no writable eventMedia storage location — refusing the write instead of failing far downstream as a filesystem error", {
-				tags: { deviceId },
-				meta: { locationsSeen: seen }
-			});
-			throw new Error(`no writable eventMedia storage location (seen: ${seen})`);
-		}
-		this.eventMediaWriteLocationCache = picked;
-		this.lastEventMediaWritePick = picked;
-		return picked;
+	resolveEventMediaWriteLocation(api, logger, deviceId) {
+		this.eventMediaWriteLocator ??= new EventMediaWriteLocator({ list: () => api.storage.listLocations.query({ type: DEFAULT_MEDIA_LOCATION }) });
+		return this.eventMediaWriteLocator.resolve(logger, deviceId);
 	}
 	/** Constructs every SQLite-backed store plus the stationary/package-drop/
 	*  sensor plumbing, in the exact pre-S7 order. Returns the non-null bundle
@@ -115964,6 +116347,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			resolveEventMediaLocation: (deviceId) => this.resolveEventMediaWriteLocation(api, logger, deviceId)
 		});
 		this.mediaStore = mediaStore;
+		this.eventMediaWriteLocator ??= new EventMediaWriteLocator({ list: () => api.storage.listLocations.query({ type: DEFAULT_MEDIA_LOCATION }) });
+		this.eventMediaLocationDoorbellUnsub?.();
+		this.eventMediaLocationDoorbellUnsub = subscribeEventMediaWriteLocator(this.ctx.eventBus, this.eventMediaWriteLocator, () => this.mediaLocationStorage?.invalidateRoots());
 		const eventLedgerWiring = this.eventLedgerWiring(api.settingsStore);
 		const retrainFrames = new RetrainFrameStore({
 			store: api.settingsStore,
@@ -116546,6 +116932,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				coreBlocks: async () => (await api.coreBlocks.list.query({})).blocks,
 				nodeAddons: (nodeId) => api.nodes.getNodeAddons.query({ nodeId })
 			},
+			readAlerts: () => api.alerts.list.query({ limit: 5e3 }),
 			getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }),
 			recognitionOutlook: ({ deviceId, trackId, className, labelKind, now }) => recognitionOutlook({
 				className,
@@ -118559,6 +118946,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		this.alarmPanelConvergence?.stop();
 		this.alarmPanelConvergence = null;
 		for (const unsub of this.subscriptionUnsubs) unsub();
+		this.eventMediaLocationDoorbellUnsub?.();
+		this.eventMediaLocationDoorbellUnsub = null;
 		this.subscriptionUnsubs = [];
 		await Promise.all([this.drainSensorHandlers(), this.motionEpisodes?.closeAll("addon-shutdown")]);
 		await this.settleTrackFusions();
@@ -125813,7 +126202,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	async refreshStorageLocationsForMigration(input) {
 		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
 		this.mediaLocationStorage?.invalidateRoots();
-		this.eventMediaWriteLocationCache = null;
+		this.eventMediaWriteLocator?.invalidate();
 		return { refreshed: true };
 	}
 	/**
@@ -126176,7 +126565,24 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	async startStorageMigrationMove(input) {
 		if (!this.mediaRelocate) throw new Error("media relocation unavailable");
 		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
-		return { jobId: this.mediaRelocate.start(input) };
+		return { jobId: await this.startMediaMover(input) };
+	}
+	/**
+	* Start a media move only while no single-location repoint holds an overlapping
+	* physical root (the storage orchestrator owns that claim). A shared recordings
+	* root is the case: a repoint of another class there must not run beside us.
+	*/
+	startMediaMover(input) {
+		const engine = this.mediaRelocate;
+		if (!engine) throw new Error("media relocation unavailable");
+		return startMoverUnderClearance({
+			clearance: (locationIds) => this.ctx.api.storageMigration.moverClearance.query({ locationIds }),
+			start: () => engine.start(input),
+			cancel: (jobId) => {
+				engine.cancel(jobId);
+			},
+			locationIds: [input.fromLocationId ?? "*", input.toLocationId]
+		});
 	}
 	async getStorageMigrationMoveStatus(input) {
 		return this.mediaRelocate?.list().find((job) => job.jobId === input.jobId) ?? null;
@@ -126194,7 +126600,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	*/
 	async relocateMedia(input) {
 		if (!this.mediaRelocate) throw new Error("media relocation unavailable");
-		const jobId = this.mediaRelocate.start(input);
+		const jobId = await this.startMediaMover(input);
 		this.ctx.logger.info("pipeline-analytics: media relocate job enqueued", { meta: {
 			jobId,
 			mode: input.mode ?? "move",