@camstack/addon-post-analysis 1.2.282 → 1.2.283

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-D0zzdvSd.js");
+const require_dist = require("../dist-CT5xOY86.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -6663,6 +6663,8 @@ var SceneEngine = class {
 var DEFAULT_LOAD_LIMIT = 1e5;
 var DurableLedger = class DurableLedger {
 	mirror = /* @__PURE__ */ new Map();
+	/** Whether ANY load has read the store successfully — see {@link hasAnswered}. */
+	answered = false;
 	spec;
 	store;
 	logger;
@@ -6718,6 +6720,7 @@ var DurableLedger = class DurableLedger {
 			}
 			this.mirror.clear();
 			for (const [key, row] of next) this.mirror.set(key, row);
+			this.answered = true;
 			if (skipped > 0) this.logger.warn("durable rows skipped as malformed — they gate NOTHING", { meta: {
 				collection: this.spec.collection,
 				skipped
@@ -6732,6 +6735,16 @@ var DurableLedger = class DurableLedger {
 			return [...this.mirror.values()];
 		}
 	}
+	/**
+	* Whether the mirror is an ANSWER from the store: true once any load has
+	* succeeded, and never false again (a later failed load keeps that answer).
+	* Before it, an empty mirror is "not read yet", never "the store is empty" —
+	* {@link load} swallows its failure, so a caller that must tell the two apart
+	* asks here (D642 review I1).
+	*/
+	hasAnswered() {
+		return this.answered;
+	}
 	/** Every mirrored row, insertion-ordered. */
 	snapshot() {
 		return [...this.mirror.values()];
@@ -8465,6 +8478,78 @@ 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: 15,
+		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_dist.NC_CONSUMABLE_SYSTEM_EVENT_KINDS.includes(kind))) continue;
+		thresholds.add(require_dist.consumableLowPercentOf(condition));
+	}
+	if (thresholds.size === 0) thresholds.add(15);
+	return [...thresholds].toSorted((a, b) => a - b);
+}
 function deriveConsumableBand(input) {
 	const { level, status } = input.reading;
 	const measured = level !== null && Number.isFinite(level);
@@ -10128,6 +10213,9 @@ function systemEventExclusion(condition, subject) {
 	if (wantedPackages !== void 0 && applies("packageNames")) {
 		if (!subjectPackages(subject).some((name) => wantedPackages.includes(name))) return "packageNames";
 	}
+	if (applies("consumableLowPercent") && subject.consumableLowPercent !== void 0) {
+		if (subject.consumableLowPercent !== require_dist.consumableLowPercentOf(condition)) return "consumableLowPercent";
+	}
 }
 function subjectNodes(subject) {
 	const ids = [...subject.nodeIds ?? []];
@@ -11007,6 +11095,7 @@ function systemSubject(input) {
 				...input.packageNames !== void 0 ? { packageNames: input.packageNames } : {},
 				...input.textCount !== void 0 ? { textCount: input.textCount } : {},
 				...input.alarmSource !== void 0 ? { alarmSource: input.alarmSource } : {},
+				...input.consumableLowPercent !== void 0 ? { consumableLowPercent: input.consumableLowPercent } : {},
 				data
 			}
 		},
@@ -11108,9 +11197,11 @@ function incomingFromBatteryBand(input) {
 * these to be treated as the battery notifications are — with two differences
 * that come from the subject and not from taste:
 *
-*  - **the subject carries the ITEM.** `consumable:<deviceId>:<key>`, because a
-*    vacuum has a brush AND a filter AND a mop pad, and one subject for all
-*    three would let the brush's alert cancel the filter's.
+*  - **the subject carries the ITEM.** `consumable@<threshold>:<deviceId>:<key>`,
+*    because a vacuum has a brush AND a filter AND a mop pad, and one subject
+*    for all three would let the brush's alert cancel the filter's. It carries
+*    the THRESHOLD too (D642): each rule's threshold is its own episode, and
+*    the engine pairs a rule with the episode judged at its own number.
 *  - **the body variant follows what is KNOWN.** An item with no percentage
 *    gets a finished sentence rather than a template with a stand-in number in
 *    it, for the same reason a binary battery does.
@@ -11119,17 +11210,46 @@ function incomingFromBatteryBand(input) {
 */
 function incomingFromConsumableBand(input) {
 	const kind = input.band === "low" ? "device-consumable-low" : "device-consumable-normal";
-	const measured = input.item.level !== null && Number.isFinite(input.item.level);
+	const level = input.item.level;
+	const percentage = level !== null && Number.isFinite(level) ? Math.round(level) : null;
+	const measured = percentage !== null;
 	return systemSubject({
 		facts: input.facts,
 		kind,
-		subject: `consumable:${input.deviceId}:${input.item.key}`,
+		subject: consumableSubject(input.thresholdPercent, input.deviceId, input.item.key),
 		titleKey: `system.${kind}.title`,
 		bodyKey: measured ? `system.${kind}.body` : `system.${kind}.body.unmeasured`,
 		textParams: {
 			...deviceTextParams(input.deviceId, input.identity),
 			item: input.item.label,
-			...measured ? { percentage: String(Math.round(input.item.level)) } : {}
+			...percentage !== null ? { percentage: String(percentage) } : {}
+		},
+		deviceId: input.deviceId,
+		consumableLowPercent: input.thresholdPercent,
+		...input.identity !== void 0 ? { deviceType: input.identity.type } : {}
+	});
+}
+/**
+* A vacuum TANK band, as a system-event subject (D642).
+*
+* Built like {@link incomingFromConsumableBand}: `tank:<deviceId>:<tank>` is
+* one subject per tank (the dust bin's alert must not cancel the clean water's),
+* and the recovery keeps it. The BODY VARIANT names the tank in the reader's
+* language — the params are frozen before the language is known, so the tank's
+* name cannot be a param; `tank` carries the stable token for a custom
+* template.
+*/
+function incomingFromTankBand(input) {
+	const kind = input.band === "low" ? "device-tank-low" : input.band === "full" ? "device-tank-full" : "device-tank-normal";
+	return systemSubject({
+		facts: input.facts,
+		kind,
+		subject: `tank:${String(input.deviceId)}:${input.tank}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body.${input.tank}`,
+		textParams: {
+			...deviceTextParams(input.deviceId, input.identity),
+			tank: input.tank
 		},
 		deviceId: input.deviceId,
 		...input.identity !== void 0 ? { deviceType: input.identity.type } : {}
@@ -11717,6 +11837,91 @@ function deliveryForKind(kind) {
 	return kind;
 }
 //#endregion
+//#region src/notification-center/alerts/tank-band.ts
+/**
+* A vacuum TANK reduced to the only thing worth storing: its band (D642).
+*
+* The `vacuum-control` slice carries four tanks — clean water, dirty water,
+* detergent, dust bin — each `null` when the hardware has none, else
+* `{ level, status }`. The operator asked for them to notify like consumables:
+* clean water / detergent running low, dirty water / dust bin full.
+*
+* ## The verdict is the provider's
+*
+* A tank's `status` is the device's own float switch (`ok` | `low` | `full`),
+* and it is the ONLY thing judged. The hub has no threshold for a tank level:
+* the rule for thresholds is that they belong to whoever generates the event,
+* and a tank that says `low` has already decided. A tank that reports only a
+* `level` is therefore not judged at all (`null`) rather than judged against a
+* number the hub would have to invent.
+*
+* ## `null` is the third answer, and it is not `normal`
+*
+* An unknown status says nothing — it neither opens nor closes an episode, for
+* the reason `battery-band.ts` gives: a reading nobody took is not evidence
+* that anything changed.
+*
+* Pure. No clock, no I/O.
+*/
+/** The four tanks `vacuum-control` names, by their slice field. */
+var NC_TANK_KEYS = [
+	"cleanWater",
+	"dirtyWater",
+	"detergent",
+	"dustBin"
+];
+/**
+* How long a tank change must HOLD before it counts (D642 review M2).
+*
+* A float switch sloshing at the edge of `low` / `full` flips its status back
+* and forth while the robot moves; each flip is a durable transition, and
+* without a hold each one is a raise and a recovery on the operator's phone.
+* One minute is two reload ticks: long enough to outlast a slosh, short enough
+* that a genuinely full dust bin is said within a minute and a half.
+*/
+var NC_TANK_HOLD_MS = 6e4;
+function deriveTankBand(reading) {
+	switch (reading.status) {
+		case "low": return "low";
+		case "full": return "full";
+		case "ok": return "normal";
+		case null: return null;
+	}
+}
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tankStatusOf(value) {
+	return value === "ok" || value === "low" || value === "full" ? value : null;
+}
+/**
+* A `device.state-changed` payload carrying a `vacuum-control` slice, reduced
+* to its tanks. `null` for any other cap. A tank the hardware does not have
+* (`null`) is skipped; a malformed field reads as unknown, never as a
+* fabricated verdict (D393: absent is not zero).
+*/
+function vacuumTanksOf(data) {
+	if (data["capName"] !== "vacuum-control") return null;
+	const deviceId = data["deviceId"];
+	const slice = data["slice"];
+	if (typeof deviceId !== "number" || !isRecord$4(slice)) return null;
+	const tanks = [];
+	for (const key of NC_TANK_KEYS) {
+		const raw = slice[key];
+		if (!isRecord$4(raw)) continue;
+		const level = raw["level"];
+		tanks.push({
+			key,
+			level: typeof level === "number" && Number.isFinite(level) ? level : null,
+			status: tankStatusOf(raw["status"])
+		});
+	}
+	return tanks.length === 0 ? null : {
+		deviceId,
+		tanks
+	};
+}
+//#endregion
 //#region src/notification-center/alerts/battery-band.ts
 /**
 * The stand-in a provider writes for a binary NORMAL. Anything below it, on a
@@ -11747,10 +11952,14 @@ function deriveBatteryBand(input) {
 * `NcDeviceAlerts` — the one place a SUSTAINED device fault becomes a
 * notification, and keeps becoming one until it stops being true.
 *
-* It owns two families and nothing else:
+* It owns these families and nothing else:
 *
 *  - **battery band** — `battery:<deviceId>`, fed by the `battery` runtime-state
 *    slice that already arrives on `device.state-changed`;
+*  - **consumable band** — `consumable@<threshold>:<deviceId>:<key>`, one
+*    episode per item per threshold a RULE asks for (D642);
+*  - **tank band** — `tank:<deviceId>:<tank>`, a vacuum's tanks, judged on the
+*    provider's own verdict (D642);
 *  - **the reminder tick** — the operator's "how often do you say it again".
 *
 * It does NOT own device liveness. `device-offline` already has a producer, a
@@ -11790,6 +11999,10 @@ var PENDING_CADENCE_MAX_MS = 36e5;
 function pendingCadenceMs(settings) {
 	return settings.renotifyMinutes > 0 ? Math.min(settings.renotifyMinutes * 6e4, PENDING_CADENCE_MAX_MS) : PENDING_CADENCE_MAX_MS;
 }
+/** The RAM key of one item's last reading — every threshold's episode reads it. */
+function itemKeyOf(deviceId, key) {
+	return `${String(deviceId)}:${key}`;
+}
 var NcDeviceAlerts = class {
 	deps;
 	now;
@@ -11801,8 +12014,28 @@ var NcDeviceAlerts = class {
 	* durable.
 	*/
 	lastReading = /* @__PURE__ */ new Map();
-	/** The last reading per consumable SUBJECT, for the reminder sweep. */
+	/**
+	* The last reading per consumable ITEM (`<deviceId>:<key>`), for the
+	* reminder sweep and for judging a threshold a rule gains later (D642).
+	*/
 	lastConsumable = /* @__PURE__ */ new Map();
+	/** The last reading per tank SUBJECT, for the reminder sweep. */
+	lastTank = /* @__PURE__ */ new Map();
+	/**
+	* Tank changes on HOLD (review M2): a band that would move the episode,
+	* first seen at `since`. It counts once it has held for `NC_TANK_HOLD_MS`,
+	* confirmed by a later slice write or by the reload tick — no timer of its
+	* own, so nothing outlives the device. Bounded by the device's tanks (four),
+	* and dropped with the device by {@link forget}.
+	*/
+	tankHold = /* @__PURE__ */ new Map();
+	/**
+	* Thresholds some episode row carries that the LAST census did not ask for.
+	* A threshold's rows are retired only when two consecutive censuses agree it
+	* is gone (D49: a read that would destroy work needs a second read to
+	* agree). RAM only: a restart costs one more tick of patience.
+	*/
+	absentThresholds = /* @__PURE__ */ new Set();
 	/**
 	* Subject → WHEN its PENDING raise was last offered, and to which
 	* {@link NcDeviceAlertsDeps.rulesVersion}. RAM only, on purpose: after a
@@ -11860,31 +12093,137 @@ var NcDeviceAlerts = class {
 	* observed.
 	*/
 	observeConsumable(deviceId, item) {
-		const subject = `consumable:${deviceId}:${item.key}`;
-		const previous = this.deps.rows.get(subject);
+		this.lastConsumable.set(itemKeyOf(deviceId, item.key), {
+			deviceId,
+			item
+		});
+		const thresholds = this.deps.consumableThresholds();
+		if (thresholds === null) {
+			this.logger()?.debug("consumable reading kept — the rules have not been read yet", {
+				tags: { deviceId },
+				meta: { item: item.key }
+			});
+			return;
+		}
 		const settings = this.deps.settings();
+		for (const thresholdPercent of thresholds) this.judgeConsumable(deviceId, item, thresholdPercent, settings);
+	}
+	/**
+	* ONE vacuum tank, from a device's `vacuum-control` slice (D642).
+	*
+	* The provider's verdict is the band (`tank-band.ts`); an unknown status
+	* leaves everything untouched, an open episode included.
+	*/
+	observeTank(deviceId, tank) {
+		const band = deriveTankBand(tank);
+		if (band === null) return;
+		const subject = `tank:${String(deviceId)}:${tank.key}`;
+		this.lastTank.set(subject, {
+			deviceId,
+			tank
+		});
+		if (!this.tankChangeHeld(subject, deviceId, band)) return;
+		this.apply(subject, band !== "normal", this.deps.settings(), (facts, alerting) => incomingFromTankBand({
+			facts,
+			deviceId,
+			band: alerting ? band : "normal",
+			tank: tank.key,
+			identity: this.deps.lookup(deviceId)
+		}));
+	}
+	/**
+	* Has this tank band held long enough to move its episode? A band that
+	* would not move it (a repeat, or low ⇄ full inside one open episode) passes
+	* at once and clears any hold — that is what makes a flapping switch start
+	* its hold over every time it flips back. A first HEALTHY observation passes
+	* too: it seeds silently, so there is nothing to hold.
+	*/
+	tankChangeHeld(subject, deviceId, band) {
+		const row = this.deps.rows.get(subject);
+		const alerting = band !== "normal";
+		if (!(row === void 0 ? alerting : row.alerting !== alerting)) {
+			this.tankHold.delete(subject);
+			return true;
+		}
+		const nowMs = this.now();
+		const held = this.tankHold.get(subject);
+		if (held === void 0 || held.band !== band) {
+			this.tankHold.set(subject, {
+				band,
+				since: nowMs
+			});
+			this.logger()?.debug("tank change on hold — counts once it has held", {
+				tags: { deviceId },
+				meta: {
+					subject,
+					band,
+					holdMs: NC_TANK_HOLD_MS
+				}
+			});
+			return false;
+		}
+		if (nowMs - held.since < 6e4) return false;
+		this.tankHold.delete(subject);
+		return true;
+	}
+	/** The tick's half of the hold: a change that has held with no new slice write. */
+	confirmHeldTanks() {
+		const nowMs = this.now();
+		for (const [subject, held] of [...this.tankHold]) {
+			if (nowMs - held.since < 6e4) continue;
+			const reading = this.lastTank.get(subject);
+			if (reading === void 0) {
+				this.tankHold.delete(subject);
+				continue;
+			}
+			this.observeTank(reading.deviceId, reading.tank);
+		}
+	}
+	/** One item against ONE threshold: its own episode, its own hysteresis. */
+	judgeConsumable(deviceId, item, thresholdPercent, settings) {
+		const subject = consumableSubject(thresholdPercent, deviceId, item.key);
+		const previous = this.deps.rows.get(subject) ?? this.adoptLegacy(subject, deviceId, item.key);
 		const band = deriveConsumableBand({
 			reading: {
 				level: item.level,
 				status: item.status
 			},
-			thresholdPercent: settings.consumableLowPercent,
+			thresholdPercent,
 			previous: previous?.alerting === true ? "low" : previous === void 0 ? void 0 : "normal"
 		});
 		if (band === null) return;
-		this.lastConsumable.set(subject, {
-			deviceId,
-			item
-		});
 		this.apply(subject, band === "low", settings, (facts, alerting) => incomingFromConsumableBand({
 			facts,
 			deviceId,
 			band: alerting ? "low" : "normal",
 			item,
+			thresholdPercent,
 			identity: this.deps.lookup(deviceId)
 		}));
 	}
 	/**
+	* A pre-D642 row of this item (`consumable:<id>:<key>`, judged at the
+	* cluster threshold, which shipped as the rule default) is carried over to
+	* the default-threshold episode rather than re-announced: the live vacuum
+	* had two items low and reminding when D642 shipped. Any other threshold
+	* starts fresh; an unadopted legacy row retires with the census.
+	*/
+	adoptLegacy(subject, deviceId, key) {
+		const parts = parseConsumableSubject(subject);
+		const legacySubject = legacyConsumableSubject(deviceId, key);
+		const legacy = this.deps.rows.get(legacySubject);
+		if (legacy === void 0 || parts === null) return void 0;
+		const legacyParts = parseConsumableSubject(legacySubject);
+		if (legacyParts === null || legacyParts.thresholdPercent !== parts.thresholdPercent) return;
+		const adopted = {
+			...legacy,
+			subject
+		};
+		this.deps.rows.put(adopted);
+		this.dropRow(legacySubject, "carried over to its threshold episode (D642)");
+		return adopted;
+	}
+	/**
 	* The reminder sweep. Called from an existing periodic tick; it allocates
 	* nothing on the healthy path.
 	*
@@ -11895,6 +12234,9 @@ var NcDeviceAlerts = class {
 	*/
 	tick() {
 		const settings = this.deps.settings();
+		const thresholds = this.deps.consumableThresholds();
+		if (thresholds !== null) this.reconcileThresholds(thresholds, settings);
+		this.confirmHeldTanks();
 		this.retryPending(settings);
 		if (settings.renotifyMinutes <= 0) return;
 		for (const row of this.deps.rows.all()) {
@@ -11927,14 +12269,58 @@ var NcDeviceAlerts = class {
 		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.lastTank.delete(subject);
 			this.offeredAt.delete(subject);
 			await this.deps.rows.remove(subject);
 		}
 		this.lastReading.delete(`battery:${deviceId}`);
+		for (const [key, reading] of this.lastConsumable) if (reading.deviceId === deviceId) this.lastConsumable.delete(key);
+		for (const subject of this.tankHold.keys()) if (alertSubjectDeviceId(subject) === deviceId) this.tankHold.delete(subject);
+		for (const subject of this.lastTank.keys()) if (alertSubjectDeviceId(subject) === deviceId) this.lastTank.delete(subject);
 		return subjects.length;
 	}
 	/**
+	* Bring the consumable episodes in line with the thresholds the rules ask
+	* for (D642). A threshold with no episode for an item yet is judged from the
+	* item's last reading — a rule that gains a threshold hears about an item
+	* already past it on the next tick, not at the next slice write. A
+	* threshold that no rule asks for any more has its episodes RETIRED, but
+	* only when two consecutive censuses agree it is gone; retiring is silent
+	* (nothing recovered — nobody is listening at that number any more) and
+	* logged per row.
+	*/
+	reconcileThresholds(thresholds, settings) {
+		for (const { deviceId, item } of this.lastConsumable.values()) for (const thresholdPercent of thresholds) {
+			if (this.deps.rows.get(consumableSubject(thresholdPercent, deviceId, item.key))) continue;
+			this.judgeConsumable(deviceId, item, thresholdPercent, settings);
+		}
+		const absent = /* @__PURE__ */ new Set();
+		for (const row of this.deps.rows.all()) {
+			const parts = parseConsumableSubject(row.subject);
+			if (parts === null || thresholds.includes(parts.thresholdPercent)) continue;
+			absent.add(parts.thresholdPercent);
+			if (this.absentThresholds.has(parts.thresholdPercent)) this.dropRow(row.subject, "retired — no rule judges consumables at this threshold (D642)");
+		}
+		this.absentThresholds = absent;
+	}
+	/** Remove one row, mirror and durable, with a line that names why. */
+	dropRow(subject, reason) {
+		this.offeredAt.delete(subject);
+		this.logger()?.info(`device alert ${reason}`, {
+			...tagsOf(subject),
+			meta: { subject }
+		});
+		this.deps.rows.remove(subject).catch((error) => {
+			this.logger()?.warn("device alert row could not be removed", {
+				...tagsOf(subject),
+				meta: {
+					subject,
+					error: error instanceof Error ? error.message : String(error)
+				}
+			});
+		});
+	}
+	/**
 	* 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
@@ -11966,14 +12352,25 @@ var NcDeviceAlerts = class {
 	}
 	/** 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({
+		const parts = parseConsumableSubject(subject);
+		const consumable = parts === null || parts.legacy ? void 0 : this.lastConsumable.get(itemKeyOf(parts.deviceId, parts.key));
+		if (parts !== null && consumable !== void 0) return (facts) => incomingFromConsumableBand({
 			facts,
 			deviceId: consumable.deviceId,
 			band: "low",
 			item: consumable.item,
+			thresholdPercent: parts.thresholdPercent,
 			identity: this.deps.lookup(consumable.deviceId)
 		});
+		const tank = this.lastTank.get(subject);
+		const tankBand = tank === void 0 ? null : deriveTankBand(tank.tank);
+		if (tank !== void 0 && (tankBand === "low" || tankBand === "full")) return (facts) => incomingFromTankBand({
+			facts,
+			deviceId: tank.deviceId,
+			band: tankBand,
+			tank: tank.tank.key,
+			identity: this.deps.lookup(tank.deviceId)
+		});
 		const battery = this.lastReading.get(subject);
 		if (battery !== void 0) return (facts) => incomingFromBatteryBand({
 			facts,
@@ -12073,11 +12470,9 @@ var NcDeviceAlerts = class {
 	report(subject, verdict, alerting) {
 		const logger = this.deps.logger;
 		if (logger === void 0) return;
-		const deviceId = alertSubjectDeviceId(subject);
-		const tags = deviceId !== void 0 ? { deviceId } : {};
 		if (verdict.kind === "silent" && !alerting) {
 			logger.debug("device alert cleared without a notification", {
-				tags,
+				...tagsOf(subject),
 				meta: {
 					subject,
 					reason: "notifyRecovery is off, or nothing changed"
@@ -12086,7 +12481,7 @@ var NcDeviceAlerts = class {
 			return;
 		}
 		logger.debug("device alert said nothing", {
-			tags,
+			...tagsOf(subject),
 			meta: {
 				subject,
 				verdict: verdict.kind
@@ -12497,6 +12892,21 @@ var en_default = {
 	"system.device-consumable-normal.title": "Consumable replaced",
 	"system.device-consumable-normal.body": "{{item}} on {{deviceName}} is back to {{percentage}}%",
 	"system.device-consumable-normal.body.unmeasured": "{{item}} on {{deviceName}} is OK again",
+	"system.device-tank-low.title": "Tank low",
+	"system.device-tank-full.title": "Tank full",
+	"system.device-tank-normal.title": "Tank OK",
+	"system.device-tank-low.body.cleanWater": "The clean water tank on {{deviceName}} is running low",
+	"system.device-tank-full.body.cleanWater": "The clean water tank on {{deviceName}} is full",
+	"system.device-tank-normal.body.cleanWater": "The clean water tank on {{deviceName}} is OK again",
+	"system.device-tank-low.body.dirtyWater": "The dirty water tank on {{deviceName}} is running low",
+	"system.device-tank-full.body.dirtyWater": "The dirty water tank on {{deviceName}} is full",
+	"system.device-tank-normal.body.dirtyWater": "The dirty water tank on {{deviceName}} is OK again",
+	"system.device-tank-low.body.detergent": "The detergent tank on {{deviceName}} is running low",
+	"system.device-tank-full.body.detergent": "The detergent tank on {{deviceName}} is full",
+	"system.device-tank-normal.body.detergent": "The detergent tank on {{deviceName}} is OK again",
+	"system.device-tank-low.body.dustBin": "The dust bin on {{deviceName}} is running low",
+	"system.device-tank-full.body.dustBin": "The dust bin on {{deviceName}} is full",
+	"system.device-tank-normal.body.dustBin": "The dust bin on {{deviceName}} is OK again",
 	"system.camera-online.title": "Device online",
 	"system.camera-online.body": "Device {{deviceName}} is online",
 	"system.camera-offline.title": "Device offline",
@@ -12786,6 +13196,21 @@ var it_default = {
 	"system.device-consumable-normal.title": "Consumabile sostituito",
 	"system.device-consumable-normal.body": "{{item}} su {{deviceName}} è tornato al {{percentage}}%",
 	"system.device-consumable-normal.body.unmeasured": "{{item}} su {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.title": "Serbatoio quasi vuoto",
+	"system.device-tank-full.title": "Serbatoio pieno",
+	"system.device-tank-normal.title": "Serbatoio a posto",
+	"system.device-tank-low.body.cleanWater": "Il serbatoio dell'acqua pulita di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.cleanWater": "Il serbatoio dell'acqua pulita di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.cleanWater": "Il serbatoio dell'acqua pulita di {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.body.dirtyWater": "Il serbatoio dell'acqua sporca di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.dirtyWater": "Il serbatoio dell'acqua sporca di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.dirtyWater": "Il serbatoio dell'acqua sporca di {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.body.detergent": "Il serbatoio del detergente di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.detergent": "Il serbatoio del detergente di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.detergent": "Il serbatoio del detergente di {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.body.dustBin": "Il contenitore della polvere di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.dustBin": "Il contenitore della polvere di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.dustBin": "Il contenitore della polvere di {{deviceName}} è di nuovo a posto",
 	"system.camera-online.title": "Dispositivo online",
 	"system.camera-online.body": "Il dispositivo {{deviceName}} è online",
 	"system.camera-offline.title": "Dispositivo offline",
@@ -14169,6 +14594,10 @@ function systemEventKeys(kind) {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body.ignored`
 	};
+	if (require_dist.NC_TANK_SYSTEM_EVENT_KINDS.includes(kind)) return {
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body.cleanWater`
+	};
 	return {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body`
@@ -16184,7 +16613,7 @@ function makeNcActionHandlers(deps) {
 			catalog: [...require_dist.NC_CONDITION_CATALOG],
 			taxonomy: require_dist.NC_TAXONOMY
 		}),
-		"nc.getTemplateCatalog": async () => ({ vars: [...require_dist.NC_TEMPLATE_VARS] }),
+		"nc.getTemplateCatalog": async () => ({ vars: require_dist.servedTemplateVars() }),
 		"nc.previewTemplate": async (input) => {
 			const texts = deps.previewTexts;
 			if (texts === void 0) throw new Error("nc.previewTemplate: text catalog not wired");
@@ -23764,7 +24193,7 @@ var NcRuleStore = class {
 	*/
 	async load() {
 		await this.ledger.load();
-		this.loaded = true;
+		if (this.ledger.hasAnswered()) this.loaded = true;
 		this.logger.debug("notification rules loaded", { meta: { rules: this.ledger.size } });
 	}
 	/**
@@ -28194,7 +28623,6 @@ var ARM_ANYWAY_REJECTION_COPY = {
 */
 var NC_DEVICE_ALERT_FALLBACK = {
 	batteryLowPercent: 20,
-	consumableLowPercent: 15,
 	renotifyMinutes: 720,
 	notifyRecovery: true
 };
@@ -29449,6 +29877,7 @@ var NotificationCenter = class NotificationCenter {
 				return (await this.consumeEventAndReport(event)).outcomes.some((outcome) => outcome.matched);
 			},
 			rulesVersion: () => this.rulesFingerprint(),
+			consumableThresholds: () => this.rules.isLoaded() ? consumableThresholdCensus(this.rules.list()) : null,
 			settings: () => this.deviceAlertSettings(),
 			lookup: (deviceId) => this.deviceDirectory.get(deviceId),
 			rows: this.alertStore.port(),
@@ -30557,6 +30986,11 @@ var NotificationCenter = class NotificationCenter {
 			for (const item of consumables.items) this.deviceAlerts.observeConsumable(consumables.deviceId, item);
 			return;
 		}
+		const tanks = event.category === "device.state-changed" ? vacuumTanksOf(event.data) : null;
+		if (tanks !== null) {
+			for (const tank of tanks.tanks) this.deviceAlerts.observeTank(tanks.deviceId, tank);
+			return;
+		}
 		const lookup = this.deviceDirectory.lookup();
 		const incoming = incomingFromSystemEvent(event, lookup);
 		if (incoming === null) {
@@ -30675,7 +31109,7 @@ var NotificationCenter = class NotificationCenter {
 				catalog: [...require_dist.NC_CONDITION_CATALOG],
 				taxonomy: require_dist.NC_TAXONOMY
 			}),
-			getTemplateCatalog: async () => ({ vars: [...require_dist.NC_TEMPLATE_VARS] }),
+			getTemplateCatalog: async () => ({ vars: require_dist.servedTemplateVars() }),
 			previewTemplate: async (input) => previewTemplate(this.texts, input),
 			getHistory: async ({ filter }) => {
 				const entries = await this.outbox.queryHistory({
@@ -32478,7 +32912,6 @@ var NotificationCenter = class NotificationCenter {
 	deviceAlertSettings() {
 		return this.deps.readDeviceAlertSettings?.() ?? {
 			batteryLowPercent: NC_DEVICE_ALERT_FALLBACK.batteryLowPercent,
-			consumableLowPercent: NC_DEVICE_ALERT_FALLBACK.consumableLowPercent,
 			renotifyMinutes: NC_DEVICE_ALERT_FALLBACK.renotifyMinutes,
 			notifyRecovery: NC_DEVICE_ALERT_FALLBACK.notifyRecovery
 		};
@@ -56100,19 +56533,6 @@ var DeviceAlertSettingsSchema = require_dist.object({
 	*/
 	batteryLowPercent: require_dist.number().int().min(1).max(99).default(20),
 	/**
-	* What counts as a nearly-exhausted CONSUMABLE — a filter, a brush, a mop pad.
-	*
-	* Its own number and not the battery's, because the two are different chores
-	* on different clocks: a battery at 20 % is hours from flat, a brush at 20 %
-	* is weeks from worn, and an operator who wants to be told early about one
-	* does not necessarily want to be told early about the other.
-	*
-	* Applies to the MEASURED side only. An item whose provider states a
-	* `replace` verdict is low whatever this says — the provider decided, and a
-	* threshold cannot talk it out of it (`alerts/consumable-band.ts`).
-	*/
-	consumableLowPercent: require_dist.number().int().min(1).max(99).default(15),
-	/**
 	* How long a still-true alert waits before it says itself again.
 	*
 	* **0 = say it once.** That is the behaviour of every other notification this
@@ -77816,7 +78236,7 @@ function buildGlobalSettingsSchema(cap) {
 		{
 			id: "device-alerts",
 			title: "Battery & offline alerts",
-			description: "What counts as a low battery, how often a still-true alert is repeated, and whether the return to normal is announced. These govern the “Battery” and “Devices & streams” system-event rules; the rules themselves still choose which devices and which kinds. A device with a binary low-battery indicator (no real percentage) is judged by the indicator, and the threshold below does not apply to it.",
+			description: "What counts as a low battery, how often a still-true alert is repeated, and whether the return to normal is announced. These govern the device-event rules; the rules themselves still choose which devices and which kinds — and each rule sets its own consumable threshold. A device with a binary low-battery indicator (no real percentage) is judged by the indicator, and the threshold below does not apply to it.",
 			columns: 2,
 			fields: [
 				{
@@ -77830,17 +78250,6 @@ function buildGlobalSettingsSchema(cap) {
 					default: DEVICE_ALERT_DEFAULTS.batteryLowPercent,
 					unit: "%"
 				},
-				{
-					type: "number",
-					key: "consumableLowPercent",
-					label: "Low consumable at",
-					description: "At or below this, a measured consumable — a filter, a brush, a mop pad — is nearly exhausted. Its own number rather than the battery’s: a battery at 20% is hours from flat, a brush at 20% is weeks from worn. An item whose device reports “replace” outright is announced whatever this says.",
-					min: 1,
-					max: 99,
-					step: 1,
-					default: DEVICE_ALERT_DEFAULTS.consumableLowPercent,
-					unit: "%"
-				},
 				{
 					type: "number",
 					key: "alertRenotifyMinutes",
@@ -84000,7 +84409,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			},
 			readDeviceAlertSettings: () => ({
 				batteryLowPercent: this.deviceAlertSettingsMirror.batteryLowPercent,
-				consumableLowPercent: this.deviceAlertSettingsMirror.consumableLowPercent,
 				renotifyMinutes: this.deviceAlertSettingsMirror.alertRenotifyMinutes,
 				notifyRecovery: this.deviceAlertSettingsMirror.alertNotifyRecovery
 			}),