@camstack/addon-provider-dreame 0.2.149 → 0.2.151

package/dist/addon.mjs

@@ -5473,7 +5473,7 @@ var ZodIssueCode$1 = {
 var ZodFirstPartyTypeKind$1;
 ZodFirstPartyTypeKind$1 || (ZodFirstPartyTypeKind$1 = {});
 //#endregion
-//#region ../types/dist/sleep-DJFUfKvA.mjs
+//#region ../types/dist/sleep-CUp20JkO.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -8365,7 +8365,11 @@ var ContributionSectionSchema = object({
 		literal(4)
 	]).optional(),
 	tab: string().optional(),
-	location: _enum(["settings", "top-tab"]).optional(),
+	location: _enum([
+		"settings",
+		"top-tab",
+		"hero"
+	]).optional(),
 	order: number().optional(),
 	fields: array(any())
 });
@@ -13312,7 +13316,11 @@ var ConfigSectionWithValuesSchema = object({
 		literal(4)
 	]).optional(),
 	tab: string().optional(),
-	location: _enum(["settings", "top-tab"]).optional(),
+	location: _enum([
+		"settings",
+		"top-tab",
+		"hero"
+	]).optional(),
 	order: number().optional(),
 	fields: array(any())
 });
@@ -17192,6 +17200,52 @@ var TierStatusSchema = object({
 	countedAt: number().nullable()
 });
 /** Operator/diagnostic view: rows per tier, last runs, refusals and drops since boot. */
+/**
+* Why a series is orphan. `device-gone`: its device is absent from the
+* successful device listings (the departure clock). `undeclared`: its `cap:`
+* key is declared by no capability any more (a field a cap removed).
+*/
+var DeviceHistoryOrphanReasonSchema = _enum(["device-gone", "undeclared"]);
+/** Rows held per stored tier. */
+var TierRowsSchema = object({
+	raw: number().int(),
+	"5m": number().int(),
+	"1h": number().int(),
+	"1d": number().int()
+});
+var OrphanSeriesSchema = object({
+	seriesId: number().int(),
+	deviceId: number().int(),
+	key: string(),
+	scope: string(),
+	/** The metric's display name; `null` when its metric row is gone too. */
+	displayName: string().nullable(),
+	reason: DeviceHistoryOrphanReasonSchema,
+	/** `device-gone`: since when the device has been absent; `null` otherwise. */
+	missingSince: number().nullable(),
+	firstTs: number(),
+	lastTs: number(),
+	rows: TierRowsSchema
+});
+var DeviceHistoryOrphanDeleteRefusalSchema = _enum([
+	"not-found",
+	"not-orphan",
+	"failed"
+]);
+var OrphanDeleteEntrySchema = discriminatedUnion("ok", [object({
+	seriesId: number().int(),
+	ok: literal(true),
+	deleted: TierRowsSchema
+}), object({
+	seriesId: number().int(),
+	ok: literal(false),
+	reason: DeviceHistoryOrphanDeleteRefusalSchema
+})]);
+var OrphanListSchema = object({
+	series: array(OrphanSeriesSchema).readonly(),
+	/** More orphans exist than {@link DEVICE_HISTORY_ORPHAN_LIST_MAX}. */
+	truncated: boolean()
+});
 var DeviceHistoryStatusSchema = object({
 	startedAt: number(),
 	/** The store is declared, series loaded and the first reconcile has answered. */
@@ -17289,7 +17343,10 @@ method(object({ deviceId: number().int() }), array(SeriesInfoSchema).readonly())
 }), object({ enabled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), DeviceHistoryStatusSchema, { auth: "admin" });
+}), method(object({}), DeviceHistoryStatusSchema, { auth: "admin" }), method(object({}), OrphanListSchema, { auth: "admin" }), method(object({ seriesIds: array(number().int()).min(1).max(50) }), object({ results: array(OrphanDeleteEntrySchema).readonly() }), {
+	kind: "mutation",
+	auth: "admin"
+});
 var DeviceCaStatusSchema = discriminatedUnion("state", [
 	object({ state: literal("absent") }),
 	object({
@@ -48029,7 +48086,6 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 		modelId: string()
 	}),
 	object({ kind: literal("cpu-device") }),
-	object({ kind: literal("coral-untouched") }),
 	object({ kind: literal("device-disabled") }),
 	object({ kind: literal("device-unavailable") }),
 	object({ kind: literal("node-offline") }),
@@ -48127,11 +48183,6 @@ var AutoTuneWarningSchema = discriminatedUnion("kind", [
 		kind: literal("detector-store-unreadable"),
 		error: string()
 	}),
-	object({
-		kind: literal("coral-enabled"),
-		nodeId: string(),
-		deviceKey: string()
-	}),
 	object({
 		kind: literal("custom-pin-kept"),
 		nodeId: string(),
@@ -55192,17 +55243,73 @@ var connectivityCapability = {
 	volatileStateFields: ["lastChangedAt"]
 };
 /**
-* Generic device-consumables capability — surfaces a device's
-* maintenance items (vacuum filters/brushes, replaceable cartridges,
-* descaling cycles, …) with their remaining life and an optional
-* "Replaced" reset action. Device-agnostic: any provider that knows its
-* device tracks consumables can register it; the cap declares no
-* vocabulary of its own — the provider names each item verbatim.
+* Generic device-consumables capability — the ONE place a device reports what
+* it uses up or fills: wear parts (vacuum filters/brushes, cartridges,
+* descaling cycles), supplies it draws from (a vacuum's clean-water tank and
+* detergent, a dishwasher's salt and rinse aid) and waste it collects (a dirty
+* water tank, a dust bin). Each item carries its remaining life or fill and an
+* optional "Replaced" reset action. Device-agnostic: any provider that knows
+* its device tracks consumables registers it; the provider names each item
+* verbatim and says which `kind` it is.
+*
+* The admin UI renders it as ONE collapsible section directly under the
+* device page's hero card (`placement: 'hero'`), for every device bound to
+* this cap — never drawn by a device type's hero card itself (D915).
 *
 * Like `childLayout`, the cap is INERT until a provider sets items: no
 * provider populates it by guessing (no HA inference). The UI renders a
 * "No consumables reported" placeholder when `items` is empty.
 */
+/**
+* What an item IS, which decides which direction is bad:
+*  - `wear`   — a part that wears out (a brush, a filter); low life is bad.
+*  - `supply` — something the device draws from (clean water, detergent,
+*    salt, rinse aid); low or empty is bad.
+*  - `waste`  — something the device fills (dirty water, a dust bin); full is
+*    bad.
+* Absent = `wear`.
+*/
+var ConsumableKindSchema = _enum([
+	"wear",
+	"supply",
+	"waste"
+]);
+/**
+* What an item LOOKS like, which decides how a client draws it — independent
+* of `kind`, which decides which direction is bad:
+*  - `part`    — a part that wears (a brush, a filter, a mop pad): a wear bar,
+*    remaining time and a reset.
+*  - `tank`    — a container of liquid (clean water, dirty water): a fill gauge.
+*  - `product` — something bought and refilled (detergent, salt, rinse aid):
+*    a stepped level and "refill".
+*  - `bin`     — a container that collects waste (a dust bin): a fill gauge
+*    that warns when full.
+* Absent = derived from the kind ({@link consumableFormOf}).
+*/
+var ConsumableFormSchema = _enum([
+	"part",
+	"tank",
+	"product",
+	"bin"
+]);
+/** The provider's own discrete verdict on an item. */
+var ConsumableStatusSchema = _enum([
+	"ok",
+	"low",
+	"empty",
+	"full",
+	"replace"
+]);
+_enum([
+	"ok",
+	"low",
+	"empty",
+	"full"
+]);
+/** The kind of an item, with the documented default for an absent one. */
+function consumableKindOf(item) {
+	return item.kind ?? "wear";
+}
 /** Units a remaining-life counter is reported in. Closed: the panel renders
 *  each. */
 var ConsumableRemainingUnitSchema = _enum([
@@ -55217,18 +55324,23 @@ var ConsumableRemainingSchema = object({
 	unit: ConsumableRemainingUnitSchema
 });
 /** A single consumable item. Either a continuous `level` (remaining
-*  life %) or a discrete `status` may be known — both may be null when a
-*  provider only knows the item exists. `level` and `status` are not
-*  mutually exclusive; a provider may report both. */
+*  life %, or fill % for a `supply` / `waste` item) or a discrete `status`
+*  may be known — both may be null when a provider only knows the item
+*  exists. `level` and `status` are not mutually exclusive; a provider may
+*  report both. */
 var ConsumableItemSchema = object({
 	/** Stable id, e.g. 'main-brush'. */
 	key: string().min(1),
 	/** Display name. */
 	label: string().min(1),
-	/** Remaining life % when known (0..100). */
+	/** Remaining life % (`wear`) or fill % (`supply`, `waste`) when known (0..100). */
 	level: number().min(0).max(100).nullable(),
-	/** Discrete state when known (binary mode). */
-	status: _enum(["ok", "replace"]).nullable(),
+	/** The provider's discrete verdict when known (binary mode). */
+	status: ConsumableStatusSchema.nullable(),
+	/** What the item is — decides whether low or full is bad. Absent = `wear`. */
+	kind: ConsumableKindSchema.optional(),
+	/** How the item is drawn (part, tank, product, bin). Absent = derived from `kind`. */
+	form: ConsumableFormSchema.optional(),
 	/** Ms epoch of the last replace, when known. */
 	lastResetAt: number().nullable(),
 	/** Whether `reset()` is meaningful for this item. */
@@ -55251,7 +55363,7 @@ var consumablesCapability = {
 		kind: "widget",
 		widgetId: "host/consumables-panel",
 		tab: "consumables",
-		topTab: true,
+		placement: "hero",
 		label: "Consumables",
 		order: 5
 	} },
@@ -55312,9 +55424,37 @@ reset: method(object({
 	*/
 	durability: "restored",
 	/**
-	* History (D850): none — `items` is an array keyed by runtime ids; a history path never enters it.
+	* History (D850, D917): one series per (item field, item `key`) — the item key
+	* is the series scope, the item `label` names it. A vacuum tank's fill, a
+	* brush's remaining life and a dishwasher's salt are each recorded the moment
+	* their provider reports them; an item that appears later gets its series.
 	*/
-	history: "none",
+	history: {
+		fields: {},
+		items: {
+			path: "items",
+			key: "key",
+			label: "label",
+			fields: {
+				level: {
+					kind: "gauge",
+					unit: "%",
+					deadband: 2,
+					displayName: "Level"
+				},
+				status: {
+					kind: "enum",
+					displayName: "Status"
+				},
+				"remaining.value": {
+					kind: "gauge",
+					unitFrom: "remaining.unit",
+					deadband: 1,
+					displayName: "Remaining"
+				}
+			}
+		}
+	},
 	/** Clocks, not content: a re-read that changed no item costs no commit. */
 	volatileStateFields: ["lastChangedAt", "lastFetchedAt"]
 };
@@ -55729,8 +55869,9 @@ onStatusChanged: { data: object({
 	volatileStateFields: ["lastChangedAt"]
 };
 /**
-* Smart-dishwasher cap — program lifecycle, door / remote-start gates,
-* consumable levels (salt, rinse aid) and common program options.
+* Smart-dishwasher cap — program lifecycle, door / remote-start gates and
+* common program options. Salt and rinse aid are NOT here: they are items of
+* the device's `consumables` cap, like every other device's (D915).
 *
 * Sources: native Bosch Home Connect (`dishwasher` device type). Reusable
 * by any integration that exposes the same program / option surface.
@@ -55778,11 +55919,6 @@ var DishwasherAvailabilitySchema = _enum([
 	"offline",
 	"description-missing"
 ]);
-var DishwasherConsumableLevelSchema = _enum([
-	"ok",
-	"low",
-	"empty"
-]);
 var DishwasherStatusSchema = object({
 	availability: DishwasherAvailabilitySchema,
 	/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
@@ -55815,8 +55951,6 @@ var DishwasherStatusSchema = object({
 	powerOn: boolean().nullable(),
 	/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
 	powerState: string().nullable(),
-	saltLevel: DishwasherConsumableLevelSchema.nullable(),
-	rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
 	/**
 	* True while the appliance asks for its filter to be cleaned (smart-filter, filter-system or
 	* combined care-and-filter reminder raised); false when every such reminder reads clear; null
@@ -64780,60 +64914,17 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserI
 	auth: "admin",
 	access: "delete"
 });
-/**
-* Robot-vacuum cap. Models HA `vacuum.*` entities — anything with a
-* cleaning lifecycle plus a return-to-base / locate surface and an
-* optional fan-speed selector.
-*
-* State follows HA's canonical vacuum lifecycle: `idle` / `cleaning` /
-* `paused` / `returning` / `docked` / `error`. `batteryLevel`
-* (0..100) is nullable — some vacuums don't report a battery
-* percentage. `fanSpeed` is the current speed token (provider-verbatim,
-* e.g. `'standard'` / `'turbo'`) and `availableFanSpeeds` lists the
-* tokens the hardware accepts so the UI renders only supported choices.
-*
-* The `setFanSpeed` method takes the bare `speed` token — the provider
-* validates it against the vacuum's own list. `locate` triggers the
-* find-me chirp; `returnToBase` sends it home.
-*
-* Consumable / waste tanks: `cleanWater` / `dirtyWater` / `detergent` /
-* `dustBin` each carry a nullable `{ level (0..100 %), status ('ok' |
-* 'low' | 'full') }` reading. Native providers (e.g. Dreame, Roborock)
-* SHOULD populate whichever tanks the hardware has — leave a field `null`
-* only when the device has no such tank at all, and use a `TankStatus`
-* with both inner fields `null` when the tank exists but its level is
-* currently unknown. HA `vacuum.*` entities expose no per-tank telemetry,
-* so the HA provider leaves all four `null`.
-*/
-var VacuumStateSchema = _enum([
-	"idle",
-	"cleaning",
-	"paused",
-	"returning",
-	"docked",
-	"drying",
-	"error"
-]);
-/**
-* One consumable / waste tank on a robot vacuum (clean-water, dirty-water,
-* detergent or dust-bin). A tank can report a numeric fill `level` (0..100),
-* a discrete `status` (binary-style hardware), or both. Both `null` means the
-* level is currently unknown; the OWNING field being `null` means the
-* hardware has no such tank at all.
-*/
-var TankStatusSchema = object({
-	/** Numeric fill 0..100 when the hardware reports a percentage; null otherwise. */
-	level: number().min(0).max(100).nullable(),
-	/** Discrete state when the hardware is binary-mode; null otherwise. */
-	status: _enum([
-		"ok",
-		"low",
-		"full"
-	]).nullable()
-});
 var VacuumControlStatusSchema = object({
 	/** Lifecycle state of the vacuum. */
-	state: VacuumStateSchema,
+	state: _enum([
+		"idle",
+		"cleaning",
+		"paused",
+		"returning",
+		"docked",
+		"drying",
+		"error"
+	]),
 	/** 0..100 battery percentage. Null when the device has no battery
 	*  reading. */
 	batteryLevel: number().min(0).max(100).nullable(),
@@ -64842,14 +64933,6 @@ var VacuumControlStatusSchema = object({
 	fanSpeed: string().nullable(),
 	/** Speed tokens the hardware accepts — drives the UI selector. */
 	availableFanSpeeds: array(string()),
-	/** Clean-water (mop) tank. Null when the hardware has no clean-water tank. */
-	cleanWater: TankStatusSchema.nullable(),
-	/** Dirty-water (recovery) tank. Null when the hardware has no dirty-water tank. */
-	dirtyWater: TankStatusSchema.nullable(),
-	/** Detergent tank. Null when the hardware has no detergent tank. */
-	detergent: TankStatusSchema.nullable(),
-	/** Dust bin. Null when the hardware has no dust bin. */
-	dustBin: TankStatusSchema.nullable(),
 	/** 0..100 cleaning-completion percentage of the current task, or null. */
 	progressPercent: number().min(0).max(100).nullable(),
 	/** Current error code (0 / null = no error). */
@@ -64911,35 +64994,14 @@ var vacuumControlCapability = {
 	*/
 	durability: "session",
 	/**
-	* History (D850): recorded series. Tank levels are fixed-object paths (`cleanWater.level`, ...).
+	* History (D850): recorded series. The tanks moved to `consumables` (D915), whose
+	* items are keyed by runtime ids and record no history.
 	*/
-	history: { fields: {
-		batteryLevel: {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"cleanWater.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"dirtyWater.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"detergent.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"dustBin.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		}
-	} }
+	history: { fields: { batteryLevel: {
+		kind: "gauge",
+		unit: "%",
+		deadband: 2
+	} } }
 };
 var ValveStatusSchema = object({
 	/** Lifecycle state of the valve. */
@@ -69349,6 +69411,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceHistory.deleteOrphanSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"deviceHistory.getDeviceEnabled": {
 		capName: "device-history",
 		capScope: "system",
@@ -69367,6 +69435,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceHistory.listOrphanSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceHistory.listSeries": {
 		capName: "device-history",
 		capScope: "system",
@@ -79372,7 +79446,7 @@ var STATE_SUMMARY_VARS = [
 	([...RULE_TEXT], [...COMBINED_ALARM]),
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
 	([...RULE_TEXT], [...BATTERY, ...CONSUMABLE]),
-	([...RULE_TEXT], [...CONSUMABLE]),
+	([...RULE_TEXT], [...CONSUMABLE, ...TANK]),
 	([...RULE_TEXT], [...TANK]),
 	[...RULE_TEXT],
 	([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
@@ -135242,8 +135316,7 @@ function dirtyWaterTankStatus(value, errorCode) {
 	return null;
 }
 /**
-* The four `vacuum-control` tank fields (clean-water / dirty-water / detergent /
-* dust-bin) decoded from the model's {@link VacuumCapabilities}, with the
+* The four tanks (clean-water / dirty-water / detergent / dust-bin) decoded from the model's {@link VacuumCapabilities}, with the
 * discrete `status` populated from the live MIoT enum props when supplied. Pure.
 *
 * The nodedreame library exposes NO tank FILL-LEVEL telemetry — the cloud shadow
@@ -135274,6 +135347,57 @@ function decodeVacuumTanks(caps, props, errorCode = null) {
 		dustBin: tank(Boolean(caps?.canAutoEmpty), props ? dustBinTankStatus(props.dustCollection, props.dustBagStatus) : null)
 	};
 }
+/** How each tank is named and what it is, in the order the panel lists them. */
+var TANK_ITEMS = [
+	{
+		key: "cleanWater",
+		label: "Clean water tank",
+		kind: "supply",
+		form: "tank"
+	},
+	{
+		key: "dirtyWater",
+		label: "Dirty water tank",
+		kind: "waste",
+		form: "tank"
+	},
+	{
+		key: "detergent",
+		label: "Detergent",
+		kind: "supply",
+		form: "product"
+	},
+	{
+		key: "dustBin",
+		label: "Dust bin",
+		kind: "waste",
+		form: "bin"
+	}
+];
+/**
+* The tanks as `consumables` items (D915): every PRESENT tank becomes a
+* `supply` (clean water, detergent) or `waste` (dirty water, dust bin) item
+* keyed by its old field name, drawn as a `tank` (the two water tanks), a
+* `product` (detergent) or a `bin` (the dust bin) — the key the notification centre's tank
+* episodes were built on, so an open episode carries on. A tank is never
+* resettable: emptying or refilling it is the reset. Pure.
+*/
+function vacuumTankItems(tanks) {
+	return TANK_ITEMS.flatMap(({ key, label, kind, form }) => {
+		const tank = tanks[key];
+		if (tank === null) return [];
+		return [{
+			key,
+			label,
+			level: tank.level,
+			status: tank.status,
+			kind,
+			form,
+			lastResetAt: null,
+			resettable: false
+		}];
+	});
+}
 /**
 * Clamp a raw consumable percentage to `[0, 100]`, or return `null` when the
 * value is absent / non-finite. The library reports remaining life as a 0..100
@@ -135302,7 +135426,8 @@ function buildVacuumConsumableItems(readings) {
 		level: clampConsumablePct(c.leftPct),
 		status: null,
 		lastResetAt: null,
-		resettable: c.resettable
+		resettable: c.resettable,
+		form: "part"
 	}));
 }
 /** Structural equality of two JSON-shaped values, key order ignored. */
@@ -182687,7 +182812,8 @@ function buildMowerConsumables(readings) {
 		level: r.remainingPercent,
 		status: null,
 		lastResetAt: null,
-		resettable: true
+		resettable: true,
+		form: "part"
 	}));
 }
 //#endregion
@@ -182711,7 +182837,7 @@ var CONSUMABLES_COLD_START = {
 	lastFetchedAt: 0
 };
 function itemEqual(a, b) {
-	return a.key === b.key && a.label === b.label && a.level === b.level && a.status === b.status && a.lastResetAt === b.lastResetAt && a.resettable === b.resettable;
+	return a.key === b.key && a.label === b.label && a.level === b.level && a.status === b.status && a.lastResetAt === b.lastResetAt && a.resettable === b.resettable && a.kind === b.kind && a.remaining?.value === b.remaining?.value && a.remaining?.unit === b.remaining?.unit;
 }
 function itemsEqual(a, b) {
 	return a.length === b.length && a.every((item, i) => {
@@ -183701,6 +183827,31 @@ var DreameSwitchDevice = class extends DreameChildDevice {
 };
 //#endregion
 //#region src/devices/dreame-vacuum-consumables.ts
+/**
+* The vacuum's `consumables` slice: when it is re-read, and what a reset does.
+*
+* The life %s and their time-left twins are settings the robot rarely re-pushes
+* over MQTT, and the library does not poll them. So they are re-read from the
+* cloud SHADOW (no robot wake) on activate, every {@link CONSUMABLES_REFRESH_MS},
+* and on the edge INTO `docked` — the moment a run has just used them up. The
+* same read reseeds the station tank-status props (dirty water, dust bag, …),
+* which otherwise arrive only as pushes.
+*
+* A reset goes through the library, which re-reads the item it reset (live,
+* else shadow) before it resolves; the slice is rebuilt from that. A shadow
+* answer may still be the pre-reset value, so it earns ONE follow-up refresh.
+*
+* The TANKS ride the same slice (D915): every push hands over the tank items
+* the device decoded, appended after the wear items. Either half may be
+* unknown for a while after a restart — the shadow has not answered, or a
+* refresh lands before the first push brought the tanks — and the slice is
+* `restored`, so an unknown half keeps the restored rows instead of erasing
+* them.
+*/
+/** A tank item (`supply` / `waste`) as opposed to a wear item. */
+function isTankItem(item) {
+	return consumableKindOf(item) !== "wear";
+}
 /** Hourly: a consumable moves by hours of cleaning, and the dock edge covers a run. */
 var CONSUMABLES_REFRESH_MS = 60 * 6e4;
 /** Time for the robot to report a reset to the cloud before the shadow is re-read. */
@@ -183717,6 +183868,8 @@ var DreameVacuumConsumables = class {
 	#refresher;
 	/** Last pushed lifecycle state; `null` until the first push after boot. */
 	#prevState = null;
+	/** Last pushed tank items; `null` until the first push after boot. */
+	#tanks = null;
 	constructor(deps) {
 		this.#deps = deps;
 		this.#refresher = new DreameConsumablesRefresher({
@@ -183736,12 +183889,14 @@ var DreameVacuumConsumables = class {
 		this.#refresher.stop();
 	}
 	/**
-	* Every `stateChanged` push: replay the cache into the slice (written only if
-	* an item changed) and refresh on the edge into `docked`. The first push after
-	* boot is not an edge — activation already reads — and neither is a hop
-	* between station routines (`drying` → `docked`): only the end of a RUN is.
+	* Every `stateChanged` push: replay the cache and the pushed tanks into the
+	* slice (written only if an item changed) and refresh on the edge into
+	* `docked`. The first push after boot is not an edge — activation already
+	* reads — and neither is a hop between station routines (`drying` →
+	* `docked`): only the end of a RUN is.
 	*/
-	onPush(state) {
+	onPush(state, tanks) {
+		this.#tanks = tanks;
 		this.#apply(false);
 		const enteredDock = this.#prevState !== null && DOCK_EDGE_FROM.has(this.#prevState) && state === "docked";
 		this.#prevState = state;
@@ -183791,7 +183946,11 @@ var DreameVacuumConsumables = class {
 		const { store, resolveVacuum, now } = this.#deps;
 		const vacuum = resolveVacuum();
 		if (vacuum === null) return;
-		writeConsumables(store, buildVacuumConsumableItems(vacuum.supportedConsumables), (now ?? Date.now)(), landed);
+		const prev = store.getCapState("consumables")?.items ?? [];
+		const read = buildVacuumConsumableItems(vacuum.supportedConsumables);
+		const wear = read.length > 0 ? read : prev.filter((item) => !isTankItem(item));
+		const tanks = this.#tanks ?? prev.filter(isTankItem);
+		writeConsumables(store, [...wear, ...tanks], (now ?? Date.now)(), landed);
 	}
 };
 function resetMeta(result) {
@@ -183811,10 +183970,6 @@ var CONTROL_COLD_START = {
 	batteryLevel: null,
 	fanSpeed: null,
 	availableFanSpeeds: [],
-	cleanWater: null,
-	dirtyWater: null,
-	detergent: null,
-	dustBin: null,
 	progressPercent: null,
 	errorCode: null,
 	errorLabel: null,
@@ -183830,11 +183985,13 @@ var CONTROL_COLD_START = {
 * `setFanSpeed`→`setSuction()` (token validated against the model's supported
 * suction levels).
 *
-* Tank state (cleanWater/dirtyWater/detergent/dustBin): the library exposes NO
-* tank fill LEVEL, so `level` is always null. PRESENCE comes from the model
-* capability flags and a discrete `status` from the station's tank-status enum
-* props (`decodeVacuumTanks`, ids in `VACUUM_TANK_PROPS`); an absent tank is
-* `null`, an unknown status is `null` — never `ok`.
+* Tanks (clean water / dirty water / detergent / dust bin) are `supply` /
+* `waste` items of the `consumables` slice (D915), not `vacuum-control` fields:
+* the library exposes NO tank fill LEVEL, so `level` is always null. PRESENCE
+* comes from the model capability flags and a discrete `status` from the
+* station's tank-status enum props (`decodeVacuumTanks`, ids in
+* `VACUUM_TANK_PROPS`); an absent tank is no item, an unknown status is `null`
+* — never `ok`.
 *
 * Consumables: whatever the model REPORTS (the library's presence-driven
 * `supportedConsumables`), re-read from the cloud shadow on activate, hourly and
@@ -183958,16 +184115,12 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 	recomputeSlice() {
 		const vacuum = this.resolveVacuum();
 		if (vacuum === null) return;
-		const tanks = decodeVacuumTanks(vacuum.vacuumCapabilities, this.readTankProps(), vacuum.errorCode);
+		const tanks = vacuumTankItems(decodeVacuumTanks(vacuum.vacuumCapabilities, this.readTankProps(), vacuum.errorCode));
 		const controlSlice = {
 			state: mapMiotStateToVacuumState(vacuum.status),
 			batteryLevel: clampBatteryLevel$1(vacuum.battery),
 			fanSpeed: suctionLevelToken(vacuum.suction),
 			availableFanSpeeds: supportedFanSpeedTokens(vacuum.supportedSuctionLevels),
-			cleanWater: tanks.cleanWater,
-			dirtyWater: tanks.dirtyWater,
-			detergent: tanks.detergent,
-			dustBin: tanks.dustBin,
 			progressPercent: clampPercent$1(vacuum.taskProgressPct),
 			errorCode: vacuum.errorCode,
 			errorLabel: vacuum.errorCode ? `Error ${vacuum.errorCode}` : null,
@@ -183975,7 +184128,7 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 		};
 		const toWrite = nextVacuumControlSlice(this.runtimeState.getCapState(CAP_NAME$1), controlSlice);
 		if (toWrite !== null) this.runtimeState.setCapState(CAP_NAME$1, toWrite);
-		this.consumables.onPush(controlSlice.state);
+		this.consumables.onPush(controlSlice.state, tanks);
 	}
 	/**
 	* Read the tank-status MIoT enum props ({@link VACUUM_TANK_PROPS}) from the