@camstack/addon-matter-broker 0.2.148 → 0.2.150

package/dist/addon.js

@@ -13,7 +13,7 @@ let node_stream_promises = require("node:stream/promises");
 let node_net = require("node:net");
 let node_dgram = require("node:dgram");
 node_dgram = require_esm.__toESM(node_dgram, 1);
-//#region ../types/dist/event-category-DHXxB8t9.mjs
+//#region ../types/dist/event-category-CT-hz5Rb.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -339,6 +339,14 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	/** The recovery edge of {@link PipelineMotionNoisy}: the motion fell back, or a detection arrived. */
 	EventCategory["PipelineMotionCalm"] = "pipeline.motion-calm";
 	/**
+	* A camera's package LLM confirm has failed closed three times in a row
+	* (D931, 2026-10-26). One edge per camera until
+	* {@link PipelinePackageLlmAnswered}.
+	*/
+	EventCategory["PipelinePackageLlmSilent"] = "pipeline.package-llm-silent";
+	/** The recovery edge of {@link PipelinePackageLlmSilent}: a confirm returned yes or no. */
+	EventCategory["PipelinePackageLlmAnswered"] = "pipeline.package-llm-answered";
+	/**
 	* Per-camera pipeline config was mutated by the orchestrator
 	* (a settings change via `setAgentInferenceDevices` /
 	* `setCameraStepToggle` / `setCameraStepSettings`). Orchestrator
@@ -5581,7 +5589,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-CARd6wZF.mjs
+//#region ../types/dist/sleep-bykKrTgu.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6596,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) {
@@ -6625,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;
 	});
@@ -6636,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;
@@ -6644,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;
@@ -6675,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]));
@@ -6699,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);
@@ -8362,6 +8370,53 @@ var READING_QUANTITIES = [
 ];
 var ReadingQuantitySchema = _enum(READING_QUANTITIES);
 new Set(READING_QUANTITIES);
+/**
+* Stored unit symbol for a quantity. `none` means the number is dimensionless
+* (or an index / ratio / count). `device` means the cap has no single unit.
+*/
+var QUANTITY_BASE = {
+	temperature: "°C",
+	pressure: "hPa",
+	speed: "m/s",
+	precipitation: "mm",
+	"precipitation-rate": "mm/h",
+	length: "m",
+	area: "m²",
+	illuminance: "lx",
+	irradiance: "W/m²",
+	power: "W",
+	energy: "kWh",
+	voltage: "V",
+	current: "A",
+	"apparent-power": "VA",
+	humidity: "%",
+	percentage: "%",
+	"concentration-volume": "ppm",
+	"concentration-mass": "µg/m³",
+	"concentration-ppb": "ppb",
+	volume: "L",
+	duration: "s",
+	"duration-ms": "ms",
+	information: "B",
+	"sound-level": "dBFS",
+	"signal-level": "dBm",
+	"colour-temperature": "mired",
+	angle: "°",
+	bitrate: "kbps",
+	rate: "fps",
+	mass: "kg",
+	index: "none",
+	ratio: "none",
+	count: "none",
+	none: "none",
+	device: "device"
+};
+/** The stored unit, or `undefined` when the quantity has no unit symbol. */
+function baseUnitOf(quantity) {
+	const symbol = QUANTITY_BASE[quantity];
+	if (symbol === "none" || symbol === "device") return void 0;
+	return symbol;
+}
 function readingMeta(quantity, extras) {
 	return {
 		quantity,
@@ -8915,6 +8970,8 @@ var CAP_NAMES = Object.freeze([
 	"filesystem-browse",
 	"flood",
 	"gas",
+	"group-commands",
+	"group-status",
 	"heating-valve",
 	"humidifier",
 	"humidity-sensor",
@@ -9733,6 +9790,20 @@ Object.freeze({
 		"path": "detected",
 		"valueType": "boolean"
 	}],
+	"group-status": [
+		{
+			"path": "included",
+			"valueType": "number"
+		},
+		{
+			"path": "excluded",
+			"valueType": "number"
+		},
+		{
+			"path": "total",
+			"valueType": "number"
+		}
+	],
 	"heating-valve": [{
 		"path": "position",
 		"valueType": "number"
@@ -11074,7 +11145,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-kEl9mevu.mjs
+//#region ../types/dist/composition-OhpuespA.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -11187,7 +11258,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;
 }
@@ -11200,7 +11271,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`);
@@ -11237,29 +11308,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");
@@ -11268,15 +11339,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");
 		}
@@ -11305,13 +11376,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) {
@@ -11337,11 +11408,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;
@@ -11358,7 +11429,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");
 		}
 	},
@@ -11829,15 +11900,74 @@ function validateExpressionSource(src) {
 	}
 	return null;
 }
-/** 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). */
-var MAX_COMPOSITION_CODE_LENGTH = 2e4;
+/**
+* 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).
+*/
 var CompositionSourceRefSchema = object({
 	/** The owning addon; `stableId` is unique only within it. */
 	addonId: string$2().min(1),
 	stableId: string$2().min(1)
 });
+var GROUP_TEMPLATE_IDS = [
+	"temperature",
+	"humidity",
+	"pressure",
+	"illuminance",
+	"power",
+	"energy",
+	"battery",
+	"numeric",
+	"motion",
+	"contact",
+	"leak",
+	"smoke",
+	"occupancy",
+	"binary",
+	"switch",
+	"light"
+];
+var NUMERIC_AGGREGATES = [
+	"mean",
+	"median",
+	"min",
+	"max",
+	"sum"
+];
+var BINARY_AGGREGATES = ["any", "all"];
+/** How an actuator group decides it is on. Unknown members never count as off. */
+var ACTIVE_CRITERIA = ["at-least-one", "all"];
+var AGGREGATE_REDUCERS = [
+	"mean",
+	"median",
+	"min",
+	"max",
+	"sum",
+	"any",
+	"all"
+];
+var GroupTemplateIdSchema = _enum(GROUP_TEMPLATE_IDS);
+var AggregateReducerSchema = _enum(AGGREGATE_REDUCERS);
+var ActiveCriterionSchema = _enum(ACTIVE_CRITERIA);
+/** One member. The field is stored so occupancy can name motion or binary. */
+var HelperMemberSchema = object({
+	source: CompositionSourceRefSchema,
+	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()
+})]);
+/** 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). */
+var MAX_COMPOSITION_CODE_LENGTH = 2e4;
 /** One field of one capability of one source device. */
 var CompositionFieldReadSchema = object({
 	source: CompositionSourceRefSchema,
@@ -11881,7 +12011,33 @@ var CompositionCodeSourceSchema = object({
 var CompositionFieldSourceSchema = discriminatedUnion("kind", [
 	CompositionFromSourceSchema,
 	CompositionExpressionSourceSchema,
-	CompositionCodeSourceSchema
+	CompositionCodeSourceSchema,
+	object({
+		kind: literal("aggregate"),
+		reducer: _enum([
+			"mean",
+			"median",
+			"min",
+			"max",
+			"sum",
+			"any",
+			"all"
+		]),
+		reads: array(CompositionFieldReadSchema).min(1).max(64),
+		/** `value` is the reading; the others are the member counts. */
+		publish: _enum([
+			"value",
+			"included",
+			"excluded",
+			"total"
+		]),
+		/** What a `value` publish does when nobody is included. Counts ignore this. */
+		empty: _enum([
+			"null",
+			"omit",
+			"offline"
+		])
+	})
 ]);
 var CompositionCommandTargetSchema = discriminatedUnion("kind", [object({
 	kind: literal("forward"),
@@ -11927,7 +12083,13 @@ var CompositionSchema = object({
 		kind: literal("existing"),
 		device: CompositionSourceRefSchema
 	})]),
-	features: array(CompositionFeatureSchema).min(1).max(16)
+	features: array(CompositionFeatureSchema).min(1).max(16),
+	/**
+	* Present when the block is a helper template. Absent on a free
+	* composition (the room example, device 4603). The editor reads this,
+	* never the compiled features.
+	*/
+	helper: HelperSpecSchema.optional()
 }).superRefine((composition, ctx) => {
 	const seen = /* @__PURE__ */ new Set();
 	composition.features.forEach((feature, index) => {
@@ -18185,7 +18347,10 @@ var CompositionProblemSchema = object({
 		"target-missing",
 		"target-unreadable",
 		"not-replaceable",
-		"native-capability-replace"
+		"native-capability-replace",
+		"mixed-quantity",
+		"helper-mismatch",
+		"member-constraint"
 	]),
 	path: string$2(),
 	message: string$2()
@@ -18206,7 +18371,8 @@ var CompositionUnavailableModeSchema = _enum([
 	"null",
 	"offline",
 	"unknown",
-	"release"
+	"release",
+	"omit"
 ]);
 /**
 * `derived` reads a source · `clock` reads only `now`, recomputed when a sibling
@@ -18420,6 +18586,275 @@ Object.freeze({
 		result: ["number", "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 = {
+	fieldPath: "lastFetchedAt",
+	expr: "now"
+};
+var CHANGED = {
+	fieldPath: "lastChangedAt",
+	expr: "now"
+};
+function numeric(input) {
+	return {
+		...input,
+		family: "numeric",
+		deviceType: DeviceType.Sensor,
+		memberDeviceType: DeviceType.Sensor,
+		commandCaps: [],
+		baseUnit: baseUnitOf(input.quantity),
+		aggregates: NUMERIC_AGGREGATES,
+		accept: [{
+			cap: input.outputCap,
+			fieldPath: input.outputField
+		}]
+	};
+}
+function binary(input) {
+	return {
+		...input,
+		family: "binary",
+		deviceType: DeviceType.Sensor,
+		memberDeviceType: DeviceType.Sensor,
+		commandCaps: [],
+		quantity: "none",
+		baseUnit: void 0,
+		aggregates: BINARY_AGGREGATES,
+		empty: "offline"
+	};
+}
+var GROUP_TEMPLATES = [
+	numeric({
+		id: "temperature",
+		summary: "Mean, median, min, max or sum of temperatures. Offline and unknown members are left out, never read as 0 °C.",
+		role: DeviceRole.TemperatureSensor,
+		outputCap: "temperature-sensor",
+		outputField: "celsius",
+		quantity: "temperature",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "humidity",
+		summary: "Humidity in percent. Offline and unknown members are left out, never read as 0 %.",
+		role: DeviceRole.HumiditySensor,
+		outputCap: "humidity-sensor",
+		outputField: "percent",
+		quantity: "humidity",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "pressure",
+		summary: "Pressure in hectopascals. Offline and unknown members are left out, never read as 0 hPa.",
+		role: DeviceRole.PressureSensor,
+		outputCap: "pressure-sensor",
+		outputField: "hpa",
+		quantity: "pressure",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "illuminance",
+		summary: "Illuminance in lux. Offline and unknown members are left out, never read as 0 lx.",
+		role: DeviceRole.AmbientLightSensor,
+		outputCap: "ambient-light-sensor",
+		outputField: "lux",
+		quantity: "illuminance",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "power",
+		summary: "Power in watts, summed by default. Nobody reporting omits the key rather than writing 0 W.",
+		role: DeviceRole.PowerSensor,
+		outputCap: "power-meter",
+		outputField: "watts",
+		quantity: "power",
+		defaultAggregate: "sum",
+		empty: "omit",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "energy",
+		summary: "Energy in kilowatt-hours, summed by default. Nobody reporting omits the key rather than writing 0 kWh.",
+		role: DeviceRole.EnergySensor,
+		outputCap: "power-meter",
+		outputField: "kwhTotal",
+		quantity: "energy",
+		defaultAggregate: "sum",
+		empty: "omit",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "battery",
+		summary: "Battery charge in percent. Offline and unknown members are left out, never read as 0 %.",
+		role: DeviceRole.BatterySensor,
+		outputCap: "battery",
+		outputField: "percentage",
+		quantity: "percentage",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [
+			{
+				fieldPath: "charging",
+				expr: "\"unknown\""
+			},
+			{
+				fieldPath: "sleeping",
+				expr: "false"
+			},
+			{
+				fieldPath: "lastUpdated",
+				expr: "now"
+			}
+		]
+	}),
+	numeric({
+		id: "numeric",
+		summary: "A numeric reading in the members’ shared quantity. Mixed quantities are refused. Nobody reporting publishes null, not 0.",
+		role: DeviceRole.NumericSensor,
+		outputCap: "numeric-sensor",
+		outputField: "value",
+		quantity: "device",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	binary({
+		id: "motion",
+		summary: "Any or all motion. Offline and unknown members are left out, never read as off. Nobody reporting takes the device offline.",
+		role: DeviceRole.MotionSensor,
+		outputCap: "motion",
+		outputField: "detected",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "motion",
+			fieldPath: "detected"
+		}],
+		companions: [{
+			fieldPath: "lastDetectedAt",
+			expr: "null"
+		}, {
+			fieldPath: "autoClearAfterMs",
+			expr: "null"
+		}]
+	}),
+	binary({
+		id: "contact",
+		summary: "Any or all open contacts. Offline and unknown members are left out, never read as closed.",
+		role: DeviceRole.ContactSensor,
+		outputCap: "contact",
+		outputField: "entryOpen",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "contact",
+			fieldPath: "entryOpen"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "leak",
+		summary: "Any or all leak detections. Offline and unknown members are left out, never read as dry.",
+		role: DeviceRole.LeakSensor,
+		outputCap: "flood",
+		outputField: "flooded",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "flood",
+			fieldPath: "flooded"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "smoke",
+		summary: "Any or all smoke detections. Offline and unknown members are left out, never read as clear.",
+		role: DeviceRole.SmokeSensor,
+		outputCap: "smoke",
+		outputField: "detected",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "smoke",
+			fieldPath: "detected"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "occupancy",
+		summary: "Any or all of motion or binary sensors, published as a binary. Presence zones are not aggregated. Nobody reporting is offline, not off.",
+		role: DeviceRole.BinarySensor,
+		outputCap: "binary",
+		outputField: "on",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "motion",
+			fieldPath: "detected"
+		}, {
+			cap: "binary",
+			fieldPath: "on"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "binary",
+		summary: "Any or all generic binary sensors. Offline and unknown members are left out, never read as off.",
+		role: DeviceRole.BinarySensor,
+		outputCap: "binary",
+		outputField: "on",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "binary",
+			fieldPath: "on"
+		}],
+		companions: [CHANGED]
+	}),
+	actuator({
+		id: "switch",
+		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",
+		commandCaps: ["switch"]
+	}),
+	actuator({
+		id: "light",
+		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",
+		commandCaps: [
+			"switch",
+			"brightness",
+			"color"
+		]
+	})
+];
+function actuator(input) {
+	return {
+		...input,
+		family: "actuator",
+		role: void 0,
+		memberDeviceType: input.deviceType,
+		outputField: "on",
+		quantity: "none",
+		baseUnit: void 0,
+		aggregates: BINARY_AGGREGATES,
+		defaultAggregate: "any",
+		empty: "offline",
+		accept: [{
+			cap: "switch",
+			fieldPath: "on"
+		}],
+		companions: [CHANGED]
+	};
+}
+new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
+DeviceFeature.LightColorRgb, DeviceFeature.LightColorHsv, DeviceFeature.LightColorMired;
 `${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
 /**
 * What a composition may BUILD on a device type (G2, D676): the caps a new
@@ -45239,6 +45674,8 @@ var NcSystemEventKindSchema = _enum([
 	"detection-blind",
 	"motion-noisy",
 	"motion-calm",
+	"package-llm-silent",
+	"package-llm-answered",
 	"recording-stalled",
 	"recording-healthy",
 	"recording-degraded",
@@ -56330,6 +56767,28 @@ var PackageVersionInfoSchema = object({
 	deprecated: string$2().optional(),
 	distTags: array(string$2()).readonly()
 });
+/**
+* One published document. `ok` is markdown from the registry. `missing` means
+* the registry answered and the file was not there. `error` is a registry or
+* tarball failure — never an empty string standing in for either.
+*/
+var PackageDocBodySchema = discriminatedUnion("status", [
+	object({
+		status: literal("ok"),
+		markdown: string$2()
+	}),
+	object({ status: literal("missing") }),
+	object({
+		status: literal("error"),
+		message: string$2()
+	})
+]);
+var PackageDocsSchema = object({
+	name: string$2(),
+	version: string$2(),
+	readme: PackageDocBodySchema,
+	changelog: PackageDocBodySchema
+});
 var SearchResultSchema = object({
 	name: string$2(),
 	version: string$2(),
@@ -56548,7 +57007,10 @@ method(object({ nodeId: string$2().optional() }).optional(), array(AddonListItem
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ name: string$2() }), array(PackageVersionInfoSchema).readonly()), method(object({ addonId: string$2() }), RestartAddonResultSchema, {
+}), method(object({ name: string$2() }), array(PackageVersionInfoSchema).readonly()), method(object({
+	name: string$2().min(1),
+	version: string$2().min(1).optional()
+}), PackageDocsSchema, { auth: "admin" }), method(object({ addonId: string$2() }), RestartAddonResultSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({ packageName: string$2() }), object({ success: literal(true) }), {
@@ -59884,6 +60346,88 @@ var gasCapability = {
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
 };
+var GroupCommandsSchema = object({ 
+/** One row per member that has been commanded. A later command replaces that member's row. */
+results: array(object({
+	deviceId: number().int().nonnegative(),
+	cap: string$2().min(1),
+	method: string$2().min(1),
+	ok: boolean(),
+	error: string$2().optional(),
+	/** Ms epoch of the attempt. */
+	at: number()
+})) });
+var groupCommandsCapability = {
+	name: "group-commands",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Switch, DeviceType.Light],
+	methods: {},
+	status: {
+		schema: GroupCommandsSchema,
+		kind: "push"
+	},
+	runtimeState: GroupCommandsSchema,
+	/**
+	* Runtime-state durability: **session** — the last attempt. A restored
+	* failure would outlive the command that caused it.
+	*
+	* 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
+* series that later statistics read is the output cap's own history block.
+*/
+var GroupStatusSchema = object({
+	/** Members whose current value entered the aggregate. */
+	included: number().int().nonnegative().meta(readingMeta("count", {
+		precision: 0,
+		label: "Reporting"
+	})),
+	/** Members left out: offline, unknown, or not a finite reading (D393). */
+	excluded: number().int().nonnegative().meta(readingMeta("count", {
+		precision: 0,
+		label: "Excluded"
+	})),
+	/** `included` + `excluded`. */
+	total: number().int().nonnegative().meta(readingMeta("count", {
+		precision: 0,
+		label: "Members"
+	}))
+});
+var groupStatusCapability = {
+	name: "group-status",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [
+		DeviceType.Sensor,
+		DeviceType.Switch,
+		DeviceType.Light
+	],
+	methods: {},
+	status: {
+		schema: GroupStatusSchema,
+		kind: "push"
+	},
+	runtimeState: GroupStatusSchema,
+	/**
+	* Runtime-state durability: **session** — recomputed from members on the
+	* next source event; a restored count would outlive the readings it named.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
 var HeatingValveStatusSchema = object({
 	/** Radiator valve opening 0 (closed) .. 100 (open). Null = not yet known. */
 	position: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
@@ -61653,12 +62197,18 @@ var motionCapability = {
 	methods: { 
 	/**
 	* Pull the current motion state synchronously. Convenience shortcut
-	* for consumers that don't need the full status object; equivalent
-	* to `getStatus()?.detected ?? false`. Will likely be folded into
-	* `getStatus` once the auto-injected status surface lands in every
-	* consumer.
+	* for consumers that don't need the full status object. A composed
+	* group answers from its slice (D944): unknown throws, it is not off.
 	*/
 isDetected: method(object({ deviceId: number() }), boolean()) },
+	/**
+	* A composed motion group serves `isDetected` from `detected` (D944).
+	* Without this the cap stays uncomposable (`has-commands`).
+	*/
+	composedMethods: { isDetected: {
+		kind: "slice",
+		field: "detected"
+	} },
 	events: { 
 	/**
 	* Fires every time the runner transitions a camera between
@@ -69466,6 +70016,8 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	featureProbe: featureProbeCapability,
 	flood: floodCapability,
 	gas: gasCapability,
+	groupCommands: groupCommandsCapability,
+	groupStatus: groupStatusCapability,
 	heatingValve: heatingValveCapability,
 	humidifier: humidifierCapability,
 	humiditySensor: humiditySensorCapability,
@@ -70842,6 +71394,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"addons.getPackageDocs": {
+		capName: "addons",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"addons.getVersions": {
 		capName: "addons",
 		capScope: "system",
@@ -73950,6 +74509,20 @@ Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"groupCommands.getStatus": {
+		capName: "group-commands",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"groupStatus.getStatus": {
+		capName: "group-status",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"heatingValve.getStatus": {
 		capName: "heating-valve",
 		capScope: "device",
@@ -83772,6 +84345,37 @@ var SENSOR_CAP_VOCABULARY = {
 			icon: "flame"
 		}]
 	},
+	"group-commands": {
+		scope: "device",
+		noun: t("Group command", "Comando di gruppo")
+	},
+	"group-status": {
+		scope: "device",
+		noun: t("Group", "Gruppo"),
+		state: [
+			{
+				kind: "numeric",
+				field: "included",
+				quantity: t("the members reporting", "i membri che rispondono"),
+				label: t("Reporting", "Rispondono"),
+				icon: "users"
+			},
+			{
+				kind: "numeric",
+				field: "excluded",
+				quantity: t("the members left out", "i membri esclusi"),
+				label: t("Excluded", "Esclusi"),
+				icon: "users"
+			},
+			{
+				kind: "numeric",
+				field: "total",
+				quantity: t("the member count", "il numero di membri"),
+				label: t("Members", "Membri"),
+				icon: "sigma"
+			}
+		]
+	},
 	"humidity-sensor": {
 		scope: "device",
 		noun: t("Humidity", "Umidità"),
@@ -85237,6 +85841,16 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"groupCommands.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"groupStatus.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"heatingValve.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -87221,6 +87835,8 @@ new Map(Object.entries({
 	"detection-blind": "device-events",
 	"motion-noisy": "device-events",
 	"motion-calm": "device-events",
+	"package-llm-silent": "device-events",
+	"package-llm-answered": "device-events",
 	"recording-stalled": "device-events",
 	"recording-healthy": "device-events",
 	"recording-degraded": "device-events",
@@ -87304,6 +87920,12 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Motion without a subject",
 		kinds: ["motion-noisy", "motion-calm"]
 	},
+	{
+		id: "package-llm",
+		family: "device-events",
+		label: "Package confirm",
+		kinds: ["package-llm-silent", "package-llm-answered"]
+	},
 	{
 		id: "recording",
 		family: "device-events",
@@ -87485,6 +88107,8 @@ var DEVICE_EVENTS = [
 	"detection-blind",
 	"motion-noisy",
 	"motion-calm",
+	"package-llm-silent",
+	"package-llm-answered",
 	"recording-stalled",
 	"recording-healthy",
 	"recording-degraded",
@@ -87753,6 +88377,15 @@ new Map([
 		snapshotLabel: "Cameras with constant motion now",
 		snapshotSection: null
 	},
+	{
+		id: "package-llm-confirm",
+		family: "device-events",
+		label: "Package confirm (not answering / answering again)",
+		bad: ["package-llm-silent"],
+		recovery: ["package-llm-answered"],
+		snapshotLabel: "Cameras whose package confirm is not answering",
+		snapshotSection: null
+	},
 	{
 		id: "recording-health",
 		family: "device-events",
@@ -196883,6 +197516,7 @@ var StubMatterController = class {
 	async removeNode(_nodeId) {
 		throw new MatterControllerNotWiredError("removeNode");
 	}
+	async syncSubscriptions() {}
 };
 /**
 * Factory seam (stub default): build a {@link StubMatterController}.
@@ -197055,7 +197689,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([
@@ -197087,8 +197727,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);
 }
 /**
@@ -197110,9 +197753,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);
@@ -197336,7 +198047,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([
@@ -197348,14 +198062,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);
@@ -197366,13 +198080,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),
@@ -197396,7 +198110,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}'`);
@@ -197421,8 +198135,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);
@@ -197443,7 +198157,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);
@@ -197463,7 +198177,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;
@@ -197475,35 +198189,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 {
@@ -197523,12 +198615,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;
@@ -197536,19 +198635,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();
@@ -197569,19 +198666,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`. */
@@ -197589,12 +198716,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;
 	}
@@ -197635,6 +198781,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);
@@ -197647,13 +198812,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;
 		}
@@ -197661,12 +198826,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;
@@ -197710,7 +198886,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) {
@@ -197726,6 +198902,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;
@@ -197811,12 +198988,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 () => {
@@ -197878,6 +199067,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. */
@@ -197937,6 +199127,7 @@ var MatterIntegrationManager = class {
 	#nodeCount = 0;
 	#lastCheckedAt = null;
 	#error = null;
+	#commission = IDLE_COMMISSION_PROGRESS;
 	constructor(options) {
 		this.#id = options.id;
 		this.#name = options.name;
@@ -197947,7 +199138,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() {
@@ -198022,6 +199223,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);
@@ -198202,6 +199404,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}"`);
@@ -198304,6 +199510,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: [{
@@ -198315,9 +199541,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…"
@@ -198394,17 +199621,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 [];
@@ -198472,10 +199696,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));
 		},
@@ -198511,7 +199732,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);
 			}
@@ -198519,13 +199740,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
 /**
@@ -198756,6 +199987,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`
@@ -198847,7 +200099,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;
@@ -198861,12 +200114,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) {
@@ -198894,7 +200152,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. */
@@ -198990,30 +200270,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",
@@ -199234,11 +200536,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) {