@camstack/addon-post-analysis 1.2.638 → 1.2.640

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-DEcrrqRz.js");
+const require_clip_model_registry = require("../clip-model-registry-C8xdbChV.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -8995,6 +8995,7 @@ var en_default = {
 	"system.device-battery-low.title": "Battery low — {{deviceName}}",
 	"system.device-battery-low.body": "{{deviceName}} is down to {{percentage}}% battery",
 	"system.device-battery-low.body.binary": "{{deviceName}} reports a low battery",
+	"system.device-battery-low.body.unmeasured": "{{deviceName}} has a low battery",
 	"system.device-battery-normal.title": "Battery back to normal — {{deviceName}}",
 	"system.device-battery-normal.body": "{{deviceName}} is back to {{percentage}}% battery",
 	"system.device-battery-normal.body.binary": "{{deviceName}} no longer reports a low battery",
@@ -9395,6 +9396,7 @@ var it_default = {
 	"system.device-battery-low.title": "Batteria scarica — {{deviceName}}",
 	"system.device-battery-low.body": "{{deviceName}} è al {{percentage}}% di batteria",
 	"system.device-battery-low.body.binary": "{{deviceName}} segnala la batteria scarica",
+	"system.device-battery-low.body.unmeasured": "{{deviceName}} ha la batteria scarica",
 	"system.device-battery-normal.title": "Batteria rientrata — {{deviceName}}",
 	"system.device-battery-normal.body": "{{deviceName}} è risalito al {{percentage}}% di batteria",
 	"system.device-battery-normal.body.binary": "{{deviceName}} non segnala più la batteria scarica",
@@ -78853,6 +78855,97 @@ function alertSubjectDeviceId(subject) {
 	return Number.isInteger(parsed) ? parsed : void 0;
 }
 //#endregion
+//#region src/notification-center/alerts/consumable-subject.ts
+/**
+* A consumable EPISODE's name, and the thresholds the rule set asks for (D642).
+*
+* Before D642 one cluster-wide threshold judged every item, so an item had one
+* episode: `consumable:<deviceId>:<key>`. The threshold is now the RULE's, and
+* the ledger keeps one episode per threshold a rule asks for — each with its
+* own hysteresis, pending raise and reminder — named
+* `consumable@<threshold>:<deviceId>:<key>`.
+*
+* The threshold rides the FAMILY segment on purpose: the device id stays the
+* second segment (`alertSubjectDeviceId`, D636 — the log tag and the indexed
+* column read it), and the item key stays last and whole, whatever it holds.
+*
+* Pure. No clock, no I/O.
+*/
+var FAMILY = "consumable";
+/** The episode of `key` on `deviceId`, judged at `thresholdPercent`. */
+function consumableSubject(thresholdPercent, deviceId, key) {
+	return `${FAMILY}@${String(thresholdPercent)}:${String(deviceId)}:${key}`;
+}
+/** The pre-D642 subject of the same item — read only to carry it over. */
+function legacyConsumableSubject(deviceId, key) {
+	return `${FAMILY}:${String(deviceId)}:${key}`;
+}
+/** `null` for a subject that is not a consumable's. */
+function parseConsumableSubject(subject) {
+	const first = subject.indexOf(":");
+	const second = first < 0 ? -1 : subject.indexOf(":", first + 1);
+	if (first < 0 || second < 0) return null;
+	const family = subject.slice(0, first);
+	const deviceId = Number(subject.slice(first + 1, second));
+	const key = subject.slice(second + 1);
+	if (!Number.isInteger(deviceId) || key.length === 0) return null;
+	if (family === FAMILY) return {
+		thresholdPercent: require_clip_model_registry.NC_CONSUMABLE_LOW_PERCENT_DEFAULT,
+		deviceId,
+		key,
+		legacy: true
+	};
+	if (!family.startsWith(`${FAMILY}@`)) return null;
+	const thresholdPercent = Number(family.slice(11));
+	if (!Number.isInteger(thresholdPercent)) return null;
+	return {
+		thresholdPercent,
+		deviceId,
+		key,
+		legacy: false
+	};
+}
+/**
+* Every consumable threshold the rule set asks for, ascending.
+*
+* A rule asks when it is a system-event rule whose kinds include a consumable
+* kind — enabled or not: a disabled rule's episode stays PENDING (no rule
+* matched it) and is re-offered the moment the rule is switched back on
+* (D636), which is what that rule would have said had it been on. With no such
+* rule at all the default is still judged, so an episode exists for the first
+* rule an operator writes to hear (D636's "offered once per rule change").
+*/
+function consumableThresholdCensus(rules) {
+	const thresholds = /* @__PURE__ */ new Set();
+	for (const rule of rules) {
+		const condition = rule.conditions.systemEvent;
+		if (rule.delivery !== "system-event" || condition === void 0) continue;
+		if (!condition.kinds.some((kind) => require_clip_model_registry.NC_CONSUMABLE_SYSTEM_EVENT_KINDS.includes(kind))) continue;
+		thresholds.add(require_clip_model_registry.consumableLowPercentOf(condition));
+	}
+	if (thresholds.size === 0) thresholds.add(require_clip_model_registry.NC_CONSUMABLE_LOW_PERCENT_DEFAULT);
+	return [...thresholds].toSorted((a, b) => a - b);
+}
+//#endregion
+//#region src/notification-center/alerts/tank-subject.ts
+function tankSubject(deviceId, key) {
+	return `tank:${String(deviceId)}:${key}`;
+}
+/** `null` for a subject that is not a leftover tank episode. */
+function parseTankSubject(subject) {
+	const first = subject.indexOf(":");
+	const second = first < 0 ? -1 : subject.indexOf(":", first + 1);
+	if (first < 0 || second < 0) return null;
+	if (subject.slice(0, first) !== "tank") return null;
+	const deviceId = Number(subject.slice(first + 1, second));
+	const key = subject.slice(second + 1);
+	if (!Number.isInteger(deviceId) || key.length === 0) return null;
+	return {
+		deviceId,
+		key
+	};
+}
+//#endregion
 //#region src/notification-center/alerts/alert-store.ts
 /**
 * @durable class=ledger owner=notification-center
@@ -78973,6 +79066,7 @@ function mergeBootWindowAlertRow(stored, provisional) {
 }
 var NcAlertStore = class {
 	ledger;
+	logger;
 	/**
 	* THE BOOT WINDOW (D698). Battery slices arrive from the moment the centre
 	* starts, and the ledger is read only in the back-fill. A row written in that
@@ -78984,6 +79078,7 @@ var NcAlertStore = class {
 	*/
 	bootWindow;
 	constructor(deps) {
+		this.logger = deps.logger;
 		this.ledger = new DurableLedger({
 			spec: NC_ALERTS_SPEC,
 			kind: deps.records.kind(ncDurableRecordKinds["device-alerts"]),
@@ -79003,6 +79098,50 @@ var NcAlertStore = class {
 		this.bootWindow.settle();
 		return loaded;
 	}
+	/**
+	* Close open `tank:<id>:<key>` leftovers once (D934). Idempotent.
+	*
+	* A row closes when the same key is already a consumable episode in this
+	* ledger, or when an answered directory has no device for it. A live device
+	* whose key has not been seen yet is kept — the next consumable observation
+	* closes it. `battery:` rows are not tank subjects and are never touched.
+	* Deletes go through this ledger (D679).
+	*/
+	async sweepOpenTankLeftovers(input) {
+		const known = consumableKeysOf(this.ledger.snapshot());
+		const closing = [];
+		let kept = 0;
+		for (const row of this.ledger.snapshot()) {
+			if (!row.alerting) continue;
+			const tank = parseTankSubject(row.subject);
+			if (tank === null) continue;
+			const reason = tankCloseReason(tank, known, input.liveOwner(tank.deviceId));
+			if (reason === "keep") kept += 1;
+			else closing.push({
+				row,
+				reason
+			});
+		}
+		for (const item of closing) {
+			const deviceId = alertSubjectDeviceId(item.row.subject);
+			await this.ledger.forget(item.row.subject);
+			this.logger.info("leftover tank alert closed", {
+				...deviceId !== void 0 ? { tags: { deviceId } } : {},
+				meta: {
+					subject: item.row.subject,
+					reason: item.reason
+				}
+			});
+		}
+		this.logger.info("leftover tank alert sweep", { meta: {
+			closed: closing.length,
+			kept
+		} });
+		return {
+			closed: closing.length,
+			kept
+		};
+	}
 	/** Drop a deleted device's mirrored rows (the durable ones go by `deleteWhere`, D871). */
 	evictDevice(deviceId) {
 		return this.ledger.evictDevice(deviceId);
@@ -79030,77 +79169,21 @@ var NcAlertStore = class {
 		};
 	}
 };
-//#endregion
-//#region src/notification-center/alerts/consumable-subject.ts
-/**
-* A consumable EPISODE's name, and the thresholds the rule set asks for (D642).
-*
-* Before D642 one cluster-wide threshold judged every item, so an item had one
-* episode: `consumable:<deviceId>:<key>`. The threshold is now the RULE's, and
-* the ledger keeps one episode per threshold a rule asks for — each with its
-* own hysteresis, pending raise and reminder — named
-* `consumable@<threshold>:<deviceId>:<key>`.
-*
-* The threshold rides the FAMILY segment on purpose: the device id stays the
-* second segment (`alertSubjectDeviceId`, D636 — the log tag and the indexed
-* column read it), and the item key stays last and whole, whatever it holds.
-*
-* Pure. No clock, no I/O.
-*/
-var FAMILY = "consumable";
-/** The episode of `key` on `deviceId`, judged at `thresholdPercent`. */
-function consumableSubject(thresholdPercent, deviceId, key) {
-	return `${FAMILY}@${String(thresholdPercent)}:${String(deviceId)}:${key}`;
-}
-/** The pre-D642 subject of the same item — read only to carry it over. */
-function legacyConsumableSubject(deviceId, key) {
-	return `${FAMILY}:${String(deviceId)}:${key}`;
-}
-/** `null` for a subject that is not a consumable's. */
-function parseConsumableSubject(subject) {
-	const first = subject.indexOf(":");
-	const second = first < 0 ? -1 : subject.indexOf(":", first + 1);
-	if (first < 0 || second < 0) return null;
-	const family = subject.slice(0, first);
-	const deviceId = Number(subject.slice(first + 1, second));
-	const key = subject.slice(second + 1);
-	if (!Number.isInteger(deviceId) || key.length === 0) return null;
-	if (family === FAMILY) return {
-		thresholdPercent: require_clip_model_registry.NC_CONSUMABLE_LOW_PERCENT_DEFAULT,
-		deviceId,
-		key,
-		legacy: true
-	};
-	if (!family.startsWith(`${FAMILY}@`)) return null;
-	const thresholdPercent = Number(family.slice(11));
-	if (!Number.isInteger(thresholdPercent)) return null;
-	return {
-		thresholdPercent,
-		deviceId,
-		key,
-		legacy: false
-	};
+function consumableKey(deviceId, key) {
+	return `${String(deviceId)}:${key}`;
 }
-/**
-* Every consumable threshold the rule set asks for, ascending.
-*
-* A rule asks when it is a system-event rule whose kinds include a consumable
-* kind — enabled or not: a disabled rule's episode stays PENDING (no rule
-* matched it) and is re-offered the moment the rule is switched back on
-* (D636), which is what that rule would have said had it been on. With no such
-* rule at all the default is still judged, so an episode exists for the first
-* rule an operator writes to hear (D636's "offered once per rule change").
-*/
-function consumableThresholdCensus(rules) {
-	const thresholds = /* @__PURE__ */ new Set();
-	for (const rule of rules) {
-		const condition = rule.conditions.systemEvent;
-		if (rule.delivery !== "system-event" || condition === void 0) continue;
-		if (!condition.kinds.some((kind) => require_clip_model_registry.NC_CONSUMABLE_SYSTEM_EVENT_KINDS.includes(kind))) continue;
-		thresholds.add(require_clip_model_registry.consumableLowPercentOf(condition));
+function consumableKeysOf(rows) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		const parts = parseConsumableSubject(row.subject);
+		if (parts !== null) keys.add(consumableKey(parts.deviceId, parts.key));
 	}
-	if (thresholds.size === 0) thresholds.add(require_clip_model_registry.NC_CONSUMABLE_LOW_PERCENT_DEFAULT);
-	return [...thresholds].toSorted((a, b) => a - b);
+	return keys;
+}
+function tankCloseReason(tank, known, owner) {
+	if (known.has(consumableKey(tank.deviceId, tank.key))) return "consumable key already known";
+	if (owner === false) return "no live owner";
+	return "keep";
 }
 //#endregion
 //#region src/notification-center/alerts/consumable-band.ts
@@ -79853,6 +79936,24 @@ function incomingFromBatteryBand(input) {
 	});
 }
 /**
+* The summary sentence for a battery episode whose slice has not been read
+* since boot. It names the device and nothing else: a missing level is not
+* 0%, and it is not the binary indicator's sentence.
+*/
+function incomingFromUnmeasuredBattery(input) {
+	const kind = "device-battery-low";
+	return systemSubject({
+		facts: input.facts,
+		kind,
+		subject: `battery:${input.deviceId}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body.unmeasured`,
+		textParams: deviceTextParams(input.deviceId, input.identity),
+		deviceId: input.deviceId,
+		...input.identity !== void 0 ? { deviceType: input.identity.type } : {}
+	});
+}
+/**
 * A consumable BAND, as a system-event subject.
 *
 * Built exactly like {@link incomingFromBatteryBand} — the operator asked for
@@ -80828,22 +80929,24 @@ function deliveryForKind(kind) {
 }
 //#endregion
 //#region src/notification-center/alerts/open-alert.ts
+/** `battery:<deviceId>` — nothing else. A `tank:` subject is not one of these. */
+function isBatterySubject(subject) {
+	const deviceId = alertSubjectDeviceId(subject);
+	return deviceId !== void 0 && subject === `battery:${String(deviceId)}`;
+}
 function unmeasuredEpisode(input) {
 	const deviceId = alertSubjectDeviceId(input.subject);
 	if (deviceId === void 0) return null;
 	const identity = input.lookup(deviceId);
 	const facts = input.facts;
-	if (input.family === "battery") return incomingFromBatteryBand({
-		facts,
-		deviceId,
-		band: "low",
-		reading: {
-			percentage: 0,
-			lastUpdated: 0,
-			binary: true
-		},
-		identity
-	});
+	if (input.family === "battery") {
+		if (!isBatterySubject(input.subject)) return null;
+		return incomingFromUnmeasuredBattery({
+			facts,
+			deviceId,
+			identity
+		});
+	}
 	const parts = parseConsumableSubject(input.subject);
 	if (parts !== null && parts.legacy) {
 		const parsed = parseProviderVerdictDetail(input.detail);
@@ -80917,6 +81020,15 @@ function isProviderVerdictDetail(detail) {
 }
 function openAlertOf(row, input) {
 	const parts = parseConsumableSubject(row.subject);
+	const battery = isBatterySubject(row.subject);
+	if (parts === null && !battery) {
+		const deviceId = alertSubjectDeviceId(row.subject);
+		input.logger?.warn("open alert skipped — subject is neither a battery nor a consumable", {
+			...deviceId !== void 0 ? { tags: { deviceId } } : {},
+			meta: { subject: row.subject }
+		});
+		return null;
+	}
 	const family = parts !== null ? "consumable" : "battery";
 	const subject = (input.restated ?? unmeasuredEpisode({
 		subject: row.subject,
@@ -81137,6 +81249,7 @@ var NcDeviceAlerts = class {
 	*/
 	/** One item from the consumables slice — every form (D934). */
 	observeConsumableItem(deviceId, sliceItem) {
+		this.closeTankLeftover(deviceId, sliceItem.key);
 		if (sliceItem.wear !== null) {
 			this.observeConsumable(deviceId, sliceItem.wear);
 			return;
@@ -81317,13 +81430,15 @@ var NcDeviceAlerts = class {
 		for (const row of this.deps.rows.all()) {
 			if (!row.alerting) continue;
 			const restated = this.restatementOf(row.subject);
+			const logger = this.logger();
 			const open = openAlertOf(row, {
 				facts,
 				restated: restated === null ? null : restated(facts),
-				lookup: this.deps.lookup
+				lookup: this.deps.lookup,
+				...logger !== void 0 ? { logger } : {}
 			});
 			if (open !== null) out.push(open);
-			else this.logger()?.debug("open alert left out of the state summary — it cannot be worded", {
+			else if (parseConsumableSubject(row.subject) !== null || isBatterySubject(row.subject)) this.logger()?.debug("open alert left out of the state summary — it cannot be worded", {
 				...tagsOf(row.subject),
 				meta: { subject: row.subject }
 			});
@@ -81388,6 +81503,16 @@ var NcDeviceAlerts = class {
 		}
 		this.absentThresholds = absent;
 	}
+	/**
+	* A leftover `tank:<id>:<key>` ends when that key is seen on the consumables
+	* slice (D934). Silent: no recovery. A real `battery:` row is a different
+	* subject and is not touched.
+	*/
+	closeTankLeftover(deviceId, key) {
+		const subject = tankSubject(deviceId, key);
+		if (this.deps.rows.get(subject) === void 0) return;
+		this.dropRow(subject, "closed — the same key is a consumable (D934)");
+	}
 	/** Remove one row, mirror and durable, with a line that names why. */
 	dropRow(subject, reason) {
 		this.offeredAt.delete(subject);
@@ -101584,7 +101709,13 @@ async function runBootBackfill(host) {
 	if (!await phase("alertEpisodes", () => host.hydrateAlertEpisodes())) return;
 	if (!await phase("deviceAlerts", async () => {
 		const rows = await host.alertStore.load();
-		host.logger.info("device alert ledger reseeded", { meta: { rows } });
+		const directoryAnswered = host.deviceDirectory.answeredGeneration() > 0;
+		const tankLeftovers = await host.alertStore.sweepOpenTankLeftovers({ liveOwner: (deviceId) => directoryAnswered ? host.deviceDirectory.get(deviceId) !== void 0 : void 0 });
+		host.logger.info("device alert ledger reseeded", { meta: {
+			rows,
+			tankLeftoversClosed: tankLeftovers.closed,
+			tankLeftoversKept: tankLeftovers.kept
+		} });
 	})) return;
 	if (!await phase("stateSummary", async () => {
 		const loaded = await host.stateSummary.load();
@@ -112207,7 +112338,7 @@ var MotionEpisodeTracker = class {
 *
 * A single timeout is the call's bound doing its job. Three uncertain confirms
 * in a row, with no yes and no no between them, is the provider not answering
-* — the shape camera 615 showed on 2026-10-26 (nine timeouts, zero answers).
+* — the shape camera 102 showed on 2026-10-26 (nine timeouts, zero answers).
 * A time window would also count a timeout that a later answer already closed.
 * The streak resets on any answer. A further uncertain while the edge is
 * open does not raise again.