@camstack/addon-provider-dreame 0.2.117 → 0.2.118

package/dist/addon.mjs

@@ -46341,6 +46341,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 9,
 			piid: 2
 		},
+		timeLeft: {
+			siid: 9,
+			piid: 1,
+			unit: "hours"
+		},
 		reset: {
 			siid: 9,
 			aiid: 1
@@ -46353,6 +46358,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 10,
 			piid: 2
 		},
+		timeLeft: {
+			siid: 10,
+			piid: 1,
+			unit: "hours"
+		},
 		reset: {
 			siid: 10,
 			aiid: 1
@@ -46365,6 +46375,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 11,
 			piid: 1
 		},
+		timeLeft: {
+			siid: 11,
+			piid: 2,
+			unit: "hours"
+		},
 		reset: {
 			siid: 11,
 			aiid: 1
@@ -46372,11 +46387,16 @@ var VACUUM_CONSUMABLES = [
 	},
 	{
 		key: "sensor",
-		label: "Sensor",
+		label: "Sensor Dirty",
 		life: {
 			siid: 16,
 			piid: 1
 		},
+		timeLeft: {
+			siid: 16,
+			piid: 2,
+			unit: "hours"
+		},
 		reset: {
 			siid: 16,
 			aiid: 1
@@ -46389,6 +46409,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 17,
 			piid: 1
 		},
+		timeLeft: {
+			siid: 17,
+			piid: 2,
+			unit: "hours"
+		},
 		reset: {
 			siid: 17,
 			aiid: 1
@@ -46401,6 +46426,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 18,
 			piid: 1
 		},
+		timeLeft: {
+			siid: 18,
+			piid: 2,
+			unit: "hours"
+		},
 		reset: {
 			siid: 18,
 			aiid: 1
@@ -46413,6 +46443,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 19,
 			piid: 2
 		},
+		timeLeft: {
+			siid: 19,
+			piid: 1,
+			unit: "days"
+		},
 		reset: {
 			siid: 19,
 			aiid: 1
@@ -46425,6 +46460,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 20,
 			piid: 1
 		},
+		timeLeft: {
+			siid: 20,
+			piid: 2,
+			unit: "days"
+		},
 		reset: {
 			siid: 20,
 			aiid: 1
@@ -46437,6 +46477,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 24,
 			piid: 1
 		},
+		timeLeft: {
+			siid: 24,
+			piid: 2,
+			unit: "days"
+		},
 		reset: {
 			siid: 24,
 			aiid: 1
@@ -46449,6 +46494,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 29,
 			piid: 2
 		},
+		timeLeft: {
+			siid: 29,
+			piid: 1,
+			unit: "days"
+		},
 		reset: {
 			siid: 29,
 			aiid: 1
@@ -46456,11 +46506,16 @@ var VACUUM_CONSUMABLES = [
 	},
 	{
 		key: "wheel",
-		label: "Wheel",
+		label: "Wheel Dirty",
 		life: {
 			siid: 30,
 			piid: 2
 		},
+		timeLeft: {
+			siid: 30,
+			piid: 1,
+			unit: "days"
+		},
 		reset: {
 			siid: 30,
 			aiid: 1
@@ -46473,6 +46528,11 @@ var VACUUM_CONSUMABLES = [
 			siid: 31,
 			piid: 2
 		},
+		timeLeft: {
+			siid: 31,
+			piid: 1,
+			unit: "days"
+		},
 		reset: {
 			siid: 31,
 			aiid: 1
@@ -46485,15 +46545,13 @@ var VACUUM_CONSUMABLES = [
 			siid: 27,
 			piid: 17
 		},
+		timeLeft: null,
 		reset: null
 	}
 ];
 function consumableSpec(key2) {
 	return VACUUM_CONSUMABLES.find((c) => c.key === key2);
 }
-function isDreameConsumableKey(key2) {
-	return VACUUM_CONSUMABLES.some((c) => c.key === key2);
-}
 var X50_AI_FEATURES = [
 	"obstacleDetection",
 	"petDetection",
@@ -49570,6 +49628,15 @@ var OssFetcher = class {
 		this.cache.clear();
 	}
 };
+function consumableProps(spec) {
+	return spec.timeLeft === null ? [spec.life] : [spec.life, {
+		siid: spec.timeLeft.siid,
+		piid: spec.timeLeft.piid
+	}];
+}
+function asError(err) {
+	return err instanceof Error ? err : new Error(String(err));
+}
 var SUCTION = enumLookup([
 	0,
 	1,
@@ -49728,23 +49795,82 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice$1 {
 		});
 	}
 	/**
-	* Seed EVERY consumable life property from the cloud shadow (no robot wake) so
-	* {@link supportedConsumables} reflects the full set on a docked robot. The
-	* consumable life values are static settings the robot rarely re-pushes over
-	* MQTT, so a fresh connect surfaces only the actively-changing ones without this.
+	* Time left before a consumable needs attention, in the unit the robot counts
+	* it in (see {@link ConsumableSpec.timeLeft}), or `null` when the model does
+	* not report it or the key has no time-left twin.
+	*/
+	consumableTimeLeft(key2) {
+		const spec = consumableSpec(key2);
+		if (spec === void 0 || spec.timeLeft === null) return null;
+		const value = this.#num(spec.timeLeft.siid, spec.timeLeft.piid);
+		return value === null ? null : {
+			value,
+			unit: spec.timeLeft.unit
+		};
+	}
+	/**
+	* Seed EVERY consumable life property AND its time-left twin from the cloud
+	* shadow (no robot wake), in one call, so {@link supportedConsumables} and
+	* {@link consumableTimeLeft} reflect the full set on a docked robot. The
+	* robot rarely re-pushes these over MQTT, so a consumer that wants them fresh
+	* must call this again — the library does not poll them.
 	*/
 	async refreshConsumables() {
-		await this.refreshCachedProperties(VACUUM_CONSUMABLES.map((c) => c.life));
+		await this.refreshCachedProperties(VACUUM_CONSUMABLES.flatMap(consumableProps));
 	}
 	/**
 	* Reset (mark replaced → life back to 100%) one consumable via its MIoT reset
-	* action. Rejects when the model exposes no reset action for the key (e.g.
-	* `dust-bag`) or the key is unknown.
+	* action, then re-read that consumable's life % and time left ONCE so the
+	* cache — and every getter after this resolves — reflects the reset. The
+	* re-read is live; if the robot does not answer it falls back to the cloud
+	* shadow (which may still hold the pre-reset value until the robot reports),
+	* and `refreshedFrom` says which one answered.
+	*
+	* Rejects when the model exposes no reset action for the key (e.g.
+	* `dust-bag`), the key is unknown, or the action itself fails. A failed
+	* RE-READ does not reject: the reset happened, and the result says the values
+	* are unknown (`refreshedFrom: null`).
 	*/
 	async resetConsumable(key2) {
 		const spec = consumableSpec(key2);
 		if (spec === void 0 || spec.reset === null) throw new DreameError(`resetConsumable: no reset action for consumable "${key2}"`);
-		return this.callAction(spec.reset.siid, spec.reset.aiid, []);
+		const actionResult = await this.callAction(spec.reset.siid, spec.reset.aiid, []);
+		const refresh2 = await this.#rereadConsumable(spec);
+		const fresh = refresh2.refreshedFrom !== null;
+		return {
+			key: key2,
+			actionResult,
+			refreshedFrom: refresh2.refreshedFrom,
+			leftPct: fresh ? this.consumableLeftPct(key2) : null,
+			timeLeft: fresh ? this.consumableTimeLeft(key2) : null,
+			refreshError: refresh2.error
+		};
+	}
+	/** One targeted re-read of a consumable's properties: live, else the cloud shadow. */
+	async #rereadConsumable(spec) {
+		const props = consumableProps(spec);
+		let liveError;
+		try {
+			await this.refreshProperties(props);
+			return {
+				refreshedFrom: "device",
+				error: null
+			};
+		} catch (err) {
+			liveError = asError(err);
+		}
+		try {
+			await this.refreshCachedProperties(props);
+			return {
+				refreshedFrom: "cloud-shadow",
+				error: liveError
+			};
+		} catch (err) {
+			return {
+				refreshedFrom: null,
+				error: asError(err)
+			};
+		}
 	}
 	/**
 	* The raw `AI_DETECTION` value (siid 4 piid 22) — an int bitmask or a JSON
@@ -58134,7 +58260,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-PEo0-Fz9.mjs
+//#region ../types/dist/sleep-DU7mu4wb.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -60115,11 +60241,17 @@ var RawStateResultSchema = object({
 method(object({ deviceId: number() }), array(StreamSourceEntrySchema)), method(object({ deviceId: number() }), array(ConfigEntrySchema$1)), method(object({
 	deviceId: number(),
 	values: record(string(), unknown())
-}), _void(), { kind: "mutation" }), method(object({
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	deviceId: number(),
 	action: string().min(1),
 	input: unknown()
-}), unknown(), { kind: "mutation" }), method(object({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), unknown().nullable()), method(object({ deviceId: number() }), RawStateResultSchema.nullable(), { auth: "protected" });
+}), unknown(), { kind: "mutation" }), method(object({ deviceId: number() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number() }), unknown().nullable()), method(object({ deviceId: number() }), RawStateResultSchema.nullable(), { auth: "protected" });
 //#endregion
 //#region ../types/dist/err-msg-IQTHeDzc.mjs
 /**
@@ -64355,7 +64487,7 @@ method(ListInputSchema, array(BrokerInfoSchema$1)), method(GetInputSchema, Broke
 }), method(UnsubscribeInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), method(GetStateInputSchema, unknown().nullable()), method(_void(), RegistryStatusSchema);
+}), method(GetStateInputSchema, unknown().nullable(), { auth: "admin" }), method(_void(), RegistryStatusSchema);
 DeviceType.Camera;
 /** Stream delivery format. (Relocated from the retired `streaming-engine` cap.) */
 var StreamFormatSchema = _enum([
@@ -65538,17 +65670,20 @@ method(object({
 	namespace: string().optional(),
 	collection: string(),
 	key: string()
-}), unknown()), method(object({
+}), unknown(), { auth: "admin" }), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	key: string(),
 	value: unknown()
-}), _void(), { kind: "mutation" }), method(object({
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	filter: QueryFilterSchema.optional(),
 	columns: array(string()).readonly().optional()
-}), array(SettingsRecordSchema).readonly()), method(object({
+}), array(SettingsRecordSchema).readonly(), { auth: "admin" }), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	/** Declared columns identifying the slot; must be covered by a UNIQUE
@@ -65558,7 +65693,10 @@ method(object({
 }), object({ 
 /** The id the row HAS: assigned by SQLite on an insert, or the existing
 *  row's own id on an update. */
-id: union([string(), number()]) }), { kind: "mutation" }), method(object({
+id: union([string(), number()]) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	record: object({
@@ -65571,38 +65709,56 @@ id: union([string(), number()]) }), { kind: "mutation" }), method(object({
 * for an absent one, or the ROWID SQLite assigned on an `INTEGER`
 * primary key — which is the only place an auto key is knowable.
 */
-id: union([string(), number()]) }), { kind: "mutation" }), method(object({
+id: union([string(), number()]) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	records: array(BulkRecordSchema).readonly()
-}), object({ inserted: number().int() }), { kind: "mutation" }), method(object({
+}), object({ inserted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	id: string(),
 	data: record(string(), unknown())
-}), _void(), { kind: "mutation" }), method(object({
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	key: string()
-}), _void(), { kind: "mutation" }), method(object({
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	filter: MutationFilterSchema
-}), object({ deleted: number().int() }), { kind: "mutation" }), method(object({
+}), object({ deleted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	filter: MutationFilterSchema,
 	data: record(string(), unknown())
-}), object({ updated: number().int() }), { kind: "mutation" }), method(object({
+}), object({ updated: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	filter: QueryFilterSchema.optional()
-}), number()), method(object({
+}), number(), { auth: "admin" }), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	fields: array(AggregateFieldSchema).readonly(),
 	filter: QueryFilterSchema.optional()
-}), AggregateResultSchema), method(object({
+}), AggregateResultSchema, { auth: "admin" }), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	field: string(),
@@ -65612,15 +65768,18 @@ id: union([string(), number()]) }), { kind: "mutation" }), method(object({
 }), array(object({
 	bucket: number().int(),
 	count: number().int()
-})).readonly()), method(object({
+})).readonly(), { auth: "admin" }), method(object({
 	namespace: string().optional(),
 	collection: string()
-}), boolean()), method(object({
+}), boolean(), { auth: "admin" }), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	columns: array(CollectionColumnSchema).readonly(),
 	indexes: array(CollectionIndexSchema).readonly().optional()
-}), _void(), { kind: "mutation" });
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
 /**
 * What one engine says about itself. The orchestrator uses `kind` to pick
 * a registrant for a collection; `engineId` is what a log line names when
@@ -66428,7 +66587,13 @@ var ExposeInputSchema = object({
 	capabilities: array(string()).optional()
 });
 var UnexposeInputSchema = object({ deviceId: string() });
-method(_void(), DeviceExportStatusSchema), method(_void(), array(DeviceKindSchema)), method(_void(), array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), { kind: "mutation" }), method(UnexposeInputSchema, _void(), { kind: "mutation" });
+method(_void(), DeviceExportStatusSchema), method(_void(), array(DeviceKindSchema)), method(_void(), array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(UnexposeInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
 /** Wire/storage schema for one icon id. */
 var LocationIconIdSchema = _enum([
 	"map-pin",
@@ -67013,7 +67178,10 @@ method(object({
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: 12 * 6e4
-}), method(DeviceRegisterPayloadSchema, _void(), { kind: "mutation" }), method(DeviceRemovePayloadSchema, _void(), { kind: "mutation" }), method(DevicePersistConfigPayloadSchema, _void(), { kind: "mutation" }), method(object({ deviceId: number() }), record(string(), unknown())), method(object({ deviceId: number() }), record(string(), unknown())), method(object({ deviceId: number() }), DeviceMetaSchema.nullable()), method(object({
+}), method(DeviceRegisterPayloadSchema, _void(), { kind: "mutation" }), method(DeviceRemovePayloadSchema, _void(), { kind: "mutation" }), method(DevicePersistConfigPayloadSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number() }), record(string(), unknown()), { auth: "admin" }), method(object({ deviceId: number() }), record(string(), unknown()), { auth: "admin" }), method(object({ deviceId: number() }), DeviceMetaSchema.nullable()), method(object({
 	deviceId: number(),
 	name: string()
 }), _void(), {
@@ -67218,7 +67386,7 @@ method(object({
 }), method(object({ deviceId: number() }), array(StreamProbeResultSchema), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ deviceId: number() }), DeviceBindingsForDeviceSchema), method(object({ deviceIds: array(number()) }), array(DeviceBindingsForDeviceSchema)), method(object({}), array(DeviceBindingsForDeviceSchema)), method(object({
+}), method(object({ deviceId: number() }), DeviceBindingsForDeviceSchema), method(object({ deviceIds: array(number()) }), array(DeviceBindingsForDeviceSchema)), method(object({}), array(DeviceBindingsForDeviceSchema)), method(object({ capNames: array(string().min(1)).min(1).max(16) }), array(number())), method(object({
 	deviceId: number(),
 	capName: string(),
 	wrapperAddonId: string(),
@@ -67573,18 +67741,30 @@ var LlmErrorCodeSchema = _enum([
 	"budget-exceeded",
 	"adapter-error"
 ]);
-var LlmGenerateResultSchema = discriminatedUnion("ok", [object({
+var LlmGenerateOkSchema = object({
 	ok: literal(true),
 	text: string(),
 	model: string(),
 	usage: LlmUsageSchema,
 	truncated: boolean(),
 	latencyMs: number()
-}), object({
+});
+/**
+* WHO refused, on a `refusal`. `guardrail` = a safety filter in front of the
+* model rejected the request before it answered (Apple Foundation Models
+* refuses surveillance-framed prompts in 0.1 s); `model` = the model itself
+* declined. They are different faults: a guardrail refusal is a property of
+* the BACKEND, so the provider falls back to the next profile; a model refusal
+* is an answer. Absent on every other code, and on a refusal a wire cannot
+* attribute.
+*/
+var LlmRefusalSourceSchema = _enum(["guardrail", "model"]);
+var LlmGenerateResultSchema = discriminatedUnion("ok", [LlmGenerateOkSchema, object({
 	ok: literal(false),
 	code: LlmErrorCodeSchema,
 	message: string(),
-	retryAfterMs: number().optional()
+	retryAfterMs: number().optional(),
+	refusalSource: LlmRefusalSourceSchema.optional()
 })]);
 /**
 * `Uint8Array` is the sanctioned binary convention — superjson + the UDS
@@ -67814,12 +67994,78 @@ var LlmRuntimeDiskUsageSchema = object({
 	modelsBytes: number(),
 	freeBytes: number().optional()
 });
-method(LlmGenerateBaseInputSchema.extend({
+var LlmRuntimeCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
 	images: array(LlmImageSchema).optional(),
 	runtime: ManagedRuntimeConfigSchema,
 	/** The managed profile's timeout, threaded by the hub provider. */
 	timeoutMs: number().int().positive().optional()
-}), LlmGenerateResultSchema, {
+});
+/**
+* Why Apple Foundation Models cannot run on a node that has it in principle.
+* The first three are Apple's own `UnavailableReason`s, verbatim; the rest are
+* ours: the OS predates the framework (macOS < 26), the helper binary is not
+* in the installed addon, or it crashed past the respawn bound.
+*/
+var AppleFmUnavailableReasonSchema = _enum([
+	"deviceNotEligible",
+	"appleIntelligenceNotEnabled",
+	"modelNotReady",
+	"osTooOld",
+	"helperMissing",
+	"helperCrashed"
+]);
+/**
+* Apple Foundation Models on ONE node — four states, never a boolean (D315).
+*
+*   - `available`            — the helper probed it; what it CAN do is reported
+*                              here (`imageInput`, `contextSize`, languages),
+*                              never typed by an operator.
+*   - `unavailable`          — a known absence, with the reason to act on.
+*   - `unsupported-platform` — not a Mac; there is nothing to enable.
+*   - `unknown`              — the probe did not answer (not yet run, timed
+*                              out, helper crashed mid-probe). A failed
+*                              measurement is NEVER `unavailable` (D393).
+*/
+var AppleFmAvailabilitySchema = discriminatedUnion("state", [
+	object({
+		state: literal("available"),
+		osVersion: string(),
+		/** Tokens, as the framework reports it. Read at runtime, never assumed. */
+		contextSize: number().int().positive(),
+		/** BCP-47-ish tags (`it-IT`) of the languages the model supports. */
+		languages: array(string()),
+		/** Whether prompts may carry images. `false` on a macOS 26 build. */
+		imageInput: boolean()
+	}),
+	object({
+		state: literal("unavailable"),
+		reason: AppleFmUnavailableReasonSchema,
+		osVersion: string().nullable(),
+		detail: string()
+	}),
+	object({
+		state: literal("unsupported-platform"),
+		platform: string()
+	}),
+	object({
+		state: literal("unknown"),
+		error: string()
+	})
+]);
+/**
+* A generation on the node's Apple Foundation Models helper. A separate verb
+* from `complete`, whose `runtime` is a llama.cpp config: overloading it would
+* drag a GGUF model reference into a backend that has none. `images` is part
+* of the contract so vision needs no cap change later; a node whose model has
+* no image input REFUSES them (`unavailable`), never drops them.
+*/
+var LlmRuntimeAppleCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
+	images: array(LlmImageSchema).optional(),
+	/** The profile's timeout, threaded by the hub provider. */
+	timeoutMs: number().int().positive().optional()
+});
+var LlmRuntimeCancelInputSchema = object({ requestId: string() });
+method(LlmRuntimeCompleteInputSchema, LlmGenerateResultSchema, {
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: AI_CAP_TRANSPORT_TIMEOUT_MS
@@ -67837,7 +68083,14 @@ method(LlmGenerateBaseInputSchema.extend({
 }), method(object({ file: string() }), _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), array(LlmNodeModelSchema), { auth: "admin" }), method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" });
+}), method(object({}), array(LlmNodeModelSchema), { auth: "admin" }), method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" }), method(LlmRuntimeCancelInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), AppleFmAvailabilitySchema, { auth: "admin" }), method(LlmRuntimeAppleCompleteInputSchema, LlmGenerateResultSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: AI_CAP_TRANSPORT_TIMEOUT_MS
+});
 /**
 * `llm` — consumer-facing LLM surface (spec §1-§3). Collection-mode: array
 * methods concat-fan across providers; single-row methods route to ONE
@@ -67854,7 +68107,8 @@ var LlmProfileKindSchema = _enum([
 	"openai",
 	"anthropic",
 	"google",
-	"managed-local"
+	"managed-local",
+	"apple-foundation"
 ]);
 var LlmProfileSchema = object({
 	id: string(),
@@ -67912,7 +68166,14 @@ var LlmProfileSchema = object({
 	toolsEnabled: boolean().default(false),
 	extraHeaders: record(string(), string()).optional(),
 	/** kind === 'managed-local' only (spec §4). */
-	runtime: ManagedRuntimeConfigSchema.optional()
+	runtime: ManagedRuntimeConfigSchema.optional(),
+	/**
+	* kind === 'apple-foundation' only: WHERE it runs — the only thing there is
+	* to configure (no key, no URL, no download; `model` is `apple-system`).
+	* `supportsVision` on such a row is stamped by the provider from the node's
+	* reported `imageInput`, never taken from the operator (D62).
+	*/
+	appleFoundation: object({ nodeId: string() }).optional()
 });
 /** ConfigUISchema tree passed through untyped on the wire (the
 *  notification-output `ConfigSchemaPassthrough` precedent at
@@ -67994,7 +68255,9 @@ var LlmRuntimeNodeSchema = object({
 	reachable: boolean(),
 	status: LlmRuntimeStatusSchema.optional(),
 	disk: LlmRuntimeDiskUsageSchema.optional(),
-	error: string().optional()
+	error: string().optional(),
+	/** Absent = the node did not answer the question (render as unknown). */
+	apple: AppleFmAvailabilitySchema.optional()
 });
 var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: array(LlmImageSchema).min(1) });
 var ProfileRefInputSchema = object({
@@ -68765,7 +69028,22 @@ var StatusSchema = object({
 	brokerCount: number(),
 	embeddedRunning: boolean()
 });
-method(_void(), array(BrokerInfoSchema)), method(IdInputSchema, BrokerConnectionDetailsSchema), method(AddBrokerInputSchema, AddBrokerResultSchema, { kind: "mutation" }), method(IdInputSchema, _void(), { kind: "mutation" }), method(IdInputSchema, TestResultSchema$1, { kind: "mutation" }), method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, { kind: "mutation" }), method(IdInputSchema, _void(), { kind: "mutation" }), method(_void(), StatusSchema);
+method(_void(), array(BrokerInfoSchema)), method(IdInputSchema, BrokerConnectionDetailsSchema, { auth: "admin" }), method(AddBrokerInputSchema, AddBrokerResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(IdInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(IdInputSchema, TestResultSchema$1, {
+	kind: "mutation",
+	auth: "admin"
+}), method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(IdInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), StatusSchema);
 var NetworkEndpointSchema = object({
 	url: string(),
 	hostname: string(),
@@ -69060,6 +69338,18 @@ var TargetKindSchema = object({
 	*/
 	iconMediaType: string().optional(),
 	configSchema: ConfigSchemaPassthrough,
+	/**
+	* The config keys that decide WHERE this kind's secrets are sent (server,
+	* base URL, instance, chat, recipient). A save that changes any of them
+	* while leaving a secret redacted is refused by the provider (D634), so an
+	* editor uses this to ask for the secret on exactly those edits instead of
+	* on every edit.
+	*
+	* Optional: absent from a provider that holds no secret (the Home Assistant
+	* kinds) and from a provider older than this field — an editor that finds
+	* it absent must assume ANY edit may need the secret.
+	*/
+	destinationKeys: array(string()).optional(),
 	supportsDiscovery: boolean(),
 	caps: TargetKindCapsSchema
 });
@@ -69098,19 +69388,34 @@ var SendResultSchema = object({
 });
 /** Same shape as SendResult — kept as a distinct name for the test panel. */
 var TestResultSchema = SendResultSchema;
-method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSchema)), method(object({
+method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSchema), { auth: "admin" }), method(object({
 	kind: string(),
 	config: record(string(), unknown()).optional()
-}), array(DiscoveredTargetSchema)), method(object({
+}), array(DiscoveredTargetSchema), { auth: "admin" }), method(object({
 	targetId: string(),
 	notification: NotificationSchema
-}), SendResultSchema, { kind: "mutation" }), method(object({
+}), SendResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	targetId: string(),
 	sample: NotificationSchema.optional()
-}), TestResultSchema, { kind: "mutation" }), method(object({ target: TargetSchema }), TargetSchema, { kind: "mutation" }), method(object({ targetId: string() }), _void(), { kind: "mutation" }), method(object({
+}), TestResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ target: TargetSchema }), TargetSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ targetId: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	targetId: string(),
 	enabled: boolean()
-}), _void(), { kind: "mutation" });
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
 new Set([
 	{
 		id: "person",
@@ -69631,6 +69936,7 @@ sub("presence", "sensor", "sensor", "#22c55e", "presence", "Presence");
 sub("enum-sensor", "sensor", "sensor", TAXONOMY_COLORS.sensor, "generic", "Sensor state");
 sub("device-event", "sensor", "sensor", "#10b981", "button", "Device event");
 sub("lock", "control", "control", "#0ea5e9", "lock", "Lock");
+sub("cover", "control", "control", "#0ea5e9", "door", "Cover");
 sub("switch", "control", "control", TAXONOMY_COLORS.control, "switch", "Switch");
 sub("siren", "control", "control", "#dc2626", "siren", "Siren");
 sub("button", "control", "control", "#10b981", "button", "Button");
@@ -69934,6 +70240,9 @@ var NcSystemEventKindSchema = _enum([
 	"device-battery-normal",
 	"device-consumable-low",
 	"device-consumable-normal",
+	"device-tank-low",
+	"device-tank-full",
+	"device-tank-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -69949,6 +70258,10 @@ var NcSystemEventKindSchema = _enum([
 	"alarm-disarmed",
 	"alarm-arming",
 	"alarm-arm-refused",
+	"alarm-pending",
+	"alarm-rearmed",
+	"alarm-sensor-bypass",
+	"alarm-check-failed",
 	"addon-updated",
 	"server-updated",
 	"export-completed",
@@ -69986,8 +70299,36 @@ var NcSystemEventConditionSchema = object({
 	* does not carry) matches no `deviceTypes` list.
 	*/
 	deviceTypes: array(string().min(1)).min(1).optional(),
+	/**
+	* Devices this rule NEVER speaks about, whatever else matched. Scoped to the
+	* same kind family as `deviceIds` (`systemEventFilterApplies(kind,
+	* 'deviceIds')`) and applied AFTER it: include first, then exclude. A
+	* consumable subject (`consumable:<id>:<key>`) is excluded by its device id.
+	*
+	* It never fails closed: a subject that carries no device id is not in the
+	* list, so it is not excluded. "Every battery except the one thermometer that
+	* reads 0 % forever" is the question this answers — expressed as an include
+	* list it would have to name every other battery device, and every device
+	* adopted later would be silently left out (D636).
+	*/
+	excludeDeviceIds: array(number().int()).min(1).optional(),
 	nodeIds: array(string().min(1)).min(1).optional(),
-	packageNames: array(string().min(1)).min(1).optional()
+	packageNames: array(string().min(1)).min(1).optional(),
+	/**
+	* At or below this remaining-life %, a consumable is LOW for THIS rule
+	* (D642). Absent = {@link NC_CONSUMABLE_LOW_PERCENT_DEFAULT}; at most
+	* {@link NC_CONSUMABLE_LOW_PERCENT_MAX}, so every episode can recover. Scoped to the
+	* consumable kinds (`systemEventFilterApplies`) and to the device-events
+	* family; ignored on every other kind.
+	*
+	* It is a property of the RULE because the operator decided so: a rule at
+	* 25 must be told about a filter at 20 %, a rule at 10 must not. The hub
+	* keeps one episode per (threshold, device, item) — its own hysteresis, its
+	* own reminder — and a rule hears only the episode judged at ITS threshold,
+	* exactly as an occupancy rule hears only the edge of its own count. A
+	* provider's own `replace` verdict is low at every threshold.
+	*/
+	consumableLowPercent: number().int().min(1).max(95).optional()
 });
 /** Hard ceiling on a window (24h). A snooze that could not expire would be an
 *  outage the operator asked for once and forgot. */
@@ -70130,6 +70471,16 @@ var NcCrossingSchema = _enum([
 	"exit",
 	"any"
 ]);
+/**
+* Which edge of a BOOLEAN sensor fires a device-event rule (D640).
+*  - `raised`  — the sensor went high: water detected, smoke, open, tampered.
+*  - `cleared` — it went back: dry, clear, closed.
+*  - absent    — both edges, which is what every rule authored before this did.
+*
+* There is no third member for "both": absence already says it, and a value
+* that means the same as absence is a second way to write one rule.
+*/
+var NcSensorTransitionSchema = _enum(["raised", "cleared"]);
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 var NcZoneConditionSchema = object({
 	ids: array(string().min(1)).min(1),
@@ -70319,6 +70670,20 @@ var NcConditionsSchema = object({
 	scene: NcSceneConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: array(number()).optional(),
+	/**
+	* Device EXCLUSION (D641) — "every device except these". Judged on the SAME
+	* subject ids {@link devices} is judged on (the camera, the sensor that
+	* fired, a linked set's sensor and row cameras), so a sensor fanned out per
+	* linked camera is excluded exactly where an include would have tested it.
+	* `min(1)`: an empty exclusion excludes nothing and is written as absent.
+	*
+	* Not for `system-event` rules — those carry their own
+	* `systemEvent.excludeDeviceIds` (D636), and the hub refuses this key there.
+	* Editors present the two lists as ONE field (All | Only these | All except
+	* these); the engine evaluates each independently, so a legacy rule
+	* carrying both still means "these, minus those".
+	*/
+	devicesExclude: array(number()).min(1).optional(),
 	/** Detector class names (any overlap with the record's class set). */
 	classes: array(string().min(1)).optional(),
 	/** Veto classes — any overlap fails the rule. */
@@ -70452,6 +70817,16 @@ var NcConditionsSchema = object({
 	*/
 	sensorKinds: array(string().min(1)).optional(),
 	/**
+	* DEVICE-EVENT only (D640). Fire on one edge of a boolean sensor —
+	* {@link NcSensorTransitionSchema}. Which field of the slice means "raised"
+	* is `@camstack/types` → `notification/sensor-raised.ts`. A reading the
+	* engine cannot place (a kind with no raise, an unreadable slice) PASSES:
+	* the condition fails open towards notifying, never towards silence. Editors
+	* offer it only when every chosen {@link sensorKinds} member has a raise
+	* (`sensorTransitionOffered`), and the hub refuses it on any other delivery.
+	*/
+	sensorTransition: NcSensorTransitionSchema.optional(),
+	/**
 	* PACKAGE-EVENT only. Which package phase fires the rule — `delivered`
 	* (a parked parcel appeared), `picked-up` (it departed), or `both`. Fails
 	* when the subject's phase does not match (a subject always carries a phase
@@ -70544,6 +70919,19 @@ var NcMediaFrameSchema = _enum([
 	"full",
 	"boxed"
 ]);
+/**
+* How a SENSOR notification shows the cameras that link the sensor.
+*
+* `mosaic` — one image composed of every linked camera's photograph, taken at
+* the trigger. `each` — one image per camera where the target takes several
+* attachments; a target that takes one keeps the first camera's (the degrade
+* engine drops the rest by order). Either way ONE notification per event.
+* Absent = `mosaic`, applied by the Notification Center and deliberately NOT
+* a Zod default (see NcRulePatchSchema: a default materialises on every
+* partial patch). Meaningless for a rule whose subject is not a sensor, and a
+* sensor linked to one camera ships that camera's plain snapshot either way.
+*/
+var NcLinkedCameraModeSchema = _enum(["mosaic", "each"]);
 var NcMediaPolicySchema = object({
 	attach: _enum([
 		"best",
@@ -70589,7 +70977,9 @@ var NcMediaPolicySchema = object({
 	* A profile that is not assigned falls back to the cheapest, and the render
 	* reports which one actually ran.
 	*/
-	profile: CamProfileSchema.optional()
+	profile: CamProfileSchema.optional(),
+	/** See {@link NcLinkedCameraModeSchema}. */
+	linkedCameras: NcLinkedCameraModeSchema.optional()
 });
 /**
 * Cooldown GRANULARITY over the subject's class — how much a fired
@@ -70709,7 +71099,7 @@ var NcRuleInputSchema = object({
 		cooldownSec: 60,
 		scope: "rule-device"
 	}),
-	/** `{{var}}` templating over camera/class/label/zones/confidence/time. */
+	/** `{{var}}` title/body. The variables are declared in `NC_TEMPLATE_VARS` (@camstack/types) and depend on the rule kind — see `templateVarsFor`. */
 	template: object({
 		title: string().max(500).optional(),
 		body: string().max(2e3).optional()
@@ -70889,6 +71279,22 @@ var NcRulePatchSchema = NcRuleInputSchema.partial().extend({
 	throttle: NcThrottleSchema.optional(),
 	priority: number().int().min(1).max(5).optional()
 });
+var NcRuleClearableKeySchema = _enum([
+	"template",
+	"schedule",
+	"targetUsers",
+	"snoozeOptions",
+	"snoozeAllowGlobal",
+	"waitForEnhancement",
+	"actions",
+	"confirm",
+	"groupIdleSec"
+]);
+var NcRuleUpdateInputSchema = object({
+	ruleId: string(),
+	patch: NcRulePatchSchema,
+	clear: array(NcRuleClearableKeySchema).optional()
+});
 /** A persisted rule. */
 var NcRuleSchema = NcRuleInputSchema.extend({
 	id: string(),
@@ -70920,6 +71326,105 @@ var NcTestResultSchema = object({
 	className: string().optional(),
 	label: string().optional()
 });
+/** The rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts` is the
+*  same union; the template-vars spec pins the two together. `mixed` is DERIVED
+*  (a stored system rule whose kinds span families, D637) and never authored. */
+var NcRuleKindSchema = _enum([
+	"detection",
+	"sensor",
+	"occupancy",
+	"sound",
+	"device-events",
+	"system",
+	"alarm",
+	"mixed"
+]);
+/**
+* The kinds a SERVED template-variable descriptor may name: the five that
+* existed before D637, frozen. `getTemplateCatalog` ships `kinds` to every
+* installed viewer, and a viewer at `@camstack/types` 1.2.25x parses them with a
+* strict five-member enum — one `device-events` in one descriptor fails the
+* whole catalog parse. So the WIRE says `system`, and the MATCH widens it:
+* `templateVarKindApplies` reads a `system` descriptor as applying to every
+* system rule kind (`device-events`, `system`, `alarm`, `mixed`).
+*/
+var NcTemplateVarKindSchema = _enum([
+	"detection",
+	"sensor",
+	"occupancy",
+	"sound",
+	"system"
+]);
+/** Which producer renders a template: an ordinary rule, a timelapse, a digest. */
+var NcTemplateFamilySchema = _enum([
+	"rule",
+	"timelapse",
+	"summary"
+]);
+/** Which text field of that producer. `previewText` is the timelapse frame
+*  caption, `captionText` the digest mosaic caption — both see fewer vars. */
+var NcTemplateFieldSchema = _enum([
+	"title",
+	"body",
+	"previewText",
+	"captionText"
+]);
+var NcTemplateVarGroupSchema = _enum([
+	"subject",
+	"place",
+	"time",
+	"rule",
+	"occupancy",
+	"sound",
+	"sensor",
+	"system",
+	"digest",
+	"ai"
+]);
+/**
+* ONE `{{var}}` a notification template may name.
+*
+* `families` / `fields` / `kinds` / `deliveries` / `systemEventKinds` say WHERE
+* it has a value; absent = no restriction on that axis. `systemEventKinds` is
+* read only for a system-event rule (any family, or `mixed`). `dynamic` declares a FAMILY of names
+* (`count_<class>`): the descriptor's `name` is the example member.
+*/
+var NcTemplateVarDescriptorSchema = object({
+	name: string().regex(/^\w+$/),
+	label: string(),
+	description: string().optional(),
+	example: string(),
+	group: NcTemplateVarGroupSchema,
+	families: array(NcTemplateFamilySchema).min(1),
+	fields: array(NcTemplateFieldSchema).optional(),
+	kinds: array(NcTemplateVarKindSchema).optional(),
+	deliveries: array(NcDeliverySchema).optional(),
+	systemEventKinds: array(NcSystemEventKindSchema).optional(),
+	dynamic: object({
+		prefix: literal("count_"),
+		from: literal("classes")
+	}).optional()
+});
+/** Input to `previewTemplate` — the editor's own context, plus the draft text. */
+var NcTemplatePreviewInputSchema = object({
+	context: object({
+		family: NcTemplateFamilySchema,
+		field: NcTemplateFieldSchema,
+		kind: NcRuleKindSchema.optional(),
+		delivery: NcDeliverySchema.optional(),
+		systemEventKinds: array(NcSystemEventKindSchema).optional()
+	}),
+	template: object({
+		title: string().max(500).optional(),
+		body: string().max(2e3).optional()
+	})
+});
+var NcTemplatePreviewSchema = object({
+	title: string().nullable(),
+	body: string().nullable(),
+	/** Names the template uses that this context never fills — they render empty. */
+	unknown: array(string())
+});
 var NcConditionDescriptorSchema = object({
 	/** Field id inside `NcConditions` (or `'schedule'` for the rule-level group). */
 	id: string(),
@@ -70940,6 +71445,7 @@ var NcConditionDescriptorSchema = object({
 	/** Editor widget the UI renders — never hardcode per-condition forms. */
 	valueType: _enum([
 		"deviceIdList",
+		"deviceIdExcludeList",
 		"stringList",
 		"number01",
 		"number",
@@ -70950,6 +71456,7 @@ var NcConditionDescriptorSchema = object({
 		"plateMatcher",
 		"packagePhase",
 		"crossingSelect",
+		"sensorTransition",
 		"polygonDraw",
 		"occupancy",
 		"audio",
@@ -71100,6 +71607,28 @@ var NcHistoryFilterSchema = object({
 	limit: number().int().min(1).max(500).default(100)
 });
 /**
+* Every rule's last run, in one answer.
+*
+* A rule ABSENT from `runs` produced no delivery inside `horizonMs` — how far
+* back this answer looked, in ms before the hub's now. It is the outbox prune
+* window (7 days by default, operator-configurable), NARROWED when the read hit
+* its row bound: the answer never claims a window it did not read. `null` means
+* the operator keeps the outbox forever AND the read reached its end, so absent
+* means "never on record". A UI derives its "not in the last N days" from this
+* value, never from a constant — and only when the call ANSWERED (D315).
+*/
+var NcRuleLastRunsSchema = object({
+	runs: array(object({
+		ruleId: string(),
+		/** Fire time of the newest row (`createdAt`, epoch ms). */
+		lastAt: number(),
+		status: NcHistoryStatusSchema,
+		/** The camera/device of that row (a digest row files under its first camera). */
+		deviceId: number()
+	})),
+	horizonMs: number().nonnegative().nullable()
+});
+/**
 * What a snooze covers. Broader scopes win when several overlap, so one window
 * leaves ONE digest rather than a rule snooze and a whole-feed snooze both
 * summarising the same silence.
@@ -71185,8 +71714,17 @@ object({
 	lastAt: number()
 });
 /**
-* The three durations the panel's state machine runs on, plus who hears about
-* an arm.
+* The per-mode lists, at most one per mode. Two lists for one mode have no
+* meaning a reader could agree on (union? the last one?), so they are refused
+* at the boundary rather than interpreted.
+*/
+var NcAlarmNonBlockingListSchema = array(object({
+	mode: AlarmArmModeSchema,
+	deviceIds: array(number().int()).max(200)
+})).max(8).refine((lists) => new Set(lists.map((l) => l.mode)).size === lists.length, { message: "nonBlocking: at most one list per arm mode" });
+/**
+* The three durations the panel's state machine runs on, who hears about its
+* transitions, and which openings each mode tolerates.
 *
 * They live on the NOTIFICATION-RULES cap, not on `alarm-panel`, on purpose:
 * `alarm-panel` is `deviceNative` and its other provider mirrors somebody
@@ -71205,21 +71743,39 @@ var NcAlarmSettingsSchema = object({
 	* existed, and therefore what an untouched install keeps doing.
 	*/
 	triggeredDurationSec: number().int().min(0).max(3600),
-	/** Send a notification when a mode takes effect. */
-	announceArm: boolean(),
 	/**
-	* Where that notification goes. Target ids from `notification-output`.
+	* Deprecated by D630 — every transition is announced. Parsed, never read;
+	* remove after one release. Optional so an older admin's patch (which still
+	* sends it) parses rather than failing the whole save.
+	*/
+	announceArm: boolean().optional(),
+	/**
+	* Target ids from `notification-output`: every alarm transition goes here.
 	*
-	* Explicit rather than "everyone": an arm announcement is a household
+	* Explicit rather than "everyone": an alarm announcement is a household
 	* message, and broadcasting it to every configured endpoint (including a
 	* webhook wired to something else) is not a default anybody would choose.
-	* Empty with `announceArm: true` sends nothing, and the server logs that —
-	* silence must be attributable.
+	* Empty sends nothing, and the server logs that — silence must be
+	* attributable.
+	*/
+	announceTargets: array(string().min(1)).max(16),
+	/**
+	* Per arm mode, the covered devices whose being OPEN does not refuse the
+	* arm (a window left ajar for the cat under `home`, say). At most one entry
+	* per mode is meaningful. Defaulted to `[]` so a blob stored before D630
+	* parses as "every opening blocks" — the behaviour it was written under.
 	*/
-	announceTargets: array(string().min(1)).max(16)
+	nonBlocking: NcAlarmNonBlockingListSchema.default([])
 });
-/** Every field optional — a tab edits one control at a time. */
-var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.partial();
+/**
+* Every field optional — a tab edits one control at a time.
+*
+* `nonBlocking` is re-declared WITHOUT its default: `.partial()` does not
+* remove an inner `.default()`, so a patch that never named the field would
+* parse to `nonBlocking: []` and wipe every mode's list on an unrelated edit
+* (the same trap {@link NcRulePatchSchema} documents).
+*/
+var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({ nonBlocking: NcAlarmNonBlockingListSchema }).partial();
 /**
 * What one arm mode actually arms, DERIVED from the enabled rules gated on it.
 * Never authored, never stored — see `alarm-mode-coverage.ts` for why a stored
@@ -71253,6 +71809,14 @@ var NcAlarmModeCoverageSchema = object({
 	/** Ids named by the covering rules. A SUBSET when `allDevices` is true. */
 	deviceIds: array(number().int()),
 	/**
+	* D641: the ids NOT covered although `allDevices` is true — every unscoped
+	* covering rule EXCLUDES them (`conditions.devicesExclude`) and no named rule
+	* covers them. Always `[]` when `allDevices` is false. Excluded by the rules,
+	* which is not the same as skipped by a switch: never in `skippedDevices`.
+	* Defaulted so an answer computed before this field parses as "none".
+	*/
+	allDevicesExcept: array(number().int()).default([]),
+	/**
 	* Devices this mode NAMES but cannot actually arm, each with the switch that
 	* excludes it.
 	*
@@ -71264,6 +71828,36 @@ var NcAlarmModeCoverageSchema = object({
 	*/
 	skippedDevices: array(NcAlarmSkippedDeviceSchema).default([])
 });
+/** One covered device that reads open, and whether that refuses the arm. */
+var NcAlarmOpeningSchema = object({
+	deviceId: number().int(),
+	name: string(),
+	/** The device's state word as read (`open`, `unlocked`, …). */
+	state: string(),
+	/** False when the mode's non-blocking list names this device. */
+	blocking: boolean()
+});
+/** A device the panel is currently ignoring, and which side of it it is on. */
+var NcAlarmExclusionViewSchema = object({
+	deviceId: number().int(),
+	name: string(),
+	phase: _enum(["open", "closed"])
+});
+/** One mode's openings: devices read open, plus those whose state is unknown. */
+var NcAlarmModeOpeningsSchema = object({
+	mode: AlarmArmModeSchema,
+	devices: array(NcAlarmOpeningSchema),
+	/** Covered devices whose state could not be read (D49): neither open nor closed. */
+	unknown: array(number().int())
+});
+var NcAlarmLiveSchema = object({
+	state: AlarmStateSchema,
+	/** The mode being armed into (exit delay) or held; null when disarmed. */
+	targetMode: AlarmArmModeSchema.nullable(),
+	availableModes: array(AlarmArmModeSchema),
+	openings: array(NcAlarmModeOpeningsSchema),
+	exclusions: array(NcAlarmExclusionViewSchema)
+});
 var NcAlarmConfigSchema = object({
 	/**
 	* The panel's device id, or null when this install has no panel (the ensure
@@ -71273,7 +71867,13 @@ var NcAlarmConfigSchema = object({
 	*/
 	deviceId: number().int().nullable(),
 	settings: NcAlarmSettingsSchema,
-	coverage: array(NcAlarmModeCoverageSchema)
+	coverage: array(NcAlarmModeCoverageSchema),
+	/**
+	* The panel as it is NOW — state, what each mode would find open, what is
+	* excluded. Optional: a panel-less hub answers without it, and a client
+	* must not read its absence as "nothing is open".
+	*/
+	live: NcAlarmLiveSchema.optional()
 });
 /**
 * ONE rule's demand on ONE camera's clip ring.
@@ -71321,10 +71921,7 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 	kind: "mutation",
 	auth: "admin",
 	caller: "required"
-}), method(object({
-	ruleId: string(),
-	patch: NcRulePatchSchema
-}), object({ rule: NcRuleSchema }), {
+}), method(NcRuleUpdateInputSchema, object({ rule: NcRuleSchema }), {
 	kind: "mutation",
 	auth: "admin",
 	caller: "required"
@@ -71352,7 +71949,10 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), method(object({}), object({
 	catalog: array(NcConditionDescriptorSchema),
 	taxonomy: NcTaxonomySchema.optional()
-})), method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }), method(object({ artifactId: string().min(1) }), object({ url: string().nullable() }), { auth: "admin" }), method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }), method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
+})), method(object({}), object({ vars: array(NcTemplateVarDescriptorSchema) })), method(NcTemplatePreviewInputSchema, NcTemplatePreviewSchema, {
+	kind: "mutation",
+	access: "view"
+}), method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }), method(object({}), NcRuleLastRunsSchema, { auth: "admin" }), method(object({ artifactId: string().min(1) }), object({ url: string().nullable() }), { auth: "admin" }), method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }), method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
 	kind: "mutation",
 	caller: "required"
 }), method(object({ snoozeId: string() }), object({ success: literal(true) }), {
@@ -75825,6 +76425,7 @@ var CAP_TO_KIND = {
 	"enum-sensor": "enum-sensor",
 	"event-emitter": "device-event",
 	"lock-control": "lock",
+	cover: "cover",
 	switch: "switch",
 	button: "button",
 	doorbell: "doorbell"
@@ -75837,7 +76438,11 @@ function buildDescriptor(capName, kind) {
 		icon: legacyIcon(t.iconId)
 	};
 }
-Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
+/**
+* Sensor / control cap name → static event-kind descriptor. A linked device
+* contributes one entry per bound cap present in this map.
+*/
+var EVENT_KIND_BY_CAP = Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
 /**
 * server-management — per-NODE singleton capability for a node's ROOT
 * package lifecycle (runtime-updatable node packages).
@@ -76385,41 +76990,65 @@ var ProviderListEntrySchema = discriminatedUnion("shouldSaveDiskSpace", [object(
 method(object({
 	location: StorageLocationRefSchema,
 	relativePath: string()
-}), string()), method(object({
+}), string(), { auth: "admin" }), method(object({
 	location: StorageLocationRefSchema,
 	relativePath: string(),
 	data: _instanceof(Uint8Array)
-}), _void(), { kind: "mutation" }), method(object({
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	location: StorageLocationRefSchema,
 	relativePath: string()
-}), _instanceof(Uint8Array)), method(object({
+}), _instanceof(Uint8Array), { auth: "admin" }), method(object({
 	location: StorageLocationRefSchema,
 	relativePath: string()
-}), boolean()), method(object({
+}), boolean(), { auth: "admin" }), method(object({
 	location: StorageLocationRefSchema,
 	prefix: string().optional()
-}), array(string()).readonly()), method(object({
+}), array(string()).readonly(), { auth: "admin" }), method(object({
 	location: StorageLocationRefSchema,
 	relativePath: string()
-}), _void(), { kind: "mutation" }), method(object({ location: StorageLocationRefSchema }), number().nullable()), method(object({
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ location: StorageLocationRefSchema }), number().nullable()), method(object({
 	location: StorageLocationRefSchema,
 	relativePath: string(),
 	sizeBytes: number().optional()
-}), object({ uploadId: string() }), { kind: "mutation" }), method(object({
+}), object({ uploadId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	uploadId: string(),
 	offset: number(),
 	data: _instanceof(Uint8Array)
-}), _void(), { kind: "mutation" }), method(object({ uploadId: string() }), _void(), { kind: "mutation" }), method(object({ uploadId: string() }), _void(), { kind: "mutation" }), method(object({
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ uploadId: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ uploadId: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	location: StorageLocationRefSchema,
 	relativePath: string()
 }), object({
 	downloadId: string(),
 	sizeBytes: number()
-}), { kind: "mutation" }), method(object({
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	downloadId: string(),
 	offset: number(),
 	length: number()
-}), _instanceof(Uint8Array)), method(object({ downloadId: string() }), _void(), { kind: "mutation" }), method(object({ type: StorageLocationTypeSchema.optional() }), array(StorageLocationSchema).readonly()), method(_void(), array(StorageLocationDeclarationSchema).readonly()), method(StorageLocationSchema.omit({
+}), _instanceof(Uint8Array), { auth: "admin" }), method(object({ downloadId: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ type: StorageLocationTypeSchema.optional() }), array(StorageLocationSchema).readonly()), method(_void(), array(StorageLocationDeclarationSchema).readonly()), method(StorageLocationSchema.omit({
 	createdAt: true,
 	updatedAt: true
 }), StorageLocationSchema, {
@@ -78024,7 +78653,67 @@ var WebrtcLadderDecisionSchema = object({
 	serverSending: boolean().nullable(),
 	/** Epoch ms. The overlay prints its age; a decision from 40 minutes ago
 	*  must not read like one from this second. */
-	at: number()
+	at: number(),
+	/** The broker's own cause when it is finer than `cause` can carry, e.g.
+	*  `trial-revert` (reported as `stall`/`loss` for older consumers). Optional:
+	*  an older server strips it instead of rejecting the answer. */
+	causeDetail: string().optional()
+});
+var WebrtcClimbHoldSchema = object({
+	/** `stall-building` — the client receives ≪ what is sent; `delivery` — the
+	*  current rung is not landing whole; `no-evidence` — no receiver feedback;
+	*  `warming` — healthy, accumulating the streak; `cooldown` — too soon after
+	*  a change; `capacity` — a MEASURED probe below the next rung's bar;
+	*  `try-unclean` — no capacity evidence, and the path is not clean enough to
+	*  try; `try-backoff` — a try reverted, waiting out its backoff; `trial` —
+	*  this rung IS a try, reverting if it does not land; `suspended` —
+	*  recorded playback on the track. */
+	code: string(),
+	/** The rung a climb would go to. */
+	nextTier: CamProfileSchema,
+	/** Bytes received ÷ bytes sent over the delivery window (≥ one GOP). */
+	deliveryRatio: number().nullable(),
+	deliveryWindowMs: number().nullable(),
+	/** The ratio a climb requires. */
+	climbDeliveryRatio: number(),
+	/** The receiver's bandwidth estimate (REMB), kbps. Capped by what is sent. */
+	capacityKbps: number().nullable(),
+	/** The viewer's downlink probe for this session, kbps. */
+	probeKbps: number().nullable(),
+	/** The next rung's measured bitrate, kbps. */
+	nextTierKbps: number().nullable(),
+	capacityMargin: number(),
+	/** The capacity a climb to `nextTier` needs, kbps (bitrate × margin, or the
+	*  client ladder threshold when the rung has measured nothing). */
+	neededKbps: number().nullable(),
+	/** For `try-unclean`: which clean-path condition failed (a `WebrtcTryBlocker`,
+	*  carried as a string for the same reason as `code`). */
+	tryBlockedBy: string().nullable(),
+	/** The delivery ratio and the loss ratio a try requires / must stay under.
+	*  Optional, like every field added to this schema after it first shipped:
+	*  the router validates output, so a REQUIRED new field makes a newer server
+	*  reject an older broker's whole answer (review m1). */
+	tryDeliveryRatio: number().optional(),
+	tryMaxLossRatio: number().optional(),
+	/** For `try-backoff`: time until the next try, ms. */
+	retryInMs: number().nullable(),
+	/** The last try that reverted in this viewer session. */
+	lastRevert: object({
+		tier: CamProfileSchema,
+		deliveryRatio: number().nullable(),
+		stalled: boolean(),
+		at: number()
+	}).nullable(),
+	/** For `trial`: how long this rung has been on trial, and for how long it must hold. */
+	trialForMs: number().nullable(),
+	trialMs: number().nullable(),
+	healthyForMs: number().nullable(),
+	requiredHealthyMs: number().nullable(),
+	/** Epoch ms this hold's code began. */
+	since: number(),
+	/** The same one-line account the broker logs, e.g.
+	*  `held: delivery 0.97 over 4.0s ok, REMB 480 kbps < mid 1800 kbps × 1.2`. */
+	summary: string()
 });
 /** Per-tier count of MEASURED downgrades this viewer session has suffered. */
 var WebrtcTierFailureSchema = object({
@@ -78088,7 +78777,12 @@ var WebrtcSessionDebugSchema = object({
 	tierFailures: array(WebrtcTierFailureSchema),
 	/** Successful promotions in this viewer session (drives the progressive
 	*  healthy timer). Null when no ladder is running. */
-	upgradeCount: number().nullable()
+	upgradeCount: number().nullable(),
+	/** Why the ladder is not climbing right now. Null when no ladder runs, it
+	*  is at the top rung, or it just moved. Optional because this output is
+	*  validated by the router: a server carrying this schema must still accept
+	*  the answer of a stream-broker deployed before the field existed. */
+	climbHold: WebrtcClimbHoldSchema.nullable().optional()
 });
 DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), array(WebrtcStreamChoiceSchema)), method(object({
 	deviceId: number().int().nonnegative(),
@@ -79908,12 +80602,20 @@ reset: method(object({
 	},
 	runtimeState: ConsumablesStatusSchema.extend({ lastFetchedAt: number() }),
 	/**
-	* Runtime-state durability: **session** — the authority is the appliance; the provider re-reads the whole item array on connect.
+	* Runtime-state durability: **restored** — nothing else holds the value
+	* (D642). A consumable can often be read only in a device's wake window (the
+	* Dreame mower's CMS counters answer only while it charges), so a restart
+	* that wiped the slice left the panel empty and the alerts blind until the
+	* next wake — 2026-09-26, mower 503 idle with `items: []`. A restored item is
+	* the previous observation, not a claim about now; the provider overwrites it
+	* the moment it reads the device again.
 	*
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "restored",
+	/** Clocks, not content: a re-read that changed no item costs no commit. */
+	volatileStateFields: ["lastChangedAt", "lastFetchedAt"]
 };
 /**
 * Door / window / opening / garage / valve contact sensor. Boolean
@@ -83457,6 +84159,11 @@ var ClientNetworkStatsSchema = object({
 	jitterMs: number(),
 	estimatedBandwidthKbps: number(),
 	packetLossPercent: number().min(0).max(100),
+	/** The viewer's latest `/adaptive-probe` reading, Mbps — whatever it read
+	*  (D635 I4). Absent when it never probed or the probe failed (unknown). */
+	downlinkMbps: number().optional(),
+	/** Age of that reading when this report was sent, ms. */
+	downlinkAgeMs: number().optional(),
 	lastUpdated: number()
 });
 var DeviceNetworkStatsSchema = object({
@@ -83469,7 +84176,11 @@ method(object({ deviceId: number() }), DeviceNetworkStatsSchema.nullable()), met
 	rttMs: number().min(0).max(6e4),
 	jitterMs: number().min(0).max(1e4),
 	estimatedBandwidthKbps: number().min(0).max(1e6),
-	packetLossPercent: number().min(0).max(100)
+	packetLossPercent: number().min(0).max(100),
+	/** Latest downlink probe, Mbps, whatever it read; absent = never / failed. */
+	downlinkMbps: number().min(0).max(1e5).optional(),
+	/** Age of that probe when this report is sent, ms. */
+	downlinkAgeMs: number().min(0).max(864e5).optional()
 }), _void(), { kind: "mutation" });
 /**
 * nodes — system-scoped singleton capability for cluster topology
@@ -83588,7 +84299,30 @@ var RenameNodeResultSchema = object({
 	nodeId: string(),
 	name: string()
 });
-method(_void(), array(TopologyNodeSchema).readonly(), { auth: "admin" }), method(NodeAddonInputSchema, SuccessSchema, {
+/**
+* The cheap node list. A consumer's rule for a STORED node id (a rule's
+* `nodeIds`) that is missing from `nodes`, whatever `complete` says: render it
+* as a removable chip labelled unknown, never drop it (D49). Even a complete
+* list omits a node that joined and left between two history captures, so a
+* missing id means "not known to the hub", never "removed". Only the operator
+* removes it.
+*
+* `complete` changes only the WORDING: `false` = no history read has ever
+* answered, so the list may be missing offline nodes the hub does know (D315).
+*
+* `name` is the history row's name (≤ 30 s behind a rename), or the id when
+* the history has none.
+*/
+var NodeDirectorySchema = object({
+	nodes: array(object({
+		id: string(),
+		name: string(),
+		isHub: boolean(),
+		isOnline: boolean()
+	})).readonly(),
+	complete: boolean()
+});
+method(_void(), array(TopologyNodeSchema).readonly(), { auth: "admin" }), method(_void(), NodeDirectorySchema, { auth: "admin" }), method(NodeAddonInputSchema, SuccessSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(NodeAddonInputSchema, SuccessSchema, {
@@ -89088,6 +89822,42 @@ var zoneRulesCapability = {
 	durability: "restored"
 };
 /**
+* LA tabella "quale booleano di questo tipo di device conta come ALTO", e il
+* valutatore puro del suo FRONTE.
+*
+* Viveva dentro il builtin virtual-doorbell
+* (`@camstack/system` — `builtins/doorbell/trigger-engine.ts`) e i suoi
+* predicati erano privati al modulo. Il recorder ne ha bisogno per il trigger
+* `RecordingTriggers.sensorDeviceIds`: copiarla avrebbe creato la SECONDA
+* tabella, che diverge alla prima cap aggiunta e il cui sintomo — "il sensore
+* fa suonare il campanello ma non registra" — è esattamente D62. Quindi si
+* SPOSTA qui e il doorbell la ri-esporta.
+*
+* ⚠ NON è `DEVICE_STATE_READERS` (`catalogs/device-state-vocabulary.ts`), e le
+* due non vanno unificate: quella risponde a "qual è la PAROLA di stato per una
+* regola" (e include `presence`, `cover`, `alarm-panel`), questa a "qual è il
+* booleano il cui FRONTE conta". Vocabolari deliberatamente diversi.
+*/
+/**
+* Known binary / switch source caps → the boolean slice field whose
+* false→true rise counts as ACTIVE. Every entry is "fire on active".
+* Sensors whose "active" reading is not a plain boolean (presence's string
+* state, connectivity's connected flag) are deliberately excluded — a
+* reconnect is not a doorbell press, and it is not a recording either.
+*/
+var SOURCE_CAP_ACTIVE_FIELD = {
+	contact: "entryOpen",
+	binary: "on",
+	switch: "on",
+	motion: "detected",
+	flood: "flooded",
+	gas: "detected",
+	smoke: "detected",
+	"carbon-monoxide": "detected",
+	vibration: "detected",
+	tamper: "tampered"
+};
+/**
 * Accessory device helpers — shared across drivers.
 *
 * Many vendor-specific drivers register accessory child devices on
@@ -93615,6 +94385,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.listDeviceIdsByCaps": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.listLocationDescriptions": {
 		capName: "device-manager",
 		capScope: "system",
@@ -94575,12 +95351,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.appleAvailability": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.cancel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.complete": {
 		capName: "llm-runtime",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.completeApple": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.deleteModel": {
 		capName: "llm-runtime",
 		capScope: "system",
@@ -95253,6 +96047,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodes.directory": {
+		capName: "nodes",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"nodes.executeQuery": {
 		capName: "nodes",
 		capScope: "system",
@@ -95421,6 +96221,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getRuleLastRuns": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationRules.getTemplateCatalog": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.listDeviceMutes": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -95439,6 +96251,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.previewTemplate": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.resolveArtifactUrl": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -101005,8 +101823,173 @@ var NC_AUDIO_DEFAULTS = {
 	samplingSeconds: 10
 };
 new Set(["devices", "classes"]);
+/**
+* WHICH narrowing filter speaks about WHICH system-event kind — one predicate,
+* consumed by the rule ENGINE and by every rule EDITOR.
+*
+* ── The failure this file exists for ───────────────────────────────────────
+* `NcSystemEventConditionSchema` carries four optional narrowing lists
+* (`deviceIds`, `deviceTypes`, `nodeIds`, `packageNames`) beside a required
+* `kinds` gate. They are not four filters over one vocabulary: each belongs to
+* a FAMILY of kinds and is meaningless outside it. A node going away has no
+* device type; a completed export has no package; `stream-offline` deliberately
+* carries no device type at all (a stream belongs to a camera by construction).
+*
+* The engine applied all four to every kind, so a filter from one family failed
+* a kind from another family CLOSED. The operator's live rule "Eventi di
+* sistema" selected eleven kinds and set `deviceTypes: ['camera']` — the only
+* way to say "only my cameras" about the two liveness kinds — and NINE of the
+* eleven silently stopped being deliverable. Four days of history contained
+* `device-online` and `device-offline` and nothing else, across a window in
+* which agents were restarted and addons were updated.
+*
+* Both editors already computed this scoping, to decide which filter boxes to
+* render; the cap's own docblock already promised it ("Narrow a `device-*` kind
+* to these device TYPES"). Only the engine disagreed, and it disagreed in the
+* destructive direction. So the rule is stated ONCE, here, and the engine and
+* the editors are readers of it rather than three independent authors.
+*
+* ── The direction ─────────────────────────────────────────────────────────
+* Out of family ⇒ the filter is IGNORED, never fail-closed. An editor that
+* hides a box has already told the operator this filter does not speak about
+* these kinds, so honouring it as an exclusion contradicts the only
+* explanation the operator was ever given. Inside its family the filter still
+* narrows, and still fails CLOSED on a subject that cannot produce the identity
+* it tests (a device the mirror cannot name is not evidence of a camera).
+*/
+/**
+* Every filter, for the callers that must cover all of them (guards, tests).
+*
+* `consumableLowPercent` (D642) is not a list but it is a filter in exactly
+* this sense: it belongs to a family of kinds (the consumable pair) and the
+* engine consults it only there. It differs in one way the readers must know —
+* its ABSENCE is not "no narrowing" but the default threshold, because a
+* consumable episode is always judged at SOME threshold.
+*/
+var NC_SYSTEM_EVENT_FILTER_KEYS = [
+	"deviceIds",
+	"deviceTypes",
+	"nodeIds",
+	"packageNames",
+	"consumableLowPercent"
+];
+new Map(Object.entries({
+	"device-online": "device-events",
+	"device-offline": "device-events",
+	"device-disabled": "device-events",
+	"device-enabled": "device-events",
+	"device-battery-low": "device-events",
+	"device-battery-normal": "device-events",
+	"device-consumable-low": "device-events",
+	"device-consumable-normal": "device-events",
+	"device-tank-low": "device-events",
+	"device-tank-full": "device-events",
+	"device-tank-normal": "device-events",
+	"stream-online": "device-events",
+	"stream-offline": "device-events",
+	"detection-blind": "device-events",
+	"node-online": "system",
+	"node-offline": "system",
+	"node-inference-unavailable": "system",
+	"addon-crash-loop": "system",
+	"addon-update-available": "system",
+	"addon-updated": "system",
+	"server-update-available": "system",
+	"server-updated": "system",
+	"wrapper-update-available": "system",
+	"backup-completed": "system",
+	"export-completed": "system",
+	"alarm-triggered": "alarm",
+	"alarm-armed": "alarm",
+	"alarm-disarmed": "alarm",
+	"alarm-arming": "alarm",
+	"alarm-arm-refused": "alarm",
+	"alarm-pending": "alarm",
+	"alarm-rearmed": "alarm",
+	"alarm-sensor-bypass": "alarm",
+	"alarm-check-failed": "alarm",
+	"camera-online": null,
+	"camera-offline": null,
+	"camera-disabled": null,
+	"camera-enabled": null
+}));
+[...NC_SYSTEM_EVENT_FILTER_KEYS];
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
 /**
+* WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
+* persists (D640 "a sensor rule fires on the raise, the clear, or both").
+*
+* A device-event rule over a flood sensor notified on BOTH edges: water
+* detected, and back to dry. `NcConditions.sensorTransition` lets the rule
+* name one edge; this file answers, for one `SensorEvent`, which edge it is.
+*
+* NOT A SECOND TABLE. The "which boolean of this cap counts as HIGH" question
+* already has one answer, `SOURCE_CAP_ACTIVE_FIELD`
+* (`catalogs/sensor-active-state.ts`, the doorbell's and the recorder's edge
+* table), and a sensor event names its kind, not its cap. So the table here is
+* DERIVED: event kind → cap (`EVENT_KIND_BY_CAP`) → that cap's active field.
+* Only kinds whose taxonomy category is `sensor` take part — a switch has an
+* `on` boolean too, but "it triggers / it clears" is not a sentence about a
+* light, and offering it there would be a knob with a misleading label.
+* `presence` is a WORD (`home` / `not_home` / a zone), not a boolean, and is
+* absent from the source table, so it is absent here.
+*
+* `undefined` = never guessed: a kind with no raise (a doorbell press, a
+* button, a cover), or a slice whose field is missing or not a boolean. The
+* engine then does NOT filter — a flood alert must not go silent because one
+* read came back unreadable (the same stance as the alarm's `sensorEdgeOf`).
+*
+* Pure, RN-safe: the viewer imports the support rule from here.
+*/
+/** Event kind → the boolean field of its cap slice that means "raised". */
+var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.entries(EVENT_KIND_BY_CAP).flatMap(([capName, descriptor]) => {
+	const field = SOURCE_CAP_ACTIVE_FIELD[capName];
+	if (field === void 0 || descriptor.category !== "sensor") return [];
+	return [[descriptor.kind, field]];
+})));
+Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
+var RULE_BODY_ONLY = ["body"];
+var RULE_TEXT = ["title", "body"];
+var BATTERY = ["device-battery-low", "device-battery-normal"];
+var CONSUMABLE = ["device-consumable-low", "device-consumable-normal"];
+var TANK = [
+	"device-tank-low",
+	"device-tank-full",
+	"device-tank-normal"
+];
+var UPDATES = [
+	"addon-update-available",
+	"server-update-available",
+	"wrapper-update-available"
+];
+var PACKAGE_UPDATES = ["addon-update-available", "server-update-available"];
+var ALARM = [
+	"alarm-triggered",
+	"alarm-armed",
+	"alarm-disarmed",
+	"alarm-arming",
+	"alarm-arm-refused",
+	"alarm-pending",
+	"alarm-rearmed",
+	"alarm-sensor-bypass",
+	"alarm-check-failed"
+];
+var COMBINED_ALARM = ["alarm-triggered"];
+var DEVICE_EVENTS = [
+	"device-online",
+	"device-offline",
+	"device-disabled",
+	"device-enabled",
+	...BATTERY,
+	...CONSUMABLE,
+	...TANK,
+	"stream-online",
+	"stream-offline",
+	"detection-blind",
+	...ALARM
+];
+[...DEVICE_EVENTS], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_BODY_ONLY], [...RULE_TEXT], [...RULE_TEXT], [...DEVICE_EVENTS], [...RULE_TEXT], [...DEVICE_EVENTS], [...RULE_TEXT], [...BATTERY, ...CONSUMABLE], [...RULE_TEXT], [...CONSUMABLE], [...RULE_TEXT], [...TANK], [...RULE_TEXT], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT];
+/**
 * TimelapseRule — the STANDALONE scheduled timelapse producer's rule model.
 *
 * Spec: `docs/superpowers/specs/2026-07-24-nc-occupancy-timelapse-design.md`
@@ -103258,10 +104241,13 @@ var DreameChildDevice = class extends BaseDevice {
 			try {
 				this.recomputeSlice();
 			} catch (err) {
-				this.ctx.logger.warn("dreame child: stateChanged handler error", { meta: {
-					dreameDeviceId: this.dreameDeviceId,
-					error: errMsg(err)
-				} });
+				this.ctx.logger.warn("dreame child: stateChanged handler error", {
+					tags: { deviceId: this.id },
+					meta: {
+						dreameDeviceId: this.dreameDeviceId,
+						error: errMsg(err)
+					}
+				});
 			}
 		};
 		this.stateChangedUnsub = dreameFacades.onStateChanged(this.brokerId, this.dreameDeviceId, onState);
@@ -103706,6 +104692,40 @@ function clampPercent$1(value) {
 	return Math.max(0, Math.min(100, value));
 }
 /**
+* Where each {@link VacuumTankProps} field lives (siid/piid). Property ids and
+* enum values are the HA Dreame integration's (Tasshack `dreame-vacuum`
+* `types.py`, `DreameVacuumProperty` → siid/piid map; same on `dev` and
+* v2.0.0b25, checked 2026-09-26). 27/1 and 27/4 were already read here; 27/2 and
+* 27/3 are their neighbours on the same station service. The robot pushes them
+* on change; the consumables refresh also re-reads them from the shadow.
+*/
+var VACUUM_TANK_PROPS = {
+	cleanWaterTankStatus: {
+		siid: 27,
+		piid: 1
+	},
+	waterTank: {
+		siid: 4,
+		piid: 6
+	},
+	detergentStatus: {
+		siid: 27,
+		piid: 4
+	},
+	dustCollection: {
+		siid: 15,
+		piid: 3
+	},
+	dirtyWaterTankStatus: {
+		siid: 27,
+		piid: 2
+	},
+	dustBagStatus: {
+		siid: 27,
+		piid: 3
+	}
+};
+/**
 * Clean-water tank `status`: prefer the richer clean-water-tank-status (27/1),
 * fall back to the coarser water-tank presence (4/6). `null` when neither maps
 * to a known good/low reading (NOT_INSTALLED / CHECKING / unknown). Pure.
@@ -103725,10 +104745,32 @@ function detergentTankStatus(value) {
 	if (value === 2) return "low";
 	return null;
 }
-/** Dust-bin `status` from dust-collection (15/3); OVER_USE reads as `full`. Pure. */
-function dustBinTankStatus(value) {
-	if (value === 1) return "ok";
-	if (value === 2) return "full";
+/**
+* Dust-bin `status` from dust-collection (15/3); OVER_USE reads as `full`. A dust
+* bag that is missing or asks to be checked (27/3 NOT_INSTALLED / CHECK) is never
+* `ok` — the enum does not say "full" either, so it is unknown. Pure.
+*/
+function dustBinTankStatus(dustCollection, dustBag) {
+	if (dustCollection === 2) return "full";
+	if (dustBag !== null && dustBag !== 0) return null;
+	if (dustCollection === 1) return "ok";
+	return null;
+}
+/**
+* Dirty-water tank `status` from dirty-water-tank-status (27/2). The robot has
+* ONE value for "not installed or full" and cannot tell them apart; lifting the
+* tank out to EMPTY it reads exactly like a full one, so that value is unknown
+* (`null`) — never `full`, which would raise a false "tank full" at the moment
+* someone is fixing it (controller ruling 2026-09-26). Absent or any other
+* value is unknown too, never `ok`.
+*
+* The unambiguous "full" is the robot's own error `MiotError.DirtyWaterTankFull`
+* (86, the library's `errorCode`, siid 2 piid 2): while it is raised the tank is
+* `full` whatever 27/2 says; once it clears, 27/2 decides again. Pure.
+*/
+function dirtyWaterTankStatus(value, errorCode) {
+	if (errorCode === MiotError.DirtyWaterTankFull) return "full";
+	if (value === 0) return "ok";
 	return null;
 }
 /**
@@ -103752,16 +104794,16 @@ function dustBinTankStatus(value) {
 *   - detergent    ← `hasDetergentReservoir`
 *   - dust-bin     ← `canAutoEmpty` (an auto-empty robot has an onboard dust bin)
 */
-function decodeVacuumTanks(caps, props) {
+function decodeVacuumTanks(caps, props, errorCode = null) {
 	const tank = (present, status) => present ? {
 		level: null,
 		status
 	} : null;
 	return {
 		cleanWater: tank(Boolean(caps?.canMop), props ? cleanWaterTankStatus(props) : null),
-		dirtyWater: tank(Boolean(caps?.canMopWash), null),
+		dirtyWater: tank(Boolean(caps?.canMopWash), dirtyWaterTankStatus(props?.dirtyWaterTankStatus ?? null, errorCode)),
 		detergent: tank(Boolean(caps?.hasDetergentReservoir), props ? detergentTankStatus(props.detergentStatus) : null),
-		dustBin: tank(Boolean(caps?.canAutoEmpty), props ? dustBinTankStatus(props.dustCollection) : null)
+		dustBin: tank(Boolean(caps?.canAutoEmpty), props ? dustBinTankStatus(props.dustCollection, props.dustBagStatus) : null)
 	};
 }
 /**
@@ -103775,19 +104817,18 @@ function clampConsumablePct(value) {
 	return Math.max(0, Math.min(100, value));
 }
 /**
-* Build the `consumables` cap runtime-state slice from a live {@link VacuumDevice}
-* handle. The returned object satisfies the cap's `runtimeState` schema
-* (`ConsumablesStatusSchema.extend({ lastFetchedAt: z.number() })`).
+* The `consumables` cap items for the consumables a vacuum REPORTS.
 *
 * PRESENCE-driven (mirrors HA): the library's `supportedConsumables` enumerates
-* ONLY the consumables this model reports (a present MIoT life property) — main/
-* side brush, filter, sensor, tank-filter, mop-pad, silver-ion, detergent,
-* squeegee, dust-bag — each with its remaining-life % and whether a reset action
-* exists. No hardcoded per-model list: a consumable the device does not expose
-* never appears, and a `resettable` item drives the real MIoT reset action.
-*/
-function buildVacuumConsumables(vacuum) {
-	const items = vacuum.supportedConsumables.map((c) => ({
+* ONLY the consumables this model reports (a present MIoT life property), each
+* with its remaining-life % and whether a reset action exists. No hardcoded
+* per-model list: a consumable the device does not expose never appears.
+*
+* `status` is `null` — the provider reports the level, the notification rule
+* decides what is low. The slice clocks are `nextConsumablesSlice`'s job. Pure.
+*/
+function buildVacuumConsumableItems(readings) {
+	return readings.map((c) => ({
 		key: c.key,
 		label: c.label,
 		level: clampConsumablePct(c.leftPct),
@@ -103795,12 +104836,26 @@ function buildVacuumConsumables(vacuum) {
 		lastResetAt: null,
 		resettable: c.resettable
 	}));
-	const now = Date.now();
-	return {
-		items: [...items],
-		lastChangedAt: now,
-		lastFetchedAt: now
-	};
+}
+/** Structural equality of two JSON-shaped values, key order ignored. */
+function jsonEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => jsonEqual(v, b[i]));
+	if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	return ka.length === kb.length && ka.every((k) => jsonEqual(Reflect.get(a, k), Reflect.get(b, k)));
+}
+/**
+* The `vacuum-control` slice to write, or `null` when only the clock moved.
+* `recomputeSlice` runs on EVERY push; without this each one was a write (and a
+* `device.state-changed`) even when nothing the robot reported had changed. Pure.
+*/
+function nextVacuumControlSlice(prev, next) {
+	if (prev === void 0) return next;
+	const { lastChangedAt: _prevAt, ...prevContent } = prev;
+	const { lastChangedAt: _nextAt, ...nextContent } = next;
+	return jsonEqual(prevContent, nextContent) ? null : next;
 }
 //#endregion
 //#region src/devices/dreame-camera-stream.ts
@@ -150354,7 +151409,7 @@ var DreameCameraDevice = class extends DreameChildDevice {
 				});
 				const rfc = await startRfc4571Server({
 					stream,
-					logger: this.ctx.logger,
+					logger: this.ctx.logger.withTags({ deviceId: this.id }),
 					keyframeTimeoutMs: WAKE_TIMEOUT_MS,
 					onConsumerDisconnect: () => {
 						this.closeStream("idle");
@@ -150829,10 +151884,13 @@ var DreameMowerActionDevice = class extends DreameChildDevice {
 		try {
 			await mower.getMap();
 		} catch (err) {
-			this.ctx.logger.debug("dreame mower action: map fetch failed (asleep?)", { meta: {
-				dreameDeviceId: this.dreameDeviceId,
-				error: errMsg(err)
-			} });
+			this.ctx.logger.debug("dreame mower action: map fetch failed (asleep?)", {
+				tags: { deviceId: this.id },
+				meta: {
+					dreameDeviceId: this.dreameDeviceId,
+					error: errMsg(err)
+				}
+			});
 		} finally {
 			this.#inflight = false;
 			this.#publishSlice();
@@ -150963,45 +152021,293 @@ var MOWER_CONSUMABLE_LABEL = {
 function isMowerConsumableKey(key) {
 	return key === "blade" || key === "brush" || key === "maintenance";
 }
-/** Below this remaining-life %, an item is flagged `replace` (mirrors the
-*  donor's low-consumable warning threshold). */
-var MOWER_CONSUMABLE_REPLACE_PCT = 10;
 /**
 * Map the library's CMS consumable readings (blade/brush/maintenance, remaining
 * %) to the `consumables` cap items. All three drive a real CMS reset, so every
-* item is `resettable`. `status` flags `replace` once life drops to the warning
-* threshold, else `ok`.
+* item is `resettable`.
+*
+* `status` is `null`: the provider reports the LEVEL and gives no verdict. When
+* a level is "low" is the notification rule's threshold (operator, per rule);
+* a provider constant here used to flag `replace` at 10 % and override it.
 */
 function buildMowerConsumables(readings) {
 	return readings.map((r) => ({
 		key: r.key,
 		label: MOWER_CONSUMABLE_LABEL[r.key],
 		level: r.remainingPercent,
-		status: r.remainingPercent <= MOWER_CONSUMABLE_REPLACE_PCT ? "replace" : "ok",
+		status: null,
 		lastResetAt: null,
 		resettable: true
 	}));
 }
 //#endregion
+//#region src/devices/dreame-consumables.ts
+/**
+* The `consumables` slice as both Dreame devices write it, and the one
+* refresher that re-reads it.
+*
+* - A slice is written only when something changed: an item (lastChangedAt), or
+*   a refresh that LANDED (lastFetchedAt, which the cap declares volatile).
+* - An empty list is never written. "The read said nothing" is not "this device
+*   has no consumables" — and the slice is `restored` across restarts (D642),
+*   so an empty write would erase the last real observation.
+* - A refresh never overlaps itself, and a failed one changes nothing (D49): the
+*   last good values stay, and the failure is logged with the device tag.
+*/
+var CONSUMABLES_CAP_NAME = "consumables";
+var CONSUMABLES_COLD_START = {
+	items: [],
+	lastChangedAt: 0,
+	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;
+}
+function itemsEqual(a, b) {
+	return a.length === b.length && a.every((item, i) => {
+		const other = b[i];
+		return other !== void 0 && itemEqual(item, other);
+	});
+}
+/**
+* The slice to write, or `null` for "write nothing".
+*
+* `landed` = these items come from a refresh that just answered (not from a
+* replay of the cache on a push), so `lastFetchedAt` may move.
+*/
+function nextConsumablesSlice(prev, items, now, landed) {
+	if (items.length === 0) return null;
+	if (prev !== void 0 && itemsEqual(prev.items, items)) return landed ? {
+		...prev,
+		items: [...prev.items],
+		lastFetchedAt: now
+	} : null;
+	return {
+		items: [...items],
+		lastChangedAt: now,
+		lastFetchedAt: landed ? now : prev?.lastFetchedAt ?? 0
+	};
+}
+/** Write {@link nextConsumablesSlice}'s answer, if it has one. */
+function writeConsumables(store, items, now, landed) {
+	const next = nextConsumablesSlice(store.getCapState(CONSUMABLES_CAP_NAME), items, now, landed);
+	if (next !== null) store.setCapState(CONSUMABLES_CAP_NAME, next);
+}
+/** Seed the cold start ONLY when nothing was restored — never wipe the last reading. */
+function seedConsumablesColdStart(store) {
+	if (store.getCapState("consumables") === void 0) store.setCapState(CONSUMABLES_CAP_NAME, CONSUMABLES_COLD_START);
+}
+/**
+* Narrow a cap-supplied reset key to one THIS device reports and can reset.
+* A real key of another model (e.g. `mop-pad` on a robot without one) would
+* otherwise send a reset action to a service the robot lacks.
+*/
+function resolveResettableKey(key, present) {
+	const hit = present.find((c) => c.key === key);
+	if (hit === void 0) throw new Error(`this device does not report "${key}"`);
+	if (!hit.resettable) throw new Error(`"${key}" has no reset action on this device`);
+	return hit.key;
+}
+var DEFAULT_FOLLOW_UP_MS = 6e4;
+var DreameConsumablesRefresher = class {
+	#deps;
+	#interval = null;
+	#followUp = null;
+	#running = null;
+	/** At most ONE run waits behind the one in flight. */
+	#queued = null;
+	#stopped = false;
+	constructor(deps) {
+		this.#deps = deps;
+	}
+	/** False once stopped — the device is gone, nothing may be written for it. */
+	live = () => !this.#stopped;
+	/** Arm the periodic re-read (the caller triggers the first read itself). */
+	start() {
+		this.#stopped = false;
+		const { intervalMs } = this.#deps;
+		if (intervalMs === void 0 || this.#interval !== null) return;
+		this.#interval = setInterval(() => {
+			this.trigger("interval");
+		}, intervalMs);
+	}
+	stop() {
+		this.#stopped = true;
+		if (this.#interval !== null) clearInterval(this.#interval);
+		if (this.#followUp !== null) clearTimeout(this.#followUp);
+		this.#interval = null;
+		this.#followUp = null;
+		this.#queued = null;
+	}
+	/**
+	* Re-read now. Resolves `true` when the read landed. A trigger while one is in
+	* flight does not start a second read: it queues one more run after it
+	* (coalesced) and shares its promise.
+	*/
+	trigger(reason) {
+		if (this.#stopped) return Promise.resolve(false);
+		if (this.#running !== null) {
+			this.#queued = reason;
+			return this.#running;
+		}
+		const run = this.#drain(reason).finally(() => {
+			this.#running = null;
+		});
+		this.#running = run;
+		return run;
+	}
+	/** One re-read after `followUpMs`; a second call replaces the first. */
+	scheduleFollowUp(reason) {
+		if (this.#stopped) return;
+		if (this.#followUp !== null) clearTimeout(this.#followUp);
+		this.#followUp = setTimeout(() => {
+			this.#followUp = null;
+			if (!this.#stopped) this.trigger(reason);
+		}, this.#deps.followUpMs ?? DEFAULT_FOLLOW_UP_MS);
+	}
+	async #drain(first) {
+		let landed = await this.#once(first);
+		while (this.#queued !== null && !this.#stopped) {
+			const next = this.#queued;
+			this.#queued = null;
+			landed = await this.#once(next);
+		}
+		return landed;
+	}
+	async #once(reason) {
+		const { deviceId, logger, subject, read } = this.#deps;
+		try {
+			await read(reason, this.live);
+			if (this.#stopped) return false;
+			logger.debug(`${subject}: consumables refreshed`, {
+				tags: { deviceId },
+				meta: { reason }
+			});
+			return true;
+		} catch (err) {
+			if (this.#stopped) return false;
+			logger.warn(`${subject}: consumables refresh failed — keeping the last values`, {
+				tags: { deviceId },
+				meta: {
+					reason,
+					error: errMsg(err)
+				}
+			});
+			return false;
+		}
+	}
+};
+//#endregion
+//#region src/devices/dreame-mower-consumables.ts
+/**
+* The mower's `consumables` slice (blade / brush / maintenance).
+*
+* The CMS counters are not cached MIoT props: they are read by a LIVE custom
+* action that answers only while the mower is awake — the instant it docks and
+* starts charging. A sleeping mower never answers, so there is no periodic
+* read: the triggers are activation (in case it is awake), the edge into
+* charging, and a reset.
+*
+* The slice is `restored` across restarts (D642), so the last reading is what
+* the panel shows while the mower sleeps. Nothing here may overwrite it with an
+* empty list: a failed, empty or missing answer is "nothing learned".
+*/
+/** Retries to ride the brief wake window when the mower transitions to charging. */
+var CONSUMABLES_WAKE_RETRIES = 2;
+/** Spacing between wake-window retries. */
+var CONSUMABLES_RETRY_DELAY_MS = 1500;
+var SUBJECT$1 = "dreame mower";
+var DreameMowerConsumables = class {
+	#deps;
+	#refresher;
+	constructor(deps) {
+		this.#deps = deps;
+		this.#refresher = new DreameConsumablesRefresher({
+			deviceId: deps.deviceId,
+			logger: deps.logger,
+			subject: SUBJECT$1,
+			read: (_reason, live) => this.#read(live)
+		});
+	}
+	/** Cold start only when nothing was restored. */
+	seed() {
+		seedConsumablesColdStart(this.#deps.store);
+	}
+	refresh(reason) {
+		return this.#refresher.trigger(reason);
+	}
+	stop() {
+		this.#refresher.stop();
+	}
+	/** Reset one counter, then re-read it; a failed re-read is logged by the refresher. */
+	async reset(key) {
+		const { deviceId, resolveMower } = this.#deps;
+		if (!isMowerConsumableKey(key)) throw new Error(`${SUBJECT$1}: this device does not report "${key}" (device=${deviceId})`);
+		const mower = resolveMower();
+		if (mower === null) throw new Error(`${SUBJECT$1}: handle unavailable (device=${deviceId})`);
+		await mower.resetConsumable(key);
+		await this.#refresher.trigger("reset");
+	}
+	async #read(live) {
+		const { resolveMower, store, now } = this.#deps;
+		const retries = this.#deps.retries ?? CONSUMABLES_WAKE_RETRIES;
+		const delayMs = this.#deps.retryDelayMs ?? CONSUMABLES_RETRY_DELAY_MS;
+		let lastError = null;
+		for (let attempt = 0; attempt <= retries; attempt++) {
+			if (attempt > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+			if (!live()) return;
+			const mower = resolveMower();
+			if (mower === null) throw new Error("mower handle unavailable");
+			try {
+				const readings = await mower.getConsumables();
+				if (!live()) return;
+				const items = readings === null ? [] : buildMowerConsumables(readings);
+				if (items.length === 0) {
+					lastError = /* @__PURE__ */ new Error("the CMS action returned no reading");
+					continue;
+				}
+				writeConsumables(store, items, (now ?? Date.now)(), true);
+				return;
+			} catch (err) {
+				lastError = err;
+			}
+		}
+		throw lastError instanceof Error ? lastError : new Error(String(lastError));
+	}
+};
+/**
+* The edge INTO the awake-and-charging window — `status == Charging` OR
+* `chargingStatus == Charging`, either marks it (mirrors the donor
+* integration). The first observation after boot is not an edge: activation
+* already reads, and a mower found charging would otherwise be read twice.
+*/
+var MowerChargingEdge = class {
+	#observed = false;
+	#prevStatus = null;
+	#prevCharging = null;
+	observe(status, charging) {
+		const edge = this.#observed && (status === MowerStatus.Charging && this.#prevStatus !== MowerStatus.Charging || charging === MowerChargingStatus.Charging && this.#prevCharging !== MowerChargingStatus.Charging);
+		this.#observed = true;
+		this.#prevStatus = status;
+		this.#prevCharging = charging;
+		return edge;
+	}
+};
+//#endregion
 //#region src/devices/dreame-mower-device.ts
 var CAP_NAME$9 = "lawn-mower-control";
-var CONSUMABLES_CAP_NAME$1 = "consumables";
 /**
 * The CMS consumable custom-action only answers while the mower is momentarily
 * awake and ACTIVELY charging — which it is the instant it docks with a depleted
 * battery. We ride that push (mirrors the donor `dreame-mower`
-* `_handle_device_update`: STATUS==CHARGING → refresh consumables), fetch once,
-* and persist the result. A fully-charged / "charging complete" / sleeping mower
-* at base does NOT answer synchronous cloud commands (verified: every cloud
-* action 80001s "device offline", even with patient backoff), so a periodic poll
-* never works — it is intentionally NOT used here. We trigger on the transition
-* into EITHER `status == Charging` OR `chargingStatus == Charging`, since both
-* mark the awake-and-charging window, to maximise the capture chance.
+* `_handle_device_update`: STATUS==CHARGING → refresh consumables). A
+* fully-charged / "charging complete" / sleeping mower at base does NOT answer
+* synchronous cloud commands (verified: every cloud action 80001s "device
+* offline", even with patient backoff), so a periodic poll never works — it is
+* intentionally NOT used here. We trigger on the transition into EITHER
+* `status == Charging` OR `chargingStatus == Charging`, since both mark the
+* awake-and-charging window, to maximise the capture chance.
 */
-/** Retries to ride the brief wake window when the mower transitions to charging. */
-var CONSUMABLES_WAKE_RETRIES = 2;
-/** Spacing between wake-window retries. */
-var CONSUMABLES_RETRY_DELAY_MS = 1500;
 /**
 * Cloud-shadow (no-wake) refresh cadence for the mower's battery / charging /
 * status props. The shadow read (`refreshFromCache` → `getCachedProperties`)
@@ -151020,11 +152326,6 @@ var COLD_START = {
 	severity: "info",
 	lastChangedAt: 0
 };
-var CONSUMABLES_COLD_START$1 = {
-	items: [],
-	lastChangedAt: 0,
-	lastFetchedAt: 0
-};
 /**
 * Dreame robotic lawn-mower device. Registers the `lawn-mower-control` and
 * `consumables` caps and maps the library `MowerDevice` getters → the cap slice
@@ -151038,20 +152339,26 @@ var CONSUMABLES_COLD_START$1 = {
 * Consumables (blade / brush / maintenance) are NOT cached MIoT props — they are
 * read via a LIVE CMS custom-action (`getConsumables()`) that only answers while
 * the mower is awake. We fetch best-effort on activate, on the charging push
-* transition (the wake window — see {@link recomputeSlice}), and after a
-* reset; the last good reading is PERSISTED in runtime state and shown while the
-* mower sleeps. Never fetched inside the synchronous `recomputeSlice`.
+* transition (the wake window — see {@link recomputeSlice}), and after a reset.
+* The `consumables` slice is `restored` across restarts, so the last good
+* reading is shown while the mower sleeps; a failed or empty read never
+* overwrites it (see `DreameMowerConsumables`).
 *
 * TODO: map data (`getMap()`/`mapSvg()`) is deferred — there is no camstack map
 * cap, and the mower `getMap()` even requires an injected batch fetcher.
 */
 var DreameMowerDevice = class extends DreameChildDevice {
-	/** Last seen `status` value — used to detect the transition into CHARGING. */
-	#prevStatus = null;
-	/** Last seen `chargingStatus` value — second awake-and-charging trigger. */
-	#prevCharging = null;
+	/** The edge into the charging wake window (the first push after boot is not one). */
+	#chargingEdge = new MowerChargingEdge();
 	/** Periodic cloud-shadow refresh timer (battery / charging / status). */
 	#shadowTimer = null;
+	/** CMS consumables: read on activate / charging edge / reset, never overlapping. */
+	#consumables = new DreameMowerConsumables({
+		deviceId: this.id,
+		logger: this.ctx.logger,
+		store: this.runtimeState,
+		resolveMower: () => this.resolveMower()
+	});
 	constructor(ctx) {
 		super(ctx);
 	}
@@ -151075,18 +152382,16 @@ var DreameMowerDevice = class extends DreameChildDevice {
 		});
 		this.runtimeState.setCapState(CAP_NAME$9, COLD_START);
 		this.ctx.registerNativeCap(consumablesCapability, {
-			getStatus: async () => this.runtimeState.getCapState(CONSUMABLES_CAP_NAME$1) ?? CONSUMABLES_COLD_START$1,
+			getStatus: async () => this.runtimeState.getCapState("consumables") ?? CONSUMABLES_COLD_START,
 			reset: async ({ key }) => {
-				if (!isMowerConsumableKey(key)) throw new Error(`dreame mower: unknown consumable "${key}" (device=${this.dreameDeviceId})`);
-				await this.requireMower().resetConsumable(key);
-				await this.refreshConsumables();
+				await this.#consumables.reset(key);
 			}
 		});
-		if (this.runtimeState.getCapState(CONSUMABLES_CAP_NAME$1) === void 0) this.runtimeState.setCapState(CONSUMABLES_CAP_NAME$1, CONSUMABLES_COLD_START$1);
+		this.#consumables.seed();
 	}
 	async onActivate() {
 		await super.onActivate();
-		this.refreshConsumables(CONSUMABLES_WAKE_RETRIES);
+		this.#consumables.refresh("activate");
 		this.#refreshShadow();
 		this.#shadowTimer = setInterval(() => {
 			this.#refreshShadow();
@@ -151097,6 +152402,7 @@ var DreameMowerDevice = class extends DreameChildDevice {
 			clearInterval(this.#shadowTimer);
 			this.#shadowTimer = null;
 		}
+		this.#consumables.stop();
 		await super.removeDevice();
 	}
 	/**
@@ -151111,10 +152417,13 @@ var DreameMowerDevice = class extends DreameChildDevice {
 		try {
 			await mower.refreshFromCache();
 		} catch (err) {
-			this.ctx.logger.debug("dreame mower: cloud-shadow refresh failed", { meta: {
-				dreameDeviceId: this.dreameDeviceId,
-				error: errMsg(err)
-			} });
+			this.ctx.logger.debug("dreame mower: cloud-shadow refresh failed", {
+				tags: { deviceId: this.id },
+				meta: {
+					dreameDeviceId: this.dreameDeviceId,
+					error: errMsg(err)
+				}
+			});
 		}
 	}
 	recomputeSlice() {
@@ -151134,42 +152443,7 @@ var DreameMowerDevice = class extends DreameChildDevice {
 			lastChangedAt: Date.now()
 		};
 		this.runtimeState.setCapState(CAP_NAME$9, slice);
-		const charging = mower.charging;
-		if (status === MowerStatus.Charging && this.#prevStatus !== MowerStatus.Charging || charging === MowerChargingStatus.Charging && this.#prevCharging !== MowerChargingStatus.Charging) this.refreshConsumables(CONSUMABLES_WAKE_RETRIES);
-		this.#prevStatus = status;
-		this.#prevCharging = charging;
-	}
-	/**
-	* Live-read the CMS consumable counters and write the `consumables` slice.
-	* Best-effort: a sleeping/unreachable mower (or a malformed response) leaves
-	* the previous (persisted) slice untouched and logs at debug. Retries a few
-	* times with a short delay to ride the brief charging-transition wake window.
-	*/
-	async refreshConsumables(retries = 0) {
-		for (let attempt = 0; attempt <= retries; attempt++) {
-			const mower = this.resolveMower();
-			if (mower === null) return;
-			try {
-				const readings = await mower.getConsumables();
-				if (readings === null) return;
-				const slice = {
-					items: [...buildMowerConsumables(readings)],
-					lastChangedAt: Date.now(),
-					lastFetchedAt: Date.now()
-				};
-				this.runtimeState.setCapState(CONSUMABLES_CAP_NAME$1, slice);
-				return;
-			} catch (err) {
-				if (attempt === retries) {
-					this.ctx.logger.debug("dreame mower: consumables fetch failed (asleep?)", { meta: {
-						dreameDeviceId: this.dreameDeviceId,
-						error: errMsg(err)
-					} });
-					return;
-				}
-				await new Promise((resolve) => setTimeout(resolve, CONSUMABLES_RETRY_DELAY_MS));
-			}
-		}
+		if (this.#chargingEdge.observe(status, mower.charging)) this.#consumables.refresh("charging");
 	}
 	/** The live typed mower handle, or throw a clear error when disconnected. */
 	requireMower() {
@@ -151295,10 +152569,13 @@ var DreameMowerMapDevice = class extends DreameChildDevice {
 			const map = await mower.getMap();
 			this.#publishRender(map);
 		} catch (err) {
-			this.ctx.logger.debug("dreame mower map: fetch/render failed", { meta: {
-				dreameDeviceId: this.dreameDeviceId,
-				error: errMsg(err)
-			} });
+			this.ctx.logger.debug("dreame mower map: fetch/render failed", {
+				tags: { deviceId: this.id },
+				meta: {
+					dreameDeviceId: this.dreameDeviceId,
+					error: errMsg(err)
+				}
+			});
 		} finally {
 			this.#inflight = false;
 		}
@@ -151365,10 +152642,13 @@ var DreameMowerMapSelectDevice = class extends DreameChildDevice {
 		try {
 			await mower.getMap();
 		} catch (err) {
-			this.ctx.logger.debug("dreame mower map-select: map fetch failed", { meta: {
-				dreameDeviceId: this.dreameDeviceId,
-				error: errMsg(err)
-			} });
+			this.ctx.logger.debug("dreame mower map-select: map fetch failed", {
+				tags: { deviceId: this.id },
+				meta: {
+					dreameDeviceId: this.dreameDeviceId,
+					error: errMsg(err)
+				}
+			});
 		} finally {
 			this.#inflight = false;
 			this.#publishSlice();
@@ -151770,9 +153050,112 @@ var DreameSwitchDevice = class extends DreameChildDevice {
 	}
 };
 //#endregion
+//#region src/devices/dreame-vacuum-consumables.ts
+/** 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. */
+var RESET_FOLLOW_UP_MS = 9e4;
+var SUBJECT = "dreame vacuum";
+/** The states a run ends from. `drying` is already on the dock. */
+var DOCK_EDGE_FROM = new Set([
+	"cleaning",
+	"returning",
+	"paused"
+]);
+var DreameVacuumConsumables = class {
+	#deps;
+	#refresher;
+	/** Last pushed lifecycle state; `null` until the first push after boot. */
+	#prevState = null;
+	constructor(deps) {
+		this.#deps = deps;
+		this.#refresher = new DreameConsumablesRefresher({
+			deviceId: deps.deviceId,
+			logger: deps.logger,
+			subject: SUBJECT,
+			read: (reason, live) => this.#read(reason, live),
+			intervalMs: CONSUMABLES_REFRESH_MS,
+			followUpMs: RESET_FOLLOW_UP_MS
+		});
+	}
+	start() {
+		this.#refresher.start();
+		this.#refresher.trigger("activate");
+	}
+	stop() {
+		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.
+	*/
+	onPush(state) {
+		this.#apply(false);
+		const enteredDock = this.#prevState !== null && DOCK_EDGE_FROM.has(this.#prevState) && state === "docked";
+		this.#prevState = state;
+		if (enteredDock) this.#refresher.trigger("docked");
+	}
+	async reset(key) {
+		const { deviceId, logger, resolveVacuum } = this.#deps;
+		const vacuum = resolveVacuum();
+		if (vacuum === null) throw new Error(`${SUBJECT}: handle unavailable (device=${deviceId})`);
+		const known = resolveResettableKey(key, vacuum.supportedConsumables);
+		const result = await vacuum.resetConsumable(known);
+		this.#apply(result.refreshedFrom !== null);
+		logger.info(`${SUBJECT}: consumable reset`, {
+			tags: { deviceId },
+			meta: resetMeta(result)
+		});
+		if (result.refreshedFrom === "device") return;
+		if (result.refreshedFrom === null) logger.warn(`${SUBJECT}: consumable reset, but its values could not be re-read`, {
+			tags: { deviceId },
+			meta: resetMeta(result)
+		});
+		this.#refresher.scheduleFollowUp("reset-follow-up");
+	}
+	async #read(reason, live) {
+		const { deviceId, logger, resolveVacuum } = this.#deps;
+		const vacuum = resolveVacuum();
+		if (vacuum === null) throw new Error("vacuum handle unavailable");
+		await vacuum.refreshConsumables();
+		if (!live()) return;
+		if (vacuum.supportedConsumables.length === 0) throw new Error("the shadow reported no consumable");
+		this.#apply(true);
+		try {
+			await vacuum.refreshCachedProperties(Object.values(VACUUM_TANK_PROPS).map((p) => ({ ...p })));
+		} catch (err) {
+			if (!live()) return;
+			logger.warn(`${SUBJECT}: tank-status refresh failed — keeping the last values`, {
+				tags: { deviceId },
+				meta: {
+					reason,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+	#apply(landed) {
+		if (!this.#refresher.live()) return;
+		const { store, resolveVacuum, now } = this.#deps;
+		const vacuum = resolveVacuum();
+		if (vacuum === null) return;
+		writeConsumables(store, buildVacuumConsumableItems(vacuum.supportedConsumables), (now ?? Date.now)(), landed);
+	}
+};
+function resetMeta(result) {
+	return {
+		key: result.key,
+		refreshedFrom: result.refreshedFrom,
+		leftPct: result.leftPct,
+		timeLeft: result.timeLeft,
+		...result.refreshError !== null ? { refreshError: result.refreshError.message } : {}
+	};
+}
+//#endregion
 //#region src/devices/dreame-vacuum-device.ts
 var CAP_NAME$1 = "vacuum-control";
-var CONSUMABLES_CAP_NAME = "consumables";
 var CONTROL_COLD_START = {
 	state: "idle",
 	batteryLevel: null,
@@ -151787,11 +153170,6 @@ var CONTROL_COLD_START = {
 	errorLabel: null,
 	lastChangedAt: 0
 };
-var CONSUMABLES_COLD_START = {
-	items: [],
-	lastChangedAt: 0,
-	lastFetchedAt: 0
-};
 /**
 * Dreame robot-vacuum device. Registers the `vacuum-control` and `consumables`
 * caps and maps the library `VacuumDevice` getters → the cap slices on every
@@ -151803,17 +153181,16 @@ var CONSUMABLES_COLD_START = {
 * suction levels).
 *
 * Tank state (cleanWater/dirtyWater/detergent/dustBin): the library exposes NO
-* tank fill-level telemetry — the live cloud shadow (verified against a real
-* `dreame.vacuum.r2538z`) carries only the water-VOLUME *setting* (a mop-flow
-* level, not a tank fill) plus brush/filter consumable life. We therefore map
-* tank PRESENCE only (from the model capability flags via `decodeVacuumTanks`):
-* a present tank reports `{ level: null, status: null }` (exists, level unknown)
-* and an absent tank reports `null`.
-*
-* Consumables: main-brush / filter (always present), side-brush (conditional on
-* `vacuumCapabilities.hasSideBrush`). The library exposes no MIoT reset action
-* for consumables, so all items report `resettable: false` and `reset()` is a
-* no-op that throws.
+* 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`.
+*
+* Consumables: whatever the model REPORTS (the library's presence-driven
+* `supportedConsumables`), re-read from the cloud shadow on activate, hourly and
+* on the edge into docked. `reset()` accepts only a key this robot reports and
+* can reset, drives its MIoT reset action, and rebuilds the slice from the
+* library's post-reset re-read (see `DreameVacuumConsumables`).
 *
 * Map data is NOT on this device: the cleaning map is surfaced as a separate
 * `image` child (`DreameVacuumMapDevice`) grouped under the same Container, per
@@ -151831,25 +153208,33 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 		const vacuum = this.resolveVacuum();
 		if (vacuum !== null) {
 			vacuum.refreshFromCache().catch((err) => {
-				this.ctx.logger.debug("dreame vacuum: state seed failed", { meta: {
-					dreameDeviceId: this.dreameDeviceId,
-					error: errMsg(err)
-				} });
+				this.ctx.logger.debug("dreame vacuum: state seed failed", {
+					tags: { deviceId: this.id },
+					meta: {
+						dreameDeviceId: this.dreameDeviceId,
+						error: errMsg(err)
+					}
+				});
 			});
 			vacuum.refreshAiDetection().catch((err) => {
-				this.ctx.logger.debug("dreame vacuum: AI_DETECTION seed failed", { meta: {
-					dreameDeviceId: this.dreameDeviceId,
-					error: errMsg(err)
-				} });
-			});
-			vacuum.refreshConsumables().catch((err) => {
-				this.ctx.logger.debug("dreame vacuum: consumables seed failed", { meta: {
-					dreameDeviceId: this.dreameDeviceId,
-					error: errMsg(err)
-				} });
+				this.ctx.logger.debug("dreame vacuum: AI_DETECTION seed failed", {
+					tags: { deviceId: this.id },
+					meta: {
+						dreameDeviceId: this.dreameDeviceId,
+						error: errMsg(err)
+					}
+				});
 			});
 		}
+		this.consumables.start();
 	}
+	/** Consumables refresh + reset — see `DreameVacuumConsumables`. */
+	consumables = new DreameVacuumConsumables({
+		deviceId: this.id,
+		logger: this.ctx.logger,
+		store: this.runtimeState,
+		resolveVacuum: () => this.resolveVacuum()
+	});
 	/** Narrow the generic handle to the library's typed {@link DreameVacuum}, or null. */
 	/** The robot's own link — one reader shared with the camera child. */
 	networkLink = new DreameNetworkLinkMonitor({
@@ -151868,6 +153253,7 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 	}
 	async removeDevice() {
 		this.networkLink.stop();
+		this.consumables.stop();
 		await super.removeDevice();
 	}
 	resolveVacuum() {
@@ -151906,30 +153292,23 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 	/**
 	* Register the `consumables` cap. The provider surfaces remaining life % for
 	* every consumable the model REPORTS (presence-driven via the library's
-	* `supportedConsumables`) and `reset()` drives the consumable's real MIoT reset
-	* action, marking it replaced (life → 100%). Items whose model has no reset
-	* action report `resettable: false` (the UI suppresses the button).
+	* `supportedConsumables`); `reset()` drives the consumable's real MIoT reset
+	* action. Items whose model has no reset action report `resettable: false`
+	* (the UI suppresses the button, and `reset()` refuses them).
 	*/
 	registerConsumablesCap() {
 		this.ctx.registerNativeCap(consumablesCapability, {
-			getStatus: async () => this.runtimeState.getCapState(CONSUMABLES_CAP_NAME) ?? CONSUMABLES_COLD_START,
+			getStatus: async () => this.runtimeState.getCapState("consumables") ?? CONSUMABLES_COLD_START,
 			reset: async ({ key }) => {
-				if (!isDreameConsumableKey(key)) throw new Error(`dreame vacuum: unknown consumable "${key}" (device=${this.dreameDeviceId})`);
-				await this.requireVacuum().resetConsumable(key);
-				this.recomputeSlice();
+				await this.consumables.reset(key);
 			}
 		});
-		this.runtimeState.setCapState(CONSUMABLES_CAP_NAME, CONSUMABLES_COLD_START);
+		seedConsumablesColdStart(this.runtimeState);
 	}
-	/**
-	* `registerControlCap()` (called by `super.onActivate()`) already registers
-	* the consumables cap before the parent seeds the first slice via
-	* `recomputeSlice()`. No additional work needed here; the override is removed.
-	*/
 	recomputeSlice() {
 		const vacuum = this.resolveVacuum();
 		if (vacuum === null) return;
-		const tanks = decodeVacuumTanks(vacuum.vacuumCapabilities, this.readTankProps());
+		const tanks = decodeVacuumTanks(vacuum.vacuumCapabilities, this.readTankProps(), vacuum.errorCode);
 		const controlSlice = {
 			state: mapMiotStateToVacuumState(vacuum.status),
 			batteryLevel: clampBatteryLevel$1(vacuum.battery),
@@ -151944,27 +153323,29 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 			errorLabel: vacuum.errorCode ? `Error ${vacuum.errorCode}` : null,
 			lastChangedAt: Date.now()
 		};
-		this.runtimeState.setCapState(CAP_NAME$1, controlSlice);
-		const consumablesSlice = buildVacuumConsumables(vacuum);
-		if (consumablesSlice.items.length > 0) this.runtimeState.setCapState(CONSUMABLES_CAP_NAME, consumablesSlice);
+		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);
 	}
 	/**
-	* Read the four tank-status MIoT enum props from the live handle for
-	* {@link decodeVacuumTanks}. Each is `null` when the device reports no such
-	* property (or a non-numeric value), so a model without these props simply
-	* falls back to presence-only tanks.
+	* Read the tank-status MIoT enum props ({@link VACUUM_TANK_PROPS}) from the
+	* live handle for {@link decodeVacuumTanks}. Each is `null` when the device
+	* reports no such property (or a non-numeric value), so a model without these
+	* props simply falls back to presence-only tanks.
 	*/
 	readTankProps() {
 		const vacuum = this.resolveVacuum();
-		const readEnum = (siid, piid) => {
-			const value = vacuum?.getProperty(siid, piid)?.value;
+		const readEnum = (prop) => {
+			const value = vacuum?.getProperty(prop.siid, prop.piid)?.value;
 			return typeof value === "number" ? value : null;
 		};
 		return {
-			cleanWaterTankStatus: readEnum(27, 1),
-			waterTank: readEnum(4, 6),
-			detergentStatus: readEnum(27, 4),
-			dustCollection: readEnum(15, 3)
+			cleanWaterTankStatus: readEnum(VACUUM_TANK_PROPS.cleanWaterTankStatus),
+			waterTank: readEnum(VACUUM_TANK_PROPS.waterTank),
+			detergentStatus: readEnum(VACUUM_TANK_PROPS.detergentStatus),
+			dustCollection: readEnum(VACUUM_TANK_PROPS.dustCollection),
+			dirtyWaterTankStatus: readEnum(VACUUM_TANK_PROPS.dirtyWaterTankStatus),
+			dustBagStatus: readEnum(VACUUM_TANK_PROPS.dustBagStatus)
 		};
 	}
 	/** The live typed vacuum handle, or throw a clear error when disconnected. */
@@ -152013,10 +153394,13 @@ var DreameVacuumMapDevice = class extends DreameChildDevice {
 		await super.onActivate();
 		const vacuum = this.resolveVacuum();
 		if (vacuum !== null) vacuum.refreshSavedMapFilename().catch((err) => {
-			this.ctx.logger.debug("dreame map: saved-map seed failed", { meta: {
-				dreameDeviceId: this.dreameDeviceId,
-				error: errMsg(err)
-			} });
+			this.ctx.logger.debug("dreame map: saved-map seed failed", {
+				tags: { deviceId: this.id },
+				meta: {
+					dreameDeviceId: this.dreameDeviceId,
+					error: errMsg(err)
+				}
+			});
 		});
 	}
 	/** Narrow the generic handle to the library's typed {@link DreameVacuum}, or null. */
@@ -152045,10 +153429,13 @@ var DreameVacuumMapDevice = class extends DreameChildDevice {
 			if (map === null) return;
 			this.#publishRender(map);
 		} catch (err) {
-			this.ctx.logger.warn("dreame map: fetch/render failed", { meta: {
-				dreameDeviceId: this.dreameDeviceId,
-				error: errMsg(err)
-			} });
+			this.ctx.logger.warn("dreame map: fetch/render failed", {
+				tags: { deviceId: this.id },
+				meta: {
+					dreameDeviceId: this.dreameDeviceId,
+					error: errMsg(err)
+				}
+			});
 		} finally {
 			this.#inflight = false;
 		}
@@ -152406,10 +153793,13 @@ var DreameContainerDevice = class extends BaseDevice {
 	getAccessoryChildren() {
 		const kind = classifyDreameModel(this.model);
 		if (kind === "unsupported") {
-			this.ctx.logger.warn("DreameContainerDevice: unsupported model; no children", { meta: {
-				model: this.model,
-				dreameDeviceId: this.dreameDeviceId
-			} });
+			this.ctx.logger.warn("DreameContainerDevice: unsupported model; no children", {
+				tags: { deviceId: this.id },
+				meta: {
+					model: this.model,
+					dreameDeviceId: this.dreameDeviceId
+				}
+			});
 			return [];
 		}
 		const meta = {
@@ -152872,10 +154262,13 @@ var DreameContainerDevice = class extends BaseDevice {
 				childLayout
 			});
 		} catch (err) {
-			this.ctx.logger.warn("dreame container: failed to persist childLayout", { meta: {
-				dreameDeviceId: this.dreameDeviceId,
-				error: errMsg(err)
-			} });
+			this.ctx.logger.warn("dreame container: failed to persist childLayout", {
+				tags: { deviceId: this.id },
+				meta: {
+					dreameDeviceId: this.dreameDeviceId,
+					error: errMsg(err)
+				}
+			});
 		}
 	}
 	/** The AI-obstacle features the live model exposes — empty when the handle is