@camstack/addon-post-analysis 1.2.330 → 1.2.332

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-DQmmIYXS.js");
+const require_clip_model_registry = require("../clip-model-registry-CthiqMDB.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -370,6 +370,20 @@ function skippedFor(deviceIds, skipProbe) {
 	return out;
 }
 /**
+* `active` / `skipped` for the arm / arming TITLE — `(n attivi, m saltati)`.
+*
+* Named coverage only: an `allDevices` mode has no finite Active set, so the
+* caller picks the `.all` title key instead of stuffing a fake number here.
+*/
+function armCountParams(coverage, bypassed = []) {
+	const skipped = new Set(coverage.skippedDevices.map((s) => s.deviceId));
+	const excluded = new Set(bypassed);
+	return {
+		active: `${coverage.deviceIds.filter((id) => !skipped.has(id) && !excluded.has(id)).length}`,
+		skipped: `${skipped.size}`
+	};
+}
+/**
 * Whether this mode arms anything, and if not, which way it fails.
 *
 * An `allDevices` mode is never a gap: `skippedDevices` only ever probes the
@@ -384,28 +398,13 @@ function alarmCoverageGap(coverage) {
 	if (coverage.skippedDevices.length < coverage.deviceIds.length) return null;
 	return "all-skipped";
 }
+/** Device names as a lock-screen bullet list (one name per line). */
+function bulletDeviceNames(names) {
+	return names.map((n) => `• ${n}`).join("\n");
+}
 /**
-* "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
-* dropped — a silently shorter list would understate what is armed, which is
-* the one error this message must not make. (It used to hard-code the English
-* `Device <id>` into both languages.)
-*
-* **Always a sentence.** It used to return null for a mode no rule is gated on,
-* on the grounds that "Night armed" followed by an unwatched night is a false
-* assurance — true, but the caller then emitted `alarm-armed` anyway with a
-* fallback body key that existed in NEITHER locale, so the operator received a
-* title and an empty line. Silence is not the third option here: SAYING that
-* the mode arms nothing is.
+* Skipped / excluded devices FIRST, then active — each name on its own
+* `•` line. The mode is in the title; the body answers "which ones".
 */
 function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 	const rules = `${coverage.ruleCount}`;
@@ -414,7 +413,11 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 	const gap = alarmCoverageGap(coverage);
 	if (gap === "uncovered") return {
 		bodyKey: "alarm.arm.body.uncovered",
-		textParams: { mode },
+		textParams: {
+			mode,
+			active: "0",
+			skipped: "0"
+		},
 		textCount: 0
 	};
 	if (gap === "all-skipped") {
@@ -425,7 +428,9 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 				rules,
 				mode,
 				devices: `${names.length}`,
-				names: names.join(", ")
+				names: bulletDeviceNames(names),
+				active: "0",
+				skipped: `${names.length}`
 			},
 			textCount: names.length
 		};
@@ -438,9 +443,10 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 				rules,
 				mode,
 				count: `${names.length}`,
-				names: names.join(", ")
+				names: bulletDeviceNames(names)
 			},
-			textCount: names.length
+			textCount: names.length,
+			titleKeySuffix: "all"
 		};
 	}
 	if (coverage.allDevices) return {
@@ -449,25 +455,30 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 			rules,
 			mode
 		},
-		textCount: coverage.ruleCount
+		textCount: coverage.ruleCount,
+		titleKeySuffix: "all"
 	};
 	if (coverage.deviceIds.length === 0) return {
 		bodyKey: "alarm.arm.body.noDevices",
 		textParams: {
 			rules,
-			mode
+			mode,
+			active: "0",
+			skipped: "0"
 		},
 		textCount: coverage.ruleCount
 	};
 	const skipped = new Set(coverage.skippedDevices.map((s) => s.deviceId));
 	const names = coverage.deviceIds.filter((id) => !skipped.has(id)).map(deviceName);
+	const counts = armCountParams(coverage);
 	if (skipped.size === 0) return {
 		bodyKey: "alarm.arm.body.devices",
 		textParams: {
 			rules,
 			mode,
 			devices: `${names.length}`,
-			names: names.join(", ")
+			names: bulletDeviceNames(names),
+			...counts
 		},
 		textCount: names.length
 	};
@@ -477,8 +488,9 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 			rules,
 			mode,
 			devices: `${names.length}`,
-			names: names.join(", "),
-			skippedNames: coverage.skippedDevices.map((s) => deviceName(s.deviceId)).join(", ")
+			names: bulletDeviceNames(names),
+			skippedNames: bulletDeviceNames(coverage.skippedDevices.map((s) => deviceName(s.deviceId))),
+			...counts
 		},
 		textCount: names.length
 	};
@@ -493,7 +505,7 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 function armedWithBypass(coverage, bypassed, deviceName) {
 	const skipped = new Set(coverage.skippedDevices.map((s) => s.deviceId));
 	const excluded = new Set(bypassed);
-	const bypassedNames = bypassed.map(deviceName).join(", ");
+	const bypassedNames = bulletDeviceNames(bypassed.map(deviceName));
 	if (coverage.allDevices) return {
 		bodyKey: "alarm.arm.body.bypassedAll",
 		textParams: {
@@ -501,10 +513,12 @@ function armedWithBypass(coverage, bypassed, deviceName) {
 			mode: coverage.mode,
 			bypassedNames
 		},
-		textCount: coverage.ruleCount
+		textCount: coverage.ruleCount,
+		titleKeySuffix: "all"
 	};
 	const armedIds = coverage.deviceIds.filter((id) => !skipped.has(id) && !excluded.has(id));
-	const names = armedIds.map(deviceName).join(", ");
+	const names = bulletDeviceNames(armedIds.map(deviceName));
+	const counts = armCountParams(coverage, bypassed);
 	return {
 		bodyKey: "alarm.arm.body.bypassed",
 		textParams: {
@@ -512,7 +526,8 @@ function armedWithBypass(coverage, bypassed, deviceName) {
 			mode: coverage.mode,
 			devices: `${armedIds.length}`,
 			names,
-			bypassedNames
+			bypassedNames,
+			...counts
 		},
 		textCount: armedIds.length
 	};
@@ -533,69 +548,159 @@ function buildArmRefusedAnnouncement(mode, names, withArmAnyway) {
 		textParams: {
 			mode,
 			devices: `${names.length}`,
-			names: names.join(", ")
+			names: bulletDeviceNames(names)
 		},
 		textCount: names.length
 	};
 }
 /**
-* The EXCEPTIONS to the same coverage, said 30 seconds earlier.
+* The same coverage lists as {@link buildArmAnnouncement}, said at second 0.
 *
-* 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
-* cannot: the warning arrives while the operator can still disarm and fix it.
-* A mode that arms nothing is worth interrupting somebody for at second 0 and
-* merely worth recording at second 30.
-*
-* **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.
+* The countdown lives in the TITLE (`system.alarm-arming.title.<mode>` renders
+* `{{seconds}}`); the body is the labelled device lists — Active and Skipped
+* (and Bypassed when the operator confirmed an open sensor). Saying the lists
+* only at second 30 left the exit-delay push as "No exclusions" / a lone
+* Esclusi line, which is exactly when the operator can still disarm and fix
+* a mute or an offline camera.
 *
 * `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 mode = coverage.mode;
+	const rules = `${coverage.ruleCount}`;
 	const textParams = {
-		mode: coverage.mode,
+		mode,
 		seconds: `${seconds}`
 	};
-	if (bypassed.length > 0) return {
-		bodyKey: "alarm.arming.body.bypassed",
+	if (bypassed.length > 0) return armingWithBypass(coverage, seconds, bypassed, deviceName);
+	const gap = alarmCoverageGap(coverage);
+	if (gap === "uncovered") return {
+		bodyKey: "alarm.arming.body.uncovered",
 		textParams: {
 			...textParams,
-			bypassedNames: bypassed.map(deviceName).join(", ")
+			active: "0",
+			skipped: "0"
 		},
 		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",
-		textParams,
-		textCount: seconds
+	if (gap === "all-skipped") {
+		const names = coverage.skippedDevices.map((s) => deviceName(s.deviceId));
+		return {
+			bodyKey: "alarm.arming.body.allSkipped",
+			textParams: {
+				...textParams,
+				rules,
+				devices: `${names.length}`,
+				names: bulletDeviceNames(names),
+				active: "0",
+				skipped: `${names.length}`
+			},
+			textCount: seconds
+		};
+	}
+	if (coverage.allDevices && coverage.allDevicesExcept.length > 0) {
+		const names = coverage.allDevicesExcept.map(deviceName);
+		return {
+			bodyKey: "alarm.arming.body.allDevicesExcept",
+			textParams: {
+				...textParams,
+				rules,
+				count: `${names.length}`,
+				names: bulletDeviceNames(names)
+			},
+			textCount: seconds,
+			titleKeySuffix: "all"
+		};
+	}
+	if (coverage.allDevices) return {
+		bodyKey: "alarm.arming.body.allDevices",
+		textParams: {
+			...textParams,
+			rules
+		},
+		textCount: seconds,
+		titleKeySuffix: "all"
 	};
-	if (gap === "all-skipped") return {
-		bodyKey: "alarm.arming.body.allSkipped",
+	if (coverage.deviceIds.length === 0) return {
+		bodyKey: "alarm.arming.body.noDevices",
 		textParams: {
 			...textParams,
-			names: skippedNames
+			rules,
+			active: "0",
+			skipped: "0"
 		},
 		textCount: seconds
 	};
-	if (coverage.skippedDevices.length > 0) return {
-		bodyKey: "alarm.arming.body.skipped",
+	const skipped = new Set(coverage.skippedDevices.map((s) => s.deviceId));
+	const names = coverage.deviceIds.filter((id) => !skipped.has(id)).map(deviceName);
+	const counts = armCountParams(coverage);
+	if (skipped.size === 0) return {
+		bodyKey: "alarm.arming.body.devices",
 		textParams: {
 			...textParams,
-			names: skippedNames
+			rules,
+			devices: `${names.length}`,
+			names: bulletDeviceNames(names),
+			...counts
 		},
-		textCount: coverage.skippedDevices.length
+		textCount: seconds
 	};
 	return {
-		bodyKey: "alarm.arming.body",
+		bodyKey: "alarm.arming.body.devicesSkipped",
+		textParams: {
+			...textParams,
+			rules,
+			devices: `${names.length}`,
+			names: bulletDeviceNames(names),
+			skippedNames: bulletDeviceNames(coverage.skippedDevices.map((s) => deviceName(s.deviceId))),
+			...counts
+		},
+		textCount: seconds
+	};
+}
+/**
+* "Attivi: Porta retro, Cancello — Bypassati: Finestra veranda" while the exit
+* delay still runs — same halves as {@link armedWithBypass}, with `seconds`
+* frozen for the title.
+*/
+function armingWithBypass(coverage, seconds, bypassed, deviceName) {
+	const skipped = new Set(coverage.skippedDevices.map((s) => s.deviceId));
+	const excluded = new Set(bypassed);
+	const bypassedNames = bulletDeviceNames(bypassed.map(deviceName));
+	const textParams = {
+		mode: coverage.mode,
+		seconds: `${seconds}`,
+		rules: `${coverage.ruleCount}`,
+		bypassedNames
+	};
+	if (coverage.allDevices) return {
+		bodyKey: "alarm.arming.body.bypassedAll",
 		textParams,
+		textCount: seconds,
+		titleKeySuffix: "all"
+	};
+	const armedIds = coverage.deviceIds.filter((id) => !skipped.has(id) && !excluded.has(id));
+	const counts = armCountParams(coverage, bypassed);
+	if (armedIds.length === 0) return {
+		bodyKey: "alarm.arming.body.bypassedOnly",
+		textParams: {
+			mode: coverage.mode,
+			seconds: `${seconds}`,
+			bypassedNames,
+			...counts
+		},
+		textCount: seconds
+	};
+	return {
+		bodyKey: "alarm.arming.body.bypassed",
+		textParams: {
+			...textParams,
+			devices: `${armedIds.length}`,
+			names: bulletDeviceNames(armedIds.map(deviceName)),
+			...counts
+		},
 		textCount: seconds
 	};
 }
@@ -3218,12 +3323,23 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 	* dropped it anyway, so the exclusion is not what ignored it.
 	*/
 	announceIgnoredTrigger(deviceId, now) {
+		const state = stateAt(this.machine, now);
 		if (!isArmed(this.machine, now)) {
 			this.ctx.logger.debug("alarm bypass not announced — the panel is not armed yet", {
 				tags: { deviceId },
 				meta: {
 					panelDeviceId: this.id,
-					state: stateAt(this.machine, now)
+					state
+				}
+			});
+			return;
+		}
+		if (state === "triggered") {
+			this.ctx.logger.debug("alarm bypass not announced — the siren is already sounding", {
+				tags: { deviceId },
+				meta: {
+					panelDeviceId: this.id,
+					state
 				}
 			});
 			return;
@@ -5929,7 +6045,7 @@ function isAdoptable(record, nowMs) {
 * what `localDayMinute` does for the same input — one behaviour for a bad
 * zone, not two.
 */
-function clockOf$7(atMs, timeZone) {
+function clockOf$6(atMs, timeZone) {
 	if (timeZone !== void 0) try {
 		return new Intl.DateTimeFormat("en-GB", {
 			timeZone,
@@ -6065,7 +6181,7 @@ var TimelapseRenderer = class {
 				includeAudio: false,
 				maxLifeMs: await this.ports.exportLifeMs(),
 				deleteAfterDownload: false,
-				title: `${request.ruleName} ${clockOf$7(window.startMs, request.timezone)}→${clockOf$7(window.endMs, request.timezone)}`,
+				title: `${request.ruleName} ${clockOf$6(window.startMs, request.timezone)}→${clockOf$6(window.endMs, request.timezone)}`,
 				timelapse: {
 					everyMs,
 					outputFps: request.framerate,
@@ -6396,7 +6512,7 @@ var TimelapseRenderer = class {
 					...meta,
 					unservedWindowCount: verdict.unservedWindows.length,
 					unservedWindows: verdict.unservedWindows.slice(0, 12).map((w) => ({
-						at: clockOf$7(request.window.startMs + w.fromSec * 1e3, request.timezone),
+						at: clockOf$6(request.window.startMs + w.fromSec * 1e3, request.timezone),
 						fromSec: Math.round(w.fromSec),
 						toSec: Math.round(w.toSec),
 						expectedDenseFrames: w.expectedDenseFrames,
@@ -13064,7 +13180,8 @@ function alarmTextKeys(transition, body) {
 	const { kind, source } = transition;
 	const combined = combinedAlarmText(kind, source);
 	if (combined !== null) return combined;
-	const titleKey = transition.mode !== void 0 ? `system.${kind}.title.${transition.mode}` : `system.${kind}.title`;
+	const baseTitle = transition.mode !== void 0 ? `system.${kind}.title.${transition.mode}` : `system.${kind}.title`;
+	const titleKey = body?.titleKeySuffix !== void 0 ? `${baseTitle}.${body.titleKeySuffix}` : baseTitle;
 	if (body !== void 0) return {
 		titleKey,
 		bodyKey: body.bodyKey
@@ -14771,34 +14888,47 @@ var en_default = {
 	"snooze.scope.anyRule": "A rule",
 	"snooze.scope.rule": "“{{rule}}”",
 	"alarm.arm.body.allDevices": "Active: all devices",
-	"alarm.arm.body.allDevicesExcept": "Active: all devices except {{names}}",
+	"alarm.arm.body.allDevicesExcept": "Active: all devices except\n{{names}}",
 	"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.devices": "Active:\n{{names}}",
+	"alarm.arm.body.devicesSkipped": "Excluded:\n{{skippedNames}}\nActive:\n{{names}}",
 	"alarm.arm.body.uncovered": "Active: none — no rule uses this mode",
-	"alarm.arm.body.allSkipped": "Active: none\nExcluded: {{names}}",
+	"alarm.arm.body.allSkipped": "Excluded:\n{{names}}\nActive: none",
 	"alarm.arming.body": "No exclusions",
+	"alarm.arming.body.allDevices": "Active: all devices",
+	"alarm.arming.body.allDevicesExcept": "Active: all devices except\n{{names}}",
+	"alarm.arming.body.noDevices": "Active: no device restriction",
+	"alarm.arming.body.devices": "Active:\n{{names}}",
+	"alarm.arming.body.devicesSkipped": "Excluded:\n{{skippedNames}}\nActive:\n{{names}}",
 	"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: {{names}}\nBypassed: {{bypassedNames}}",
-	"alarm.arm.body.bypassedAll": "Active: all devices\nBypassed: {{bypassedNames}}",
-	"alarm.arming.body.bypassed": "Bypassed: {{bypassedNames}}",
-	"alarm.armRefused.body": "Open: {{names}}",
-	"alarm.armRefused.body.hint": "Open: {{names}}\nTap “Arm anyway” to arm with them excluded.",
+	"alarm.arming.body.allSkipped": "Excluded:\n{{names}}\nActive: none",
+	"alarm.arming.body.skipped": "Excluded:\n{{names}}",
+	"alarm.arm.body.bypassed": "Bypassed:\n{{bypassedNames}}\nActive:\n{{names}}",
+	"alarm.arm.body.bypassedAll": "Bypassed:\n{{bypassedNames}}\nActive: all devices",
+	"alarm.arming.body.bypassed": "Bypassed:\n{{bypassedNames}}\nActive:\n{{names}}",
+	"alarm.arming.body.bypassedAll": "Bypassed:\n{{bypassedNames}}\nActive: all devices",
+	"alarm.arming.body.bypassedOnly": "Bypassed:\n{{bypassedNames}}",
+	"alarm.armRefused.body": "Open:\n{{names}}",
+	"alarm.armRefused.body.hint": "Open:\n{{names}}\nTap “Arm anyway” to arm with them excluded.",
 	"alarm.device.unnamed": "Device {{id}}",
 	"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.title.home": "Arming home — {{seconds}}s ({{active}} active, {{skipped}} skipped)",
+	"system.alarm-arming.title.away": "Arming away — {{seconds}}s ({{active}} active, {{skipped}} skipped)",
+	"system.alarm-arming.title.night": "Arming night — {{seconds}}s ({{active}} active, {{skipped}} skipped)",
+	"system.alarm-arming.title.home.all": "Arming home — {{seconds}}s",
+	"system.alarm-arming.title.away.all": "Arming away — {{seconds}}s",
+	"system.alarm-arming.title.night.all": "Arming night — {{seconds}}s",
 	"system.alarm-arming.body": "Arming",
-	"system.alarm-armed.title.home": "Alarm armed: home",
-	"system.alarm-armed.title.away": "Alarm armed: away",
-	"system.alarm-armed.title.night": "Alarm armed: night",
+	"system.alarm-armed.title.home": "Alarm active: home ({{active}} active, {{skipped}} skipped)",
+	"system.alarm-armed.title.away": "Alarm active: away ({{active}} active, {{skipped}} skipped)",
+	"system.alarm-armed.title.night": "Alarm active: night ({{active}} active, {{skipped}} skipped)",
+	"system.alarm-armed.title.home.all": "Alarm active: home (all)",
+	"system.alarm-armed.title.away.all": "Alarm active: away (all)",
+	"system.alarm-armed.title.night.all": "Alarm active: night (all)",
 	"system.alarm-armed.body": "Alarm armed",
 	"system.alarm-disarmed.title": "Disarmed",
 	"system.alarm-disarmed.body": "Alarm disarmed",
@@ -14896,7 +15026,16 @@ var en_default = {
 	"summary.line.update": "{{packageName}} {{currentVersion}} → {{latestVersion}}",
 	"summary.line.update.onNode": "{{packageName}} {{currentVersion}} → {{latestVersion}} on {{nodeId}}",
 	"summary.line.wrapper-update": "Container {{currentVersion}} → {{latestVersion}}",
-	"summary.line.tank-unread": "{{deviceName}} — the {{tank}} tank needs attention"
+	"summary.line.tank-unread": "{{deviceName}} — the {{tank}} tank needs attention",
+	"calendar-events.title": "{{rule}}: {{count}} upcoming",
+	"calendar-events.empty": "No events in the next {{horizonDays}} day(s).",
+	"calendar-events.day.today": "Today — {{date}}",
+	"calendar-events.day.tomorrow": "★ Tomorrow — {{date}}",
+	"calendar-events.day.other": "{{date}}",
+	"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"
 };
 //#endregion
 //#region src/notification-center/texts/it.json
@@ -15100,34 +15239,47 @@ var it_default = {
 	"snooze.scope.anyRule": "Una regola",
 	"snooze.scope.rule": "“{{rule}}”",
 	"alarm.arm.body.allDevices": "Attivi: tutti i dispositivi",
-	"alarm.arm.body.allDevicesExcept": "Attivi: tutti i dispositivi tranne {{names}}",
+	"alarm.arm.body.allDevicesExcept": "Attivi: tutti i dispositivi tranne\n{{names}}",
 	"alarm.arm.body.noDevices": "Attivi: nessuna restrizione",
-	"alarm.arm.body.devices": "Attivi: {{names}}",
-	"alarm.arm.body.devicesSkipped": "Attivi: {{names}}\nEsclusi: {{skippedNames}}",
+	"alarm.arm.body.devices": "Attivi:\n{{names}}",
+	"alarm.arm.body.devicesSkipped": "Esclusi:\n{{skippedNames}}\nAttivi:\n{{names}}",
 	"alarm.arm.body.uncovered": "Attivi: nessuno — nessuna regola usa questa modalità",
-	"alarm.arm.body.allSkipped": "Attivi: nessuno\nEsclusi: {{names}}",
+	"alarm.arm.body.allSkipped": "Esclusi:\n{{names}}\nAttivi: nessuno",
 	"alarm.arming.body": "Nessuna esclusione",
+	"alarm.arming.body.allDevices": "Attivi: tutti i dispositivi",
+	"alarm.arming.body.allDevicesExcept": "Attivi: tutti i dispositivi tranne\n{{names}}",
+	"alarm.arming.body.noDevices": "Attivi: nessuna restrizione",
+	"alarm.arming.body.devices": "Attivi:\n{{names}}",
+	"alarm.arming.body.devicesSkipped": "Esclusi:\n{{skippedNames}}\nAttivi:\n{{names}}",
 	"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: {{names}}\nBypassati: {{bypassedNames}}",
-	"alarm.arm.body.bypassedAll": "Attivi: tutti i dispositivi\nBypassati: {{bypassedNames}}",
-	"alarm.arming.body.bypassed": "Bypassati: {{bypassedNames}}",
-	"alarm.armRefused.body": "Aperti: {{names}}",
-	"alarm.armRefused.body.hint": "Aperti: {{names}}\nTocca “Arma comunque” per armare escludendoli.",
+	"alarm.arming.body.allSkipped": "Esclusi:\n{{names}}\nAttivi: nessuno",
+	"alarm.arming.body.skipped": "Esclusi:\n{{names}}",
+	"alarm.arm.body.bypassed": "Bypassati:\n{{bypassedNames}}\nAttivi:\n{{names}}",
+	"alarm.arm.body.bypassedAll": "Bypassati:\n{{bypassedNames}}\nAttivi: tutti i dispositivi",
+	"alarm.arming.body.bypassed": "Bypassati:\n{{bypassedNames}}\nAttivi:\n{{names}}",
+	"alarm.arming.body.bypassedAll": "Bypassati:\n{{bypassedNames}}\nAttivi: tutti i dispositivi",
+	"alarm.arming.body.bypassedOnly": "Bypassati:\n{{bypassedNames}}",
+	"alarm.armRefused.body": "Aperti:\n{{names}}",
+	"alarm.armRefused.body.hint": "Aperti:\n{{names}}\nTocca “Arma comunque” per armare escludendoli.",
 	"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": "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.title.home": "Inserimento Casa — {{seconds}}s ({{active}} attivi, {{skipped}} saltati)",
+	"system.alarm-arming.title.away": "Inserimento Fuori — {{seconds}}s ({{active}} attivi, {{skipped}} saltati)",
+	"system.alarm-arming.title.night": "Inserimento Notte — {{seconds}}s ({{active}} attivi, {{skipped}} saltati)",
+	"system.alarm-arming.title.home.all": "Inserimento Casa — {{seconds}}s",
+	"system.alarm-arming.title.away.all": "Inserimento Fuori — {{seconds}}s",
+	"system.alarm-arming.title.night.all": "Inserimento Notte — {{seconds}}s",
 	"system.alarm-arming.body": "Inserimento in corso",
-	"system.alarm-armed.title.home": "Allarme inserito: Casa",
-	"system.alarm-armed.title.away": "Allarme inserito: Fuori",
-	"system.alarm-armed.title.night": "Allarme inserito: Notte",
+	"system.alarm-armed.title.home": "Allarme attivo: Casa ({{active}} attivi, {{skipped}} saltati)",
+	"system.alarm-armed.title.away": "Allarme attivo: Fuori ({{active}} attivi, {{skipped}} saltati)",
+	"system.alarm-armed.title.night": "Allarme attivo: Notte ({{active}} attivi, {{skipped}} saltati)",
+	"system.alarm-armed.title.home.all": "Allarme attivo: Casa (tutti)",
+	"system.alarm-armed.title.away.all": "Allarme attivo: Fuori (tutti)",
+	"system.alarm-armed.title.night.all": "Allarme attivo: Notte (tutti)",
 	"system.alarm-armed.body": "Allarme inserito",
 	"system.alarm-disarmed.title": "Disinserito",
 	"system.alarm-disarmed.body": "Allarme disinserito",
@@ -15225,7 +15377,16 @@ var it_default = {
 	"summary.line.update": "{{packageName}} {{currentVersion}} → {{latestVersion}}",
 	"summary.line.update.onNode": "{{packageName}} {{currentVersion}} → {{latestVersion}} su {{nodeId}}",
 	"summary.line.wrapper-update": "Container {{currentVersion}} → {{latestVersion}}",
-	"summary.line.tank-unread": "{{deviceName}} — il serbatoio {{tank}} richiede attenzione"
+	"summary.line.tank-unread": "{{deviceName}} — il serbatoio {{tank}} richiede attenzione",
+	"calendar-events.title": "{{rule}}: {{count}} in arrivo",
+	"calendar-events.empty": "Nessun evento nei prossimi {{horizonDays}} giorno/i.",
+	"calendar-events.day.today": "Oggi — {{date}}",
+	"calendar-events.day.tomorrow": "★ Domani — {{date}}",
+	"calendar-events.day.other": "{{date}}",
+	"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}}"
 };
 //#endregion
 //#region src/notification-center/text-catalog.ts
@@ -15479,12 +15640,12 @@ var NC_RULE_AI_WORDS_FALLBACK = 24;
 *
 * | kind (declared `bodyMaxLen`) | words |
 * | --- | --- |
-* | zentik (500) | 12 |
+* | (legacy 500-char push) | 12 |
 * | pushover (1024) | 24 |
 * | discord (2000) | 36 |
 * | home-assistant (3500) | 46 |
 * | ntfy · gotify · telegram · whatsapp (4096) | 48 |
-* | webhook (1 000 000) | 120 |
+* | webhook · zentik (1 000 000) | 120 |
 *
 * Which is the operator's sentence, arrived at from a declared number: a push
 * notification is truncated by the screen and wants few words; a webhook or a
@@ -29844,7 +30005,7 @@ function buildRuleAiSystemPrompt(shape, language, maxWords, grouped = false) {
 	].join("");
 }
 /** `HH:MM` in the host timezone. */
-function clockOf$6(atMs) {
+function clockOf$5(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -29882,7 +30043,7 @@ function buildRuleAiPrompt(input) {
 	if (shape === "detection-track") {
 		lines.push(`Camera: ${camera}.${located} Subject: ${subject}. The stills, in order:`);
 		for (const [i, frame] of input.frames.entries()) {
-			const when = frame.atMs !== void 0 ? ` · ${clockOf$6(frame.atMs)}` : "";
+			const when = frame.atMs !== void 0 ? ` · ${clockOf$5(frame.atMs)}` : "";
 			lines.push(`${String(i + 1)}.${when}`);
 		}
 		return lines.join("\n");
@@ -31653,7 +31814,7 @@ var DEFAULT_PROMPT_EN = "What happened during this period? Summarise it for a ho
 */
 var SummaryAnswerSchema = require_clip_model_registry.object({ summary: require_clip_model_registry.string() });
 /** `HH:MM` in the host timezone — the two numbers a frame label needs. */
-function clockOf$5(atMs) {
+function clockOf$4(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -31676,7 +31837,7 @@ function buildSummaryAiPrompt(input, frames) {
 	const roster = frames.map((f, i) => {
 		const location = plainLabel(f.location ?? "");
 		const where = location.length > 0 ? ` (${location})` : "";
-		return `${String(i + 1)}. ${plainLabel(f.deviceName)}${where} · ${clockOf$5(f.atMs)} · ${plainVocabulary(f.className) || "subject"}`;
+		return `${String(i + 1)}. ${plainLabel(f.deviceName)}${where} · ${clockOf$4(f.atMs)} · ${plainVocabulary(f.className) || "subject"}`;
 	}).join("\n");
 	const described = /* @__PURE__ */ new Map();
 	for (const f of frames) {
@@ -32279,7 +32440,7 @@ var NO_DETECTIONS$1 = {
 *  has to check is a key somebody can get wrong. */
 var BODY_SEPARATOR$1 = " · ";
 /** `HH:MM` in the host timezone. */
-function clockOf$4(atMs) {
+function clockOf$3(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -32293,8 +32454,8 @@ function clockOf$4(atMs) {
 function summaryTemplateVars(input) {
 	return {
 		rule: input.ruleName,
-		from: clockOf$4(input.window.startMs),
-		to: clockOf$4(input.window.endMs),
+		from: clockOf$3(input.window.startMs),
+		to: clockOf$3(input.window.endMs),
 		time: ncClockText(input.texts.language, input.generatedAt),
 		events: String(input.tileCount),
 		cameras: String(input.cameraCount),
@@ -32389,11 +32550,11 @@ function summaryRecordId(ruleId, windowEndMs) {
 /** The caption burned onto the mosaic's title band, with the same `{{var}}`
 *  vocabulary the title and body use. `''` is a real answer ("no caption"). */
 function summaryCaptionText(input) {
-	if (input.captionText === void 0) return `${input.ruleName} — ${clockOf$4(input.window.startMs)}→${clockOf$4(input.window.endMs)}`;
+	if (input.captionText === void 0) return `${input.ruleName} — ${clockOf$3(input.window.startMs)}→${clockOf$3(input.window.endMs)}`;
 	return renderTemplate(input.captionText, {
 		rule: input.ruleName,
-		from: clockOf$4(input.window.startMs),
-		to: clockOf$4(input.window.endMs)
+		from: clockOf$3(input.window.startMs),
+		to: clockOf$3(input.window.endMs)
 	}) ?? "";
 }
 /**
@@ -33325,7 +33486,7 @@ var NcSummaryProducer = class {
 				purpose: "summary",
 				tiles: tiles.map(({ candidate, jpeg }) => ({
 					jpeg,
-					...plan.tileLabels ? { label: `${names.get(candidate.deviceId) ?? candidate.deviceId} · ${clockOf$3(candidate.firstSeen)} · ${candidate.className}` } : {},
+					...plan.tileLabels ? { label: `${names.get(candidate.deviceId) ?? candidate.deviceId} · ${clockOf$2(candidate.firstSeen)} · ${candidate.className}` } : {},
 					deviceId: candidate.deviceId,
 					sourceId: candidate.trackId
 				})),
@@ -33548,7 +33709,7 @@ var NcSummaryProducer = class {
 	}
 };
 /** `HH:MM` in the host timezone — the two numbers a tile label needs. */
-function clockOf$3(atMs) {
+function clockOf$2(atMs) {
 	const d = new Date(atMs);
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
@@ -34049,8 +34210,6 @@ var NcCalendarEventsStore = class {
 };
 //#endregion
 //#region src/notification-center/calendar-events/calendar-events-body.ts
-/** Visual weight on the tomorrow header — Telegram/Zentik plain text. */
-var CALENDAR_EVENTS_TOMORROW_MARK = "★";
 /** Separates the tomorrow block from the rest of the horizon. */
 var CALENDAR_EVENTS_DAY_DELIMITER = "────────";
 var MAX_EVENT_LINES = 40;
@@ -34071,26 +34230,50 @@ function addLocalDays(atMs, days) {
 	d.setDate(d.getDate() + days);
 	return d.getTime();
 }
-function dayHeadingFor(dayStartMs, todayKey, tomorrowKey) {
-	const key = localDayKey(dayStartMs);
-	const label = new Date(dayStartMs).toLocaleDateString(void 0, {
+function dayDateLabel(texts, dayStartMs) {
+	return new Intl.DateTimeFormat(texts.language, {
 		weekday: "short",
 		month: "short",
 		day: "numeric"
-	});
-	if (key === todayKey) return `Today — ${label}`;
-	if (key === tomorrowKey) return `${CALENDAR_EVENTS_TOMORROW_MARK} Tomorrow — ${label}`;
-	return label;
+	}).format(new Date(dayStartMs));
 }
-/** `HH:MM` local, or `YYYY-MM-DD HH:MM` when the end falls on another day. */
-function clockOf$2(atMs) {
-	const d = new Date(atMs);
-	return `${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+function dayHeadingFor(texts, dayStartMs, todayKey, tomorrowKey) {
+	const key = localDayKey(dayStartMs);
+	const date = dayDateLabel(texts, dayStartMs);
+	if (key === todayKey) return texts.text({
+		key: "calendar-events.day.today",
+		vars: { date }
+	});
+	if (key === tomorrowKey) return texts.text({
+		key: "calendar-events.day.tomorrow",
+		vars: { date }
+	});
+	return texts.text({
+		key: "calendar-events.day.other",
+		vars: { date }
+	});
 }
-function formatEventLine(event) {
-	const when = event.allDay === true ? "All day" : `${clockOf$2(event.startMs)}–${clockOf$2(event.endMs)}`;
-	const where = event.location !== void 0 && event.location.length > 0 ? ` @ ${event.location}` : "";
-	return `• ${when} ${event.title}${where}`;
+function formatEventLine(texts, event) {
+	const where = event.location !== void 0 && event.location.length > 0 ? texts.text({
+		key: "calendar-events.where",
+		vars: { location: event.location }
+	}) : "";
+	if (event.allDay === true) return texts.text({
+		key: "calendar-events.line.allDay",
+		vars: {
+			title: event.title,
+			where
+		}
+	});
+	const when = `${ncClockText(texts.language, event.startMs)}–${ncClockText(texts.language, event.endMs)}`;
+	return texts.text({
+		key: "calendar-events.line.timed",
+		vars: {
+			when,
+			title: event.title,
+			where
+		}
+	});
 }
 function groupByLocalDay(events) {
 	const map = /* @__PURE__ */ new Map();
@@ -34114,8 +34297,11 @@ function groupByLocalDay(events) {
 *
 * @param nowMs — fire time; tomorrow is the local calendar day after this.
 */
-function formatCalendarEventsBody(events, nowMs, horizonDays) {
-	if (events.length === 0) return `No events in the next ${String(horizonDays)} day(s).`;
+function formatCalendarEventsBody(texts, events, nowMs, horizonDays) {
+	if (events.length === 0) return texts.text({
+		key: "calendar-events.empty",
+		vars: { horizonDays: String(horizonDays) }
+	});
 	const todayKey = localDayKey(nowMs);
 	const tomorrowKey = localDayKey(addLocalDays(startOfLocalDay(nowMs), 1));
 	const buckets = groupByLocalDay(events);
@@ -34127,17 +34313,20 @@ function formatCalendarEventsBody(events, nowMs, horizonDays) {
 	let emitted = 0;
 	const pushBucket = (bucket) => {
 		if (emitted >= MAX_EVENT_LINES) return;
-		lines.push(dayHeadingFor(bucket.dayStartMs, todayKey, tomorrowKey));
+		lines.push(dayHeadingFor(texts, bucket.dayStartMs, todayKey, tomorrowKey));
 		for (const ev of bucket.events) {
 			if (emitted >= MAX_EVENT_LINES) break;
-			lines.push(formatEventLine(ev));
+			lines.push(formatEventLine(texts, ev));
 			emitted += 1;
 		}
 	};
 	for (const bucket of lead) pushBucket(bucket);
 	if (lead.length > 0 && later.length > 0) lines.push(CALENDAR_EVENTS_DAY_DELIMITER);
 	for (const bucket of later) pushBucket(bucket);
-	if (events.length > MAX_EVENT_LINES) lines.push(`…and ${String(events.length - MAX_EVENT_LINES)} more`);
+	if (events.length > MAX_EVENT_LINES) lines.push(texts.text({
+		key: "calendar-events.more",
+		vars: { count: String(events.length - MAX_EVENT_LINES) }
+	}));
 	return lines.join("\n");
 }
 //#endregion
@@ -34151,7 +34340,7 @@ function clockOf$1(atMs) {
 	return `${`${String(d.getFullYear())}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`} ${`${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`}`;
 }
 function derivedBody$1(input) {
-	return formatCalendarEventsBody(input.events, input.eventWindow.startMs, input.horizonDays);
+	return formatCalendarEventsBody(input.texts, input.events, input.eventWindow.startMs, input.horizonDays);
 }
 function templateVars(input) {
 	return {
@@ -34177,7 +34366,11 @@ function paramsFor$1(target) {
 function buildCalendarEventsOutboxInputs(input) {
 	const vars = templateVars(input);
 	const optedOut = new Set(input.disabledTargetIds ?? []);
-	const title = renderTemplate(input.template?.title, vars) ?? `${input.ruleName}: ${String(input.events.length)} upcoming`;
+	const title = input.texts.text({
+		key: "calendar-events.title",
+		template: input.template?.title,
+		vars
+	});
 	const body = renderTemplate(input.template?.body, vars) ?? derivedBody$1(input);
 	const recordId = calendarEventsRecordId(input.ruleId, input.scheduleWindow.endMs);
 	return input.targets.filter((t) => !optedOut.has(t.targetId)).map((target) => {
@@ -34326,6 +34519,7 @@ var NcCalendarEventsProducer = class {
 	}
 	async enqueue(rule, scheduleWindow, eventWindow, calendarIds, events) {
 		const inputs = buildCalendarEventsOutboxInputs({
+			texts: this.deps.texts,
 			ruleId: rule.id,
 			ruleName: rule.name,
 			scheduleWindow,
@@ -34340,7 +34534,7 @@ var NcCalendarEventsProducer = class {
 			priority: rule.priority,
 			...rule.template !== void 0 ? { template: rule.template } : {}
 		});
-		for (const input of inputs) await this.deps.outbox.enqueue(input);
+		await this.deps.outbox.enqueue(inputs);
 		this.deps.logger.info("calendar-events delivered", { meta: {
 			ruleId: rule.id,
 			events: events.length,
@@ -35699,16 +35893,25 @@ function stateItem(row, lookup) {
 /**
 * THE RECONCILE (D647 review I2, D8): a ledger row is a memory, never the
 * truth. A device item is listed only while the device EXISTS in the directory
-* and is not an accessory — and an "offline" one only while the device
-* manager does not call it online. A node item only while the node is known
-* to a complete node directory (a forgotten node is gone), and an "offline"
-* one only while the directory does not call it online.
+* — and an "offline" one only while the device manager does not call it
+* online. A node item only while the node is known to a complete node
+* directory (a forgotten node is gone), and an "offline" one only while the
+* directory does not call it online.
+*
+* Accessories are silenced only on the liveness / switched-off section
+* (`device-state`). Battery, consumable and tank alerts ride the SAME
+* reconcile, and a vacuum that is a child of its Dreame container
+* (`parentDeviceId` set) still owns those alerts — filtering every accessory
+* here dropped every tank line of the 2026-10-05 evening summary for
+* deviceId 4385 while the episode was open and the instant path had already
+* held `device-tank-low` for that rule.
 */
 function stillTrue(item, ports) {
 	const deviceId = item.subject.deviceId;
 	if (deviceId !== void 0) {
 		const identity = ports.lookup(deviceId);
-		if (identity === void 0 || isAccessoryIdentity(identity)) return false;
+		if (identity === void 0) return false;
+		if (item.section === "device-state" && isAccessoryIdentity(identity)) return false;
 		if (item.subject.kind === "device-offline" && identity.online === true) return false;
 	}
 	const nodeId = item.subject.nodeId;
@@ -38817,6 +39020,7 @@ var NotificationCenter = class {
 			store: this.calendarEventsRules,
 			outbox: this.outbox,
 			calendars: calendarsPort,
+			texts: this.texts,
 			logger: this.logger.child("calendar-events"),
 			now: this.now
 		});
@@ -40987,8 +41191,14 @@ var NotificationCenter = class {
 		}
 		if (kind !== "alarm-armed" && kind !== "alarm-arming") return null;
 		if (mode === void 0) return null;
-		const coverage = this.coverageFor(panel).find((c) => c.mode === mode);
-		if (coverage === void 0) return null;
+		const coverage = this.coverageFor(panel).find((c) => c.mode === mode) ?? {
+			mode,
+			ruleCount: 0,
+			allDevices: false,
+			allDevicesExcept: [],
+			deviceIds: [],
+			skippedDevices: []
+		};
 		const name = this.deviceNameFromDirectory();
 		const bypassed = panel.excludedDevices();
 		const text = kind === "alarm-arming" ? buildArmingAnnouncement(coverage, transition.seconds ?? 0, name, bypassed) : buildArmAnnouncement(coverage, name, bypassed);
@@ -57660,36 +57870,68 @@ var DEFAULT_STATE_ANALYZER_CONFIG = {
 	stillWindowMs: DEFAULT_STILL_WINDOW_MS,
 	stillSpanFraction: DEFAULT_STILL_SPAN_FRACTION
 };
+function shortSideOf(bbox) {
+	return Math.min(bbox.w, bbox.h);
+}
 var StateAnalyzer = class {
 	config;
 	states = /* @__PURE__ */ new Map();
+	parked = /* @__PURE__ */ new Map();
 	constructor(config = {}) {
 		this.config = {
 			...DEFAULT_STATE_ANALYZER_CONFIG,
 			...config
 		};
 	}
-	/** D683: a fused continuation keeps its movement state under the survivor id. */
+	/**
+	* D683: a fused continuation keeps its movement state under the survivor id.
+	*
+	* The absorbed piece is the live continuation, but a still subject that L1
+	* split must not lose the dwell the survivor already paid — `rename` MERGES
+	* the stillness clocks when the geometry across the gap is still still, and
+	* only takes the live piece alone when the subject actually moved.
+	*/
 	rename(from, to) {
-		renameKey(this.states, from, to);
+		const live = this.states.get(from) ?? this.parked.get(from)?.state;
+		if (live === void 0) return;
+		this.states.delete(from);
+		this.parked.delete(from);
+		const survivor = this.states.get(to) ?? this.parked.get(to)?.state;
+		this.parked.delete(to);
+		if (survivor === void 0) {
+			this.states.set(to, live);
+			return;
+		}
+		this.states.set(to, this.mergeContinuation(survivor, live));
 	}
 	analyze(tracks, timestamp) {
+		this.pruneParked(timestamp);
 		const currentIds = new Set(tracks.map((t) => t.trackId));
 		const results = [];
 		for (const track of tracks) {
 			let ts = this.states.get(track.trackId);
+			if (ts === void 0) {
+				const parked = this.parked.get(track.trackId);
+				if (parked !== void 0) {
+					this.parked.delete(track.trackId);
+					ts = parked.state;
+					this.states.set(track.trackId, ts);
+				}
+			}
 			const center = bboxCentroid({
 				x: track.bbox.x,
 				y: track.bbox.y,
 				w: track.bbox.w,
 				h: track.bbox.h
 			});
+			const shortSide = shortSideOf(track.bbox);
 			if (!ts) {
 				ts = {
 					enteredAt: timestamp,
 					stationarySince: void 0,
 					totalDistancePx: 0,
 					lastPosition: center,
+					lastShortSide: shortSide,
 					frameCount: 1,
 					recent: [{
 						x: center.x,
@@ -57704,14 +57946,14 @@ var StateAnalyzer = class {
 				const dist = Math.sqrt(dx * dx + dy * dy);
 				ts.totalDistancePx += dist;
 				ts.lastPosition = center;
+				ts.lastShortSide = shortSide;
 				ts.frameCount++;
 				ts.recent.push({
 					x: center.x,
 					y: center.y,
 					at: timestamp
 				});
-				const cutoff = timestamp - this.config.stillWindowMs;
-				while (ts.recent.length > 2 && ts.recent[1].at < cutoff) ts.recent.shift();
+				this.trimRecent(ts, timestamp);
 			}
 			const velocity = track.velocity ? Math.sqrt(track.velocity.dx ** 2 + track.velocity.dy ** 2) : 0;
 			const dwellTimeMs = timestamp - ts.enteredAt;
@@ -57747,10 +57989,62 @@ var StateAnalyzer = class {
 				dwellTimeMs: timestamp - ts.enteredAt
 			});
 			this.states.delete(trackId);
+			this.parked.set(trackId, {
+				state: ts,
+				parkedAt: timestamp
+			});
 		}
 		return results;
 	}
 	/**
+	* Fold a live continuation into its ended survivor.
+	*
+	* Stillness is what the parked-object ledger votes on (`idle` only). A gap
+	* past L1's coast budget that L2 later heals must not restart that clock
+	* when the centroid never left the still span. A continuation that DID move
+	* drops the survivor's `stationarySince` so a walk after a pause is still
+	* `moving`.
+	*/
+	mergeContinuation(survivor, live) {
+		const gapTravel = Math.hypot(live.lastPosition.x - survivor.lastPosition.x, live.lastPosition.y - survivor.lastPosition.y);
+		const subject = Math.max(survivor.lastShortSide, live.lastShortSide);
+		const stillAcrossGap = survivor.stationarySince !== void 0 && subject > 0 && gapTravel <= subject * this.config.stillSpanFraction;
+		const lastAt = live.recent[live.recent.length - 1]?.at;
+		if (stillAcrossGap && survivor.stationarySince !== void 0 && lastAt !== void 0) {
+			const anchorAt = lastAt - this.config.stillWindowMs;
+			const recent = [{
+				x: live.lastPosition.x,
+				y: live.lastPosition.y,
+				at: anchorAt
+			}, ...live.recent.filter((s) => s.at > anchorAt)];
+			return {
+				enteredAt: Math.min(survivor.enteredAt, live.enteredAt),
+				stationarySince: live.stationarySince !== void 0 ? Math.min(survivor.stationarySince, live.stationarySince) : survivor.stationarySince,
+				totalDistancePx: survivor.totalDistancePx + live.totalDistancePx,
+				lastPosition: live.lastPosition,
+				lastShortSide: live.lastShortSide,
+				frameCount: Math.max(survivor.frameCount + live.frameCount, this.config.enteringFrames + 1),
+				recent
+			};
+		}
+		return {
+			enteredAt: live.enteredAt,
+			stationarySince: live.stationarySince,
+			totalDistancePx: survivor.totalDistancePx + live.totalDistancePx,
+			lastPosition: live.lastPosition,
+			lastShortSide: live.lastShortSide,
+			frameCount: live.frameCount,
+			recent: [...live.recent]
+		};
+	}
+	trimRecent(ts, timestamp) {
+		const cutoff = timestamp - this.config.stillWindowMs;
+		while (ts.recent.length > 2 && ts.recent[1].at < cutoff) ts.recent.shift();
+	}
+	pruneParked(timestamp) {
+		for (const [id, parked] of this.parked) if (timestamp - parked.parkedAt > LINK_WINDOW_MS) this.parked.delete(id);
+	}
+	/**
 	* The SPEED half of the settled test.
 	*
 	* Uncalibrated (`stillSpeedFracPerSec` undefined) this is the original line
@@ -57812,6 +58106,7 @@ var StateAnalyzer = class {
 	}
 	reset() {
 		this.states.clear();
+		this.parked.clear();
 	}
 };
 //#endregion
@@ -87001,23 +87296,19 @@ function sweepOne(deps, deviceId) {
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/stationary/stationary-zones.ts
+/** Shared with every call — ZoneEngine is stateless for annotateDetection. */
+var ENGINE = new ZoneEngine();
 /**
-* Zone ids whose 0–1 polygon contains the entry's normalised bbox centroid.
-* Empty when the entry has no frame dims (can't normalise) or no zone matches.
+* Zone ids whose bbox overlap exceeds `minOverlap` (0–1 fraction of the
+* detection's own area) — identical to {@link ZoneEngine.annotateDetection}.
+* Empty when the entry has no frame dims or no zone meets the bar.
+*
+* `minOverlap` is required: callers pass `TrackingSettings.zoneMembershipMinOverlap`
+* so parked and live never disagree on the threshold.
 */
-function computeStationaryEntryZones(entry, zones) {
+function computeStationaryEntryZones(entry, zones, minOverlap) {
 	if (entry.frameWidth <= 0 || entry.frameHeight <= 0 || zones.length === 0) return [];
-	const centroidPx = bboxCentroid(entry.bbox);
-	const point = {
-		x: centroidPx.x / entry.frameWidth,
-		y: centroidPx.y / entry.frameHeight
-	};
-	const matched = [];
-	for (const zone of zones) {
-		if (zone.polygon.length < 3) continue;
-		if (pointInPolygon$1(point, zone.polygon)) matched.push(zone.id);
-	}
-	return matched;
+	return ENGINE.annotateDetection(entry.bbox, zones, entry.frameWidth, entry.frameHeight, void 0, void 0, void 0, minOverlap).map((m) => m.zoneId);
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/package-drop-detector.ts
@@ -87117,15 +87408,17 @@ var PackageDropDetector = class {
 		}
 		const ruleZoneIds = new Set(rules.flatMap((r) => r.zoneIds));
 		const zones = await this.deps.resolveZones(entry.deviceId);
-		const entryZones = computeStationaryEntryZones(entry, zones);
+		const minOverlap = await this.deps.resolveZoneMembershipMinOverlap(entry.deviceId);
+		const entryZones = computeStationaryEntryZones(entry, zones, minOverlap);
 		const hitZones = entryZones.filter((z) => ruleZoneIds.has(z));
 		if (hitZones.length === 0) {
-			this.deps.logger.info("package gate 2/5 zone — centroid outside every package zone", {
+			this.deps.logger.info("package gate 2/5 zone — no package zone meets membership overlap", {
 				tags,
 				meta: {
 					entryId: entry.id,
 					bbox: entry.bbox,
 					entryZones,
+					minOverlap,
 					ruleZoneIds: [...ruleZoneIds],
 					zonesOnDevice: zones.length
 				}
@@ -100897,7 +101190,7 @@ function buildDetectionSettingsSections() {
 					type: "number",
 					key: "zoneMembershipMinOverlap",
 					label: "Zone membership minimum overlap",
-					description: "How much of a detection box must fall inside a zone for the detection to be STAMPED with it — as a fraction of the BOX area, not of the zone. 0 stamps on any touch, which is what let a plant brushing a zone by 6% fire a \"person on the doorstep\" rule. Only a stamped zone can match a zone-scoped notification rule. Read the \"zone membership stamped on event\" log line to choose the value: it prints the achieved percentage per zone.",
+					description: "How much of a detection box must fall inside a zone for the detection to be STAMPED with it — as a fraction of the BOX area, not of the zone. Same bar for live tracks and parked (stationary) occupancy. 0 stamps on any touch, which is what let a plant brushing a zone by 6% fire a \"person on the doorstep\" rule. Only a stamped zone can match a zone-scoped notification rule. Read the \"zone membership stamped on event\" log line to choose the value: it prints the achieved percentage per zone.",
 					min: 0,
 					max: 1,
 					step: .05,
@@ -104118,14 +104411,21 @@ var ZoneAnalyticsProvider = class {
 				meta: { error: err instanceof Error ? err.message : String(err) }
 			});
 		}
+		const minOverlap = await this.resolveMinOverlap(deviceId);
 		const ts = mostRecentStationaryConfirmedAt(entries) || Date.now();
 		return buildStationarySnapshot({
 			deviceId,
 			entries,
 			zones,
-			timestamp: ts
+			timestamp: ts,
+			minOverlap
 		});
 	}
+	/** Tracking membership bar — schema default when the host did not wire it. */
+	async resolveMinOverlap(deviceId) {
+		if (this.ctx.resolveZoneMembershipMinOverlap === void 0) return TRACKING_DEFAULTS.zoneMembershipMinOverlap;
+		return this.ctx.resolveZoneMembershipMinOverlap(deviceId);
+	}
 	/**
 	* Baseline sampler tick: for every device with parked objects, append a
 	* hydrated sample to the history ring at the CURRENT time — but only when a
@@ -104143,11 +104443,13 @@ var ZoneAnalyticsProvider = class {
 			try {
 				zones = await this.ctx.resolveZones?.(deviceId) ?? [];
 			} catch {}
+			const minOverlap = await this.resolveMinOverlap(deviceId);
 			const snapshot = buildStationarySnapshot({
 				deviceId,
 				entries,
 				zones,
-				timestamp: now
+				timestamp: now,
+				minOverlap
 			});
 			if (snapshot) {
 				this.appendHistory(deviceId, snapshot);
@@ -104304,18 +104606,18 @@ function mostRecentStationaryConfirmedAt(entries) {
 /**
 * Build an occupancy snapshot from parked-object registry entries alone —
 * used when no live inference frame is available (fresh respawn, camera
-* detached). Each entry is folded into the frame aggregate AND attributed to
-* the zones its normalised bbox centroid falls inside (via
-* {@link computeStationaryEntryZones}), so a zone drawn over a parked car
-* reports a count of 1. Returns `null` for an empty entry list. Reuses
-* {@link computeSnapshot} — the SAME aggregation the live frame path runs.
+* detached). Each entry is folded into the frame aggregate AND attributed via
+* {@link computeStationaryEntryZones} (same `ZoneEngine` + `minOverlap` as
+* live stamps), so a zone drawn over a parked car reports a count of 1.
+* Returns `null` for an empty entry list. Reuses {@link computeSnapshot} —
+* the SAME aggregation the live frame path runs.
 */
 function buildStationarySnapshot(input) {
 	if (input.entries.length === 0) return null;
 	const tracked = input.entries.map((e) => ({
 		trackId: `stationary:${e.id}`,
 		className: e.className,
-		zones: computeStationaryEntryZones(e, input.zones),
+		zones: computeStationaryEntryZones(e, input.zones, input.minOverlap),
 		standing: true
 	}));
 	const first = input.entries[0];
@@ -107138,6 +107440,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			resolveZones: (deviceId) => this.resolveDeviceZones(deviceId),
 			resolvePackageRules: (deviceId) => this.resolveDevicePackageRules(deviceId),
 			resolveSettings: (deviceId) => this.resolveDevicePackageDropSettings(deviceId),
+			resolveZoneMembershipMinOverlap: async (deviceId) => (await this.resolveDeviceTrackingSettings(deviceId)).zoneMembershipMinOverlap,
 			onPersisted: (ev, phase) => this.notificationCenter?.onPackageEventPersisted(ev, phase),
 			onError: (scope, err) => logger.warn("package-drop detector error", { meta: {
 				scope,
@@ -107433,6 +107736,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			listStationaryObjects: (deviceId) => this.stationaryRegistry?.listViews(deviceId) ?? [],
 			listStationaryDeviceIds: () => this.stationaryRegistry?.deviceIds() ?? [],
 			resolveZones: (deviceId) => this.resolveDeviceZones(deviceId),
+			resolveZoneMembershipMinOverlap: async (deviceId) => (await this.resolveDeviceTrackingSettings(deviceId)).zoneMembershipMinOverlap,
 			onSnapshot: (deviceId, snapshot, evidence) => this.notificationCenter?.observeOccupancy(deviceId, snapshot, evidence)
 		});
 		this.zoneAnalytics = zoneAnalytics;
@@ -109769,7 +110073,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		const stationaryAsTracked = stationaryViews.map((v) => ({
 			trackId: `stationary:${v.id}`,
 			className: v.className,
-			zones: computeStationaryEntryZones(v, liveZones),
+			zones: computeStationaryEntryZones(v, liveZones, trk.zoneMembershipMinOverlap),
 			standing: true
 		}));
 		this.zoneAnalytics?.recordFrame({