@camstack/addon-post-analysis 1.2.70 → 1.2.71

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-DnpVHUcH.js");
+const require_dist = require("../dist-DjPaVd2L.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -555,7 +555,14 @@ function alarmCoverageGap(coverage) {
 	return "all-skipped";
 }
 /**
-* "Away armed — 3 cameras: Front door, Garage, Gate."
+* "Attivi: Cancello, Garage — Esclusi: Porta retro."
+*
+* A LIST, not a sentence. The mode is in the title and the body is one
+* `Label: names` line per device group, because this is read on a lock screen
+* and the question is always "which one" — the prose version ("3 dispositivi
+* attivi: …. Esclusi: ….") made the operator parse a paragraph to find a
+* window. Each variant still owns its own catalog key, so the Texts tab can
+* re-word "nothing is armed" without touching "these are armed".
 *
 * Names, not ids: this is read by a person standing at a door. An id that has
 * no name falls back to a NAMED, translated placeholder rather than being
@@ -634,7 +641,7 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 	};
 }
 /**
-* "Home armed — with the veranda window open, excluded."
+* "Attivi: 2 — Bypassati: Finestra veranda."
 *
 * The bypassed sensors are named and the armed ones are COUNTED, not listed:
 * this sentence's subject is the exception, and burying it under thirteen
@@ -657,13 +664,13 @@ function armedWithBypass(coverage, bypassed, deviceName) {
 	};
 }
 /**
-* "The alarm was NOT armed: the veranda window is open."
+* "Aperti: Finestra veranda, Porta retro" + how to arm anyway.
 *
 * The one alarm sentence about something that did not happen, so it has to
 * carry both halves an operator needs to act: WHICH sensors are open, and that
 * pressing arm again arms without them. Naming them is the whole message — a
 * refusal that says only "cannot arm" is a panel the operator will conclude is
-* broken.
+* broken — so the names are the FIRST line and the retry hint is the second.
 */
 function buildArmRefusedAnnouncement(mode, names, retrySeconds) {
 	return {
@@ -678,7 +685,7 @@ function buildArmRefusedAnnouncement(mode, names, retrySeconds) {
 	};
 }
 /**
-* The same coverage, said 30 seconds earlier: "Armed in 30 seconds."
+* The EXCEPTIONS to the same coverage, said 30 seconds earlier.
 *
 * The exit-delay sentence is deliberately SHORTER than the arm one — it is read
 * on the way out of a door — and it carries exactly one thing the arm sentence
@@ -686,8 +693,15 @@ function buildArmRefusedAnnouncement(mode, names, retrySeconds) {
 * A mode that arms nothing is worth interrupting somebody for at second 0 and
 * merely worth recording at second 30.
 *
-* Pluralises on the SECONDS, not on the devices: this sentence's only number is
-* the countdown, and Italian needs "1 secondo" / "30 secondi".
+* **It never repeats the device list.** The countdown lives in the TITLE
+* (`system.alarm-arming.title.<mode>` renders `{{seconds}}`), and the armed
+* list arrives thirty seconds later in the arm announcement — printing it
+* twice is the verbosity that made the operator stop reading both. So the body
+* is what is WRONG: what was bypassed, what is excluded, or that nothing is.
+*
+* `seconds` stays in the params because the title asks for it, and `textCount`
+* stays with it: a row enqueued before this deploy still pluralises on the
+* countdown it was written for.
 */
 function buildArmingAnnouncement(coverage, seconds, deviceName, bypassed = []) {
 	const textParams = {
@@ -702,6 +716,7 @@ function buildArmingAnnouncement(coverage, seconds, deviceName, bypassed = []) {
 		},
 		textCount: seconds
 	};
+	const skippedNames = coverage.skippedDevices.map((s) => deviceName(s.deviceId)).join(", ");
 	const gap = alarmCoverageGap(coverage);
 	if (gap === "uncovered") return {
 		bodyKey: "alarm.arming.body.uncovered",
@@ -712,10 +727,18 @@ function buildArmingAnnouncement(coverage, seconds, deviceName, bypassed = []) {
 		bodyKey: "alarm.arming.body.allSkipped",
 		textParams: {
 			...textParams,
-			names: coverage.skippedDevices.map((s) => deviceName(s.deviceId)).join(", ")
+			names: skippedNames
 		},
 		textCount: seconds
 	};
+	if (coverage.skippedDevices.length > 0) return {
+		bodyKey: "alarm.arming.body.skipped",
+		textParams: {
+			...textParams,
+			names: skippedNames
+		},
+		textCount: coverage.skippedDevices.length
+	};
 	return {
 		bodyKey: "alarm.arming.body",
 		textParams,
@@ -4342,69 +4365,38 @@ var en_default = {
 	"snooze.scope.anyDevice": "A camera",
 	"snooze.scope.anyRule": "A rule",
 	"snooze.scope.rule": "“{{rule}}”",
-	"alarm.arm.body.allDevices": {
-		"one": "Every device is armed ({{rules}} rule).",
-		"other": "Every device is armed ({{rules}} rules)."
-	},
-	"alarm.arm.body.noDevices": {
-		"one": "{{rules}} rule, no device restriction.",
-		"other": "{{rules}} rules, no device restriction."
-	},
-	"alarm.arm.body.devices": {
-		"one": "{{devices}} device armed: {{names}}.",
-		"other": "{{devices}} devices armed: {{names}}."
-	},
-	"alarm.arm.body.devicesSkipped": {
-		"one": "{{devices}} device armed: {{names}}. Excluded: {{skippedNames}}.",
-		"other": "{{devices}} devices armed: {{names}}. Excluded: {{skippedNames}}."
-	},
-	"alarm.arm.body.uncovered": "Nothing is armed — no enabled rule is gated on this mode.",
-	"alarm.arm.body.allSkipped": {
-		"one": "Nothing is armed: the {{devices}} device this mode covers is excluded ({{names}}).",
-		"other": "Nothing is armed: all {{devices}} devices this mode covers are excluded ({{names}})."
-	},
-	"alarm.arming.body": {
-		"one": "Armed in {{seconds}} second.",
-		"other": "Armed in {{seconds}} seconds."
-	},
-	"alarm.arming.body.uncovered": {
-		"one": "Armed in {{seconds}} second — but no enabled rule is gated on this mode, so it will protect nothing.",
-		"other": "Armed in {{seconds}} seconds — but no enabled rule is gated on this mode, so it will protect nothing."
-	},
-	"alarm.arming.body.allSkipped": {
-		"one": "Armed in {{seconds}} second — but every device this mode covers is excluded ({{names}}), so it will protect nothing.",
-		"other": "Armed in {{seconds}} seconds — but every device this mode covers is excluded ({{names}}), so it will protect nothing."
-	},
-	"alarm.arm.body.bypassed": {
-		"one": "{{devices}} device armed — open and excluded: {{bypassedNames}}.",
-		"other": "{{devices}} devices armed — open and excluded: {{bypassedNames}}."
-	},
-	"alarm.arming.body.bypassed": {
-		"one": "Armed in {{seconds}} second, excluding what is open: {{bypassedNames}}.",
-		"other": "Armed in {{seconds}} seconds, excluding what is open: {{bypassedNames}}."
-	},
-	"alarm.armRefused.body": {
-		"one": "{{names}} is open. Press arm again within {{seconds}}s to arm without it.",
-		"other": "These are open: {{names}}. Press arm again within {{seconds}}s to arm without them."
-	},
+	"alarm.arm.body.allDevices": "Active: all devices",
+	"alarm.arm.body.noDevices": "Active: no device restriction",
+	"alarm.arm.body.devices": "Active: {{names}}",
+	"alarm.arm.body.devicesSkipped": "Active: {{names}}\nExcluded: {{skippedNames}}",
+	"alarm.arm.body.uncovered": "Active: none — no rule uses this mode",
+	"alarm.arm.body.allSkipped": "Active: none\nExcluded: {{names}}",
+	"alarm.arming.body": "No exclusions",
+	"alarm.arming.body.uncovered": "Active: none — no rule uses this mode",
+	"alarm.arming.body.allSkipped": "Active: none\nExcluded: {{names}}",
+	"alarm.arming.body.skipped": "Excluded: {{names}}",
+	"alarm.arm.body.bypassed": "Active: {{devices}}\nBypassed: {{bypassedNames}}",
+	"alarm.arming.body.bypassed": "Bypassed: {{bypassedNames}}",
+	"alarm.armRefused.body": "Open: {{names}}\nRepeat within {{seconds}}s to arm with bypass.",
 	"alarm.device.unnamed": "Device {{id}}",
-	"system.alarm-arm-refused.title.home": "Home NOT armed",
-	"system.alarm-arm-refused.title.away": "Away NOT armed",
-	"system.alarm-arm-refused.title.night": "Night NOT armed",
-	"system.alarm-arm-refused.body": "The alarm could not be armed — something it covers is open.",
-	"system.alarm-arming.title.home": "Arming home",
-	"system.alarm-arming.title.away": "Arming away",
-	"system.alarm-arming.title.night": "Arming night",
-	"system.alarm-arming.body": "The alarm is arming",
-	"system.alarm-armed.title.home": "Home armed",
-	"system.alarm-armed.title.away": "Away armed",
-	"system.alarm-armed.title.night": "Night armed",
-	"system.alarm-armed.body": "The alarm was armed",
-	"system.alarm-disarmed.title": "Alarm disarmed",
-	"system.alarm-disarmed.body": "The alarm was disarmed",
+	"alarm.combined.title": "Alarm: {{deviceName}}",
+	"system.alarm-arm-refused.title.home": "Arming home refused",
+	"system.alarm-arm-refused.title.away": "Arming away refused",
+	"system.alarm-arm-refused.title.night": "Arming night refused",
+	"system.alarm-arm-refused.body": "Arming refused",
+	"system.alarm-arming.title.home": "Arming home — {{seconds}}s",
+	"system.alarm-arming.title.away": "Arming away — {{seconds}}s",
+	"system.alarm-arming.title.night": "Arming night — {{seconds}}s",
+	"system.alarm-arming.body": "Arming",
+	"system.alarm-armed.title.home": "Armed: home",
+	"system.alarm-armed.title.away": "Armed: away",
+	"system.alarm-armed.title.night": "Armed: night",
+	"system.alarm-armed.body": "Alarm armed",
+	"system.alarm-disarmed.title": "Disarmed",
+	"system.alarm-disarmed.body": "Alarm disarmed",
 	"system.alarm-triggered.title": "ALARM",
-	"system.alarm-triggered.body": "The alarm was triggered",
-	"system.alarm-triggered.body.rule": "The alarm was triggered by {{rule}} on {{deviceName}}",
+	"system.alarm-triggered.body": "Alarm triggered",
+	"system.alarm-triggered.body.rule": "Triggered by {{rule}} on {{deviceName}}",
 	"button.snooze.minutes": "Snooze {{minutes}} min",
 	"button.snooze.hours": {
 		"one": "Snooze {{hours}} hour",
@@ -4536,69 +4528,38 @@ var it_default = {
 	"snooze.scope.anyDevice": "Una camera",
 	"snooze.scope.anyRule": "Una regola",
 	"snooze.scope.rule": "“{{rule}}”",
-	"alarm.arm.body.allDevices": {
-		"one": "Ogni dispositivo è attivo ({{rules}} regola).",
-		"other": "Ogni dispositivo è attivo ({{rules}} regole)."
-	},
-	"alarm.arm.body.noDevices": {
-		"one": "{{rules}} regola, nessuna restrizione sui dispositivi.",
-		"other": "{{rules}} regole, nessuna restrizione sui dispositivi."
-	},
-	"alarm.arm.body.devices": {
-		"one": "{{devices}} dispositivo attivo: {{names}}.",
-		"other": "{{devices}} dispositivi attivi: {{names}}."
-	},
-	"alarm.arm.body.devicesSkipped": {
-		"one": "{{devices}} dispositivo attivo: {{names}}. Esclusi: {{skippedNames}}.",
-		"other": "{{devices}} dispositivi attivi: {{names}}. Esclusi: {{skippedNames}}."
-	},
-	"alarm.arm.body.uncovered": "Non è attivo nulla — nessuna regola abilitata è legata a questa modalità.",
-	"alarm.arm.body.allSkipped": {
-		"one": "Non è attivo nulla: l'unico dispositivo ({{devices}}) coperto da questa modalità è escluso ({{names}}).",
-		"other": "Non è attivo nulla: tutti i {{devices}} dispositivi coperti da questa modalità sono esclusi ({{names}})."
-	},
-	"alarm.arming.body": {
-		"one": "Attivo tra {{seconds}} secondo.",
-		"other": "Attivo tra {{seconds}} secondi."
-	},
-	"alarm.arming.body.uncovered": {
-		"one": "Attivo tra {{seconds}} secondo — ma nessuna regola abilitata è legata a questa modalità: non proteggerà nulla.",
-		"other": "Attivo tra {{seconds}} secondi — ma nessuna regola abilitata è legata a questa modalità: non proteggerà nulla."
-	},
-	"alarm.arming.body.allSkipped": {
-		"one": "Attivo tra {{seconds}} secondo — ma ogni dispositivo coperto da questa modalità è escluso ({{names}}): non proteggerà nulla.",
-		"other": "Attivo tra {{seconds}} secondi — ma ogni dispositivo coperto da questa modalità è escluso ({{names}}): non proteggerà nulla."
-	},
-	"alarm.arm.body.bypassed": {
-		"one": "{{devices}} dispositivo attivo — aperto ed escluso: {{bypassedNames}}.",
-		"other": "{{devices}} dispositivi attivi — aperti ed esclusi: {{bypassedNames}}."
-	},
-	"alarm.arming.body.bypassed": {
-		"one": "Attivo tra {{seconds}} secondo, escludendo ciò che è aperto: {{bypassedNames}}.",
-		"other": "Attivo tra {{seconds}} secondi, escludendo ciò che è aperto: {{bypassedNames}}."
-	},
-	"alarm.armRefused.body": {
-		"one": "{{names}} è aperto. Premi di nuovo entro {{seconds}}s per inserire senza di esso.",
-		"other": "Sono aperti: {{names}}. Premi di nuovo entro {{seconds}}s per inserire senza di essi."
-	},
+	"alarm.arm.body.allDevices": "Attivi: tutti i dispositivi",
+	"alarm.arm.body.noDevices": "Attivi: nessuna restrizione",
+	"alarm.arm.body.devices": "Attivi: {{names}}",
+	"alarm.arm.body.devicesSkipped": "Attivi: {{names}}\nEsclusi: {{skippedNames}}",
+	"alarm.arm.body.uncovered": "Attivi: nessuno — nessuna regola usa questa modalità",
+	"alarm.arm.body.allSkipped": "Attivi: nessuno\nEsclusi: {{names}}",
+	"alarm.arming.body": "Nessuna esclusione",
+	"alarm.arming.body.uncovered": "Attivi: nessuno — nessuna regola usa questa modalità",
+	"alarm.arming.body.allSkipped": "Attivi: nessuno\nEsclusi: {{names}}",
+	"alarm.arming.body.skipped": "Esclusi: {{names}}",
+	"alarm.arm.body.bypassed": "Attivi: {{devices}}\nBypassati: {{bypassedNames}}",
+	"alarm.arming.body.bypassed": "Bypassati: {{bypassedNames}}",
+	"alarm.armRefused.body": "Aperti: {{names}}\nRipeti entro {{seconds}}s per inserire con bypass.",
 	"alarm.device.unnamed": "Dispositivo {{id}}",
+	"alarm.combined.title": "Allarme: {{deviceName}}",
 	"system.alarm-arm-refused.title.home": "Inserimento Casa rifiutato",
 	"system.alarm-arm-refused.title.away": "Inserimento Fuori rifiutato",
 	"system.alarm-arm-refused.title.night": "Inserimento Notte rifiutato",
-	"system.alarm-arm-refused.body": "L'allarme non è stato inserito — qualcosa che copre è aperto.",
-	"system.alarm-arming.title.home": "Inserimento Casa",
-	"system.alarm-arming.title.away": "Inserimento Fuori",
-	"system.alarm-arming.title.night": "Inserimento Notte",
-	"system.alarm-arming.body": "L'allarme si sta inserendo",
-	"system.alarm-armed.title.home": "Casa attivato",
-	"system.alarm-armed.title.away": "Fuori attivato",
-	"system.alarm-armed.title.night": "Notte attivato",
-	"system.alarm-armed.body": "L'allarme è stato inserito",
-	"system.alarm-disarmed.title": "Allarme disattivato",
-	"system.alarm-disarmed.body": "L'allarme è stato disattivato",
+	"system.alarm-arm-refused.body": "Inserimento rifiutato",
+	"system.alarm-arming.title.home": "Inserimento Casa — {{seconds}}s",
+	"system.alarm-arming.title.away": "Inserimento Fuori — {{seconds}}s",
+	"system.alarm-arming.title.night": "Inserimento Notte — {{seconds}}s",
+	"system.alarm-arming.body": "Inserimento in corso",
+	"system.alarm-armed.title.home": "Inserito: Casa",
+	"system.alarm-armed.title.away": "Inserito: Fuori",
+	"system.alarm-armed.title.night": "Inserito: Notte",
+	"system.alarm-armed.body": "Allarme inserito",
+	"system.alarm-disarmed.title": "Disinserito",
+	"system.alarm-disarmed.body": "Allarme disinserito",
 	"system.alarm-triggered.title": "ALLARME",
-	"system.alarm-triggered.body": "L'allarme è scattato",
-	"system.alarm-triggered.body.rule": "L'allarme è scattato per {{rule}} su {{deviceName}}",
+	"system.alarm-triggered.body": "Allarme scattato",
+	"system.alarm-triggered.body.rule": "Scattato da {{rule}} su {{deviceName}}",
 	"button.snooze.minutes": "Silenzia {{minutes}} min",
 	"button.snooze.hours": {
 		"one": "Silenzia {{hours}} ora",
@@ -5317,7 +5278,8 @@ var NcDispatcher = class {
 		const systemEvent = subject.systemEvent;
 		const displayDeviceId = systemEvent?.deviceId ?? subject.deviceId;
 		const deviceName = systemEvent !== void 0 && systemEvent.deviceId === void 0 ? "system" : await this.deps.getDeviceName(displayDeviceId).catch(() => null) ?? `camera ${displayDeviceId}`;
-		const zoneLabels = systemEvent !== void 0 ? [] : await resolveZoneLabels(this.deps.getZoneNames, subject.deviceId, subject.zones);
+		const alarmSource = systemEvent?.alarmSource;
+		const zoneLabels = systemEvent === void 0 ? await resolveZoneLabels(this.deps.getZoneNames, subject.deviceId, subject.zones) : alarmSource?.zones !== void 0 && alarmSource.zones.length > 0 ? await resolveZoneLabels(this.deps.getZoneNames, alarmSource.deviceId, alarmSource.zones) : [];
 		const vars = buildTemplateVars(this.texts, entry, deviceName, zoneLabels);
 		const systemCount = systemEvent?.textCount !== void 0 ? { count: systemEvent.textCount } : {};
 		const title = this.renderText({
@@ -5660,6 +5622,10 @@ async function resolveZoneLabels(getZoneNames, deviceId, zoneIds) {
 		return [...zoneIds];
 	}
 }
+/** `{{confidence}}` as a whole percent, or empty when nothing measured one. */
+function percentOf(confidence) {
+	return confidence !== void 0 ? `${Math.round(confidence * 100)}%` : "";
+}
 /**
 * The variable map ONE render pass sees: scalars, then the composites built
 * from them, then the params a system-event row froze at intake.
@@ -5675,19 +5641,23 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels) {
 	const subject = entry.payload.subject;
 	const occupancy = subject.occupancy;
 	const systemEvent = subject.systemEvent;
+	const detection = systemEvent?.alarmSource?.className !== void 0 ? systemEvent.alarmSource : void 0;
 	return {
 		camera: deviceName,
-		class: subject.className,
-		label: subject.label ?? "",
+		class: detection?.className ?? subject.className,
+		label: detection?.label ?? subject.label ?? "",
 		zones: zoneLabels.join(", "),
-		subject: systemEvent?.subject ?? ncSubjectText(texts, {
+		subject: detection?.className !== void 0 ? ncSubjectText(texts, {
+			className: detection.className,
+			...detection.label !== void 0 ? { label: detection.label } : {}
+		}) : systemEvent?.subject ?? ncSubjectText(texts, {
 			className: subject.className,
 			...subject.label !== void 0 ? { label: subject.label } : {}
 		}),
 		inZones: ncInZonesText(texts, zoneLabels),
 		scope: occupancy?.zone ?? deviceName,
 		zone: occupancy?.zone ?? zoneLabels[0] ?? "",
-		confidence: subject.confidence !== void 0 ? `${Math.round(subject.confidence * 100)}%` : "",
+		confidence: percentOf(detection?.confidence ?? subject.confidence),
 		time: new Date(subject.timestamp).toLocaleTimeString(),
 		rule: entry.payload.ruleName,
 		count: occupancy !== void 0 ? `${occupancy.count}` : "",
@@ -6227,6 +6197,35 @@ function incomingFromSystemEvent(event, lookup) {
 	}
 }
 /**
+* The COMBINED row's two keys, or null when this transition is not one.
+*
+* A rule that trips the alarm produces ONE notification, and the operator has
+* to be able to read it: the title is the severity marker over the camera
+* (`alarm.combined.title`, shipped as `Alarm: {{deviceName}}` and re-wordable
+* per rule or in the Texts tab), and the body is `detection.body` — the exact
+* sentence that rule's ordinary notification would have carried, with its own
+* class, identity and zones.
+*
+* The alarm used to write its own prose here ("The alarm was triggered by
+* Person at gate on Ingresso"), which made the one notification that matters
+* the only one in the system that did not look like the rule's others: no
+* identity, no zone, a different subject. The prefix carries the severity; the
+* familiar line carries the meaning.
+*
+* **Gated on the detection vocabulary, not on the source.** `detection.body`
+* renders `{{subject}}`, and a fire ref with no class composes it from the
+* system event's dedup slot — "alarm:42 su Ingresso". A source without a class
+* therefore keeps the alarm's own sentence, which is also what every row
+* enqueued before this deploy carries.
+*/
+function combinedAlarmText(source) {
+	if (source?.className === void 0) return null;
+	return {
+		titleKey: "alarm.combined.title",
+		bodyKey: "detection.body"
+	};
+}
+/**
 * The panel's own transition, as a system-event subject.
 *
 * IN-PROCESS, not off the bus. The alarm and the Notification Center live in
@@ -6249,6 +6248,7 @@ function incomingFromAlarmTransition(input) {
 	const deviceId = source?.deviceId ?? panelDeviceId;
 	const identity = input.lookup(deviceId);
 	const kind = transition.kind;
+	const combined = combinedAlarmText(source);
 	return systemSubject({
 		facts: {
 			eventId: `alarm:${kind}:${String(transition.at)}`,
@@ -6264,12 +6264,13 @@ function incomingFromAlarmTransition(input) {
 		},
 		kind,
 		subject: `alarm:${String(panelDeviceId)}`,
-		titleKey: transition.mode !== void 0 ? `system.${kind}.title.${transition.mode}` : `system.${kind}.title`,
-		bodyKey: input.body?.bodyKey ?? (source !== void 0 ? `system.${kind}.body.rule` : `system.${kind}.body`),
+		titleKey: combined !== null ? combined.titleKey : transition.mode !== void 0 ? `system.${kind}.title.${transition.mode}` : `system.${kind}.title`,
+		bodyKey: combined?.bodyKey ?? input.body?.bodyKey ?? (source !== void 0 ? `system.${kind}.body.rule` : `system.${kind}.body`),
 		textParams: {
 			...deviceTextParams(deviceId, identity),
 			...transition.mode !== void 0 ? { mode: transition.mode } : {},
 			...source !== void 0 ? { rule: source.ruleName } : {},
+			...kind === "alarm-arming" ? { seconds: `${transition.seconds ?? 0}` } : {},
 			...input.body?.textParams
 		},
 		deviceId,
@@ -12584,6 +12585,7 @@ function frozenOccupancy(rule, occ) {
 */
 function fireRefFor(rule, subject, kind) {
 	const hasEventMedia = kind === "object-event" || kind === "package-event";
+	const className = subject.classNames[0];
 	return {
 		ruleId: rule.id,
 		ruleName: rule.name,
@@ -12592,7 +12594,11 @@ function fireRefFor(rule, subject, kind) {
 		recordId: subject.recordId,
 		...subject.trackId !== void 0 ? { trackId: subject.trackId } : {},
 		...hasEventMedia ? { eventId: subject.recordId } : {},
-		timestamp: subject.timestamp
+		timestamp: subject.timestamp,
+		...className !== void 0 ? { className } : {},
+		...subject.label !== void 0 ? { label: subject.label } : {},
+		zones: notificationZones(rule, subject),
+		...subject.confidence !== void 0 ? { confidence: subject.confidence } : {}
 	};
 }
 function notificationZones(rule, subject) {
@@ -36070,6 +36076,138 @@ var BindingCache = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/runtime/detection-coverage-cache.ts
+/**
+* DetectionCoverageCache — fleet-seeded, event-invalidated mirror of WHICH
+* devices carry a WRAPPED `detection-pipeline` binding. This is the alarm's
+* coverage authority ("Away armed, 12 cameras" is false if three of them are
+* offline or no longer wrapped), read by the notification centre's device
+* directory (`listDeviceIdentities`).
+*
+* WHY a mirror, not a per-tick sweep. The directory refreshes on the NC's 30 s
+* rule-reload tick. Answering "who still has detection?" with a fleet-wide
+* `getAllBindings` on EVERY tick cost 903 ms / 373 KB / ~505 `getBindings:
+* default wrappers skipped` log lines on the live hub (524 devices), forever —
+* ~3% of hub-main's main thread plus a permanent log-spam baseline. Same defect
+* and fix as `SystemMirror.refreshBinding` (639073e8): ONE fleet read to warm,
+* then per-device updates driven by `DeviceBindingsChanged` events. A wrapper
+* toggle emits that event carrying the device's id and `capName`
+* (`detection-pipeline`), so a single `getBindings(deviceId)` — 21 ms / 613 B —
+* keeps the mirror current without ever touching the fleet again.
+*
+* ── Destructive-direction discipline (D49) ──────────────────────────────────
+*
+* `detectionActive: false` reports a camera as UNCOVERED / switched-off (D62) —
+* the destructive answer, and the one an operator reads as "my alarm is not
+* watching that door". A transient `getBindings` blip must never flip a
+* known-covered camera to uncovered:
+*   • a failed refresh KEEPS the previous value (a read that throws changes
+*     nothing), and
+*   • a single read that would flip a known `true → false` is confirmed by a
+*     concordant SECOND read before it lands — an empty binding list is not
+*     proof the wrapper is gone.
+* A COLD mirror (seed not yet landed, or a seed that failed) answers `undefined`
+* for every id — and unknown never reports a camera as excluded from coverage.
+*/
+var DetectionCoverageCache = class {
+	api;
+	logger;
+	/** deviceId → "has a WRAPPED detection-pipeline binding". Absent = unknown. */
+	state = /* @__PURE__ */ new Map();
+	warm = false;
+	seeding = null;
+	constructor(deps) {
+		this.api = deps.api;
+		this.logger = deps.logger;
+	}
+	/** Has the ONE fleet seed ever landed? A cold mirror knows nothing. */
+	isWarm() {
+		return this.warm;
+	}
+	/** Do we have an answer for this id at all? (`false` ⇒ absent ⇒ unknown.) */
+	has(deviceId) {
+		return this.state.has(deviceId);
+	}
+	/** The coverage answer, or `undefined` when this id is unknown. No I/O. */
+	get(deviceId) {
+		return this.state.get(deviceId);
+	}
+	/**
+	* Seed the whole fleet ONCE with a single `getAllBindings`. Idempotent: a
+	* warm cache is a no-op, and concurrent callers coalesce onto one read. A
+	* failed seed leaves the mirror COLD so the next tick retries — during that
+	* window every id answers unknown, which never reports a camera as excluded.
+	*/
+	async ensureWarm() {
+		if (this.warm) return;
+		if (this.seeding) return this.seeding;
+		this.seeding = this.seed();
+		try {
+			await this.seeding;
+		} finally {
+			this.seeding = null;
+		}
+	}
+	async seed() {
+		try {
+			const rows = await this.api.deviceManager.getAllBindings.query({});
+			for (const row of rows) {
+				if (this.state.has(row.deviceId)) continue;
+				this.state.set(row.deviceId, hasWrappedDetection(row.entries));
+			}
+			this.warm = true;
+			this.logger.info("detection-coverage mirror warm", { meta: { devices: this.state.size } });
+		} catch (err) {
+			this.logger.warn("detection-coverage seed failed — coverage unknown until it lands", { meta: { error: String(err) } });
+		}
+	}
+	/**
+	* A `DeviceBindingsChanged` for the detection cap re-reads THAT ONE device
+	* (never the fleet). Fire-and-forget from the synchronous event handler.
+	*/
+	onBindingsChanged(event) {
+		if (event.capName !== "detection-pipeline") return Promise.resolve();
+		return this.refreshDevice(event.deviceId);
+	}
+	/** Drop a device the fleet no longer has (`device.unregistered`). */
+	forget(deviceId) {
+		this.state.delete(deviceId);
+	}
+	/** Return to cold — used on addon shutdown. */
+	clearAll() {
+		this.state.clear();
+		this.warm = false;
+		this.seeding = null;
+	}
+	async refreshDevice(deviceId) {
+		try {
+			const active = await this.readWrappedDetection(deviceId);
+			const prev = this.state.get(deviceId);
+			if (!active && prev === true) {
+				if (await this.readWrappedDetection(deviceId)) {
+					this.state.set(deviceId, true);
+					return;
+				}
+			}
+			this.state.set(deviceId, active);
+		} catch (err) {
+			this.logger.debug("detection-coverage refresh failed — keeping the previous value", {
+				tags: { deviceId },
+				meta: { error: String(err) }
+			});
+		}
+	}
+	async readWrappedDetection(deviceId) {
+		return hasWrappedDetection((await this.api.deviceManager.getBindings.query({ deviceId })).entries);
+	}
+};
+/** The one authority: a WRAPPED `detection-pipeline` binding is present. A
+*  native binding of the same cap is NOT coverage (D62: absence of the WRAPPED
+*  binding is how a deactivated wrapper is represented). */
+function hasWrappedDetection(entries) {
+	return entries.some((e) => e.capName === "detection-pipeline" && e.kind === "wrapped");
+}
+//#endregion
 //#region src/pipeline-analytics/runtime/capture-scheduler.ts
 /**
 * Kind-derived default priorities (0 = highest). Explicit `priority` wins.
@@ -41452,6 +41590,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*  path). Null on non-post-processing nodes or when disabled. */
 	embeddingDispatcher = null;
 	bindingCache = null;
+	/** Alarm-coverage mirror the NC device directory reads — WHICH devices carry
+	*  a wrapped `detection-pipeline` binding. Fleet-seeded ONCE, then per-device
+	*  updates off `DeviceBindingsChanged`, so the 30 s rule-reload tick stops
+	*  sweeping `getAllBindings` over the whole fleet. See
+	*  `runtime/detection-coverage-cache.ts`. */
+	detectionCoverage = null;
 	/** Per-device throttle for the inactive-binding frame-drop warn (5 min). */
 	inactiveBindingDropWarnAt = /* @__PURE__ */ new Map();
 	zoneAnalytics = null;
@@ -42635,6 +42779,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			api,
 			logger: logger.child("BindingCache")
 		});
+		this.detectionCoverage = new DetectionCoverageCache({
+			api,
+			logger: logger.child("DetectionCoverage")
+		});
 		const zoneAnalytics = new ZoneAnalyticsProvider({
 			logger: logger.child("ZoneAnalytics"),
 			onOccupancySample: (deviceId, count, at, zoneId) => this.lts?.note("occupancy", deviceId, count, at, zoneId ?? ""),
@@ -42716,17 +42864,15 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			},
 			listDeviceIdentities: async () => {
 				const all = await api.deviceManager.listAll.query({ projection: "slim" });
-				const detection = await api.deviceManager.getAllBindings.query({}).then((rows) => new Map(rows.map((row) => [row.deviceId, row.entries.some((e) => e.capName === "detection-pipeline" && e.kind === "wrapped")]))).catch((err) => {
-					this.ctx.logger.debug("bindings read failed — alarm coverage cannot report skips", { meta: { error: String(err) } });
-					return /* @__PURE__ */ new Map();
-				});
+				const coverage = this.detectionCoverage;
+				if (coverage) await coverage.ensureWarm();
 				return all.map((d) => ({
 					deviceId: d.id,
 					type: d.type,
 					name: d.name,
 					isCamera: d.isCamera,
 					online: d.online && !d.disabled,
-					...detection.has(d.id) ? { detectionActive: detection.get(d.id) === true } : {}
+					...coverage?.has(d.id) ? { detectionActive: coverage.get(d.id) === true } : {}
 				}));
 			},
 			readDeviceZoneIds: async (ids) => {
@@ -43434,6 +43580,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*  `runtime/wire-subscriptions.ts`. */
 	handleBindingsChangedEvent(data) {
 		this.bindingCache?.onBindingsChanged(data);
+		this.detectionCoverage?.onBindingsChanged(data);
 		if (data.capName === "pipeline-analytics" && data.reason === "wrapper-deactivated") {
 			this.trackStore?.clearDevice(data.deviceId);
 			this.residents.closeDevice(data.deviceId);
@@ -43459,6 +43606,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.audioMarkers?.forgetDevice(deviceId);
 		this.settingsCaches.clearDevice(deviceId);
 		this.bindingCache?.invalidate(deviceId);
+		this.detectionCoverage?.forget(deviceId);
 		this.zoneAnalytics?.forgetDevice(deviceId);
 		this.audioMetrics?.forgetDevice(deviceId);
 		this.releaseProxy(deviceId);
@@ -43664,6 +43812,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.trackStore?.clearAll();
 		this.stationaryRegistry = null;
 		this.bindingCache?.clearAll();
+		this.detectionCoverage?.clearAll();
 		await this.eventMediaDataPlane?.dispose();
 		this.eventMediaDataPlane = null;
 		this.eventMediaBaseUrl = null;