@camstack/addon-matter-broker 0.2.149 → 0.2.151

package/dist/addon.js

@@ -5589,7 +5589,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-bykKrTgu.mjs
+//#region ../types/dist/sleep--jXS9hWo.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6604,7 +6604,7 @@ var SecretOverwriteRefusedError = class extends Error {
 		this.name = "SecretOverwriteRefusedError";
 	}
 };
-function isRecord$4(value) {
+function isRecord$4$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolvedValue(pass, marker) {
@@ -6633,7 +6633,7 @@ function inArray(pass, incoming, stored) {
 	return incoming.map((item, index) => {
 		const twin = stored[index];
 		if (isSecretMarker(twin)) return typeof item === "string" && item === resolvedValue(pass, twin) ? twin : item;
-		if (isRecord$4(item) && isRecord$4(twin)) return inArrayRow(pass, item, twin);
+		if (isRecord$4$1(item) && isRecord$4$1(twin)) return inArrayRow(pass, item, twin);
 		if (Array.isArray(item) && Array.isArray(twin)) return inArray(pass, item, twin);
 		return item;
 	});
@@ -6644,7 +6644,7 @@ function inArrayRow(pass, incoming, stored) {
 		const twin = stored[key];
 		if (isSecretMarker(twin)) {
 			if (typeof value === "string" && value === resolvedValue(pass, twin)) out[key] = twin;
-		} else if (isRecord$4(value) && isRecord$4(twin)) out[key] = inArrayRow(pass, value, twin);
+		} else if (isRecord$4$1(value) && isRecord$4$1(twin)) out[key] = inArrayRow(pass, value, twin);
 		else if (Array.isArray(value) && Array.isArray(twin)) out[key] = inArray(pass, value, twin);
 	}
 	return out;
@@ -6652,7 +6652,7 @@ function inArrayRow(pass, incoming, stored) {
 async function walk(pass, incoming, stored) {
 	if (isSecretMarker(stored)) return atMarker(pass, incoming, stored);
 	if (Array.isArray(incoming) && Array.isArray(stored)) return inArray(pass, incoming, stored);
-	if (!isRecord$4(incoming) || !isRecord$4(stored)) return incoming;
+	if (!isRecord$4$1(incoming) || !isRecord$4$1(stored)) return incoming;
 	const out = { ...incoming };
 	for (const [key, value] of Object.entries(incoming)) out[key] = await walk(pass, value, stored[key]);
 	return out;
@@ -6683,7 +6683,7 @@ async function restoreUnchangedSecrets(input) {
 function isJsonEqual(a, b) {
 	if (Object.is(a, b)) return true;
 	if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((v, i) => isJsonEqual(v, b[i]));
-	if (isRecord$4(a) && isRecord$4(b)) {
+	if (isRecord$4$1(a) && isRecord$4$1(b)) {
 		const keys = Object.keys(a);
 		if (keys.length !== Object.keys(b).length) return false;
 		return keys.every((k) => Object.prototype.hasOwnProperty.call(b, k) && isJsonEqual(a[k], b[k]));
@@ -6707,7 +6707,7 @@ function markerKeysOf(blob, owner) {
 }
 function nodeFromStored(value, owner) {
 	if (isSecretMarker(value)) return isSecretRefOwnedBy(value.$secret, owner) ? { kind: "leaf" } : null;
-	if (!isRecord$4(value)) return null;
+	if (!isRecord$4$1(value)) return null;
 	const children = /* @__PURE__ */ new Map();
 	for (const [key, child] of Object.entries(value)) {
 		const node = nodeFromStored(child, owner);
@@ -8970,6 +8970,7 @@ var CAP_NAMES = Object.freeze([
 	"filesystem-browse",
 	"flood",
 	"gas",
+	"group-active",
 	"group-commands",
 	"group-status",
 	"heating-valve",
@@ -8992,6 +8993,7 @@ var CAP_NAMES = Object.freeze([
 	"login-method",
 	"media-player",
 	"mesh-network",
+	"meter",
 	"metrics-provider",
 	"model-convert",
 	"model-distributor",
@@ -9790,6 +9792,10 @@ Object.freeze({
 		"path": "detected",
 		"valueType": "boolean"
 	}],
+	"group-active": [{
+		"path": "active",
+		"valueType": "boolean"
+	}],
 	"group-status": [
 		{
 			"path": "included",
@@ -10049,6 +10055,10 @@ Object.freeze({
 			]
 		}
 	],
+	"meter": [{
+		"path": "value",
+		"valueType": "number"
+	}],
 	"motion": [
 		{
 			"path": "detected",
@@ -10792,7 +10802,7 @@ object({
 	params: record(string$2(), union([string$2(), number()])).optional()
 });
 //#endregion
-//#region ../types/dist/err-msg-BXKzRBwg.mjs
+//#region ../types/dist/err-msg-DIorGYeC.mjs
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Camera"] = "camera";
 	DeviceType["Hub"] = "hub";
@@ -10886,8 +10896,14 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["PetFeeder"] = "pet-feeder";
 	/** Built-in dishwasher — program lifecycle, door / remote-start gates,
 	*  salt and rinse-aid levels. Installed with the `dishwasher` cap.
-	*  Sources: native Bosch Home Connect, reusable by similar integrations. */
+	*  Sources: native Bosch Home Connect, reusable by similar integrations.
+	*  A plug-built dishwasher carries running-state and power instead. */
 	DeviceType["Dishwasher"] = "dishwasher";
+	/** Washing machine. A plug-built one is running while its power stays
+	*  above a threshold. No program cap — that surface is the dishwasher's. */
+	DeviceType["Washer"] = "washer";
+	/** Tumble dryer. Same plug-built running surface as {@link Washer}. */
+	DeviceType["Dryer"] = "dryer";
 	return DeviceType;
 }({});
 var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
@@ -11145,7 +11161,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-OhpuespA.mjs
+//#region ../types/dist/composition-Bb8iwHEJ.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -11258,7 +11274,7 @@ var ExpressionEvalError = class extends Error {
 		this.name = "ExpressionEvalError";
 	}
 };
-function asFiniteNumber(value, name, index) {
+function asFiniteNumber$1(value, name, index) {
 	if (typeof value !== "number" || !Number.isFinite(value)) throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a finite number`);
 	return value;
 }
@@ -11271,7 +11287,7 @@ function finiteResult(value, name) {
 	return value;
 }
 function allFiniteNumbers(args, name) {
-	return args.map((a, idx) => asFiniteNumber(a, name, idx));
+	return args.map((a, idx) => asFiniteNumber$1(a, name, idx));
 }
 function asBoolean$2(value, name, index) {
 	if (typeof value !== "boolean") throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a boolean`);
@@ -11308,29 +11324,29 @@ var table = {
 	abs: {
 		minArgs: 1,
 		maxArgs: 1,
-		apply: (args) => finiteResult(Math.abs(asFiniteNumber(args[0], "abs", 0)), "abs")
+		apply: (args) => finiteResult(Math.abs(asFiniteNumber$1(args[0], "abs", 0)), "abs")
 	},
 	floor: {
 		minArgs: 1,
 		maxArgs: 1,
-		apply: (args) => finiteResult(Math.floor(asFiniteNumber(args[0], "floor", 0)), "floor")
+		apply: (args) => finiteResult(Math.floor(asFiniteNumber$1(args[0], "floor", 0)), "floor")
 	},
 	ceil: {
 		minArgs: 1,
 		maxArgs: 1,
-		apply: (args) => finiteResult(Math.ceil(asFiniteNumber(args[0], "ceil", 0)), "ceil")
+		apply: (args) => finiteResult(Math.ceil(asFiniteNumber$1(args[0], "ceil", 0)), "ceil")
 	},
 	sqrt: {
 		minArgs: 1,
 		maxArgs: 1,
-		apply: (args) => finiteResult(Math.sqrt(asFiniteNumber(args[0], "sqrt", 0)), "sqrt")
+		apply: (args) => finiteResult(Math.sqrt(asFiniteNumber$1(args[0], "sqrt", 0)), "sqrt")
 	},
 	round: {
 		minArgs: 1,
 		maxArgs: 2,
 		apply: (args) => {
-			const x = asFiniteNumber(args[0], "round", 0);
-			const digits = args.length > 1 ? Math.trunc(asFiniteNumber(args[1], "round", 1)) : 0;
+			const x = asFiniteNumber$1(args[0], "round", 0);
+			const digits = args.length > 1 ? Math.trunc(asFiniteNumber$1(args[1], "round", 1)) : 0;
 			if (digits < 0 || digits > 100) throw new ExpressionEvalError("round: digits must be between 0 and 100");
 			const factor = 10 ** digits;
 			return finiteResult(Math.round(x * factor) / factor, "round");
@@ -11339,15 +11355,15 @@ var table = {
 	pow: {
 		minArgs: 2,
 		maxArgs: 2,
-		apply: (args) => finiteResult(asFiniteNumber(args[0], "pow", 0) ** asFiniteNumber(args[1], "pow", 1), "pow")
+		apply: (args) => finiteResult(asFiniteNumber$1(args[0], "pow", 0) ** asFiniteNumber$1(args[1], "pow", 1), "pow")
 	},
 	clamp: {
 		minArgs: 3,
 		maxArgs: 3,
 		apply: (args) => {
-			const x = asFiniteNumber(args[0], "clamp", 0);
-			const lo = asFiniteNumber(args[1], "clamp", 1);
-			const hi = asFiniteNumber(args[2], "clamp", 2);
+			const x = asFiniteNumber$1(args[0], "clamp", 0);
+			const lo = asFiniteNumber$1(args[1], "clamp", 1);
+			const hi = asFiniteNumber$1(args[2], "clamp", 2);
 			if (lo > hi) throw new ExpressionEvalError("clamp: lower bound is greater than upper bound");
 			return finiteResult(Math.min(hi, Math.max(lo, x)), "clamp");
 		}
@@ -11376,13 +11392,13 @@ var table = {
 	age: {
 		minArgs: 2,
 		maxArgs: 2,
-		apply: (args) => finiteResult(asFiniteNumber(args[0], "age", 0) - asFiniteNumber(args[1], "age", 1), "age")
+		apply: (args) => finiteResult(asFiniteNumber$1(args[0], "age", 0) - asFiniteNumber$1(args[1], "age", 1), "age")
 	},
 	convert: {
 		minArgs: 3,
 		maxArgs: 3,
 		apply: (args, hooks) => {
-			const x = asFiniteNumber(args[0], "convert", 0);
+			const x = asFiniteNumber$1(args[0], "convert", 0);
 			const from = asString(args[1], "convert", 1).trim();
 			const to = asString(args[2], "convert", 2).trim();
 			if (hooks.convert) {
@@ -11408,11 +11424,11 @@ var table = {
 		minArgs: 2,
 		maxArgs: 2,
 		apply: (args, hooks) => {
-			const windowMs = asFiniteNumber(args[1], "within", 1);
+			const windowMs = asFiniteNumber$1(args[1], "within", 1);
 			if (windowMs < 0) throw new ExpressionEvalError("within: the window must not be negative");
 			const at = args[0];
 			if (at === null) return false;
-			const ts = asFiniteNumber(at, "within", 0);
+			const ts = asFiniteNumber$1(at, "within", 0);
 			const now = hooks.now;
 			if (now === void 0 || !Number.isFinite(now)) throw new ExpressionEvalError("within: no clock was supplied to this evaluation");
 			const inside = now - ts <= windowMs;
@@ -11429,7 +11445,7 @@ var table = {
 		minArgs: 1,
 		maxArgs: INF,
 		apply: (args) => {
-			const present = args.flatMap((a, i) => a === null ? [] : [asFiniteNumber(a, "latest", i)]);
+			const present = args.flatMap((a, i) => a === null ? [] : [asFiniteNumber$1(a, "latest", i)]);
 			return present.length === 0 ? null : finiteResult(Math.max(...present), "latest");
 		}
 	},
@@ -11460,6 +11476,13 @@ var table = {
 		apply: () => {
 			throw new ExpressionEvalError("latchedAt: stateful evaluation context is required");
 		}
+	},
+	schmitt: {
+		minArgs: 3,
+		maxArgs: 5,
+		apply: () => {
+			throw new ExpressionEvalError("schmitt: stateful evaluation context is required");
+		}
 	}
 };
 Object.freeze(Object.assign(Object.create(null), table));
@@ -11901,6 +11924,99 @@ function validateExpressionSource(src) {
 	return null;
 }
 /**
+* One power reading becomes a washer, dryer or dishwasher (D944 helper).
+*
+* Standby of the control board is under 5 W; a motor or a heater is far
+* above that, so 5 W is the line. A door lock or a short pump spike is not
+* a cycle, so running starts only after 30 s above the line.
+*
+* A wash, dry or dishwasher pause (soak, heat-wait, heater off between
+* bursts) lasts several minutes. Ending the cycle on the first dip would
+* report "finished" in the middle of the program, so the stop dwell is
+* 10 minutes on every type. The number is stored per type so one machine
+* can move later without moving the others.
+*/
+var APPLIANCE_TEMPLATE_ID = "appliance";
+var APPLIANCE_KINDS = [
+	"washer",
+	"dryer",
+	"dishwasher"
+];
+DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
+/**
+* Statistics and integrals over a history read (D944).
+*
+* Pure: the same points always give the same answer, so a restart recomputes
+* rather than trusting a buffer. A gauge mean is time-weighted (value × ms),
+* never the mean of the samples. A hole with no held value is not integrated
+* as zero. A truncated read is not published.
+*/
+var STATISTIC_STATS = [
+	"min",
+	"max",
+	"mean",
+	"sum",
+	"count",
+	"change"
+];
+/**
+* The range a statistics or integral helper asks history for (D944).
+*
+* Calendar edges are the hub's timezone, never UTC midnight: a day is 23, 24
+* or 25 hours across a DST change. A tier is eligible only when its retention
+* is strictly longer than the longest that range can be. Forever qualifies.
+* Equal to a tier's retention is a refusal, not a short answer.
+*/
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var ROLLING_SPANS = [
+	"1h",
+	"24h",
+	"2d",
+	"7d",
+	"30d",
+	"custom"
+];
+var CALENDAR_PERIODS = [
+	"today",
+	"yesterday",
+	"this-week",
+	"this-month"
+];
+var RESET_PERIODS = [
+	"never",
+	"daily",
+	"weekly",
+	"monthly"
+];
+5 * MINUTE_MS;
+24 * HOUR_MS, 2 * DAY_MS, 7 * DAY_MS, 30 * DAY_MS;
+7 * DAY_MS, 30 * DAY_MS, 365 * DAY_MS;
+var rollingWindowObject = object({
+	kind: literal("rolling"),
+	span: _enum(ROLLING_SPANS),
+	customMinutes: number().int().min(5).optional()
+}).check((payload) => {
+	if (payload.value.span === "custom" && payload.value.customMinutes === void 0) payload.issues.push({
+		code: "custom",
+		message: "a custom range needs a duration in minutes",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+	if (payload.value.span !== "custom" && payload.value.customMinutes !== void 0) payload.issues.push({
+		code: "custom",
+		message: "only a custom range carries a duration",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+});
+var RollingWindowSchema = rollingWindowObject;
+var StatisticWindowSchema = discriminatedUnion("kind", [rollingWindowObject, object({
+	kind: literal("calendar"),
+	period: _enum(CALENDAR_PERIODS)
+})]);
+/**
 * A composition source identity: `(addonId, stableId)`, never a numeric device
 * id. Split out so helper schemas can name it without a cycle through
 * `composition.ts` (D659).
@@ -11926,7 +12042,13 @@ var GROUP_TEMPLATE_IDS = [
 	"occupancy",
 	"binary",
 	"switch",
-	"light"
+	"light",
+	"fan",
+	"cover",
+	"valve",
+	"lock",
+	"media-player",
+	"climate"
 ];
 var NUMERIC_AGGREGATES = [
 	"mean",
@@ -11956,14 +12078,73 @@ var HelperMemberSchema = object({
 	cap: string$2().min(1),
 	fieldPath: string$2().min(1)
 });
-var HelperSpecSchema = discriminatedUnion("kind", [object({
-	kind: literal("group"),
-	templateId: GroupTemplateIdSchema,
-	aggregate: AggregateReducerSchema,
-	members: array(HelperMemberSchema).min(1).max(64),
-	/** Actuator groups only. Readings leave this unset. */
-	active: ActiveCriterionSchema.optional()
-})]);
+var HelperSpecSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("group"),
+		templateId: GroupTemplateIdSchema,
+		aggregate: AggregateReducerSchema,
+		members: array(HelperMemberSchema).min(1).max(64),
+		/** Actuator groups only. Readings leave this unset. */
+		active: ActiveCriterionSchema.optional()
+	}),
+	object({
+		kind: literal("appliance"),
+		templateId: literal(APPLIANCE_TEMPLATE_ID),
+		appliance: _enum(APPLIANCE_KINDS),
+		thresholdWatts: number().positive(),
+		startDwellMs: number().int().nonnegative(),
+		stopDwellMs: number().int().nonnegative(),
+		member: HelperMemberSchema
+	}),
+	object({
+		kind: literal("statistic"),
+		stat: _enum(STATISTIC_STATS),
+		window: StatisticWindowSchema,
+		source: HelperMemberSchema
+	}),
+	object({
+		kind: literal("integral"),
+		reset: _enum(RESET_PERIODS),
+		output: _enum(["energy", "meter"]),
+		source: HelperMemberSchema
+	}),
+	object({
+		kind: literal("threshold"),
+		source: HelperMemberSchema,
+		high: number(),
+		low: number(),
+		onForMs: number().int().nonnegative(),
+		offForMs: number().int().nonnegative()
+	}),
+	object({
+		kind: literal("arithmetic"),
+		op: _enum([
+			"sum",
+			"difference",
+			"ratio"
+		]),
+		inputs: array(HelperMemberSchema).min(2).max(64)
+	}),
+	object({
+		kind: literal("expression"),
+		expr: string$2().min(1),
+		inputs: array(object({
+			name: string$2().min(1),
+			member: HelperMemberSchema
+		})).min(1).max(64),
+		output: _enum(["number", "boolean"])
+	}),
+	object({
+		kind: literal("derivative"),
+		window: RollingWindowSchema,
+		per: _enum([
+			"second",
+			"minute",
+			"hour"
+		]),
+		source: HelperMemberSchema
+	})
+]);
 /** A composed device's stableId is this prefix plus the block id. */
 var COMPOSED_DEVICE_STABLE_ID_PREFIX = "composed-";
 /** Longest snippet a `code` source may carry (slice 4). */
@@ -12024,6 +12205,12 @@ var CompositionFieldSourceSchema = discriminatedUnion("kind", [
 			"all"
 		]),
 		reads: array(CompositionFieldReadSchema).min(1).max(64),
+		/**
+		* Set when the reads are an enum state, not a yes/no: the listed states
+		* count as active (a cover is `open`). A state outside the list is inactive;
+		* a read that is not a state at all is left out. Only `any` / `all` use it.
+		*/
+		activeWhen: array(string$2().min(1)).min(1).optional(),
 		/** `value` is the reading; the others are the member counts. */
 		publish: _enum([
 			"value",
@@ -12037,6 +12224,26 @@ var CompositionFieldSourceSchema = discriminatedUnion("kind", [
 			"omit",
 			"offline"
 		])
+	}),
+	object({
+		kind: literal("series"),
+		read: CompositionFieldReadSchema,
+		/** `value` is the statistic or the integral. The others are the gap counts. */
+		publish: _enum([
+			"value",
+			"included",
+			"excluded",
+			"total"
+		]),
+		/**
+		* What an unanswered `value` does. Counts ignore this. `offline` leaves the
+		* device unseeded until history answers, so a restart cannot publish 0.
+		*/
+		empty: _enum([
+			"null",
+			"omit",
+			"offline"
+		])
 	})
 ]);
 var CompositionCommandTargetSchema = discriminatedUnion("kind", [object({
@@ -17196,7 +17403,22 @@ var BrokerProviderInfoSchema = object({
 		*/
 		interactiveConnectPath: string$2().min(1).optional(),
 		/** Relative hub path to disconnect the linked account (same popup pattern). */
-		interactiveDisconnectPath: string$2().min(1).optional()
+		interactiveDisconnectPath: string$2().min(1).optional(),
+		/**
+		* The kind signs in through a server-held interactive session instead of
+		* (or before) typed credentials. `basePath` is a hub-relative route set
+		* served by the owning addon (`/addon/<id>/...`) speaking the sign-in
+		* contract: `POST {basePath}/start` (body: the form's settings) answers
+		* `{ sessionId, loginUrl }`; `GET {basePath}/status?sessionId=` answers
+		* `{ phase: 'starting' | 'awaiting-login' | 'captured' | 'error' |
+		* 'cancelled', loginUrl, error }`; `POST {basePath}/commit`
+		* (`{ sessionId, name, brokerId? }`) stores the credentials on a new or
+		* existing broker and answers `{ brokerId }`; `POST {basePath}/cancel`
+		* (`{ sessionId }`) drops the session. The dialog that edits a broker
+		* offers it as the default path; the fields the session fills are
+		* marked `filledBySignIn` in the kind's settings schema.
+		*/
+		signIn: object({ basePath: string$2().min(1) }).optional()
 	}))
 });
 var ListInputSchema = object({ 
@@ -18350,7 +18572,8 @@ var CompositionProblemSchema = object({
 		"native-capability-replace",
 		"mixed-quantity",
 		"helper-mismatch",
-		"member-constraint"
+		"member-constraint",
+		"retention"
 	]),
 	path: string$2(),
 	message: string$2()
@@ -18584,13 +18807,17 @@ Object.freeze({
 	latchedAt: {
 		kind: "fixed",
 		result: ["number", "null"]
+	},
+	schmitt: {
+		kind: "fixed",
+		result: ["boolean", "null"]
 	}
 });
 /**
 * One catalog row per base reading a group helper can build (D944 §3).
 * Data, not a form default written into the block.
 */
-var NOW = {
+var NOW$2 = {
 	fieldPath: "lastFetchedAt",
 	expr: "now"
 };
@@ -18604,6 +18831,8 @@ function numeric(input) {
 		family: "numeric",
 		deviceType: DeviceType.Sensor,
 		memberDeviceType: DeviceType.Sensor,
+		memberDeviceTypes: [DeviceType.Sensor],
+		activeWhen: void 0,
 		commandCaps: [],
 		baseUnit: baseUnitOf(input.quantity),
 		aggregates: NUMERIC_AGGREGATES,
@@ -18619,6 +18848,8 @@ function binary(input) {
 		family: "binary",
 		deviceType: DeviceType.Sensor,
 		memberDeviceType: DeviceType.Sensor,
+		memberDeviceTypes: [DeviceType.Sensor],
+		activeWhen: void 0,
 		commandCaps: [],
 		quantity: "none",
 		baseUnit: void 0,
@@ -18636,7 +18867,7 @@ var GROUP_TEMPLATES = [
 		quantity: "temperature",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "humidity",
@@ -18647,7 +18878,7 @@ var GROUP_TEMPLATES = [
 		quantity: "humidity",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "pressure",
@@ -18658,7 +18889,7 @@ var GROUP_TEMPLATES = [
 		quantity: "pressure",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "illuminance",
@@ -18669,7 +18900,7 @@ var GROUP_TEMPLATES = [
 		quantity: "illuminance",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "power",
@@ -18680,7 +18911,7 @@ var GROUP_TEMPLATES = [
 		quantity: "power",
 		defaultAggregate: "sum",
 		empty: "omit",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "energy",
@@ -18691,7 +18922,7 @@ var GROUP_TEMPLATES = [
 		quantity: "energy",
 		defaultAggregate: "sum",
 		empty: "omit",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "battery",
@@ -18726,7 +18957,7 @@ var GROUP_TEMPLATES = [
 		quantity: "device",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	binary({
 		id: "motion",
@@ -18820,6 +19051,11 @@ var GROUP_TEMPLATES = [
 		summary: "On when at least one switch is on, or when all of them are. Offline and unknown members are left out of that decision, never read as off, and still receive the command.",
 		deviceType: DeviceType.Switch,
 		outputCap: "switch",
+		outputField: "on",
+		member: {
+			cap: "switch",
+			fieldPath: "on"
+		},
 		commandCaps: ["switch"]
 	}),
 	actuator({
@@ -18827,34 +19063,136 @@ var GROUP_TEMPLATES = [
 		summary: "On when at least one light is on, or when all of them are. Brightness and colour are offered only when every member has them. A command is not sent to a member that lacks it.",
 		deviceType: DeviceType.Light,
 		outputCap: "switch",
+		outputField: "on",
+		member: {
+			cap: "switch",
+			fieldPath: "on"
+		},
 		commandCaps: [
 			"switch",
 			"brightness",
 			"color"
 		]
+	}),
+	actuator({
+		id: "fan",
+		summary: "On when at least one fan is on, or when all of them are. Speed, preset, direction and oscillation are offered only when every fan has them. A command is not sent to a fan that lacks it.",
+		deviceType: DeviceType.Fan,
+		outputCap: "switch",
+		outputField: "on",
+		member: {
+			cap: "switch",
+			fieldPath: "on"
+		},
+		commandCaps: ["switch", "fan-control"]
+	}),
+	actuator({
+		id: "cover",
+		summary: "Open when at least one cover is open or part-open, or only when all of them are. Position and tilt are offered only when every cover has them. A cover that reports nothing is left out, never read as closed.",
+		deviceType: DeviceType.Cover,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "cover",
+			fieldPath: "state"
+		},
+		activeWhen: [
+			"open",
+			"opening",
+			"stopped"
+		],
+		commandCaps: ["cover"]
+	}),
+	actuator({
+		id: "valve",
+		summary: "Open when at least one valve is open or part-open, or only when all of them are. Position is offered only when every valve has it. A valve that reports nothing is left out, never read as closed.",
+		deviceType: DeviceType.Valve,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "valve",
+			fieldPath: "state"
+		},
+		activeWhen: [
+			"open",
+			"opening",
+			"stopped"
+		],
+		commandCaps: ["valve"]
+	}),
+	actuator({
+		id: "lock",
+		summary: "Locked when at least one lock is locked, or only when all of them are. A jammed or moving lock is not locked. Locking is one tap; unlocking the group needs a confirmation every time, and nothing is sent without it.",
+		deviceType: DeviceType.Lock,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "lock-control",
+			fieldPath: "state"
+		},
+		activeWhen: ["locked"],
+		commandCaps: ["lock-control"]
+	}),
+	actuator({
+		id: "media-player",
+		summary: "Playing when at least one player is playing, or only when all of them are. Volume is offered only when every player has it. A player that reports nothing is left out, never read as stopped.",
+		deviceType: DeviceType.MediaPlayer,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "media-player",
+			fieldPath: "state"
+		},
+		activeWhen: ["playing", "buffering"],
+		commandCaps: ["media-player"]
+	}),
+	actuator({
+		id: "climate",
+		summary: "Running when at least one thermostat or air conditioner is not off, or only when all of them are. Target temperature and fan are offered only when every device has them. A device that reports nothing is left out, never read as off.",
+		deviceType: DeviceType.Thermostat,
+		memberDeviceTypes: [DeviceType.Thermostat, DeviceType.Climate],
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "climate-control",
+			fieldPath: "mode"
+		},
+		activeWhen: [
+			"heat",
+			"cool",
+			"auto",
+			"heat_cool",
+			"fan_only",
+			"dry"
+		],
+		commandCaps: ["climate-control"]
 	})
 ];
 function actuator(input) {
 	return {
-		...input,
+		id: input.id,
+		summary: input.summary,
+		deviceType: input.deviceType,
+		outputCap: input.outputCap,
+		outputField: input.outputField,
+		commandCaps: input.commandCaps,
 		family: "actuator",
 		role: void 0,
 		memberDeviceType: input.deviceType,
-		outputField: "on",
+		memberDeviceTypes: input.memberDeviceTypes ?? [input.deviceType],
+		activeWhen: input.activeWhen,
 		quantity: "none",
 		baseUnit: void 0,
 		aggregates: BINARY_AGGREGATES,
 		defaultAggregate: "any",
 		empty: "offline",
-		accept: [{
-			cap: "switch",
-			fieldPath: "on"
-		}],
+		accept: [input.member],
 		companions: [CHANGED]
 	};
 }
 new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
 DeviceFeature.LightColorRgb, DeviceFeature.LightColorHsv, DeviceFeature.LightColorMired;
+DeviceType.Camera;
 `${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
 /**
 * What a composition may BUILD on a device type (G2, D676): the caps a new
@@ -44078,7 +44416,7 @@ var NetworkAccessStatusSchema = object({
 });
 /**
 * Optional, richer endpoint shape returned by providers that expose
-* MORE than one ingress concurrently (Tailscale Ingress with mixed
+* MORE than one ingress concurrently (Tailscale Funnel with mixed
 * serve+funnel rules, future ngrok multi-tunnel, …). Each entry carries
 * the originating provider config (mode + sourcePort) so the
 * orchestrator UI can label rows distinctly. Providers that expose only
@@ -46765,7 +47103,20 @@ var NcRuleInputSchema = object({
 	* save by the hub's grouping guard). `.optional()`, never `.default()`: the addon cap
 	* path does not run Zod defaults.
 	*/
-	groupingSec: number().int().min(5).max(60).optional()
+	groupingSec: number().int().min(5).max(60).optional(),
+	/**
+	* ASK ME TO CONFIRM DETECTIONS (#243): a DETECTION notification of this rule
+	* carries "Correct" / "Wrong" buttons (and, where the channel has room, a
+	* "Wrong, it is a <class>" choice). A tap marks the track for retraining, the
+	* same mark the Library writes, and records whose notification it was and
+	* when. A channel with no buttons gets the same two choices as links.
+	*
+	* `.optional()`, never `.default()` (a Zod default does not run on the addon
+	* cap path): absent and `false` both mean off, which is what every rule
+	* authored before this field meant. An editor turns it off by writing
+	* `false`, so it needs no `clear` key.
+	*/
+	askVerdict: boolean().optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -57485,7 +57836,8 @@ var BATTERY_DEVICE_TYPES = [
 	DeviceType.Switch,
 	DeviceType.PetFeeder,
 	DeviceType.Container,
-	DeviceType.Thermostat
+	DeviceType.Thermostat,
+	DeviceType.EventEmitter
 ];
 /** Generic Customize target for the percentage reading (D936). */
 var batteryCustomize = {
@@ -60362,7 +60714,17 @@ var groupCommandsCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Switch, DeviceType.Light],
+	deviceTypes: [
+		DeviceType.Switch,
+		DeviceType.Light,
+		DeviceType.Fan,
+		DeviceType.Cover,
+		DeviceType.Valve,
+		DeviceType.Lock,
+		DeviceType.MediaPlayer,
+		DeviceType.Thermostat,
+		DeviceType.Climate
+	],
 	methods: {},
 	status: {
 		schema: GroupCommandsSchema,
@@ -60380,6 +60742,49 @@ var groupCommandsCapability = {
 	history: "none"
 };
 /**
+* Whether a helper actuator group counts as active (D944): at least one
+* included member is, or every included member is. What "active" means is the
+* type's: a cover is open, a lock is locked, a media player is playing, a
+* climate device is not off. A group of lights, switches and fans reports
+* `switch.on` instead; this cap is for the types whose own state is not a
+* yes/no. Unknown members are left out (`group-status` counts them) and an
+* empty included set takes the device offline, never `active: false`.
+*/
+var GroupActiveSchema = object({
+	active: boolean().meta({ label: "Active" }),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+var groupActiveCapability = {
+	name: "group-active",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [
+		DeviceType.Cover,
+		DeviceType.Valve,
+		DeviceType.Lock,
+		DeviceType.MediaPlayer,
+		DeviceType.Climate,
+		DeviceType.Thermostat
+	],
+	methods: {},
+	status: {
+		schema: GroupActiveSchema,
+		kind: "push"
+	},
+	runtimeState: GroupActiveSchema,
+	/**
+	* Runtime-state durability: **session** — recomputed from the members on the
+	* next source event; a restored value would outlive the members it named.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
+/**
 * How many members of a helper group answered (D944). Counts are integers,
 * not measurements: zero included is a real count, never a stand-in reading.
 * The reading itself stays on the output capability. History is none — the
@@ -60410,7 +60815,14 @@ var groupStatusCapability = {
 	deviceTypes: [
 		DeviceType.Sensor,
 		DeviceType.Switch,
-		DeviceType.Light
+		DeviceType.Light,
+		DeviceType.Fan,
+		DeviceType.Cover,
+		DeviceType.Valve,
+		DeviceType.Lock,
+		DeviceType.MediaPlayer,
+		DeviceType.Thermostat,
+		DeviceType.Climate
 	],
 	methods: {},
 	status: {
@@ -61683,7 +62095,14 @@ var lockControlCapability = {
 		}),
 		unlock: method(object({
 			deviceId: number().int().nonnegative(),
-			code: string$2().min(1).optional()
+			code: string$2().min(1).optional(),
+			/**
+			* Honoured by a helper lock GROUP only (D944): unlocking several doors
+			* with one call is refused unless the caller says it was confirmed. A
+			* single lock ignores it. The refusal lives in the callee, so no
+			* automation or API caller reaches the doors by skipping a dialog.
+			*/
+			confirm: boolean().optional()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
@@ -61720,6 +62139,44 @@ var lockControlCapability = {
 	volatileStateFields: ["lastChangedAt"]
 };
 /**
+* A monotonic total between resets (D944). Energy uses `power-meter.kwhTotal`
+* so dashboards keep one series; every other instantaneous reading lands here.
+* `value` is the time integral in the source quantity's accumulated base
+* (base-unit seconds, or kWh on the power meter). `null` is a gap, never zero.
+*/
+var MeterStatusSchema = object({
+	value: number().nullable().meta(readingMeta("device", { label: "Total" })),
+	lastFetchedAt: number()
+});
+var meterCapability = {
+	name: "meter",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Sensor],
+	methods: {},
+	status: {
+		schema: MeterStatusSchema,
+		kind: "push"
+	},
+	runtimeState: MeterStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — the total is a cache of the
+	* history integral. A restart shows it only until the history pass
+	* recomputes the open period; it is not an in-memory buffer.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	history: { fields: { value: {
+		kind: "counter",
+		deadband: .001,
+		minIntervalMs: 6e4
+	} } },
+	volatileStateFields: ["lastFetchedAt"]
+};
+/**
 * Media-player cap. Models HA `media_player.*` (Sonos, Chromecast,
 * Apple TV, Spotify, Roku, generic OTT receivers, …) on
 * `DeviceType.MediaPlayer`. Disjoint from the camera streaming
@@ -64231,9 +64688,9 @@ var PowerMeterStatusSchema = object({
 	/** Cumulative energy in kilowatt-hours since the meter was reset. */
 	kwhTotal: number().optional().meta(readingMeta("energy", { label: "Energy" })),
 	/** Voltage in volts. */
-	volts: number().optional().meta(readingMeta("voltage")),
+	volts: number().optional().meta(readingMeta("voltage", { label: "Voltage" })),
 	/** Current in amperes. */
-	amps: number().optional().meta(readingMeta("current")),
+	amps: number().optional().meta(readingMeta("current", { label: "Current" })),
 	/** Apparent power in volt-amperes. */
 	va: number().optional().meta(readingMeta("apparent-power")),
 	/** Power factor (0..1) if reported. */
@@ -64241,12 +64698,74 @@ var PowerMeterStatusSchema = object({
 	/** Ms epoch when the slice was last updated. */
 	lastFetchedAt: number()
 });
+/**
+* Loads that draw metered mains power (D951). The reading is a feature of the
+* device itself — a plug, a lamp, a fan, an air conditioner, a boiler, a
+* vacuum dock — not a separate sensor beside it. A `Sensor` stays: a clamp
+* meter or a standalone energy monitor IS the device. Cover, lock, valve,
+* camera and the like are left out: their draw is not what anyone meters.
+*/
+var POWER_METER_DEVICE_TYPES = [
+	DeviceType.Sensor,
+	DeviceType.Switch,
+	DeviceType.Light,
+	DeviceType.Fan,
+	DeviceType.Climate,
+	DeviceType.Thermostat,
+	DeviceType.Humidifier,
+	DeviceType.WaterHeater,
+	DeviceType.MediaPlayer,
+	DeviceType.Washer,
+	DeviceType.Dryer,
+	DeviceType.Dishwasher,
+	DeviceType.Vacuum,
+	DeviceType.LawnMower,
+	DeviceType.PetFeeder
+];
+/** Everything but a bare `Sensor`: a sensor that takes its reading from another sensor adds nothing. */
+var POWER_METER_CUSTOMIZE_DEVICE_TYPES = POWER_METER_DEVICE_TYPES.filter((type) => type !== DeviceType.Sensor);
+/** One scalar target per reading; each is sourced from a device of its own (D951). */
+function powerTarget(id, unit) {
+	return {
+		id,
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "power-meter",
+			stateField: id
+		},
+		deviceTypes: POWER_METER_CUSTOMIZE_DEVICE_TYPES,
+		apply: "add",
+		path: id,
+		sources: [{
+			kind: "numeric",
+			requiredUnit: unit,
+			transforms: [{ kind: "identity" }]
+		}],
+		companions: [{
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "always"
+		}],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: true
+	};
+}
+/** "Power and energy" extension: watts, energy, voltage and current from other devices (D951). */
+var powerMeterCustomize = {
+	version: 1,
+	targets: [
+		powerTarget("watts", "W"),
+		powerTarget("kwhTotal", "kWh"),
+		powerTarget("volts", "V"),
+		powerTarget("amps", "A")
+	]
+};
 var powerMeterCapability = {
 	name: "power-meter",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Sensor],
+	deviceTypes: POWER_METER_DEVICE_TYPES,
 	methods: {},
 	status: {
 		schema: PowerMeterStatusSchema,
@@ -64303,7 +64822,8 @@ var powerMeterCapability = {
 	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"]
+	volatileStateFields: ["lastFetchedAt"],
+	customize: powerMeterCustomize
 };
 /**
 * Presence cap. Models HA `person.*` and `device_tracker.*` entities
@@ -64984,6 +65504,8 @@ var runningCustomize = {
 			stateField: "running"
 		},
 		deviceTypes: [
+			DeviceType.Washer,
+			DeviceType.Dryer,
 			DeviceType.Dishwasher,
 			DeviceType.Vacuum,
 			DeviceType.LawnMower,
@@ -67473,7 +67995,8 @@ var switchCapability = {
 	deviceTypes: [
 		DeviceType.Switch,
 		DeviceType.Siren,
-		DeviceType.Light
+		DeviceType.Light,
+		DeviceType.Fan
 	],
 	methods: { setState: method(object({
 		deviceId: number(),
@@ -69686,8 +70209,9 @@ method(object({}), array(TrainingBaseModelSchema).readonly(), { auth: "admin" })
 	kind: "mutation",
 	auth: "admin"
 });
+DeviceFeature.FanSpeed, DeviceFeature.FanPreset, DeviceFeature.FanDirection, DeviceFeature.FanOscillating, DeviceFeature.CoverPositionable, DeviceFeature.CoverTilt, DeviceFeature.ValvePositionable, DeviceFeature.MediaPlayerVolume, DeviceFeature.ClimateFanMode;
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
-DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Camera, DeviceType.Camera, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder;
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Camera, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder;
 String.raw`rose\(active(\d+), changed(\d+), (\d+(?:\.\d+)?)\)`;
 DeviceRole.BinarySensor, DeviceRole.MotionSensor;
 new Set(CAP_NAMES);
@@ -70016,6 +70540,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	featureProbe: featureProbeCapability,
 	flood: floodCapability,
 	gas: gasCapability,
+	groupActive: groupActiveCapability,
 	groupCommands: groupCommandsCapability,
 	groupStatus: groupStatusCapability,
 	heatingValve: heatingValveCapability,
@@ -70027,6 +70552,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	lawnMowerControl: lawnMowerControlCapability,
 	lockControl: lockControlCapability,
 	mediaPlayer: mediaPlayerCapability,
+	meter: meterCapability,
 	motion: motionCapability,
 	motionTrigger: motionTriggerCapability,
 	motionZones: motionZonesCapability,
@@ -71286,7 +71812,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 		return toDeviceSummary(device, this.addonId);
 	}
 };
-DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher;
+DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer;
 new Set(Object.values(DeviceType));
 Object.freeze({
 	"accessories.getStatus": {
@@ -74509,6 +75035,13 @@ Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"groupActive.getStatus": {
+		capName: "group-active",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"groupCommands.getStatus": {
 		capName: "group-commands",
 		capScope: "device",
@@ -75475,6 +76008,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"meter.getStatus": {
+		capName: "meter",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"metricsProvider.collectSnapshot": {
 		capName: "metrics-provider",
 		capScope: "system",
@@ -83573,7 +84113,39 @@ var APPLIANCE_CAP_VOCABULARY = {
 				phrase: t("When {device} finishes", "Quando {device} finisce"),
 				icon: "square"
 			}
-		}
+		},
+		overrides: { byType: {
+			[DeviceType.Washer]: {
+				state: { running: {
+					whenTrue: t("When the washing machine starts", "Quando la lavatrice inizia"),
+					whenFalse: t("When the washing machine has finished", "Quando la lavatrice ha finito")
+				} },
+				events: {
+					onStarted: { phrase: t("When the washing machine starts", "Quando la lavatrice inizia") },
+					onFinished: { phrase: t("When the washing machine has finished", "Quando la lavatrice ha finito") }
+				}
+			},
+			[DeviceType.Dryer]: {
+				state: { running: {
+					whenTrue: t("When the dryer starts", "Quando l'asciugatrice inizia"),
+					whenFalse: t("When the dryer has finished", "Quando l'asciugatrice ha finito")
+				} },
+				events: {
+					onStarted: { phrase: t("When the dryer starts", "Quando l'asciugatrice inizia") },
+					onFinished: { phrase: t("When the dryer has finished", "Quando l'asciugatrice ha finito") }
+				}
+			},
+			[DeviceType.Dishwasher]: {
+				state: { running: {
+					whenTrue: t("When the dishwasher starts", "Quando la lavastoviglie inizia"),
+					whenFalse: t("When the dishwasher has finished", "Quando la lavastoviglie ha finito")
+				} },
+				events: {
+					onStarted: { phrase: t("When the dishwasher starts", "Quando la lavastoviglie inizia") },
+					onFinished: { phrase: t("When the dishwasher has finished", "Quando la lavastoviglie ha finito") }
+				}
+			}
+		} }
 	},
 	update: {
 		scope: "device",
@@ -84345,6 +84917,10 @@ var SENSOR_CAP_VOCABULARY = {
 			icon: "flame"
 		}]
 	},
+	"group-active": {
+		scope: "device",
+		noun: t("Group state", "Stato del gruppo")
+	},
 	"group-commands": {
 		scope: "device",
 		noun: t("Group command", "Comando di gruppo")
@@ -84401,6 +84977,17 @@ var SENSOR_CAP_VOCABULARY = {
 		}],
 		events: { onMotionChanged: { notOperatorFacing: "the `detected` state trigger phrases both edges, from the mirror that survives a dropped event (D49)" } }
 	},
+	meter: {
+		scope: "device",
+		noun: t("Meter", "Contatore"),
+		state: [{
+			kind: "numeric",
+			field: "value",
+			quantity: t("the total", "il totale"),
+			label: t("Total", "Totale"),
+			icon: "gauge"
+		}]
+	},
 	"numeric-sensor": {
 		scope: "device",
 		noun: t("Sensor", "Sensore"),
@@ -84873,8 +85460,47 @@ function projectAction(cap, action) {
 	};
 }
 Object.entries(CAP_VOCABULARY_BY_NAME).flatMap(([cap, entry]) => entry.scope === "device" ? (entry.actions ?? []).map((a) => projectAction(cap, a)) : []);
-DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer;
 DeviceFeature.BatteryOperated;
+DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
+var HA_AS = "a power sensor (device_class power). Home Assistant has no laundry domain. running-state stays unexported until a null reading can be published as unavailable.";
+var HOMEKIT_REASON = "HomeKit has no laundry-appliance service. The export tab would pair an accessory with nothing on it: running-state is withheld until a null reading can be unavailable, and power is not a HomeKit service this export honours.";
+var ALEXA_REASON = "Alexa has no laundry category in this export, and neither power nor running has an Alexa interface.";
+var GOOGLE_REASON = "Google WASHER, DRYER and DISHWASHER require RunCycle. A power threshold is not that trait, and this export does not publish RunCycle.";
+var MATTER_REASON = "No Matter export is built. The closest device types are Laundry Washer (0x0073) and Laundry Dryer (0x0074); a power threshold is not the Laundry Washer Mode cluster.";
+function withheld(reason) {
+	return {
+		[DeviceType.Washer]: {
+			exported: false,
+			reason
+		},
+		[DeviceType.Dryer]: {
+			exported: false,
+			reason
+		},
+		[DeviceType.Dishwasher]: {
+			exported: false,
+			reason
+		}
+	};
+}
+function offered(received) {
+	return {
+		[DeviceType.Washer]: {
+			exported: true,
+			as: received
+		},
+		[DeviceType.Dryer]: {
+			exported: true,
+			as: received
+		},
+		[DeviceType.Dishwasher]: {
+			exported: true,
+			as: received
+		}
+	};
+}
+offered(HA_AS), withheld(HOMEKIT_REASON), withheld(ALEXA_REASON), withheld(GOOGLE_REASON), withheld(MATTER_REASON);
 Object.freeze({
 	"accessories.getStatus": [{
 		name: "deviceId",
@@ -85841,6 +86467,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"groupActive.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"groupCommands.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -86051,6 +86682,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"meter.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"motion.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -87658,7 +88294,6 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
-DeviceType.Camera;
 /**
 * A saved Customize assignment (D936). The schema is the type: callers use
 * `z.infer`, they do not restate the shape.
@@ -197516,6 +198151,7 @@ var StubMatterController = class {
 	async removeNode(_nodeId) {
 		throw new MatterControllerNotWiredError("removeNode");
 	}
+	async syncSubscriptions() {}
 };
 /**
 * Factory seam (stub default): build a {@link StubMatterController}.
@@ -197688,7 +198324,13 @@ var MatterAttributeId = {
 	/** ElectricalPowerMeasurement.ActivePower (int64, mW). */
 	ActivePower: 8,
 	/** ElectricalEnergyMeasurement.CumulativeEnergyImported (energy struct, mWh). */
-	CumulativeEnergyImported: 1
+	CumulativeEnergyImported: 1,
+	/** DoorLock.LockState (enum: 0 NotFullyLocked, 1 Locked, 2 Unlocked, 3 Unlatched). */
+	LockState: 0,
+	/** DoorLock.DoorState (enum; 2 = DoorJammed). Present only with the door sensor. */
+	DoorState: 3,
+	/** DoorLock.RequirePinForRemoteOperation (bool). */
+	RequirePinForRemoteOperation: 51
 };
 /** Thermostat.SystemMode enum → CamStack HvacMode (climate-control). */
 var SYSTEM_MODE_TO_HVAC = new Map([
@@ -197720,8 +198362,11 @@ function asBoolean(value) {
 * matter.js may surface a `MeasuredValue` either as a plain scaled int or wrapped
 * in an energy-measurement struct (`{ energy }`). Pull the numeric payload out.
 */
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null;
+}
 function asEnergyMilliWattHours(value) {
-	if (typeof value === "object" && value !== null && "energy" in value) return asNumber(value.energy);
+	if (isRecord$4(value) && "energy" in value) return asNumber(value["energy"]);
 	return asNumber(value);
 }
 /**
@@ -197743,9 +198388,77 @@ function decodeMatterAttribute(input) {
 		case MatterClusterId.Thermostat: return decodeThermostat(attributeId, value);
 		case MatterClusterId.ElectricalPowerMeasurement: return decodeElectricalPower(attributeId, value);
 		case MatterClusterId.ElectricalEnergyMeasurement: return decodeElectricalEnergy(attributeId, value);
+		case MatterClusterId.DoorLock: return decodeDoorLock(attributeId, value);
 		default: return null;
 	}
 }
+/** LockState enum → cap state. NotFullyLocked has no cap value of its own. */
+var LOCK_STATE_TO_CAP = new Map([
+	[0, {
+		state: "jammed",
+		detail: "not-fully-locked"
+	}],
+	[1, { state: "locked" }],
+	[2, { state: "unlocked" }],
+	[3, {
+		state: "unlocked",
+		detail: "unlatched"
+	}]
+]);
+/** DoorState enum → a detail. Only DoorJammed also moves the lock cap. */
+var DOOR_STATE_DETAIL = new Map([
+	[0, "door-open"],
+	[1, "door-closed"],
+	[2, "door-jammed"],
+	[3, "door-forced-open"],
+	[4, "door-unspecified"],
+	[5, "door-ajar"]
+]);
+function decodeDoorLock(attributeId, value) {
+	if (attributeId === MatterAttributeId.LockState) {
+		const raw = asNumber(value);
+		if (raw === null) return null;
+		const mapped = LOCK_STATE_TO_CAP.get(raw);
+		if (mapped === void 0) return null;
+		return {
+			cap: "lock-control",
+			patch: {
+				state: mapped.state,
+				lastChangedAt: Date.now()
+			},
+			...mapped.detail !== void 0 ? { detail: mapped.detail } : {}
+		};
+	}
+	if (attributeId === MatterAttributeId.DoorState) {
+		const raw = asNumber(value);
+		if (raw === null) return null;
+		const detail = DOOR_STATE_DETAIL.get(raw);
+		if (detail === void 0) return null;
+		if (detail === "door-jammed") return {
+			cap: "lock-control",
+			patch: {
+				state: "jammed",
+				lastChangedAt: Date.now()
+			},
+			detail
+		};
+		return {
+			cap: "lock-control",
+			patch: {},
+			detail
+		};
+	}
+	if (attributeId === MatterAttributeId.RequirePinForRemoteOperation) {
+		const required = asBoolean(value);
+		if (required === null) return null;
+		return {
+			cap: "lock-control",
+			patch: {},
+			detail: required ? "pin-required" : "pin-not-required"
+		};
+	}
+	return null;
+}
 function decodeOnOff(attributeId, value) {
 	if (attributeId !== MatterAttributeId.OnOff) return null;
 	const on = asBoolean(value);
@@ -197969,7 +198682,10 @@ var ATTR_NAME_TO_ID = new Map([
 	["voltage", MatterAttributeId.Voltage],
 	["activeCurrent", MatterAttributeId.ActiveCurrent],
 	["activePower", MatterAttributeId.ActivePower],
-	["cumulativeEnergyImported", MatterAttributeId.CumulativeEnergyImported]
+	["cumulativeEnergyImported", MatterAttributeId.CumulativeEnergyImported],
+	["lockState", MatterAttributeId.LockState],
+	["doorState", MatterAttributeId.DoorState],
+	["requirePinForRemoteOperation", MatterAttributeId.RequirePinForRemoteOperation]
 ]);
 /** clusterId → matter.js behavior id (camelCase) for outbound command clusters. */
 var CLUSTER_ID_TO_BEHAVIOR_ID = new Map([
@@ -197981,14 +198697,14 @@ var CLUSTER_ID_TO_BEHAVIOR_ID = new Map([
 	[258, "windowCovering"]
 ]);
 /** True when `value` is a non-null object (cast-free record narrowing). */
-function isRecord$1(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null;
 }
 /** Read a finite numeric cluster id from a `Behavior.Type`'s `.cluster.id`. */
 function clusterIdOf(behaviorType) {
-	if (!isRecord$1(behaviorType)) return null;
+	if (!isRecord$3(behaviorType)) return null;
 	const cluster = behaviorType["cluster"];
-	if (!isRecord$1(cluster)) return null;
+	if (!isRecord$3(cluster)) return null;
 	const id = cluster["id"];
 	if (typeof id === "number" && Number.isFinite(id)) return id;
 	if (typeof id === "bigint") return Number(id);
@@ -197999,13 +198715,13 @@ function clusterIdOf(behaviorType) {
 * the matter.js `Endpoint` interop at one typed boundary.
 */
 function asDynamicEndpoint(value) {
-	if (!isRecord$1(value)) return null;
+	if (!isRecord$3(value)) return null;
 	const number = value["number"];
 	const behaviors = value["behaviors"];
 	const parts = value["parts"];
 	const stateOf = value["stateOf"];
 	const commandsOf = value["commandsOf"];
-	if (typeof number === "number" && isRecord$1(behaviors) && "supported" in behaviors && typeof stateOf === "function" && typeof commandsOf === "function" && isIterable$1(parts)) return {
+	if (typeof number === "number" && isRecord$3(behaviors) && "supported" in behaviors && typeof stateOf === "function" && typeof commandsOf === "function" && isIterable$2(parts)) return {
 		number,
 		behaviors: { supported: behaviors["supported"] },
 		parts: mapIterable(parts, asDynamicEndpointOrThrow),
@@ -198029,7 +198745,7 @@ async function invokeNodeCommand(input) {
 	const behaviorId = CLUSTER_ID_TO_BEHAVIOR_ID.get(clusterId);
 	if (behaviorId === void 0) throw new Error(`matter-broker: cluster 0x${clusterId.toString(16)} has no command binding`);
 	const commands = target.commandsOf(behaviorId);
-	if (!isRecord$1(commands)) throw new Error(`matter-broker: endpoint ${endpointId} has no '${behaviorId}' commands`);
+	if (!isRecord$3(commands)) throw new Error(`matter-broker: endpoint ${endpointId} has no '${behaviorId}' commands`);
 	const command = commands[commandName];
 	const fn = asCommandFn(command);
 	if (fn === null) throw new Error(`matter-broker: command '${commandName}' unavailable on '${behaviorId}'`);
@@ -198054,8 +198770,8 @@ function asDynamicEndpointOrThrow(value) {
 	if (ep === null) throw new TypeError("matter-broker: unexpected non-endpoint child part");
 	return ep;
 }
-function isIterable$1(value) {
-	return isRecord$1(value) && typeof Reflect.get(value, Symbol.iterator) === "function";
+function isIterable$2(value) {
+	return isRecord$3(value) && typeof Reflect.get(value, Symbol.iterator) === "function";
 }
 function* mapIterable(it, fn) {
 	for (const v of it) yield fn(v);
@@ -198076,7 +198792,7 @@ function collectEndpoint(endpoint, out) {
 	const supported = endpoint.behaviors.supported;
 	const clusterIds = [];
 	const attributes = [];
-	if (isRecord$1(supported)) for (const [behaviorId, behaviorType] of Object.entries(supported)) {
+	if (isRecord$3(supported)) for (const [behaviorId, behaviorType] of Object.entries(supported)) {
 		const clusterId = clusterIdOf(behaviorType);
 		if (clusterId === null) continue;
 		clusterIds.push(clusterId);
@@ -198096,7 +198812,7 @@ function readBehaviorAttributes(endpoint, behaviorId, clusterId, attributes) {
 	} catch {
 		return;
 	}
-	if (!isRecord$1(struct)) return;
+	if (!isRecord$3(struct)) return;
 	for (const [attrName, value] of Object.entries(struct)) {
 		const attributeId = ATTR_NAME_TO_ID.get(attrName);
 		if (attributeId === void 0) continue;
@@ -198108,35 +198824,413 @@ function readBehaviorAttributes(endpoint, behaviorId, clusterId, attributes) {
 	}
 }
 //#endregion
+//#region src/matter-commission-progress.ts
+/**
+* Commissioning progress the admin UI polls, plus the named failures a share
+* code can produce. Pure — no matter.js import.
+*
+* Phases follow the on-network share path: discover the device, establish
+* PASE, then commission onto this fabric. A missing or malformed code never
+* becomes a later phase.
+*/
+var CommissionPhase = {
+	Idle: "idle",
+	Discovering: "discovering",
+	Pase: "pase",
+	Commissioning: "commissioning",
+	Done: "done",
+	Failed: "failed"
+};
+var CommissionFailureCode = {
+	CodeExpired: "code-expired",
+	DeviceNotFound: "device-not-found",
+	WrongCode: "wrong-code",
+	InvalidCode: "invalid-code",
+	Unknown: "unknown"
+};
+var IDLE_COMMISSION_PROGRESS = {
+	phase: CommissionPhase.Idle,
+	failure: null,
+	message: null
+};
+/** Stable prefix the UI matches. The human text follows the colon. */
+function commissionFailureMessage(code, detail) {
+	return `matter-commission:${code}: ${detail}`;
+}
+/**
+* Map a controller or matter.js error onto a named failure. Order matters:
+* an expired commissioning window is not "device not found", and a rejected
+* passcode is not a network miss.
+*/
+function classifyCommissionError(message) {
+	const text = message.toLowerCase();
+	if (text.includes("invalid pairing code") || text.includes("11 or 21")) return CommissionFailureCode.InvalidCode;
+	if (text.includes("expired") || text.includes("commissioning window") || text.includes("window closed")) return CommissionFailureCode.CodeExpired;
+	if (text.includes("passcode") || text.includes("wrong code") || text.includes("pase") || text.includes("authentication failed") || text.includes("status 0x7e") || text.includes("invalid code")) return CommissionFailureCode.WrongCode;
+	if (text.includes("not found") || text.includes("no device") || text.includes("no commissionable") || text.includes("discovery") || text.includes("timed out") || text.includes("timeout") || text.includes("unreachable")) return CommissionFailureCode.DeviceNotFound;
+	return CommissionFailureCode.Unknown;
+}
+//#endregion
+//#region src/matter-subscription.ts
+/**
+* Per-node Matter attribute subscriptions. The matter.js call itself lives in
+* {@link import('./matter-peer-subscribe.js')}; this module owns the lifecycle:
+* open, resubscribe after the session drops or the node returns, and a bounded
+* backoff. A report whose value is missing is not a value (D393) and is dropped.
+*/
+/** First wait after a dropped subscription. */
+var SUBSCRIPTION_BACKOFF_INITIAL_MS = 1e3;
+/** Cap so a sleepy Thread node cannot be hammered. */
+var SUBSCRIPTION_BACKOFF_MAX_MS = 6e4;
+/**
+* One supervisor per fabric. `sync` is safe to call on start, after commission,
+* and on the reconcile timer (the backstop when a lifecycle event was missed).
+*/
+var MatterSubscriptionSupervisor = class {
+	#brokerId;
+	#logger;
+	#resolveDeviceId;
+	#onReport;
+	#slots = /* @__PURE__ */ new Map();
+	#stopped = false;
+	constructor(options) {
+		this.#brokerId = options.brokerId;
+		this.#logger = options.logger;
+		this.#resolveDeviceId = options.resolveDeviceId;
+		this.#onReport = options.onReport;
+	}
+	/** How many times `subscribe` has been entered for a node (tests). */
+	subscribeAttempts(nodeId) {
+		return this.#slots.get(nodeId)?.generation ?? 0;
+	}
+	phase(nodeId) {
+		return this.#slots.get(nodeId)?.phase ?? null;
+	}
+	async sync(peers) {
+		if (this.#stopped) return;
+		const live = /* @__PURE__ */ new Set();
+		for (const peer of peers) {
+			live.add(peer.nodeId);
+			const slot = this.#slots.get(peer.nodeId);
+			if (slot === void 0) {
+				await this.#open(peer);
+				continue;
+			}
+			slot.peer = peer;
+			if (slot.phase !== "subscribed" && peer.online() && slot.phase !== "resubscribing") {
+				slot.attempt = 0;
+				await this.#open(peer);
+			}
+		}
+		for (const [nodeId, slot] of this.#slots) {
+			if (live.has(nodeId)) continue;
+			await this.#drop(slot);
+			this.#slots.delete(nodeId);
+		}
+	}
+	async stop() {
+		this.#stopped = true;
+		for (const slot of this.#slots.values()) await this.#drop(slot);
+		this.#slots.clear();
+	}
+	async #open(peer) {
+		if (this.#stopped) return;
+		const existing = this.#slots.get(peer.nodeId);
+		if (existing?.phase === "subscribed" && existing.subscription !== null) return;
+		if (existing?.timer !== null && existing?.timer !== void 0) {
+			clearTimeout(existing.timer);
+			existing.timer = null;
+		}
+		const generation = (existing?.generation ?? 0) + 1;
+		const slot = existing ?? this.#fresh(peer);
+		slot.peer = peer;
+		slot.generation = generation;
+		slot.phase = "resubscribing";
+		this.#slots.set(peer.nodeId, slot);
+		this.#listen(slot);
+		this.#log(peer.nodeId, "resubscribing");
+		let subscription;
+		try {
+			subscription = await peer.subscribe({
+				onReport: (report) => {
+					if (report.value === void 0 || report.value === null) return;
+					this.#onReport(report);
+				},
+				onClosed: () => {
+					const current = this.#slots.get(peer.nodeId);
+					if (current === void 0 || current.generation !== generation) return;
+					this.#onClosed(peer.nodeId);
+				}
+			});
+		} catch (err) {
+			this.#log(peer.nodeId, "subscribe-failed", { error: errMsg(err) });
+			const current = this.#slots.get(peer.nodeId);
+			if (current === void 0 || current.generation !== generation) return;
+			current.phase = "subscribe-failed";
+			this.#schedule(peer.nodeId);
+			return;
+		}
+		if (this.#stopped || this.#slots.get(peer.nodeId)?.generation !== generation) {
+			await subscription.close().catch(() => void 0);
+			return;
+		}
+		slot.subscription = subscription;
+		slot.phase = "subscribed";
+		slot.attempt = 0;
+		this.#log(peer.nodeId, "subscribed");
+	}
+	#onClosed(nodeId) {
+		const slot = this.#slots.get(nodeId);
+		if (slot === void 0 || slot.dropping) return;
+		if (slot.phase !== "subscribed" && slot.phase !== "resubscribing") return;
+		slot.subscription = null;
+		slot.phase = "closed";
+		this.#log(nodeId, "closed");
+		if (!slot.peer.online()) {
+			slot.phase = "offline";
+			this.#log(nodeId, "offline");
+			return;
+		}
+		this.#schedule(nodeId);
+	}
+	#schedule(nodeId) {
+		const slot = this.#slots.get(nodeId);
+		if (slot === void 0 || this.#stopped) return;
+		if (slot.timer !== null) clearTimeout(slot.timer);
+		const delay = Math.min(SUBSCRIPTION_BACKOFF_MAX_MS, SUBSCRIPTION_BACKOFF_INITIAL_MS * 2 ** slot.attempt);
+		slot.attempt += 1;
+		slot.phase = "backing-off";
+		this.#log(nodeId, "backing-off", {
+			delayMs: delay,
+			attempt: slot.attempt
+		});
+		slot.timer = setTimeout(() => {
+			slot.timer = null;
+			this.#open(slot.peer);
+		}, delay);
+		if (typeof slot.timer.unref === "function") slot.timer.unref();
+	}
+	#listen(slot) {
+		if (slot.listening) return;
+		slot.listening = true;
+		slot.unlisten.push(slot.peer.onOffline(() => {
+			const current = this.#slots.get(slot.peer.nodeId);
+			if (current === void 0) return;
+			if (current.phase === "offline") return;
+			current.phase = "offline";
+			this.#log(slot.peer.nodeId, "offline");
+		}));
+		slot.unlisten.push(slot.peer.onOnline(() => {
+			const current = this.#slots.get(slot.peer.nodeId);
+			if (current === void 0 || this.#stopped) return;
+			current.attempt = 0;
+			if (current.timer !== null) {
+				clearTimeout(current.timer);
+				current.timer = null;
+			}
+			this.#log(slot.peer.nodeId, "online");
+			this.#open(current.peer);
+		}));
+	}
+	async #drop(slot) {
+		slot.dropping = true;
+		if (slot.timer !== null) clearTimeout(slot.timer);
+		slot.timer = null;
+		for (const unlisten of slot.unlisten) unlisten();
+		slot.unlisten = [];
+		const subscription = slot.subscription;
+		slot.subscription = null;
+		if (subscription !== null) try {
+			await subscription.close();
+		} catch (err) {
+			this.#logger.warn("Matter subscription close failed", {
+				tags: this.#tags(slot.peer.nodeId),
+				meta: {
+					nodeId: slot.peer.nodeId,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+	#fresh(peer) {
+		return {
+			peer,
+			phase: "resubscribing",
+			attempt: 0,
+			timer: null,
+			subscription: null,
+			unlisten: [],
+			generation: 0,
+			listening: false,
+			dropping: false
+		};
+	}
+	#tags(nodeId) {
+		const deviceId = this.#resolveDeviceId(nodeId);
+		if (deviceId !== null) return { deviceId };
+		return { brokerId: this.#brokerId };
+	}
+	#log(nodeId, phase, extra) {
+		const deviceId = this.#resolveDeviceId(nodeId);
+		this.#logger.info("Matter subscription state", {
+			tags: deviceId !== null ? { deviceId } : { brokerId: this.#brokerId },
+			meta: {
+				nodeId,
+				phase,
+				...extra
+			}
+		});
+	}
+};
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null;
+}
+function asFiniteNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "bigint") {
+		const n = Number(value);
+		return Number.isFinite(n) ? n : null;
+	}
+	return null;
+}
+function isIterable$1(value) {
+	return isRecord$2(value) && typeof Reflect.get(value, Symbol.iterator) === "function";
+}
+function isAsyncIterable(value) {
+	return isRecord$2(value) && typeof Reflect.get(value, Symbol.asyncIterator) === "function";
+}
+/**
+* Pull attribute values out of a matter.js `ReadResult` (or a recorded fixture
+* of the same shape). Status reports and missing values are skipped — they are
+* not a measurement.
+*/
+async function collectAttributeReports(nodeId, update) {
+	const out = [];
+	const chunks = isAsyncIterable(update) ? update : isIterable$1(update) ? update : [];
+	for await (const chunk of chunks) {
+		const reports = isIterable$1(chunk) ? chunk : [];
+		for (const report of reports) {
+			const decoded = reportFromRecord(nodeId, report);
+			if (decoded !== null) out.push(decoded);
+		}
+	}
+	return out;
+}
+function reportFromRecord(nodeId, report) {
+	if (!isRecord$2(report)) return null;
+	if (report["kind"] !== "attr-value") return null;
+	if (report["value"] === void 0 || report["value"] === null) return null;
+	const path = report["path"];
+	if (!isRecord$2(path)) return null;
+	const endpointId = asFiniteNumber(path["endpointId"]);
+	const clusterId = asFiniteNumber(path["clusterId"]);
+	const attributeId = asFiniteNumber(path["attributeId"]);
+	if (endpointId === null || clusterId === null || attributeId === null) return null;
+	return {
+		nodeId,
+		endpointId,
+		clusterId,
+		attributeId,
+		value: report["value"]
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function peerOnline$1(peer) {
+	const lifecycle = peer["lifecycle"];
+	if (!isRecord$1(lifecycle)) return false;
+	return lifecycle["isOnline"] === true;
+}
+function listenLifecycle(peer, event, handler) {
+	const lifecycle = peer["lifecycle"];
+	if (!isRecord$1(lifecycle)) return () => void 0;
+	const observable = lifecycle[event];
+	if (!isRecord$1(observable)) return () => void 0;
+	const on = observable["on"];
+	const off = observable["off"];
+	if (typeof on !== "function" || typeof off !== "function") return () => void 0;
+	Reflect.apply(on, observable, [handler]);
+	return () => {
+		Reflect.apply(off, observable, [handler]);
+	};
+}
+/** Stop matter.js's own wildcard subscription so this addon owns the session. */
+function disableAutoSubscribe(peer) {
+	const stateOf = peer["stateOf"];
+	if (typeof stateOf !== "function") return;
+	let network;
+	try {
+		network = Reflect.apply(stateOf, peer, ["network"]);
+	} catch {
+		return;
+	}
+	if (!isRecord$1(network)) return;
+	if ("autoSubscribe" in network) network["autoSubscribe"] = false;
+}
+function subscriptionFrom(result) {
+	return { close: async () => {
+		if (!isRecord$1(result)) return;
+		const fn = result["close"];
+		if (typeof fn !== "function") return;
+		await Promise.resolve(Reflect.apply(fn, result, []));
+	} };
+}
+/**
+* Build a subscribable view of a commissioned peer, or null when the peer has
+* no `interaction.subscribe` (nothing to attach — the caller logs that).
+*/
+function subscribableFromPeer(peer, nodeId) {
+	if (!isRecord$1(peer)) return null;
+	const interaction = peer["interaction"];
+	if (!isRecord$1(interaction) || typeof interaction["subscribe"] !== "function") return null;
+	const subscribe = interaction["subscribe"];
+	return {
+		nodeId,
+		online: () => peerOnline$1(peer),
+		onOnline: (handler) => listenLifecycle(peer, "online", handler),
+		onOffline: (handler) => listenLifecycle(peer, "offline", handler),
+		subscribe: async (handlers) => {
+			disableAutoSubscribe(peer);
+			const request = {
+				sustain: true,
+				keepSubscriptions: false,
+				fabricFilter: true,
+				attributes: [{}],
+				minIntervalFloor: require_esm.Seconds(0),
+				maxIntervalCeiling: require_esm.Seconds(60),
+				bootstrapWithRead: true,
+				updated: async (update) => {
+					const reports = await collectAttributeReports(nodeId, update);
+					for (const report of reports) handlers.onReport(report);
+				},
+				closed: () => {
+					handlers.onClosed();
+				}
+			};
+			return subscriptionFrom(await Promise.resolve(Reflect.apply(subscribe, interaction, [request])));
+		}
+	};
+}
+//#endregion
 //#region src/matter-controller-impl.ts
 /**
-* Real {@link MatterController} backed by matter.js v0.17 (`@matter/main` +
-* `@matter/nodejs`).
-*
-* matter.js v0.17 uses the "node API": a {@link ServerNode} owns the controller
-* fabric, and commissioned devices are {@link ClientNode} peers reachable via
-* `serverNode.peers`. This class wraps exactly one `ServerNode` per broker
-* (= one fabric), persisting it under the addon `dataDir` via the matter.js
-* `Environment`'s `storage.path` variable.
-*
-* Bound API (matter.js 0.17.3):
-*   - `ServerNode.create({ environment, id })` — fabric owner; storage at dataDir.
-*   - `serverNode.peers.commission({ pairingCode })` — commission a node from a
-*     QR (`MT:…`) or manual pairing code; resolves to a `ClientNode`.
-*   - `serverNode.peers` — iterable of commissioned `ClientNode`s.
-*   - `clientNode.lifecycle.isOnline`, `clientNode.peerAddress.nodeId` — liveness
-*     + stable node id.
-*   - `clientNode.decommission()` — remove a node from the fabric.
-*   - endpoint `commandsOf(behaviorId)[name](args)` — outbound cluster commands.
-*
-* The dynamic endpoint/cluster/attribute introspection lives in
-* `matter-endpoint-introspect.ts` (the single matter.js dynamic-shape boundary).
-* This class polls each node's endpoint state on reconcile + emits decoded
-* attribute reports, and re-emits on node online/offline transitions.
-*
-* BLE commissioning (`@matter/nodejs-ble`) is NOT wired — that package is not
-* installed. IP / on-network commissioning is the supported path; see the class
-* `commissionNode` note.
+* Real {@link MatterController} backed by matter.js (`@matter/main` +
+* `@matter/nodejs`). ServerNode / ClientNode is the API this controller uses.
+*
+* One `ServerNode` per broker (= one fabric). Storage is matter.js's own
+* files under the addon `dataDir` (`Environment` `storage.path`) — the
+* library-owned exception for fabric root / NOC / node registry, same class
+* as HAP pairing files. Not the keychain.
+*
+* Bound API:
+*   - `ServerNode.create({ environment, id })` — fabric owner.
+*   - `serverNode.peers.commission({ pairingCode, continueCommissioningAfterPase })`.
+*   - `clientNode.interaction.subscribe({ sustain: true })` — attribute reports.
+*   - `clientNode.lifecycle` online / offline — resubscribe.
+*   - endpoint `commandsOf(behaviorId)[name](args)` — outbound commands.
+*
+* BLE commissioning is not wired. IP / on-network share codes only.
 */
 /** A commissioning failure (bad code / device unreachable), distinct from runtime. */
 var MatterCommissioningError = class extends Error {
@@ -198156,12 +199250,19 @@ var MatterJsController = class {
 	#options;
 	#logger;
 	#handlers = /* @__PURE__ */ new Set();
+	#subscriptions;
 	#server = null;
 	/** Last emitted value per `node:endpoint:cluster:attribute` (change detection). */
 	#lastValues = /* @__PURE__ */ new Map();
 	constructor(options, logger) {
 		this.#options = options;
 		this.#logger = logger;
+		this.#subscriptions = new MatterSubscriptionSupervisor({
+			brokerId: options.brokerId,
+			logger,
+			resolveDeviceId: options.resolveDeviceId ?? (() => null),
+			onReport: (report) => this.#emitIfChanged(report)
+		});
 	}
 	get options() {
 		return this.#options;
@@ -198169,19 +199270,17 @@ var MatterJsController = class {
 	/** Boot the ServerNode fabric, loading/persisting state from `dataDir`. */
 	async start() {
 		if (this.#server !== null) return;
-		const environment = this.#buildEnvironment();
-		const server = await ServerNode.create({
-			environment,
-			id: this.#options.brokerId
-		});
+		const server = this.#options.openServer !== void 0 ? await this.#options.openServer() : await this.#openProductionServer();
 		this.#server = server;
 		await server.start();
 		this.#logger.info("MatterJsController: ServerNode online", { tags: { brokerId: this.#options.brokerId } });
+		await this.syncSubscriptions();
 		this.#emitAllReports();
 	}
-	/** Close the ServerNode FIRST (frees OS sockets/subscriptions), then clear. */
+	/** Close subscriptions FIRST, then the ServerNode. */
 	async stop() {
 		this.#handlers.clear();
+		await this.#subscriptions.stop();
 		const server = this.#server;
 		this.#server = null;
 		this.#lastValues.clear();
@@ -198202,19 +199301,49 @@ var MatterJsController = class {
 	*/
 	async commissionNode(pairingCode) {
 		const server = this.#requireServer("commissionNode");
+		this.#progress({
+			phase: CommissionPhase.Discovering,
+			failure: null,
+			message: null
+		});
 		try {
-			const node = await server.peers.commission({ pairingCode });
+			const node = await server.commission({
+				pairingCode,
+				onPase: () => {
+					this.#progress({
+						phase: CommissionPhase.Pase,
+						failure: null,
+						message: null
+					});
+					this.#progress({
+						phase: CommissionPhase.Commissioning,
+						failure: null,
+						message: null
+					});
+				}
+			});
 			const view = this.#viewPeer(node);
 			this.#logger.info("MatterJsController: node commissioned", {
 				tags: { brokerId: this.#options.brokerId },
 				meta: { nodeId: view?.id ?? "(unknown)" }
 			});
+			await this.syncSubscriptions();
 			this.#emitAllReports();
 			if (view === null) throw new MatterCommissioningError("commissioned node exposed no operational id");
+			this.#progress({
+				phase: CommissionPhase.Done,
+				failure: null,
+				message: null
+			});
 			return { nodeId: view.id };
 		} catch (err) {
-			if (err instanceof MatterCommissioningError) throw err;
-			throw new MatterCommissioningError(errMsg(err), { cause: err });
+			if (err instanceof MatterCommissioningError && err.message.includes("no operational id")) {
+				this.#failCommission(err.message);
+				throw err;
+			}
+			const message = errMsg(err);
+			this.#failCommission(message);
+			throw new MatterCommissioningError(commissionFailureMessage(classifyCommissionError(message), message), { cause: err });
 		}
 	}
 	/** Pull the live commissioned-node inventory off `serverNode.peers`. */
@@ -198222,12 +199351,31 @@ var MatterJsController = class {
 		const server = this.#server;
 		if (server === null) return [];
 		const out = [];
-		for (const peer of this.#peers(server)) {
+		for (const peer of server.listPeers()) {
 			const snapshot = this.#snapshot(peer);
 			if (snapshot !== null) out.push(snapshot);
 		}
 		return out;
 	}
+	async syncSubscriptions() {
+		const server = this.#server;
+		if (server === null) return;
+		const peers = [];
+		for (const peer of server.listPeers()) {
+			const view = this.#viewPeer(peer);
+			if (view === null) continue;
+			const subscribable = subscribableFromPeer(peer, view.id);
+			if (subscribable === null) {
+				this.#logger.warn("MatterJsController: peer has no attribute subscription", {
+					tags: { brokerId: this.#options.brokerId },
+					meta: { nodeId: view.id }
+				});
+				continue;
+			}
+			peers.push(subscribable);
+		}
+		await this.#subscriptions.sync(peers);
+	}
 	async getNode(nodeId) {
 		return (await this.listNodes()).find((n) => n.nodeId === nodeId) ?? null;
 	}
@@ -198268,6 +199416,25 @@ var MatterJsController = class {
 			throw err;
 		}
 	}
+	async #openProductionServer() {
+		const environment = this.#buildEnvironment();
+		const server = await ServerNode.create({
+			environment,
+			id: this.#options.brokerId
+		});
+		return {
+			start: () => server.start(),
+			close: () => server.close(),
+			listPeers: () => this.#serverPeers(server),
+			commission: ({ pairingCode, onPase }) => server.peers.commission({
+				pairingCode,
+				continueCommissioningAfterPase: () => {
+					onPase();
+					return true;
+				}
+			})
+		};
+	}
 	#buildEnvironment() {
 		const env = require_esm.Environment.default;
 		env.vars.set("storage.path", this.#options.dataDir);
@@ -198280,13 +199447,13 @@ var MatterJsController = class {
 		return this.#server;
 	}
 	/** Iterate the commissioned peers of a ServerNode (cast-free). */
-	#peers(server) {
+	#serverPeers(server) {
 		const peers = server.peers;
 		if (isIterable(peers)) return peers;
 		return [];
 	}
 	#findPeer(server, nodeId) {
-		for (const peer of this.#peers(server)) {
+		for (const peer of server.listPeers()) {
 			const view = this.#viewPeer(peer);
 			if (view !== null && view.id === nodeId) return view;
 		}
@@ -198294,12 +199461,23 @@ var MatterJsController = class {
 	}
 	/** Raw (un-viewed) peer object for operations that call its methods. */
 	#rawPeer(server, nodeId) {
-		for (const peer of this.#peers(server)) {
+		for (const peer of server.listPeers()) {
 			const view = this.#viewPeer(peer);
 			if (view !== null && view.id === nodeId) return peer;
 		}
 		return null;
 	}
+	#progress(progress) {
+		this.#options.onCommissionProgress?.(progress);
+	}
+	#failCommission(message) {
+		const failure = classifyCommissionError(message);
+		this.#progress({
+			phase: CommissionPhase.Failed,
+			failure,
+			message: commissionFailureMessage(failure, message)
+		});
+	}
 	/** Reduce a peer to the read-only view the addon models. */
 	#viewPeer(peer) {
 		if (!isRecord(peer)) return null;
@@ -198343,7 +199521,7 @@ var MatterJsController = class {
 	#emitAllReports() {
 		const server = this.#server;
 		if (server === null) return;
-		for (const peer of this.#peers(server)) {
+		for (const peer of server.listPeers()) {
 			const view = this.#viewPeer(peer);
 			if (view === null) continue;
 			for (const ep of readNodeEndpoints(view.rootEndpoint)) for (const attr of ep.attributes) {
@@ -198359,6 +199537,7 @@ var MatterJsController = class {
 		}
 	}
 	#emitIfChanged(report) {
+		if (report.value === void 0 || report.value === null) return;
 		const key = `${report.nodeId}:${report.endpointId}:${report.clusterId}:${report.attributeId}`;
 		const prev = this.#lastValues.get(key);
 		if (prev !== void 0 && shallowEqual(prev, report.value)) return;
@@ -198444,12 +199623,24 @@ var MatterNodeResolver = class {
 	#attrs = /* @__PURE__ */ new Map();
 	/** Live attribute-report subscribers (endpoint device classes). */
 	#listeners = /* @__PURE__ */ new Set();
+	/** Adopted container id per Matter node, for subscription logs. */
+	#deviceIds = /* @__PURE__ */ new Map();
 	/**
 	* Subscribe to live attribute reports across all brokers. Endpoint device
 	* classes subscribe on activate (filtering to their own node/endpoint) so a
 	* push report decodes straight into their runtime-state slice. Returns a
 	* disposer.
 	*/
+	/** Remember the CamStack container id for a commissioned node. */
+	bindDevice(nodeId, deviceId) {
+		this.#deviceIds.set(nodeId, deviceId);
+	}
+	unbindDevice(nodeId) {
+		this.#deviceIds.delete(nodeId);
+	}
+	deviceIdFor(nodeId) {
+		return this.#deviceIds.get(nodeId) ?? null;
+	}
 	onAttributeReport(listener) {
 		this.#listeners.add(listener);
 		return () => {
@@ -198511,6 +199702,7 @@ var MatterNodeResolver = class {
 		this.#nodes.clear();
 		this.#attrs.clear();
 		this.#listeners.clear();
+		this.#deviceIds.clear();
 	}
 };
 /** The single in-process per-broker node resolver shared across the addon. */
@@ -198570,6 +199762,7 @@ var MatterIntegrationManager = class {
 	#nodeCount = 0;
 	#lastCheckedAt = null;
 	#error = null;
+	#commission = IDLE_COMMISSION_PROGRESS;
 	constructor(options) {
 		this.#id = options.id;
 		this.#name = options.name;
@@ -198580,7 +199773,17 @@ var MatterIntegrationManager = class {
 		this.#onDisconnected = options.onDisconnected;
 		this.#onNodesChanged = options.onNodesChanged;
 		this.#onAttributeReport = options.onAttributeReport;
-		this.#makeController = options.makeController ?? ((opts) => new MatterJsController(opts, this.#logger));
+		this.#makeController = options.makeController ?? ((opts) => new MatterJsController({
+			...opts,
+			onCommissionProgress: (progress) => {
+				this.#commission = progress;
+			},
+			resolveDeviceId: (nodeId) => matterNodes.deviceIdFor(nodeId)
+		}, this.#logger));
+	}
+	/** Latest commissioning phase for `broker.getState({ key: 'commission' })`. */
+	getCommissionProgress() {
+		return this.#commission;
 	}
 	/** The connection settings the manager is currently configured with. */
 	getConnection() {
@@ -198655,6 +199858,7 @@ var MatterIntegrationManager = class {
 		if (controller === null) return;
 		try {
 			const nodes = await controller.listNodes();
+			await controller.syncSubscriptions();
 			this.#nodeCount = nodes.length;
 			this.#lastCheckedAt = Date.now();
 			matterNodes.setNodes(this.#id, nodes);
@@ -198835,6 +200039,10 @@ var MatterBrokerRegistry = class {
 		if (!mgr) throw new Error(`MatterBrokerRegistry: unknown broker id "${brokerId}"`);
 		return mgr.commissionNode(pairingCode);
 	}
+	getCommissionProgress(brokerId) {
+		const mgr = this.#managers.get(brokerId);
+		return mgr ? mgr.getCommissionProgress() : null;
+	}
 	async removeNode(brokerId, nodeId) {
 		const mgr = this.#managers.get(brokerId);
 		if (!mgr) throw new Error(`MatterBrokerRegistry: unknown broker id "${brokerId}"`);
@@ -198937,6 +200145,26 @@ function toRecord(value) {
 function settingsToMatterConnection(settings) {
 	return matterConnectionSchema.parse(toRecord(settings));
 }
+/**
+* Settings readers see an empty string for both secrets. The stored value
+* stays in the keychain (records `secret` meta). An empty round-trip must
+* not wipe it — see {@link mergeMatterSecrets}.
+*/
+function publicMatterConnection(connection) {
+	return {
+		...connection,
+		wifiPassword: "",
+		threadDataset: ""
+	};
+}
+/** Keep a stored secret when the form sent back the redacted empty string. */
+function mergeMatterSecrets(existing, incoming) {
+	return {
+		...incoming,
+		wifiPassword: incoming.wifiPassword.length > 0 ? incoming.wifiPassword : existing.wifiPassword,
+		threadDataset: incoming.threadDataset.length > 0 ? incoming.threadDataset : existing.threadDataset
+	};
+}
 /** Hand-written connection form for the broker/integration creation UI. */
 function buildConnectionFormSchema() {
 	return { sections: [{
@@ -198948,9 +200176,10 @@ function buildConnectionFormSchema() {
 		columns: 1,
 		fields: [
 			{
-				type: "text",
+				type: "password",
 				key: "threadDataset",
 				secret: true,
+				showToggle: true,
 				label: "Thread operational dataset (hex, optional)",
 				labelKey: "matter-broker:connection.s_matter-fabric.threadDataset.label",
 				placeholder: "0e08000000000001…"
@@ -199027,17 +200256,14 @@ var MATTER_KIND = "matter";
 * Construct the `broker` cap provider for the Matter addon. Pure builder.
 * Mirrors `buildEcowittBrokerProvider`. The defining Matter operation —
 * commissioning — is surfaced through `publish` with
-* `target: { action: 'commissionNode' }` and `payload: { pairingCode }`. The
-* Wi-Fi password is the only secret; it is redacted on settings reads and
-* preserved on an empty round-trip.
+* `target: { action: 'commissionNode' }` and `payload: { pairingCode }`.
+* `threadDataset` and `wifiPassword` are redacted on settings reads and
+* preserved on an empty round-trip. Fabric keys stay in matter.js storage.
 */
 function buildMatterBrokerProvider(deps) {
 	const { ownerAddonId, registry, getBrokers, persistBrokers, cascadeRemoveDevices, logger } = deps;
 	const owns = (id) => getBrokers().some((b) => b.id === id);
-	const redact = (entry) => ({
-		...entry.connection,
-		wifiPassword: ""
-	});
+	const redact = (entry) => publicMatterConnection(entry.connection);
 	return {
 		list: async ({ kind }) => {
 			if (kind && kind !== MATTER_KIND) return [];
@@ -199105,10 +200331,7 @@ function buildMatterBrokerProvider(deps) {
 			const existing = getBrokers().find((b) => b.id === id);
 			if (!existing) return;
 			const parsed = settingsToMatterConnection(settings);
-			const merged = {
-				...parsed,
-				wifiPassword: parsed.wifiPassword.length > 0 ? parsed.wifiPassword : existing.connection.wifiPassword
-			};
+			const merged = mergeMatterSecrets(existing.connection, parsed);
 			const updated = await registry.updateEntry(id, merged);
 			await persistBrokers(getBrokers().map((b) => b.id === id ? updated : b));
 		},
@@ -199144,7 +200367,7 @@ function buildMatterBrokerProvider(deps) {
 			if (!owns(brokerId)) throw new Error(`matter: unknown broker ${brokerId}`);
 			const action = typeof target["action"] === "string" ? target["action"] : void 0;
 			if (action === "commissionNode") {
-				const code = typeof payload === "object" && payload !== null && "pairingCode" in payload ? String(payload["pairingCode"] ?? "") : "";
+				const code = pairingCodeFromPayload(payload);
 				parsePairingCode(code);
 				return registry.commissionNode(brokerId, code);
 			}
@@ -199152,13 +200375,23 @@ function buildMatterBrokerProvider(deps) {
 		},
 		subscribe: async () => ({ subscriptionId: "" }),
 		unsubscribe: async () => void 0,
-		getState: async () => null,
+		getState: async ({ brokerId, key }) => {
+			if (key !== "commission") return null;
+			return registry.getCommissionProgress(brokerId);
+		},
 		getStatus: async () => ({
 			brokerCount: registry.size(),
 			connectedCount: registry.connectedCount()
 		})
 	};
 }
+function pairingCodeFromPayload(payload) {
+	if (typeof payload !== "object" || payload === null || !("pairingCode" in payload)) return "";
+	const code = payload.pairingCode;
+	if (typeof code === "string") return code;
+	if (typeof code === "number" && Number.isFinite(code)) return String(code);
+	return "";
+}
 //#endregion
 //#region src/matter-discovery.ts
 /**
@@ -199389,6 +200622,27 @@ function setBrokerDevicesOnline(devices, brokerId, online) {
 	return count;
 }
 //#endregion
+//#region src/matter-lock-command.ts
+/**
+* Decide the command arguments. `pinRequired` comes from the live
+* RequirePinForRemoteOperation attribute, not from a stored secret.
+*/
+function planDoorLockCommand(input) {
+	const code = input.code?.trim() ?? "";
+	if (input.pinRequired && code.length === 0) return {
+		ok: false,
+		reason: "pin-required"
+	};
+	if (code.length > 0) return {
+		ok: true,
+		args: { pinCode: code }
+	};
+	return {
+		ok: true,
+		args: {}
+	};
+}
+//#endregion
 //#region src/devices/matter-endpoint-device.ts
 /**
 * Persisted config every Matter endpoint child carries. `nodeId`/`endpointId`
@@ -199480,7 +200734,8 @@ var COLD_POWER = { lastFetchedAt: 0 };
 * arrives, each cap reads its cold-start default.
 */
 var MatterEndpointDevice = class extends BaseDevice {
-	features = [];
+	/** Live RequirePinForRemoteOperation. Commands read this, not a stored PIN. */
+	pinRequired = false;
 	brokerId;
 	nodeId;
 	endpointId;
@@ -199494,12 +200749,17 @@ var MatterEndpointDevice = class extends BaseDevice {
 		this.nodeId = persisted.nodeId;
 		this.endpointId = persisted.endpointId;
 		this.caps = persisted.capabilities.filter(isKnownCap);
+		this.pinRequired = matterNodes.getAttribute(this.brokerId, this.nodeId, this.endpointId, MatterClusterId.DoorLock, MatterAttributeId.RequirePinForRemoteOperation) === true;
 		this.online = matterNodes.getNode(this.brokerId, this.nodeId)?.online ?? true;
 		this.updateSourceInfo({
 			id: `${this.nodeId}:${this.endpointId}`,
 			system: "matter"
 		});
 	}
+	/** PIN-required locks advertise the feature the lock UI already understands. */
+	get features() {
+		return this.pinRequired ? [DeviceFeature.LockPinRequired] : [];
+	}
 	async onActivate() {
 		await super.onActivate();
 		for (const cap of this.caps) {
@@ -199527,7 +200787,29 @@ var MatterEndpointDevice = class extends BaseDevice {
 			value: report.value
 		});
 		if (decoded === null) return;
+		if (decoded.detail === "pin-required" || decoded.detail === "pin-not-required") {
+			const next = decoded.detail === "pin-required";
+			if (next !== this.pinRequired) {
+				this.pinRequired = next;
+				this.ctx.logger.info("Matter lock PIN requirement changed", {
+					tags: { deviceId: this.id },
+					meta: {
+						nodeId: this.nodeId,
+						endpointId: this.endpointId,
+						pinRequired: next
+					}
+				});
+			}
+		} else if (decoded.detail !== void 0) this.ctx.logger.info("Matter lock detail", {
+			tags: { deviceId: this.id },
+			meta: {
+				nodeId: this.nodeId,
+				endpointId: this.endpointId,
+				detail: decoded.detail
+			}
+		});
 		if (!this.registeredCaps.has(decoded.cap)) return;
+		if (Object.keys(decoded.patch).length === 0) return;
 		this.runtimeState.patchCapState(CAP_SLICE_NAME[decoded.cap], decoded.patch);
 	}
 	/** Invoke a cluster command on this endpoint via the live controller. */
@@ -199623,30 +200905,52 @@ var MatterEndpointDevice = class extends BaseDevice {
 		};
 		this.ctx.registerNativeCap(lockControlCapability, {
 			getStatus: async () => this.runtimeState.getCapState("lock-control") ?? COLD,
-			lock: async () => {
-				await this.invoke(MatterClusterId.DoorLock, "lockDoor");
-				this.runtimeState.setCapState("lock-control", {
-					state: "locked",
-					lastChangedAt: Date.now()
-				});
+			lock: async ({ code }) => {
+				await this.invokeLock("lockDoor", "locking", code);
 			},
-			unlock: async () => {
-				await this.invoke(MatterClusterId.DoorLock, "unlockDoor");
-				this.runtimeState.setCapState("lock-control", {
-					state: "unlocked",
-					lastChangedAt: Date.now()
-				});
+			unlock: async ({ code }) => {
+				await this.invokeLock("unlockDoor", "unlocking", code);
 			},
 			open: async () => {
-				await this.invoke(MatterClusterId.DoorLock, "unlockDoor");
-				this.runtimeState.setCapState("lock-control", {
-					state: "unlocked",
-					lastChangedAt: Date.now()
-				});
+				await this.invokeLock("unlockDoor", "unlocking", void 0);
 			}
 		});
 		this.runtimeState.setCapState("lock-control", COLD);
 	}
+	/**
+	* Send lockDoor / unlockDoor. The final locked/unlocked state arrives on the
+	* attribute subscription — this method only records the in-flight transition.
+	* A PIN is forwarded on the command and nowhere else.
+	*/
+	async invokeLock(commandName, pending, code) {
+		const plan = planDoorLockCommand({
+			pinRequired: this.pinRequired,
+			code
+		});
+		if (!plan.ok) {
+			this.ctx.logger.warn("Matter lock command refused: PIN required and none was provided", {
+				tags: { deviceId: this.id },
+				meta: {
+					nodeId: this.nodeId,
+					endpointId: this.endpointId,
+					commandName
+				}
+			});
+			throw new Error("matter-broker: this lock requires a PIN for remote operation");
+		}
+		const previous = this.runtimeState.getCapState("lock-control");
+		this.runtimeState.setCapState("lock-control", {
+			state: pending,
+			lastChangedAt: Date.now()
+		});
+		try {
+			const args = "pinCode" in plan.args ? plan.args : void 0;
+			await this.invoke(MatterClusterId.DoorLock, commandName, args);
+		} catch (err) {
+			if (previous !== void 0) this.runtimeState.setCapState("lock-control", previous);
+			throw err;
+		}
+	}
 	registerCover() {
 		const COLD = {
 			state: "closed",
@@ -199867,11 +201171,16 @@ var MatterNodeDevice = class extends BaseDevice {
 		this.nodeId = cfg.nodeId;
 		this.integrationId = cfg.integrationId;
 		this.online = matterNodes.getNode(this.brokerId, this.nodeId)?.online ?? false;
+		matterNodes.bindDevice(this.nodeId, this.id);
 		this.updateSourceInfo({
 			id: this.nodeId,
 			system: "matter"
 		});
 	}
+	async removeDevice() {
+		matterNodes.unbindDevice(this.nodeId);
+		await super.removeDevice();
+	}
 	getAccessoryChildren() {
 		const specs = [];
 		for (const endpoint of this.config.values.endpoints) {