@camstack/addon-post-analysis 1.2.277 → 1.2.279

package/dist/pipeline-analytics/{hostInit-CN-6SOYG.mjs → hostInit-Bhp_DANc.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.251",
+				version: "1.2.253",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.201",
+				version: "1.2.203",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

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-MPbaDp6L.js");
+const require_dist = require("../dist-BUtk8EU2.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -8219,6 +8219,99 @@ var NcAlarmLiveReadLog = class {
 	}
 };
 //#endregion
+//#region src/notification-center/alerts/alert-episode.ts
+function decideAlert(input) {
+	const previous = input.previous;
+	if (previous === void 0) return input.alerting ? { kind: "raise" } : { kind: "seeded" };
+	if (previous.alerting !== input.alerting) {
+		if (input.alerting) return { kind: "raise" };
+		if (previous.lastNotifiedAt <= 0) return { kind: "silent" };
+		return input.notifyRecovery ? { kind: "recover" } : { kind: "silent" };
+	}
+	if (!input.alerting) return { kind: "silent" };
+	if (input.renotifyMs <= 0) return { kind: "silent" };
+	if (previous.lastNotifiedAt <= 0) return { kind: "silent" };
+	if (input.nowMs - previous.lastNotifiedAt < input.renotifyMs) return { kind: "silent" };
+	return {
+		kind: "remind",
+		reminderIndex: previous.reminders + 1
+	};
+}
+/**
+* The row that survives a verdict.
+*
+* Split from {@link decideAlert} rather than returned with it because the
+* caller must be able to persist a row for a verdict it did NOT deliver — the
+* suppressed recovery is the whole reason (rule 3), and so is the silent seed.
+*/
+function nextAlertRow(subject, previous, alerting, verdict, nowMs) {
+	switch (verdict.kind) {
+		case "seeded": return {
+			subject,
+			alerting,
+			since: nowMs,
+			lastNotifiedAt: 0,
+			reminders: 0
+		};
+		case "raise":
+		case "recover": return {
+			subject,
+			alerting,
+			since: nowMs,
+			lastNotifiedAt: nowMs,
+			reminders: 0
+		};
+		case "remind": return {
+			subject,
+			alerting,
+			since: previous?.since ?? nowMs,
+			lastNotifiedAt: nowMs,
+			reminders: verdict.reminderIndex
+		};
+		case "silent":
+			if (previous === void 0) return {
+				subject,
+				alerting,
+				since: nowMs,
+				lastNotifiedAt: 0,
+				reminders: 0
+			};
+			if (previous.alerting !== alerting) return {
+				subject,
+				alerting,
+				since: nowMs,
+				lastNotifiedAt: previous.lastNotifiedAt,
+				reminders: 0
+			};
+			return previous;
+	}
+}
+/**
+* The `recordId` a notification for this episode carries — and therefore, via
+* the outbox's fallback, its `dedupRef`.
+*
+* `reminderIndex: 0` is the opening notification (and the recovery, which
+* opens the `normal` episode). Every reminder appends `:r<n>`, which is what
+* stops the 7-day outbox dedup swallowing it.
+*/
+function alertRecordId(subject, since, reminderIndex) {
+	const base = `${subject}:${since}`;
+	return reminderIndex > 0 ? `${base}:r${reminderIndex}` : base;
+}
+/**
+* The device a subject is about: `battery:3602` → 3602, and
+* `consumable:4385:sensor` → 4385. The id is the SECOND segment, never the
+* last — reading the last one turned every consumable subject into "no
+* device", which lost the `deviceId` tag on its log lines and the indexed
+* column on its durable row. `undefined` for a subject that names no device.
+*/
+function alertSubjectDeviceId(subject) {
+	const raw = subject.split(":")[1];
+	if (raw === void 0 || raw === "") return void 0;
+	const parsed = Number(raw);
+	return Number.isInteger(parsed) ? parsed : void 0;
+}
+//#endregion
 //#region src/notification-center/alerts/alert-store.ts
 /**
 * @durable class=ledger owner=notification-center
@@ -8276,9 +8369,9 @@ var NC_ALERTS_INDEXES = [{
 	name: "idx_nc_alerts_device",
 	columns: ["deviceId"]
 }];
+/** The device a subject is about — see {@link alertSubjectDeviceId}. */
 function deviceIdOf(subject) {
-	const parsed = Number(subject.slice(subject.lastIndexOf(":") + 1));
-	return Number.isInteger(parsed) ? parsed : void 0;
+	return alertSubjectDeviceId(subject);
 }
 var NC_ALERTS_SPEC = {
 	collection: NC_ALERTS_COLLECTION,
@@ -8338,7 +8431,8 @@ var NcAlertStore = class {
 			put: (row) => {
 				this.ledger.put(row).catch(() => void 0);
 			},
-			all: () => this.ledger.snapshot()
+			all: () => this.ledger.snapshot(),
+			remove: (subject) => this.ledger.forget(subject)
 		};
 	}
 };
@@ -9949,6 +10043,10 @@ function systemEventExclusion(condition, subject) {
 	if (condition.deviceIds !== void 0 && applies("deviceIds")) {
 		if (subject.deviceId === void 0 || !condition.deviceIds.includes(subject.deviceId)) return "deviceIds";
 	}
+	const excluded = condition.excludeDeviceIds;
+	if (excluded !== void 0 && applies("deviceIds")) {
+		if (subject.deviceId !== void 0 && excluded.includes(subject.deviceId)) return "excludeDeviceIds";
+	}
 	if (condition.deviceTypes !== void 0 && applies("deviceTypes")) {
 		if (subject.deviceType === void 0 || !condition.deviceTypes.includes(subject.deviceType)) return "deviceTypes";
 	}
@@ -11511,85 +11609,6 @@ function deliveryForKind(kind) {
 	return kind;
 }
 //#endregion
-//#region src/notification-center/alerts/alert-episode.ts
-function decideAlert(input) {
-	const previous = input.previous;
-	if (previous === void 0) return input.alerting ? { kind: "raise" } : { kind: "seeded" };
-	if (previous.alerting !== input.alerting) {
-		if (input.alerting) return { kind: "raise" };
-		return input.notifyRecovery ? { kind: "recover" } : { kind: "silent" };
-	}
-	if (!input.alerting) return { kind: "silent" };
-	if (input.renotifyMs <= 0) return { kind: "silent" };
-	if (previous.lastNotifiedAt <= 0) return { kind: "silent" };
-	if (input.nowMs - previous.lastNotifiedAt < input.renotifyMs) return { kind: "silent" };
-	return {
-		kind: "remind",
-		reminderIndex: previous.reminders + 1
-	};
-}
-/**
-* The row that survives a verdict.
-*
-* Split from {@link decideAlert} rather than returned with it because the
-* caller must be able to persist a row for a verdict it did NOT deliver — the
-* suppressed recovery is the whole reason (rule 3), and so is the silent seed.
-*/
-function nextAlertRow(subject, previous, alerting, verdict, nowMs) {
-	switch (verdict.kind) {
-		case "seeded": return {
-			subject,
-			alerting,
-			since: nowMs,
-			lastNotifiedAt: 0,
-			reminders: 0
-		};
-		case "raise":
-		case "recover": return {
-			subject,
-			alerting,
-			since: nowMs,
-			lastNotifiedAt: nowMs,
-			reminders: 0
-		};
-		case "remind": return {
-			subject,
-			alerting,
-			since: previous?.since ?? nowMs,
-			lastNotifiedAt: nowMs,
-			reminders: verdict.reminderIndex
-		};
-		case "silent":
-			if (previous === void 0) return {
-				subject,
-				alerting,
-				since: nowMs,
-				lastNotifiedAt: 0,
-				reminders: 0
-			};
-			if (previous.alerting !== alerting) return {
-				subject,
-				alerting,
-				since: nowMs,
-				lastNotifiedAt: previous.lastNotifiedAt,
-				reminders: 0
-			};
-			return previous;
-	}
-}
-/**
-* The `recordId` a notification for this episode carries — and therefore, via
-* the outbox's fallback, its `dedupRef`.
-*
-* `reminderIndex: 0` is the opening notification (and the recovery, which
-* opens the `normal` episode). Every reminder appends `:r<n>`, which is what
-* stops the 7-day outbox dedup swallowing it.
-*/
-function alertRecordId(subject, since, reminderIndex) {
-	const base = `${subject}:${since}`;
-	return reminderIndex > 0 ? `${base}:r${reminderIndex}` : base;
-}
-//#endregion
 //#region src/notification-center/alerts/battery-band.ts
 /**
 * The stand-in a provider writes for a binary NORMAL. Anything below it, on a
@@ -11651,6 +11670,18 @@ function deriveBatteryBand(input) {
 * that is already a FAULT — see `alert-episode.ts` rule 2 for why that is D141
 * rather than a loophole.
 */
+/** One hour — the longest a pending raise waits before it is offered again. */
+var PENDING_CADENCE_MAX_MS = 36e5;
+/**
+* How often a pending raise is offered again with the rules unchanged: the
+* re-notify interval, capped at one hour. The cap matters because the
+* cadence counts from the raise: with a 12 h interval, a rule whose schedule
+* opens for one hour a day could keep being missed. Reminders off ("say it
+* once") still has to say it once, hourly.
+*/
+function pendingCadenceMs(settings) {
+	return settings.renotifyMinutes > 0 ? Math.min(settings.renotifyMinutes * 6e4, PENDING_CADENCE_MAX_MS) : PENDING_CADENCE_MAX_MS;
+}
 var NcDeviceAlerts = class {
 	deps;
 	now;
@@ -11664,6 +11695,13 @@ var NcDeviceAlerts = class {
 	lastReading = /* @__PURE__ */ new Map();
 	/** The last reading per consumable SUBJECT, for the reminder sweep. */
 	lastConsumable = /* @__PURE__ */ new Map();
+	/**
+	* Subject → WHEN its PENDING raise was last offered, and to which
+	* {@link NcDeviceAlertsDeps.rulesVersion}. RAM only, on purpose: after a
+	* restart every pending raise is offered once more, which is bounded by the
+	* number of open episodes.
+	*/
+	offeredAt = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
 		this.now = deps.now ?? Date.now;
@@ -11749,34 +11787,94 @@ var NcDeviceAlerts = class {
 	*/
 	tick() {
 		const settings = this.deps.settings();
+		this.retryPending(settings);
 		if (settings.renotifyMinutes <= 0) return;
 		for (const row of this.deps.rows.all()) {
-			if (!row.alerting) continue;
-			const consumable = this.lastConsumable.get(row.subject);
-			if (consumable !== void 0) {
-				this.apply(row.subject, true, settings, (facts) => incomingFromConsumableBand({
-					facts,
-					deviceId: consumable.deviceId,
-					band: "low",
-					item: consumable.item,
-					identity: this.deps.lookup(consumable.deviceId)
-				}));
-				continue;
-			}
-			const restatement = this.lastReading.get(row.subject);
-			if (restatement === void 0) continue;
-			this.apply(row.subject, true, settings, (facts) => incomingFromBatteryBand({
-				facts,
-				deviceId: restatement.deviceId,
-				band: "low",
-				reading: restatement.reading,
-				identity: this.deps.lookup(restatement.deviceId)
-			}));
+			if (!row.alerting || isPending(row)) continue;
+			const build = this.restatementOf(row.subject);
+			if (build === null) continue;
+			this.apply(row.subject, true, settings, build);
 		}
 	}
-	/** Drop a subject (device removed), so a re-adoption starts a fresh episode. */
-	forget(deviceId) {
+	/**
+	* Every device that holds an alert row — what the deleted-device reconcile
+	* must look at besides the devices a rule names (a battery device no rule
+	* names still has a row).
+	*/
+	deviceIds() {
+		const ids = /* @__PURE__ */ new Set();
+		for (const row of this.deps.rows.all()) {
+			const id = alertSubjectDeviceId(row.subject);
+			if (id !== void 0) ids.add(id);
+		}
+		return [...ids];
+	}
+	/**
+	* A DELETED device: drop its battery row and every consumable row, durable
+	* and in RAM, so nothing restates it and a re-adoption starts a fresh
+	* episode. Called only by the deleted-device prune (D633), after the second
+	* read agreed the device is gone. Returns how many rows went.
+	*/
+	async forget(deviceId) {
+		const subjects = this.deps.rows.all().map((row) => row.subject).filter((subject) => alertSubjectDeviceId(subject) === deviceId);
+		for (const subject of subjects) {
+			this.lastReading.delete(subject);
+			this.lastConsumable.delete(subject);
+			this.offeredAt.delete(subject);
+			await this.deps.rows.remove(subject);
+		}
 		this.lastReading.delete(`battery:${deviceId}`);
+		return subjects.length;
+	}
+	/**
+	* Offer every PENDING raise once more — when the rule set changed since its
+	* last offer, OR when {@link pendingCadenceMs} has passed since it. The
+	* cadence is what delivers a raise refused only by a rule's SCHEDULE (or any
+	* other time-dependent gate): the rules do not change when the window
+	* opens. The restatement is RAM: a row whose reading has not arrived since
+	* the restart waits for it (the slice arrives on its own).
+	*/
+	retryPending(settings) {
+		const version = this.deps.rulesVersion();
+		const nowMs = this.now();
+		const cadenceMs = pendingCadenceMs(settings);
+		for (const row of this.deps.rows.all()) {
+			if (!isPending(row)) continue;
+			const last = this.offeredAt.get(row.subject);
+			const changed = last === void 0 || last.version !== version;
+			if (!changed && nowMs - last.at < cadenceMs) continue;
+			const build = this.restatementOf(row.subject);
+			if (build === null) continue;
+			this.logger()?.debug("device alert re-offered — no rule has matched it yet", {
+				...tagsOf(row.subject),
+				meta: {
+					subject: row.subject,
+					since: row.since,
+					reason: changed ? "rules" : "cadence"
+				}
+			});
+			this.speak(row.subject, row, { kind: "raise" }, build);
+		}
+	}
+	/** How to re-word a subject's alert from the last reading, or `null`. */
+	restatementOf(subject) {
+		const consumable = this.lastConsumable.get(subject);
+		if (consumable !== void 0) return (facts) => incomingFromConsumableBand({
+			facts,
+			deviceId: consumable.deviceId,
+			band: "low",
+			item: consumable.item,
+			identity: this.deps.lookup(consumable.deviceId)
+		});
+		const battery = this.lastReading.get(subject);
+		if (battery !== void 0) return (facts) => incomingFromBatteryBand({
+			facts,
+			deviceId: battery.deviceId,
+			band: "low",
+			reading: battery.reading,
+			identity: this.deps.lookup(battery.deviceId)
+		});
+		return null;
 	}
 	/**
 	* The shared half: decide, persist, and speak only when the verdict says to.
@@ -11801,16 +11899,63 @@ var NcDeviceAlerts = class {
 			this.report(subject, verdict, alerting);
 			return;
 		}
+		this.speak(subject, next, verdict, (facts) => build(facts, alerting));
+	}
+	/**
+	* Emit one verdict through the door, and — for a RAISE — hear whether any
+	* rule matched it. A raise no rule matched is put back to PENDING
+	* (`lastNotifiedAt: 0`), unless the row moved meanwhile; it is re-offered
+	* by {@link retryPending} when the rules change. A reminder or a recovery is
+	* not re-offered: the episode was already announced (or is over).
+	*/
+	speak(subject, row, verdict, build) {
+		const nowMs = this.now();
 		const reminderIndex = verdict.kind === "remind" ? verdict.reminderIndex : 0;
-		this.deps.emit(build({
-			eventId: alertRecordId(subject, next.since, reminderIndex),
+		const event = build({
+			eventId: alertRecordId(subject, row.since, reminderIndex),
 			timestamp: nowMs,
 			category: require_dist.EventCategory.DeviceStateChanged,
 			data: {
 				alertVerdict: verdict.kind,
 				reminderIndex
 			}
-		}, alerting));
+		});
+		if (verdict.kind !== "raise") {
+			this.deps.emit(event).catch(() => void 0);
+			return;
+		}
+		this.offeredAt.set(subject, {
+			version: this.deps.rulesVersion(),
+			at: nowMs
+		});
+		this.deps.emit(event).then((heard) => this.settleRaise(subject, row.since, heard, nowMs)).catch(() => void 0);
+	}
+	/** The door answered a raise. */
+	settleRaise(subject, since, heard, nowMs) {
+		const current = this.deps.rows.get(subject);
+		if (current === void 0 || !current.alerting || current.since !== since) return;
+		if (heard) {
+			this.offeredAt.delete(subject);
+			if (current.lastNotifiedAt !== nowMs) this.deps.rows.put({
+				...current,
+				lastNotifiedAt: nowMs
+			});
+			return;
+		}
+		if (current.lastNotifiedAt !== 0) this.deps.rows.put({
+			...current,
+			lastNotifiedAt: 0
+		});
+		this.logger()?.info("device alert matched NO rule — kept pending, offered again on a rule change or within the hour", {
+			...tagsOf(subject),
+			meta: {
+				subject,
+				since
+			}
+		});
+	}
+	logger() {
+		return this.deps.logger;
 	}
 	/**
 	* A dropped branch is never silent. The suppressed recovery in particular:
@@ -11820,7 +11965,7 @@ var NcDeviceAlerts = class {
 	report(subject, verdict, alerting) {
 		const logger = this.deps.logger;
 		if (logger === void 0) return;
-		const deviceId = deviceIdOfSubject(subject);
+		const deviceId = alertSubjectDeviceId(subject);
 		const tags = deviceId !== void 0 ? { deviceId } : {};
 		if (verdict.kind === "silent" && !alerting) {
 			logger.debug("device alert cleared without a notification", {
@@ -11844,11 +11989,16 @@ var NcDeviceAlerts = class {
 function speaks(verdict) {
 	return verdict.kind === "raise" || verdict.kind === "recover" || verdict.kind === "remind";
 }
-/** `battery:3602` → 3602. Undefined for a subject that names no device. */
-function deviceIdOfSubject(subject) {
-	const raw = subject.slice(subject.lastIndexOf(":") + 1);
-	const parsed = Number(raw);
-	return Number.isInteger(parsed) ? parsed : void 0;
+/**
+* A raise no rule matched: alerting, and never announced. A row in the
+* alerting state is otherwise always stamped, because it was raised.
+*/
+function isPending(row) {
+	return row.alerting && row.lastNotifiedAt <= 0;
+}
+function tagsOf(subject) {
+	const deviceId = alertSubjectDeviceId(subject);
+	return deviceId !== void 0 ? { tags: { deviceId } } : {};
 }
 //#endregion
 //#region src/notification-center/cap-caller.ts
@@ -19084,6 +19234,7 @@ var NcDeletedSubjectPruner = class {
 		return this.serialise(async () => {
 			if (!this.ready("event", deviceId)) return;
 			if (!await this.confirmDeleted(deviceId, "event")) return;
+			await this.forgetAlerts(deviceId, "event");
 			const deleted = new Set([deviceId]);
 			await this.apply(planDevicePrune(this.snapshot(), deleted, this.guard()), "event", (fresh) => planDevicePrune(fresh, deleted, this.guard()));
 		}, deviceId);
@@ -19093,15 +19244,17 @@ var NcDeletedSubjectPruner = class {
 		return this.serialise(async () => {
 			if (!this.ready("reconcile")) return;
 			const directory = this.deps.directory;
-			const candidates = [...referencedDeviceIds(this.snapshot())].filter((id) => directory.absentFromLastTwoAnswers(id));
+			const alerting = new Set(this.deps.alerts?.deviceIds() ?? []);
+			const candidates = [...new Set([...referencedDeviceIds(this.snapshot()), ...alerting])].filter((id) => directory.absentFromLastTwoAnswers(id));
 			if (candidates.length === 0) return;
 			const first = planDevicePrune(this.snapshot(), new Set(candidates), this.guard());
-			if (isEmptyPlan(first)) return;
-			const subjects = [...planSubjects(first)].map(Number);
+			const subjects = [...new Set([...[...planSubjects(first)].map(Number), ...candidates.filter((id) => alerting.has(id))])];
+			if (subjects.length === 0) return;
 			if (!this.withinBound("device", subjects.map(String))) return;
 			const confirmed = /* @__PURE__ */ new Set();
 			for (const id of subjects) if (await this.confirmDeleted(id, "reconcile")) confirmed.add(id);
 			if (confirmed.size === 0) return;
+			for (const id of confirmed) if (alerting.has(id)) await this.forgetAlerts(id, "reconcile");
 			await this.apply(planDevicePrune(this.snapshot(), confirmed, this.guard()), "reconcile", (fresh) => planDevicePrune(fresh, confirmed, this.guard()));
 		});
 	}
@@ -19179,6 +19332,33 @@ var NcDeletedSubjectPruner = class {
 			return false;
 		}
 	}
+	/**
+	* Drop a CONFIRMED-deleted device's alert rows. A failure is logged and
+	* retried by the next reconcile, which still sees the row.
+	*/
+	async forgetAlerts(deviceId, source) {
+		const alerts = this.deps.alerts;
+		if (alerts === void 0) return;
+		try {
+			const forgotten = await alerts.forget(deviceId);
+			if (forgotten === 0) return;
+			this.deps.logger.info("deleted device alerts forgotten", {
+				tags: { deviceId },
+				meta: {
+					source,
+					rows: forgotten
+				}
+			});
+		} catch (err) {
+			this.deps.logger.warn("deleted device alerts NOT forgotten — retried next tick", {
+				tags: { deviceId },
+				meta: {
+					source,
+					error: String(err)
+				}
+			});
+		}
+	}
 	withinBound(subjectKind, subjects) {
 		if (subjects.length <= 16) {
 			this.lastAbort.delete(subjectKind);
@@ -28268,9 +28448,10 @@ var NotificationCenter = class NotificationCenter {
 			logger: this.logger.child("device-alerts")
 		});
 		this.deviceAlerts = new NcDeviceAlerts({
-			emit: (event) => {
-				this.consumeEvent(event);
+			emit: async (event) => {
+				return (await this.consumeEventAndReport(event)).outcomes.some((outcome) => outcome.matched);
 			},
+			rulesVersion: () => this.rulesFingerprint(),
 			settings: () => this.deviceAlertSettings(),
 			lookup: (deviceId) => this.deviceDirectory.get(deviceId),
 			rows: this.alertStore.port(),
@@ -28372,6 +28553,7 @@ var NotificationCenter = class NotificationCenter {
 			summary: this.summaryRules,
 			mutes: this.deviceMutes,
 			alarm: () => this.alarmPanel,
+			alerts: this.deviceAlerts,
 			directory: this.deviceDirectory,
 			isDeviceDeleted: deps.isDeviceDeleted,
 			targetCatalog: () => this.dispatcher.catalogSnapshot()
@@ -31077,6 +31259,14 @@ var NotificationCenter = class NotificationCenter {
 	* wiring that silently disabled the feature would be indistinguishable from
 	* a hub with no low batteries on it.
 	*/
+	/**
+	* Which rules exist, and at which revision — the question "did anything
+	* change that could make an undelivered alert deliverable now?". Cheap: the
+	* rule mirror is in RAM and holds tens of rows.
+	*/
+	rulesFingerprint() {
+		return this.rules.list().map((rule) => `${rule.id}@${String(rule.updatedAt)}`).join("|");
+	}
 	deviceAlertSettings() {
 		return this.deps.readDeviceAlertSettings?.() ?? {
 			batteryLowPercent: NC_DEVICE_ALERT_FALLBACK.batteryLowPercent,