@riddix/hamh 2.1.0-alpha.411 → 2.1.0-alpha.413

package/dist/backend/cli.js

@@ -2229,12 +2229,12 @@ var init_Diagnostic = __esm({
         const diagnostic = Array();
         format(details);
         return Diagnostic2("error", diagnostic);
-        function format({ id, message: message2, path: path8, cause }) {
+        function format({ id, message: message2, path: path9, cause }) {
           if (id) {
             diagnostic.push(Diagnostic2.squash("[", Diagnostic2.strong(id), "]"));
           }
-          if (path8) {
-            diagnostic.push(Diagnostic2.squash(path8, ":"));
+          if (path9) {
+            diagnostic.push(Diagnostic2.squash(path9, ":"));
           }
           const hasCause = cause !== void 0;
           if (hasCause) {
@@ -2324,12 +2324,12 @@ var init_Diagnostic = __esm({
         let message2;
         let rawStack;
         let id;
-        let path8;
+        let path9;
         if (error2 !== void 0 && error2 !== null) {
           if (typeof error2 === "string" || typeof error2 === "number") {
             return { message: `${error2}` };
           }
-          ({ message: message2, stack: rawStack, id, path: path8 } = error2);
+          ({ message: message2, stack: rawStack, id, path: path9 } = error2);
           if (message2 === void 0) {
             message2 = error2.toString();
           }
@@ -2348,7 +2348,7 @@ var init_Diagnostic = __esm({
           }
         }
         if (!rawStack) {
-          return { message: message2, id, path: path8 };
+          return { message: message2, id, path: path9 };
         }
         rawStack = rawStack.toString();
         rawStack = rawStack.replace(/^.*?\n\nError: /gs, "Error: ");
@@ -2403,7 +2403,7 @@ var init_Diagnostic = __esm({
         if (truncatedToParent) {
           stack.push(Diagnostic2.weak("(see parent frames)"));
         }
-        return { message: message2, id, path: path8, stack, stackLines };
+        return { message: message2, id, path: path9, stack, stackLines };
       }
       Diagnostic2.messageAndStackFor = messageAndStackFor;
     })(Diagnostic || (Diagnostic = {}));
@@ -8818,16 +8818,16 @@ var init_RuntimeService = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+general@0.16.10/node_modules/@matter/general/dist/esm/environment/VariableService.js
-function addVariable(into, path8, value) {
-  if (!path8.length) {
+function addVariable(into, path9, value) {
+  if (!path9.length) {
     return;
   }
-  const firstPathEntry = path8[0];
+  const firstPathEntry = path9[0];
   if (firstPathEntry === "__proto__" || firstPathEntry === "constructor" || firstPathEntry === "prototype") {
     throw new ImplementationError(`Invalid variable path name: ${firstPathEntry}`);
   }
   let current = into[firstPathEntry];
-  if (path8.length === 1) {
+  if (path9.length === 1) {
     if (current === void 0) {
       into[firstPathEntry] = value;
     }
@@ -8836,7 +8836,7 @@ function addVariable(into, path8, value) {
   if (typeof current !== "object") {
     current = into[firstPathEntry] = {};
   }
-  addVariable(current, path8.slice(1), value);
+  addVariable(current, path9.slice(1), value);
 }
 function parseUnixStyle(values4) {
   const variables = {};
@@ -9031,16 +9031,16 @@ var init_VariableService = __esm({
         return value;
       }
       addConfigStyle(vars) {
-        const path8 = Array();
+        const path9 = Array();
         const add = (vars2) => {
           for (const name in vars2) {
             const val = vars2[name];
             if (isObject(val)) {
-              path8.push(name);
+              path9.push(name);
               add(val);
-              path8.pop();
+              path9.pop();
             } else {
-              this.set([...path8, name].join("."), val);
+              this.set([...path9, name].join("."), val);
             }
           }
         };
@@ -11045,8 +11045,8 @@ var init_AppAddress = __esm({
               host = `${host}:${definition.transport.port}`;
             }
           }
-          const path8 = definition.path ?? "/";
-          definition = `${protocol}://${host}${path8}`;
+          const path9 = definition.path ?? "/";
+          definition = `${protocol}://${host}${path9}`;
         }
         try {
           super(definition);
@@ -16441,8 +16441,8 @@ var init_errors2 = __esm({
   "../../node_modules/.pnpm/@matter+model@0.16.10/node_modules/@matter/model/dist/esm/common/errors.js"() {
     init_esm();
     SchemaImplementationError = class extends MatterError {
-      constructor(path8, message) {
-        super(`Definition of ${path8.path ?? path8}: ${message}`);
+      constructor(path9, message) {
+        super(`Definition of ${path9.path ?? path9}: ${message}`);
       }
     };
   }
@@ -38183,10 +38183,10 @@ var init_ModelTraversal = __esm({
           if (type === void 0) {
             return;
           }
-          const path8 = type.split(".");
-          if (path8.length === 1) {
+          const path9 = type.split(".");
+          if (path9.length === 1) {
             for (const tag3 of model.allowedBaseTags) {
-              const found = this.findType(this.findParent(model), path8[0], tag3);
+              const found = this.findType(this.findParent(model), path9[0], tag3);
               if (found) {
                 return found;
               }
@@ -38194,7 +38194,7 @@ var init_ModelTraversal = __esm({
             return;
           }
           for (const tag3 of model.allowedBaseTags) {
-            const found = this.findQualifiedType(this.findParent(model), path8, tag3);
+            const found = this.findQualifiedType(this.findParent(model), path9, tag3);
             if (found) {
               return found;
             }
@@ -38489,21 +38489,21 @@ var init_ModelTraversal = __esm({
        * This is quite complicated and would be painfully slow except in practice we don't use many qualified types and
        * those we do use resolve with few failing branches in the search once the root qualifier of the name matches.
        */
-      findQualifiedType(scope, path8, tag3) {
+      findQualifiedType(scope, path9, tag3) {
         if (!scope) {
           return;
         }
         function resolve4(scope2, position = 0) {
-          if (position === path8.length - 1) {
-            return scope2.children.select(path8[position], tag3);
+          if (position === path9.length - 1) {
+            return scope2.children.select(path9[position], tag3);
           }
-          for (const subscope of scope2.children.selectAll(path8[position])) {
+          for (const subscope of scope2.children.selectAll(path9[position])) {
             const result = resolve4(subscope, position + 1);
             if (result) {
               return result;
             }
           }
-          if (position === 0 && scope2.tag === ElementTag.Matter && path8[0] === "Matter") {
+          if (position === 0 && scope2.tag === ElementTag.Matter && path9[0] === "Matter") {
             const result = resolve4(scope2, position + 1);
             if (result) {
               return result;
@@ -91490,9 +91490,9 @@ function encodeAttributePayload(attributePayload, options) {
   if (attributeData === void 0) {
     return TlvAttributeReport.encodeTlv({ attributeStatus });
   }
-  const { path: path8, schema: schema6, payload, dataVersion } = attributeData;
+  const { path: path9, schema: schema6, payload, dataVersion } = attributeData;
   return TlvAttributeReport.encodeTlv({
-    attributeData: { path: path8, data: schema6.encodeTlv(payload, options), dataVersion }
+    attributeData: { path: path9, data: schema6.encodeTlv(payload, options), dataVersion }
   });
 }
 function encodeEventPayload(eventPayload, options) {
@@ -91501,7 +91501,7 @@ function encodeEventPayload(eventPayload, options) {
     return TlvEventReport.encodeTlv({ eventStatus });
   }
   const {
-    path: path8,
+    path: path9,
     schema: schema6,
     payload,
     eventNumber,
@@ -91513,7 +91513,7 @@ function encodeEventPayload(eventPayload, options) {
   } = eventData;
   return TlvEventReport.encodeTlv({
     eventData: {
-      path: path8,
+      path: path9,
       data: schema6.encodeTlv(payload, options),
       priority: priority3,
       systemTimestamp,
@@ -91543,7 +91543,7 @@ function chunkAttributePayload(attributePayload) {
       `Cannot chunk an AttributePayload with just a attributeStatus: ${Diagnostic.json(attributePayload)}`
     );
   }
-  const { schema: schema6, path: path8, dataVersion, payload } = attributeData;
+  const { schema: schema6, path: path9, dataVersion, payload } = attributeData;
   if (!(schema6 instanceof ArraySchema) || !Array.isArray(payload)) {
     throw new MatterFlowError(
       `Cannot chunk an AttributePayload with attributeData that is not an array: ${Diagnostic.json(
@@ -91554,14 +91554,14 @@ function chunkAttributePayload(attributePayload) {
   const chunks = new Array();
   chunks.push({
     hasFabricSensitiveData,
-    attributeData: { schema: schema6, path: { ...path8, listIndex: void 0 }, payload: [], dataVersion }
+    attributeData: { schema: schema6, path: { ...path9, listIndex: void 0 }, payload: [], dataVersion }
   });
   payload.forEach((element2) => {
     chunks.push({
       hasFabricSensitiveData,
       attributeData: {
         schema: schema6.elementSchema,
-        path: { ...path8, listIndex: null },
+        path: { ...path9, listIndex: null },
         payload: element2,
         dataVersion
       }
@@ -92074,13 +92074,13 @@ var init_InteractionMessenger = __esm({
       static convertServerInteractionReport(report) {
         switch (report.kind) {
           case "attr-value": {
-            const { path: path8, value: payload, version: dataVersion, tlv: schema6 } = report;
+            const { path: path9, value: payload, version: dataVersion, tlv: schema6 } = report;
             if (schema6 === void 0) {
-              throw new InternalError(`Attribute ${path8.clusterId}/${path8.attributeId} not found`);
+              throw new InternalError(`Attribute ${path9.clusterId}/${path9.attributeId} not found`);
             }
             const data = {
               attributeData: {
-                path: path8,
+                path: path9,
                 payload,
                 schema: schema6,
                 dataVersion
@@ -92091,10 +92091,10 @@ var init_InteractionMessenger = __esm({
             return data;
           }
           case "attr-status": {
-            const { path: path8, status: status3, clusterStatus } = report;
+            const { path: path9, status: status3, clusterStatus } = report;
             const statusReport = {
               attributeStatus: {
-                path: path8,
+                path: path9,
                 status: { status: status3 }
               },
               hasFabricSensitiveData: false
@@ -92106,7 +92106,7 @@ var init_InteractionMessenger = __esm({
           }
           case "event-value": {
             const {
-              path: path8,
+              path: path9,
               value: payload,
               number: eventNumber,
               priority: priority3,
@@ -92115,7 +92115,7 @@ var init_InteractionMessenger = __esm({
             } = report;
             const data = {
               eventData: {
-                path: path8,
+                path: path9,
                 eventNumber,
                 priority: priority3,
                 epochTimestamp,
@@ -92128,10 +92128,10 @@ var init_InteractionMessenger = __esm({
             return data;
           }
           case "event-status": {
-            const { path: path8, status: status3, clusterStatus } = report;
+            const { path: path9, status: status3, clusterStatus } = report;
             const statusReport = {
               eventStatus: {
-                path: path8,
+                path: path9,
                 status: { status: status3 }
               },
               hasFabricSensitiveData: false
@@ -101110,8 +101110,8 @@ function normalizeAndDecodeReadAttributeReport(data, leftoverAttributeReports) {
       if (attributeData === void 0) {
         break;
       }
-      const { path: path8, data: tlvData } = attributeData;
-      if (path8.listIndex !== void 0) {
+      const { path: path9, data: tlvData } = attributeData;
+      if (path9.listIndex !== void 0) {
         chunkedArrayDataFound = true;
         continue;
       } else if (chunkedArrayDataFound || // We found chunked elements before so this must be array initial value now
@@ -101136,25 +101136,25 @@ function expandPathsInAttributeData(data, acceptWildcardPaths = false) {
   let lastPath;
   data.forEach((value) => {
     if (value === void 0) return;
-    const { path: path8 } = value;
-    if (path8.enableTagCompression) {
+    const { path: path9 } = value;
+    if (path9.enableTagCompression) {
       if (lastPath === void 0) throw new UnexpectedDataError("Tag compression enabled, but no previous path");
-      if (path8.nodeId === void 0 && lastPath.nodeId !== void 0) path8.nodeId = lastPath.nodeId;
-      if (path8.endpointId === void 0) path8.endpointId = lastPath.endpointId;
-      if (path8.clusterId === void 0) path8.clusterId = lastPath.clusterId;
-      if (path8.attributeId === void 0) path8.attributeId = lastPath.attributeId;
+      if (path9.nodeId === void 0 && lastPath.nodeId !== void 0) path9.nodeId = lastPath.nodeId;
+      if (path9.endpointId === void 0) path9.endpointId = lastPath.endpointId;
+      if (path9.clusterId === void 0) path9.clusterId = lastPath.clusterId;
+      if (path9.attributeId === void 0) path9.attributeId = lastPath.attributeId;
       if (value.dataVersion === void 0 && lastPath.dataVersion !== void 0)
         value.dataVersion = lastPath.dataVersion;
-    } else if (path8.endpointId !== void 0 && path8.clusterId !== void 0 && path8.attributeId !== void 0) {
+    } else if (path9.endpointId !== void 0 && path9.clusterId !== void 0 && path9.attributeId !== void 0) {
       lastPath = {
-        nodeId: path8.nodeId,
-        endpointId: path8.endpointId,
-        clusterId: path8.clusterId,
-        attributeId: path8.attributeId,
+        nodeId: path9.nodeId,
+        endpointId: path9.endpointId,
+        clusterId: path9.clusterId,
+        attributeId: path9.attributeId,
         dataVersion: value.dataVersion
       };
     } else if (!acceptWildcardPaths) {
-      throw new UnexpectedDataError("Tag compression disabled, but path is incomplete: " + Diagnostic.json(path8));
+      throw new UnexpectedDataError("Tag compression disabled, but path is incomplete: " + Diagnostic.json(path9));
     }
   });
   return data;
@@ -103077,77 +103077,77 @@ var init_errors5 = __esm({
     init_esm3();
     init_esm2();
     SchemaViolationError = class extends StatusResponseError {
-      constructor(prefix, path8, message, code) {
-        const text = `${prefix} ${path8.path ?? path8}: ${message} (${code})`;
+      constructor(prefix, path9, message, code) {
+        const text = `${prefix} ${path9.path ?? path9}: ${message} (${code})`;
         super(text, code);
         this.message = text;
       }
     };
     ReadError = class extends SchemaViolationError {
-      constructor(path8, message, code) {
-        super("Reading", path8, message, code ?? Status2.UnsupportedRead);
+      constructor(path9, message, code) {
+        super("Reading", path9, message, code ?? Status2.UnsupportedRead);
       }
     };
     WriteError = class extends SchemaViolationError {
-      constructor(path8, message, code) {
-        super("Writing", path8, message, code ?? Status2.UnsupportedWrite);
+      constructor(path9, message, code) {
+        super("Writing", path9, message, code ?? Status2.UnsupportedWrite);
       }
     };
     InvokeError = class extends SchemaViolationError {
-      constructor(path8, message, code) {
-        super("Invoking", path8, message, code ?? Status2.UnsupportedAccess);
+      constructor(path9, message, code) {
+        super("Invoking", path9, message, code ?? Status2.UnsupportedAccess);
       }
     };
     ValidateError = class extends SchemaViolationError {
-      constructor(path8, message, code) {
-        super("Validating", path8, message, code ?? Status2.InvalidDataType);
+      constructor(path9, message, code) {
+        super("Validating", path9, message, code ?? Status2.InvalidDataType);
       }
     };
     DatatypeError = class extends ValidateError {
-      constructor(path8, type, value, code) {
+      constructor(path9, type, value, code) {
         let str = `${value}`;
         if (str.length > 60) {
           str = `${str.substring(60)}\u2026`;
         }
-        super(path8, `Value "${str}" is not ${type}`, code);
+        super(path9, `Value "${str}" is not ${type}`, code);
       }
     };
     ConstraintError = class extends ValidateError {
-      constructor(schema6, path8, message) {
-        super(path8, `Constraint "${schema6.constraint}": ${message}`, Status2.ConstraintError);
+      constructor(schema6, path9, message) {
+        super(path9, `Constraint "${schema6.constraint}": ${message}`, Status2.ConstraintError);
       }
     };
     IntegerRangeError = class extends ValidateError {
-      constructor(path8, message) {
-        super(path8, message, Status2.ConstraintError);
+      constructor(path9, message) {
+        super(path9, message, Status2.ConstraintError);
       }
     };
     UnknownEnumValueError = class extends ValidateError {
-      constructor(path8, message) {
-        super(path8, message, Status2.ConstraintError);
+      constructor(path9, message) {
+        super(path9, message, Status2.ConstraintError);
       }
     };
     ConformanceError = class extends ValidateError {
-      constructor(schema6, path8, message, choice) {
+      constructor(schema6, path9, message, choice) {
         let prefix;
         if (choice) {
           prefix = `Conformance choice "${choice}"`;
         } else {
           prefix = `Conformance "${schema6.conformance}"`;
         }
-        super(path8, `${prefix}: ${message}`, Status2.ConstraintError);
+        super(path9, `${prefix}: ${message}`, Status2.ConstraintError);
       }
     };
     EnumValueConformanceError = class extends ConformanceError {
     };
     ExpiredReferenceError = class extends SchemaViolationError {
-      constructor(path8) {
-        super("Referencing", path8, "This value is no longer available because its context has exited", Status2.Failure);
+      constructor(path9) {
+        super("Referencing", path9, "This value is no longer available because its context has exited", Status2.Failure);
       }
     };
     PhantomReferenceError = class extends SchemaViolationError {
-      constructor(path8) {
-        super("Referencing", path8, "Container was removed", Status2.Failure);
+      constructor(path9) {
+        super("Referencing", path9, "Container was removed", Status2.Failure);
       }
     };
   }
@@ -103183,8 +103183,8 @@ function Read(optionsOrSelector, ...selectors) {
     isFabricFiltered: fabricFilter,
     interactionModelRevision,
     [Diagnostic.value]: () => Diagnostic.dict({
-      attributes: attributeRequests?.length ? selectors.filter(({ kind }) => kind === "attribute").map((path8) => resolvePathForSpecifier(path8)).join(", ") : void 0,
-      events: eventRequests?.length ? selectors.filter(({ kind }) => kind === "event").map((path8) => resolvePathForSpecifier(path8)).join(", ") : void 0,
+      attributes: attributeRequests?.length ? selectors.filter(({ kind }) => kind === "attribute").map((path9) => resolvePathForSpecifier(path9)).join(", ") : void 0,
+      events: eventRequests?.length ? selectors.filter(({ kind }) => kind === "event").map((path9) => resolvePathForSpecifier(path9)).join(", ") : void 0,
       dataVersionFilters: versionFilters?.length ? versionFilters.map(
         ({ path: { endpointId, clusterId: clusterId3 }, dataVersion }) => `${endpointId}/${clusterId3}=${dataVersion}`
       ).join(", ") : void 0,
@@ -103357,8 +103357,8 @@ var init_Subscribe = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+protocol@0.16.10/node_modules/@matter/protocol/dist/esm/action/request/Write.js
-function isAclOrExtensionPath(path8) {
-  const { clusterId: clusterId3, attributeId } = path8;
+function isAclOrExtensionPath(path9) {
+  const { clusterId: clusterId3, attributeId } = path9;
   return clusterId3 === AclClusterId && (attributeId === AclAttributeId || attributeId === AclExtensionAttributeId);
 }
 function Write(optionsOrData, ...data) {
@@ -103512,29 +103512,29 @@ var init_SubscribeResult = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+protocol@0.16.10/node_modules/@matter/protocol/dist/esm/common/ExpandedPath.js
-function ExpandedPath({ path: path8, matter: matter2, base, kind }) {
+function ExpandedPath({ path: path9, matter: matter2, base, kind }) {
   if (matter2 === void 0) {
     matter2 = Matter;
   }
   if (base && "path" in base) {
     base = base.path;
   }
-  const endpointIdent = path8.endpointId ?? "*";
+  const endpointIdent = path9.endpointId ?? "*";
   base = base ? base.at(endpointIdent, "endpoint") : DataModelPath(endpointIdent, "endpoint");
   let cluster2;
-  base = base.at(identityOf(matter2, ClusterModel, path8.clusterId), "cluster");
-  if ("attributeId" in path8) {
-    base = base.at("state").at(identityOf(cluster2, AttributeModel, path8.attributeId));
-    if (path8.listIndex) {
-      return base.at(path8.listIndex, "entry");
+  base = base.at(identityOf(matter2, ClusterModel, path9.clusterId), "cluster");
+  if ("attributeId" in path9) {
+    base = base.at("state").at(identityOf(cluster2, AttributeModel, path9.attributeId));
+    if (path9.listIndex) {
+      return base.at(path9.listIndex, "entry");
     }
     return base;
   }
-  if ("commandId" in path8) {
-    return base.at(identityOf(cluster2, CommandModel, path8.commandId));
+  if ("commandId" in path9) {
+    return base.at(identityOf(cluster2, CommandModel, path9.commandId));
   }
-  if ("eventId" in path8) {
-    return base.at("events").at(identityOf(cluster2, EventModel, path8.eventId));
+  if ("eventId" in path9) {
+    return base.at("events").at(identityOf(cluster2, EventModel, path9.eventId));
   }
   return base.at("*", kind ?? "element");
   function identityOf(parent, type, id) {
@@ -103621,13 +103621,13 @@ var init_PathError = __esm({
     PathError = class extends StatusResponseError {
       #id;
       #path;
-      constructor({ path: path8, status: { id, status: status3, clusterStatus }, message }) {
+      constructor({ path: path9, status: { id, status: status3, clusterStatus }, message }) {
         if (message === void 0) {
           message = capitalize(decamelize(camelize(id), " "));
         }
         super(message, status3, clusterStatus);
         this.#id = id;
-        this.#path = path8;
+        this.#path = path9;
       }
       get id() {
         return this.#id;
@@ -103651,9 +103651,9 @@ var init_WriteResult = __esm({
     ((WriteResult2) => {
       function assertSuccess(result) {
         const errors = result.filter((attr) => attr.status !== Status2.Success).map((attr) => {
-          const path8 = ExpandedPath({ ...attr, kind: "attribute" });
+          const path9 = ExpandedPath({ ...attr, kind: "attribute" });
           const status3 = new ExpandedStatus(attr);
-          return new PathError({ path: path8, status: status3 });
+          return new PathError({ path: path9, status: status3 });
         });
         if (!errors.length) {
           return;
@@ -104105,11 +104105,11 @@ var init_AttributeReadResponse = __esm({
               (this.#versions[endpointId] ?? (this.#versions[endpointId] = {}))[clusterId3] = dataVersion;
             }
           }
-          for (const path8 of attributeRequests) {
-            if (path8.endpointId === void 0 || path8.clusterId === void 0 || path8.attributeId === void 0) {
-              this.addWildcard(path8);
+          for (const path9 of attributeRequests) {
+            if (path9.endpointId === void 0 || path9.clusterId === void 0 || path9.attributeId === void 0) {
+              this.addWildcard(path9);
             } else {
-              this.addConcrete(path8);
+              this.addConcrete(path9);
             }
           }
           if (this.#dataProducers) {
@@ -104150,8 +104150,8 @@ var init_AttributeReadResponse = __esm({
       /**
        * Validate a wildcard path and update internal state.
        */
-      addWildcard(path8) {
-        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, attributeId, wildcardPathFlags } = path8;
+      addWildcard(path9) {
+        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, attributeId, wildcardPathFlags } = path9;
         if (clusterId3 === void 0 && attributeId !== void 0 && !GlobalAttrIds.has(attributeId)) {
           throw new StatusResponseError(
             `Illegal read of wildcard cluster with non-global attribute #${attributeId}`,
@@ -104166,7 +104166,7 @@ var init_AttributeReadResponse = __esm({
           this.#addProducer(function* () {
             this.#wildcardPathFlags = wpf;
             for (const endpoint2 of this.node) {
-              yield* this.readEndpointForWildcard(endpoint2, path8);
+              yield* this.readEndpointForWildcard(endpoint2, path9);
             }
           });
           return;
@@ -104175,17 +104175,17 @@ var init_AttributeReadResponse = __esm({
         if (endpoint) {
           this.#addProducer(function() {
             this.#wildcardPathFlags = wpf;
-            return this.readEndpointForWildcard(endpoint, path8);
+            return this.readEndpointForWildcard(endpoint, path9);
           });
         }
       }
       /**
        * Validate a concrete path and update internal state.
        */
-      addConcrete(path8) {
-        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, attributeId } = path8;
+      addConcrete(path9) {
+        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, attributeId } = path9;
         if (nodeId3 !== void 0 && this.nodeId !== nodeId3) {
-          this.addStatus(path8, Status2.UnsupportedNode);
+          this.addStatus(path9, Status2.UnsupportedNode);
           return;
         }
         const endpoint = this.node[endpointId];
@@ -104193,7 +104193,7 @@ var init_AttributeReadResponse = __esm({
         const attribute2 = cluster2?.type.attributes[attributeId];
         let limits;
         if (attribute2 === void 0) {
-          const modelAttr = this.node.matter.member(path8.clusterId, [ElementTag.Cluster])?.member(path8.attributeId, [ElementTag.Attribute]);
+          const modelAttr = this.node.matter.member(path9.clusterId, [ElementTag.Cluster])?.member(path9.attributeId, [ElementTag.Attribute]);
           if (modelAttr) {
             limits = AccessControl4(modelAttr).limits;
           } else {
@@ -104216,32 +104216,32 @@ var init_AttributeReadResponse = __esm({
             case AccessControl4.Authority.Granted:
               break;
             case AccessControl4.Authority.Unauthorized:
-              this.addStatus(path8, Status2.UnsupportedAccess);
+              this.addStatus(path9, Status2.UnsupportedAccess);
               return;
             case AccessControl4.Authority.Restricted:
-              this.addStatus(path8, Status2.AccessRestricted);
+              this.addStatus(path9, Status2.AccessRestricted);
               return;
             default:
               throw new InternalError(`Unsupported authorization state ${permission}`);
           }
         }
         if (endpoint === void 0) {
-          this.addStatus(path8, Status2.UnsupportedEndpoint);
+          this.addStatus(path9, Status2.UnsupportedEndpoint);
           return;
         }
         if (cluster2 === void 0) {
-          this.addStatus(path8, Status2.UnsupportedCluster);
+          this.addStatus(path9, Status2.UnsupportedCluster);
           return;
         }
         if (attribute2 === void 0 || !cluster2.type.attributes[attribute2.id]) {
-          this.addStatus(path8, Status2.UnsupportedAttribute);
+          this.addStatus(path9, Status2.UnsupportedAttribute);
           return;
         }
         if (!limits.readable) {
-          this.addStatus(path8, Status2.UnsupportedRead);
+          this.addStatus(path9, Status2.UnsupportedRead);
           return;
         }
-        const skipVersion = this.#versions?.[path8.endpointId]?.[path8.clusterId];
+        const skipVersion = this.#versions?.[path9.endpointId]?.[path9.clusterId];
         if (skipVersion !== void 0 && skipVersion === cluster2.version) {
           this.#filteredCount++;
           return;
@@ -104264,9 +104264,9 @@ var init_AttributeReadResponse = __esm({
           const value = this.#currentState[attributeId];
           const version = cluster2.version;
           logger55.debug(
-            () => `Reading attribute ${this.node.inspectPath(path8)}=${serialize(value)} (version=${version})`
+            () => `Reading attribute ${this.node.inspectPath(path9)}=${serialize(value)} (version=${version})`
           );
-          this.#addValue(path8, value, version, this.#currentCluster.type.attributes[attributeId].tlv);
+          this.#addValue(path9, value, version, this.#currentCluster.type.attributes[attributeId].tlv);
         });
       }
       /**
@@ -104279,7 +104279,7 @@ var init_AttributeReadResponse = __esm({
        *
        * TODO - skip endpoints for which subject is unauthorized as optimization
        */
-      *readEndpointForWildcard(endpoint, path8) {
+      *readEndpointForWildcard(endpoint, path9) {
         if (endpoint.wildcardPathFlags & this.#wildcardPathFlags) {
           return;
         }
@@ -104291,15 +104291,15 @@ var init_AttributeReadResponse = __esm({
           this.#currentEndpoint = endpoint;
           this.#currentCluster = void 0;
         }
-        const { clusterId: clusterId3 } = path8;
+        const { clusterId: clusterId3 } = path9;
         if (clusterId3 === void 0) {
           for (const cluster2 of endpoint) {
-            this.readClusterForWildcard(cluster2, path8);
+            this.readClusterForWildcard(cluster2, path9);
           }
         } else {
           const cluster2 = endpoint[clusterId3];
           if (cluster2 !== void 0) {
-            this.readClusterForWildcard(cluster2, path8);
+            this.readClusterForWildcard(cluster2, path9);
           }
         }
       }
@@ -104310,7 +104310,7 @@ var init_AttributeReadResponse = __esm({
        *
        * TODO - skip clusters for which subject is unauthorized
        */
-      readClusterForWildcard(cluster2, path8) {
+      readClusterForWildcard(cluster2, path9) {
         if (cluster2.type.wildcardPathFlags & this.#wildcardPathFlags) {
           return;
         }
@@ -104318,7 +104318,7 @@ var init_AttributeReadResponse = __esm({
           this.#currentCluster = cluster2;
           this.#currentState = void 0;
         }
-        const { attributeId } = path8;
+        const { attributeId } = path9;
         const skipVersion = this.#versions?.[this.#guardedCurrentEndpoint.id]?.[cluster2.type.id];
         const filteredByVersion = skipVersion !== void 0 && skipVersion === cluster2.version;
         if (attributeId === void 0) {
@@ -104331,7 +104331,7 @@ var init_AttributeReadResponse = __esm({
             return;
           }
           for (const attribute2 of cluster2.type.attributes) {
-            this.readAttributeForWildcard(attribute2, path8);
+            this.readAttributeForWildcard(attribute2, path9);
           }
         } else {
           if (filteredByVersion) {
@@ -104340,7 +104340,7 @@ var init_AttributeReadResponse = __esm({
           }
           const attribute2 = cluster2.type.attributes[attributeId];
           if (attribute2 !== void 0) {
-            this.readAttributeForWildcard(attribute2, path8);
+            this.readAttributeForWildcard(attribute2, path9);
           }
         }
       }
@@ -104349,7 +104349,7 @@ var init_AttributeReadResponse = __esm({
        *
        * Depends on state initialized by {@link #readClusterForWildcard}.
        */
-      readAttributeForWildcard(attribute2, path8) {
+      readAttributeForWildcard(attribute2, path9) {
         if (!this.#guardedCurrentCluster.type.attributes[attribute2.id]) {
           return;
         }
@@ -104364,12 +104364,12 @@ var init_AttributeReadResponse = __esm({
         }
         const value = this.#currentState[attribute2.id];
         if (value === void 0) {
-          logger55.warn(`Attribute ${this.node.inspectPath(path8)} defined and enabled but has no value.`);
+          logger55.warn(`Attribute ${this.node.inspectPath(path9)} defined and enabled but has no value.`);
           return;
         }
         this.#addValue(
           {
-            ...path8,
+            ...path9,
             endpointId: this.#guardedCurrentEndpoint.id,
             clusterId: this.#guardedCurrentCluster.type.id,
             attributeId: attribute2.id
@@ -104399,13 +104399,13 @@ var init_AttributeReadResponse = __esm({
       /**
        * Add a status value.
        */
-      addStatus(path8, status3) {
+      addStatus(path9, status3) {
         logger55.debug(
-          () => `Error reading attribute ${this.node.inspectPath(path8)}: Status=${StatusCode[status3]}(${status3})`
+          () => `Error reading attribute ${this.node.inspectPath(path9)}: Status=${StatusCode[status3]}(${status3})`
         );
         const report = {
           kind: "attr-status",
-          path: path8,
+          path: path9,
           status: status3
         };
         this.#addReportData(report);
@@ -104414,10 +104414,10 @@ var init_AttributeReadResponse = __esm({
       /**
        * Add an attribute value.
        */
-      #addValue(path8, value, version, tlv) {
+      #addValue(path9, value, version, tlv) {
         const report = {
           kind: "attr-value",
-          path: path8,
+          path: path9,
           value,
           version,
           tlv
@@ -104460,32 +104460,32 @@ var init_AttributeSubscriptionResponse = __esm({
         }
         return this.#currentClusterDirty;
       }
-      addConcrete(path8) {
-        const { endpointId, clusterId: clusterId3, attributeId } = path8;
+      addConcrete(path9) {
+        const { endpointId, clusterId: clusterId3, attributeId } = path9;
         if (this.#dirty[endpointId]?.[clusterId3]?.has(attributeId) === void 0) {
           return;
         }
-        super.addConcrete(path8);
+        super.addConcrete(path9);
       }
-      *readEndpointForWildcard(endpoint, path8) {
+      *readEndpointForWildcard(endpoint, path9) {
         this.#currentEndpointDirty = this.#dirty[endpoint.id];
         if (this.#currentEndpointDirty === void 0) {
           return;
         }
-        yield* super.readEndpointForWildcard(endpoint, path8);
+        yield* super.readEndpointForWildcard(endpoint, path9);
       }
-      readClusterForWildcard(cluster2, path8) {
+      readClusterForWildcard(cluster2, path9) {
         this.#currentClusterDirty = this.currentEndpointDirty[cluster2.type.id];
         if (this.#currentClusterDirty === void 0) {
           return;
         }
-        super.readClusterForWildcard(cluster2, path8);
+        super.readClusterForWildcard(cluster2, path9);
       }
-      readAttributeForWildcard(attribute2, path8) {
+      readAttributeForWildcard(attribute2, path9) {
         if (!this.currentClusterDirty.has(attribute2.id)) {
           return;
         }
-        super.readAttributeForWildcard(attribute2, path8);
+        super.readAttributeForWildcard(attribute2, path9);
       }
       addStatus() {
       }
@@ -104568,9 +104568,9 @@ var init_AttributeWriteResponse = __esm({
         try {
           const _writing = __using19(_stack, this.join("writing"));
           const writeResponses = new Array();
-          for (const { path: path8, data, dataVersion } of writeRequests) {
-            if (path8.endpointId === void 0 || path8.clusterId === void 0 || path8.attributeId === void 0) {
-              const responses = await this.#processWildcard(path8, data);
+          for (const { path: path9, data, dataVersion } of writeRequests) {
+            if (path9.endpointId === void 0 || path9.clusterId === void 0 || path9.attributeId === void 0) {
+              const responses = await this.#processWildcard(path9, data);
               if (responses !== void 0) {
                 writeResponses.push(...responses);
               }
@@ -104579,7 +104579,7 @@ var init_AttributeWriteResponse = __esm({
                 throw new StatusResponseError("Group writes can not be concrete paths", StatusCode.InvalidAction);
               }
               writeResponses.push(
-                await this.#writeConcrete(path8, data, dataVersion)
+                await this.#writeConcrete(path9, data, dataVersion)
               );
             }
           }
@@ -104617,8 +104617,8 @@ var init_AttributeWriteResponse = __esm({
       /**
        * Validate a wildcard path and update internal state.
        */
-      async #processWildcard(path8, value) {
-        const { nodeId: nodeId3, endpointId } = path8;
+      async #processWildcard(path9, value) {
+        const { nodeId: nodeId3, endpointId } = path9;
         if (nodeId3 !== void 0 && nodeId3 !== this.nodeId) {
           return;
         }
@@ -104638,7 +104638,7 @@ var init_AttributeWriteResponse = __esm({
             if (groupEndpoints !== void 0 && !groupEndpoints.includes(endpoint2.id)) {
               continue;
             }
-            const response = await this.#writeEndpointForWildcard(endpoint2, path8, value);
+            const response = await this.#writeEndpointForWildcard(endpoint2, path9, value);
             if (response !== void 0) {
               responses.push(response);
             }
@@ -104653,7 +104653,7 @@ var init_AttributeWriteResponse = __esm({
         }
         const endpoint = this.node[endpointId];
         if (endpoint) {
-          const response = await this.#writeEndpointForWildcard(endpoint, path8, value);
+          const response = await this.#writeEndpointForWildcard(endpoint, path9, value);
           if (response !== void 0) {
             return [response];
           }
@@ -104662,17 +104662,17 @@ var init_AttributeWriteResponse = __esm({
       /**
        * Write to a concrete path and update internal state.
        */
-      async #writeConcrete(path8, value, version) {
-        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, attributeId } = path8;
+      async #writeConcrete(path9, value, version) {
+        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, attributeId } = path9;
         if (nodeId3 !== void 0 && this.nodeId !== nodeId3) {
-          return this.#asStatus(path8, Status2.UnsupportedNode);
+          return this.#asStatus(path9, Status2.UnsupportedNode);
         }
         const endpoint = this.node[endpointId];
         const cluster2 = endpoint?.[clusterId3];
         const attribute2 = cluster2?.type.attributes[attributeId];
         let limits;
         if (attribute2 === void 0) {
-          const modelAttr = this.node.matter.member(path8.clusterId, [ElementTag.Cluster])?.member(path8.attributeId, [ElementTag.Attribute]);
+          const modelAttr = this.node.matter.member(path9.clusterId, [ElementTag.Cluster])?.member(path9.attributeId, [ElementTag.Attribute]);
           if (modelAttr) {
             limits = AccessControl4(modelAttr).limits;
           } else {
@@ -104695,39 +104695,39 @@ var init_AttributeWriteResponse = __esm({
             case AccessControl4.Authority.Granted:
               break;
             case AccessControl4.Authority.Unauthorized:
-              return this.#asStatus(path8, Status2.UnsupportedAccess);
+              return this.#asStatus(path9, Status2.UnsupportedAccess);
             case AccessControl4.Authority.Restricted:
-              return this.#asStatus(path8, Status2.AccessRestricted);
+              return this.#asStatus(path9, Status2.AccessRestricted);
             default:
               throw new InternalError(`Unsupported authorization state ${permission}`);
           }
         }
         if (endpoint === void 0) {
-          return this.#asStatus(path8, Status2.UnsupportedEndpoint);
+          return this.#asStatus(path9, Status2.UnsupportedEndpoint);
         }
         if (cluster2 === void 0) {
-          return this.#asStatus(path8, Status2.UnsupportedCluster);
+          return this.#asStatus(path9, Status2.UnsupportedCluster);
         }
         if (attribute2 === void 0 || !cluster2.type.attributes[attribute2.id]) {
-          return this.#asStatus(path8, Status2.UnsupportedAttribute);
+          return this.#asStatus(path9, Status2.UnsupportedAttribute);
         }
         if (!limits.writable) {
           this.#errorCount++;
-          return this.#asStatus(path8, Status2.UnsupportedWrite);
+          return this.#asStatus(path9, Status2.UnsupportedWrite);
         }
         if (hasRemoteActor(this.session)) {
           if (limits.timed && !this.session.timed) {
             this.#errorCount++;
-            return this.#asStatus(path8, Status2.NeedsTimedInteraction);
+            return this.#asStatus(path9, Status2.NeedsTimedInteraction);
           }
           if (limits.fabricScoped && !this.session.fabric) {
             this.#errorCount++;
-            return this.#asStatus(path8, Status2.UnsupportedAccess);
+            return this.#asStatus(path9, Status2.UnsupportedAccess);
           }
         }
         if (version !== void 0 && version !== cluster2.version) {
           this.#errorCount++;
-          return this.#asStatus(path8, Status2.DataVersionMismatch);
+          return this.#asStatus(path9, Status2.DataVersionMismatch);
         }
         if (this.#currentEndpoint !== endpoint) {
           this.#currentEndpoint = endpoint;
@@ -104735,7 +104735,7 @@ var init_AttributeWriteResponse = __esm({
         } else if (this.#currentCluster !== cluster2) {
           this.#currentCluster = cluster2;
         }
-        return await this.writeValue(attribute2, path8, value);
+        return await this.writeValue(attribute2, path9, value);
       }
       /**
        * Starts new chunk or adds to current chunk all values from {@link endpoint} selected by {@link path}.
@@ -104745,8 +104745,8 @@ var init_AttributeWriteResponse = __esm({
        *
        * TODO - skip endpoints for which subject is unauthorized as optimization
        */
-      #writeEndpointForWildcard(endpoint, path8, value) {
-        const { clusterId: clusterId3, attributeId } = path8;
+      #writeEndpointForWildcard(endpoint, path9, value) {
+        const { clusterId: clusterId3, attributeId } = path9;
         if (clusterId3 === void 0 || attributeId === void 0) {
           throw new StatusResponseError(
             "Wildcard path write must specify a clusterId and attributeId",
@@ -104759,7 +104759,7 @@ var init_AttributeWriteResponse = __esm({
         }
         const cluster2 = endpoint[clusterId3];
         if (cluster2 !== void 0) {
-          return this.#writeClusterForWildcard(cluster2, path8, value);
+          return this.#writeClusterForWildcard(cluster2, path9, value);
         }
       }
       /**
@@ -104769,17 +104769,17 @@ var init_AttributeWriteResponse = __esm({
        *
        * TODO - skip clusters for which subject is unauthorized
        */
-      #writeClusterForWildcard(cluster2, path8, value) {
+      #writeClusterForWildcard(cluster2, path9, value) {
         if (this.#currentCluster !== cluster2) {
           this.#currentCluster = cluster2;
         }
-        const { attributeId } = path8;
+        const { attributeId } = path9;
         if (attributeId === void 0) {
           throw new StatusResponseError("Wildcard path write must specify an attributeId", StatusCode.InvalidAction);
         } else {
           const attribute2 = cluster2.type.attributes[attributeId];
           if (attribute2 !== void 0) {
-            return this.#writeAttributeForWildcard(attribute2, path8, value);
+            return this.#writeAttributeForWildcard(attribute2, path9, value);
           }
         }
       }
@@ -104788,7 +104788,7 @@ var init_AttributeWriteResponse = __esm({
        *
        * Depends on state initialized by {@link #writeClusterForWildcard}.
        */
-      #writeAttributeForWildcard(attribute2, path8, value) {
+      #writeAttributeForWildcard(attribute2, path9, value) {
         if (!this.#guardedCurrentCluster.type.attributes[attribute2.id]) {
           return;
         }
@@ -104806,7 +104806,7 @@ var init_AttributeWriteResponse = __esm({
         return this.writeValue(
           attribute2,
           {
-            ...path8,
+            ...path9,
             endpointId: this.#guardedCurrentEndpoint.id,
             clusterId: this.#guardedCurrentCluster.type.id,
             attributeId: attribute2.id
@@ -104817,15 +104817,15 @@ var init_AttributeWriteResponse = __esm({
       /**
        * Add a status value.
        */
-      #asStatus(path8, status3, clusterStatus) {
+      #asStatus(path9, status3, clusterStatus) {
         if (status3 !== Status2.Success) {
           logger56.debug(
-            () => `Error writing attribute ${this.node.inspectPath(path8)}: Status=${StatusCode[status3]}(${toHex(status3)}), ClusterStatus=${clusterStatus !== void 0 ? toHex(clusterStatus) : void 0}`
+            () => `Error writing attribute ${this.node.inspectPath(path9)}: Status=${StatusCode[status3]}(${toHex(status3)}), ClusterStatus=${clusterStatus !== void 0 ? toHex(clusterStatus) : void 0}`
           );
         }
         const report = {
           kind: "attr-status",
-          path: path8,
+          path: path9,
           status: status3,
           clusterStatus
         };
@@ -104834,8 +104834,8 @@ var init_AttributeWriteResponse = __esm({
         }
         return report;
       }
-      async writeValue(attribute2, path8, value) {
-        const { attributeId, listIndex } = path8;
+      async writeValue(attribute2, path9, value) {
+        const { attributeId, listIndex } = path9;
         if (listIndex !== void 0 && listIndex !== null) {
           throw new StatusResponseError(
             `Unsupported Write path provided: listIndex === ${listIndex}`,
@@ -104846,7 +104846,7 @@ var init_AttributeWriteResponse = __esm({
           const { tlv } = attribute2;
           if (listIndex === void 0) {
             const decoded = this.#decodeWithSchema(tlv, value);
-            logger56.debug(() => `Writing attribute ${this.node.inspectPath(path8)}=${Diagnostic.json(decoded)}`);
+            logger56.debug(() => `Writing attribute ${this.node.inspectPath(path9)}=${Diagnostic.json(decoded)}`);
             const writeState = await this.#guardedCurrentCluster.openForWrite(this.session);
             writeState[attributeId] = decoded;
             await this.session.transaction?.commit();
@@ -104860,7 +104860,7 @@ var init_AttributeWriteResponse = __esm({
             const writeState = await this.#guardedCurrentCluster.openForWrite(this.session);
             const decoded = this.#decodeWithSchema(tlv.elementSchema, value);
             logger56.debug(
-              () => `Writing attribute chunk ${this.node.inspectPath(path8)} adding ${serialize(decoded)}`
+              () => `Writing attribute chunk ${this.node.inspectPath(path9)} adding ${serialize(decoded)}`
             );
             writeState[attributeId].push(decoded);
             await this.session.transaction?.commit();
@@ -104869,12 +104869,12 @@ var init_AttributeWriteResponse = __esm({
           await this.session.transaction?.rollback();
           if (StatusResponseError.is(error)) {
             this.#errorCount++;
-            return this.#asStatus(path8, error.code, error.clusterCode);
+            return this.#asStatus(path9, error.code, error.clusterCode);
           }
           throw error;
         }
         this.#successCount++;
-        return this.#asStatus(path8, Status2.Success);
+        return this.#asStatus(path9, Status2.Success);
       }
       #decodeWithSchema(tlv, value) {
         return tlv.injectField(
@@ -104972,15 +104972,15 @@ var init_CommandInvokeResponse = __esm({
           const _invoking = __using20(_stack, this.join("invoking"));
           const multipleInvokes = invokeRequests.length > 1;
           for (const command of invokeRequests) {
-            const { commandPath: path8, commandFields, commandRef } = command;
-            if (path8.endpointId === void 0 || path8.clusterId === void 0 || path8.commandId === void 0) {
+            const { commandPath: path9, commandFields, commandRef } = command;
+            if (path9.endpointId === void 0 || path9.clusterId === void 0 || path9.commandId === void 0) {
               if (multipleInvokes) {
                 throw new StatusResponseError(
                   "Wildcard path must not be used with multiple invokes",
                   StatusCode.InvalidAction
                 );
               }
-              this.#processWildcard(path8, commandRef, commandFields);
+              this.#processWildcard(path9, commandRef, commandFields);
             } else {
               if (Subject.isGroup(this.session.subject)) {
                 throw new StatusResponseError("Group commands connot be concrete paths", StatusCode.InvalidAction);
@@ -104991,7 +104991,7 @@ var init_CommandInvokeResponse = __esm({
                   StatusCode.InvalidAction
                 );
               }
-              this.#processConcrete(path8, commandRef, commandFields);
+              this.#processConcrete(path9, commandRef, commandFields);
             }
           }
           if (this.#invokers) {
@@ -105022,8 +105022,8 @@ var init_CommandInvokeResponse = __esm({
       /**
        * Process a wildcard path and invoke commands on all endpoints that match the path.
        */
-      #processWildcard(path8, commandRef, commandFields) {
-        const { clusterId: clusterId3, endpointId, commandId: commandId3 } = path8;
+      #processWildcard(path9, commandRef, commandFields) {
+        const { clusterId: clusterId3, endpointId, commandId: commandId3 } = path9;
         const isGroupPath = Subject.isGroup(this.session.subject);
         if (isGroupPath && endpointId !== void 0) {
           throw new StatusResponseError(
@@ -105051,19 +105051,19 @@ var init_CommandInvokeResponse = __esm({
             if (groupEndpoints !== void 0 && !groupEndpoints.includes(endpoint.id)) {
               continue;
             }
-            yield* this.#processEndpointForWildcard(endpoint, path8, commandRef, commandFields);
+            yield* this.#processEndpointForWildcard(endpoint, path9, commandRef, commandFields);
           }
         });
       }
       /**
        * Invoke a command specified by a concrete path
        */
-      #processConcrete(path8, commandRef, commandFields) {
-        const { endpointId, clusterId: clusterId3, commandId: commandId3 } = path8;
+      #processConcrete(path9, commandRef, commandFields) {
+        const { endpointId, clusterId: clusterId3, commandId: commandId3 } = path9;
         const pathKey = `${endpointId}-${clusterId3}-${commandId3}`;
         if (this.#registeredPaths.has(pathKey)) {
           throw new StatusResponseError(
-            `Duplicate concrete command path ${this.node.inspectPath(path8)} on batch invoke`,
+            `Duplicate concrete command path ${this.node.inspectPath(path9)} on batch invoke`,
             StatusCode.InvalidAction
           );
         }
@@ -105082,7 +105082,7 @@ var init_CommandInvokeResponse = __esm({
         const command = cluster2?.type.commands[commandId3];
         let limits;
         if (command === void 0) {
-          const modelAttr = this.node.matter.member(path8.clusterId, [ElementTag.Cluster])?.member(path8.commandId, [ElementTag.Command]);
+          const modelAttr = this.node.matter.member(path9.clusterId, [ElementTag.Cluster])?.member(path9.commandId, [ElementTag.Command]);
           if (modelAttr) {
             limits = AccessControl4(modelAttr).limits;
           } else {
@@ -105105,34 +105105,34 @@ var init_CommandInvokeResponse = __esm({
             case AccessControl4.Authority.Granted:
               break;
             case AccessControl4.Authority.Unauthorized:
-              return this.#addStatus(path8, commandRef, Status2.UnsupportedAccess);
+              return this.#addStatus(path9, commandRef, Status2.UnsupportedAccess);
             case AccessControl4.Authority.Restricted:
-              return this.#addStatus(path8, commandRef, Status2.AccessRestricted);
+              return this.#addStatus(path9, commandRef, Status2.AccessRestricted);
             default:
               throw new InternalError(`Unsupported authorization state ${permission}`);
           }
         }
         if (endpoint === void 0) {
-          return this.#addStatus(path8, commandRef, Status2.UnsupportedEndpoint);
+          return this.#addStatus(path9, commandRef, Status2.UnsupportedEndpoint);
         }
         if (cluster2 === void 0) {
-          return this.#addStatus(path8, commandRef, Status2.UnsupportedCluster);
+          return this.#addStatus(path9, commandRef, Status2.UnsupportedCluster);
         }
         if (command === void 0 || !cluster2.type.commands[command.id]) {
-          return this.#addStatus(path8, commandRef, Status2.UnsupportedCommand);
+          return this.#addStatus(path9, commandRef, Status2.UnsupportedCommand);
         }
         if (hasRemoteActor(this.session)) {
           if (limits.largeMessage && !this.session.largeMessage) {
             this.#errorCount++;
-            return this.#addStatus(path8, commandRef, Status2.InvalidTransportType);
+            return this.#addStatus(path9, commandRef, Status2.InvalidTransportType);
           }
           if (limits.fabricScoped && !this.session.fabric) {
             this.#errorCount++;
-            return this.#addStatus(path8, commandRef, Status2.UnsupportedAccess);
+            return this.#addStatus(path9, commandRef, Status2.UnsupportedAccess);
           }
           if (limits.timed && !this.session.timed) {
             this.#errorCount++;
-            return this.#addStatus(path8, commandRef, Status2.NeedsTimedInteraction);
+            return this.#addStatus(path9, commandRef, Status2.NeedsTimedInteraction);
           }
         }
         this.#addInvoker(async function* invokeConcretePath() {
@@ -105143,7 +105143,7 @@ var init_CommandInvokeResponse = __esm({
             }
             this.#currentEndpoint = endpoint;
           }
-          await this.#invokeCommand(command, path8, commandRef, commandFields, cluster2.commands[command.id]);
+          await this.#invokeCommand(command, path9, commandRef, commandFields, cluster2.commands[command.id]);
         });
       }
       /**
@@ -105154,8 +105154,8 @@ var init_CommandInvokeResponse = __esm({
        **
        * TODO - skip endpoints for which subject is unauthorized as optimization
        */
-      async *#processEndpointForWildcard(endpoint, path8, commandRef, commandFields) {
-        const { clusterId: clusterId3 } = path8;
+      async *#processEndpointForWildcard(endpoint, path9, commandRef, commandFields) {
+        const { clusterId: clusterId3 } = path9;
         if (this.#currentEndpoint !== endpoint) {
           if (this.#chunk) {
             yield this.#chunk;
@@ -105165,7 +105165,7 @@ var init_CommandInvokeResponse = __esm({
         }
         const cluster2 = endpoint[clusterId3];
         if (cluster2 !== void 0) {
-          const { commandId: commandId3 } = path8;
+          const { commandId: commandId3 } = path9;
           const command = cluster2.type.commands[commandId3];
           if (command !== void 0) {
             if (hasRemoteActor(this.session)) {
@@ -105186,7 +105186,7 @@ var init_CommandInvokeResponse = __esm({
             await this.#invokeCommand(
               command,
               {
-                ...path8,
+                ...path9,
                 endpointId: endpoint.id
               },
               commandRef,
@@ -105216,15 +105216,15 @@ var init_CommandInvokeResponse = __esm({
       /**
        * Add a status value.
        */
-      #addStatus(path8, commandRef, status3, clusterStatus) {
+      #addStatus(path9, commandRef, status3, clusterStatus) {
         if (status3 !== StatusCode.Success) {
           logger57.info(
-            () => `Invoke error ${this.node.inspectPath(path8)}: Status=${StatusCode[status3]}(${status3}), ClusterStatus=${clusterStatus}`
+            () => `Invoke error ${this.node.inspectPath(path9)}: Status=${StatusCode[status3]}(${status3}), ClusterStatus=${clusterStatus}`
           );
         }
         const response = {
           kind: "cmd-status",
-          path: path8,
+          path: path9,
           status: status3,
           clusterStatus,
           commandRef
@@ -105234,7 +105234,7 @@ var init_CommandInvokeResponse = __esm({
         }
         this.#addResponse(response);
       }
-      async #invokeCommand(command, path8, commandRef, commandFields, invoker) {
+      async #invokeCommand(command, path9, commandRef, commandFields, invoker) {
         try {
           const { requestTlv, responseTlv } = command;
           const request = this.#decodeWithSchema(requestTlv, commandFields);
@@ -105244,12 +105244,12 @@ var init_CommandInvokeResponse = __esm({
           this.#successCount++;
           const encodedResponse = responseTlv.encodeTlv(response);
           if (encodedResponse.length === 0) {
-            this.#addStatus(path8, commandRef, StatusCode.Success);
+            this.#addStatus(path9, commandRef, StatusCode.Success);
           } else {
             this.#addResponse({
               kind: "cmd-response",
               path: {
-                ...path8,
+                ...path9,
                 commandId: command.responseId
               },
               data: encodedResponse,
@@ -105272,7 +105272,7 @@ var init_CommandInvokeResponse = __esm({
             } else {
               logger57.info(errorLogText);
             }
-            this.#addStatus(path8, commandRef, errorCode, error.clusterCode);
+            this.#addStatus(path9, commandRef, errorCode, error.clusterCode);
             return;
           }
           throw error;
@@ -105338,11 +105338,11 @@ var init_EventReadResponse = __esm({
         if (isFabricFiltered) {
           this.#filteredForFabricIndex = this.session.fabric ?? FabricIndex3.NO_FABRIC;
         }
-        for (const path8 of eventRequests) {
-          if (path8.endpointId === void 0 || path8.clusterId === void 0 || path8.eventId === void 0) {
-            this.#addWildcard(path8);
+        for (const path9 of eventRequests) {
+          if (path9.endpointId === void 0 || path9.clusterId === void 0 || path9.eventId === void 0) {
+            this.#addWildcard(path9);
           } else {
-            const status3 = this.#addConcrete(path8);
+            const status3 = this.#addConcrete(path9);
             if (status3 !== void 0) {
               yield [status3];
               this.#statusCount++;
@@ -105378,8 +105378,8 @@ var init_EventReadResponse = __esm({
       /**
        * Validate a wildcard path and update the internal state.
        */
-      #addWildcard(path8) {
-        const { nodeId: nodeId3, clusterId: clusterId3, endpointId, eventId: eventId3 } = path8;
+      #addWildcard(path9) {
+        const { nodeId: nodeId3, clusterId: clusterId3, endpointId, eventId: eventId3 } = path9;
         if (clusterId3 === void 0 && eventId3 !== void 0) {
           throw new StatusResponseError("Illegal read request with wildcard cluster ID", StatusCode.InvalidAction);
         }
@@ -105388,29 +105388,29 @@ var init_EventReadResponse = __esm({
         }
         if (endpointId === void 0) {
           for (const endpoint2 of this.node) {
-            this.#addEndpointForWildcard(endpoint2, path8);
+            this.#addEndpointForWildcard(endpoint2, path9);
           }
           return;
         }
         const endpoint = this.node[endpointId];
         if (endpoint) {
-          return this.#addEndpointForWildcard(endpoint, path8);
+          return this.#addEndpointForWildcard(endpoint, path9);
         }
       }
       /**
        * Validate a concrete path and update the internal state.
        */
-      #addConcrete(path8) {
-        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, eventId: eventId3 } = path8;
+      #addConcrete(path9) {
+        const { nodeId: nodeId3, endpointId, clusterId: clusterId3, eventId: eventId3 } = path9;
         if (nodeId3 !== void 0 && this.nodeId !== nodeId3) {
-          return this.#asStatus(path8, Status2.UnsupportedNode);
+          return this.#asStatus(path9, Status2.UnsupportedNode);
         }
         const endpoint = this.node[endpointId];
         const cluster2 = endpoint?.[clusterId3];
         const event3 = cluster2?.type.events[eventId3];
         let limits;
         if (event3 === void 0) {
-          const modelEvent = this.node.matter.member(path8.clusterId, [ElementTag.Cluster])?.member(path8.eventId, [ElementTag.Event]);
+          const modelEvent = this.node.matter.member(path9.clusterId, [ElementTag.Cluster])?.member(path9.eventId, [ElementTag.Event]);
           if (modelEvent) {
             limits = AccessControl4(modelEvent).limits;
           } else {
@@ -105433,21 +105433,21 @@ var init_EventReadResponse = __esm({
             case AccessControl4.Authority.Granted:
               break;
             case AccessControl4.Authority.Unauthorized:
-              return this.#asStatus(path8, Status2.UnsupportedAccess);
+              return this.#asStatus(path9, Status2.UnsupportedAccess);
             case AccessControl4.Authority.Restricted:
-              return this.#asStatus(path8, Status2.AccessRestricted);
+              return this.#asStatus(path9, Status2.AccessRestricted);
             default:
               throw new InternalError(`Unsupported authorization state ${permission}`);
           }
         }
         if (endpoint === void 0) {
-          return this.#asStatus(path8, Status2.UnsupportedEndpoint);
+          return this.#asStatus(path9, Status2.UnsupportedEndpoint);
         }
         if (cluster2 === void 0) {
-          return this.#asStatus(path8, Status2.UnsupportedCluster);
+          return this.#asStatus(path9, Status2.UnsupportedCluster);
         }
         if (event3 === void 0 || !cluster2.type.events[event3.id]) {
-          return this.#asStatus(path8, Status2.UnsupportedEvent);
+          return this.#asStatus(path9, Status2.UnsupportedEvent);
         }
         if (this.#currentEndpoint !== endpoint) {
           this.#currentEndpoint = endpoint;
@@ -105455,7 +105455,7 @@ var init_EventReadResponse = __esm({
         } else if (this.#currentCluster !== cluster2) {
           this.#currentCluster = cluster2;
         }
-        this.#registerEventPath(path8);
+        this.#registerEventPath(path9);
       }
       /**
        * Starts new chunk or adds to current chunk all values from {@link endpoint} selected by {@link path}.
@@ -105465,20 +105465,20 @@ var init_EventReadResponse = __esm({
        *
        * TODO - skip endpoints for which subject is unauthorized
        */
-      #addEndpointForWildcard(endpoint, path8) {
+      #addEndpointForWildcard(endpoint, path9) {
         if (this.#currentEndpoint !== endpoint) {
           this.#currentEndpoint = endpoint;
           this.#currentCluster = void 0;
         }
-        const { clusterId: clusterId3 } = path8;
+        const { clusterId: clusterId3 } = path9;
         if (clusterId3 === void 0) {
           for (const cluster2 of endpoint) {
-            this.#addClusterForWildcard(cluster2, { ...path8, endpointId: endpoint.id });
+            this.#addClusterForWildcard(cluster2, { ...path9, endpointId: endpoint.id });
           }
         } else {
           const cluster2 = endpoint[clusterId3];
           if (cluster2 !== void 0) {
-            this.#addClusterForWildcard(cluster2, { ...path8, endpointId: endpoint.id });
+            this.#addClusterForWildcard(cluster2, { ...path9, endpointId: endpoint.id });
           }
         }
       }
@@ -105489,15 +105489,15 @@ var init_EventReadResponse = __esm({
        *
        * TODO - skip endpoints for which subject is unauthorized as optimization
        */
-      #addClusterForWildcard(cluster2, path8) {
+      #addClusterForWildcard(cluster2, path9) {
         if (this.#currentCluster !== cluster2) {
           this.#currentCluster = cluster2;
         }
-        const { eventId: eventId3 } = path8;
+        const { eventId: eventId3 } = path9;
         if (eventId3 === void 0) {
           for (const event3 of cluster2.type.events) {
             this.#addEventForWildcard(event3, {
-              ...path8,
+              ...path9,
               clusterId: cluster2.type.id
             });
           }
@@ -105505,7 +105505,7 @@ var init_EventReadResponse = __esm({
           const event3 = cluster2.type.events[eventId3];
           if (event3 !== void 0) {
             this.#addEventForWildcard(event3, {
-              ...path8,
+              ...path9,
               clusterId: cluster2.type.id
             });
           }
@@ -105516,24 +105516,24 @@ var init_EventReadResponse = __esm({
        *
        * Depends on state initialized by {@link #addClusterForWildcard}.
        */
-      #addEventForWildcard(event3, path8) {
+      #addEventForWildcard(event3, path9) {
         if (!this.#guardedCurrentCluster.type.events[event3.id]) {
           return;
         }
         if (hasRemoteActor(this.session) && this.session.authorityAt(event3.limits.readLevel, this.#guardedCurrentCluster.location) !== AccessControl4.Authority.Granted) {
           return;
         }
-        this.#registerEventPath({ ...path8, eventId: event3.id });
+        this.#registerEventPath({ ...path9, eventId: event3.id });
       }
-      #createEventKey(path8) {
-        const { endpointId, clusterId: clusterId3, eventId: eventId3 } = path8;
+      #createEventKey(path9) {
+        const { endpointId, clusterId: clusterId3, eventId: eventId3 } = path9;
         return `${endpointId}:${clusterId3}:${eventId3}`;
       }
-      #registerEventPath(path8) {
-        const { eventId: eventId3 } = path8;
+      #registerEventPath(path9) {
+        const { eventId: eventId3 } = path9;
         this.#allowedEventPaths.set(
           this.#createEventKey({
-            ...path8,
+            ...path9,
             endpointId: this.#guardedCurrentEndpoint.id,
             clusterId: this.#guardedCurrentCluster.type.id,
             eventId: eventId3
@@ -105563,11 +105563,11 @@ var init_EventReadResponse = __esm({
       /**
        * Add a status value.
        */
-      #asStatus(path8, status3) {
-        logger58.debug(`Error reading event ${this.node.inspectPath(path8)}: Status=${StatusCode[status3]}(${status3})`);
+      #asStatus(path9, status3) {
+        logger58.debug(`Error reading event ${this.node.inspectPath(path9)}: Status=${StatusCode[status3]}(${status3})`);
         const report = {
           kind: "event-status",
-          path: path8,
+          path: path9,
           status: status3
         };
         return report;
@@ -109223,8 +109223,8 @@ var init_DclClient = __esm({
     };
     MatterDclResponseError = class extends MatterDclError {
       response;
-      constructor(path8, error, options) {
-        super(`Error fetching ${path8} from DCL: ${error.code} - ${error.message}`, options);
+      constructor(path9, error, options) {
+        super(`Error fetching ${path9} from DCL: ${error.code} - ${error.message}`, options);
         this.response = error;
       }
     };
@@ -109234,11 +109234,11 @@ var init_DclClient = __esm({
         this.#baseUrl = this.production ? DCL_PRODUCTION_URL : DCL_TEST_URL;
       }
       #baseUrl;
-      async #fetchPaginatedJson(path8, paginatedField, options) {
+      async #fetchPaginatedJson(path9, paginatedField, options) {
         const allItems = [];
         let nextKey;
         do {
-          const currentPath = nextKey !== void 0 ? `${path8}${path8.includes("?") ? "&" : "?"}pagination.key=${encodeURIComponent(nextKey)}` : path8;
+          const currentPath = nextKey !== void 0 ? `${path9}${path9.includes("?") ? "&" : "?"}pagination.key=${encodeURIComponent(nextKey)}` : path9;
           const response = await this.#fetchJson(currentPath, options);
           const items = response[paginatedField];
           if (items && Array.isArray(items)) {
@@ -109248,8 +109248,8 @@ var init_DclClient = __esm({
         } while (nextKey);
         return allItems;
       }
-      async #fetchJson(path8, options) {
-        const url2 = new URL(path8, this.#baseUrl).toString();
+      async #fetchJson(path9, options) {
+        const url2 = new URL(path9, this.#baseUrl).toString();
         logger70.debug(`Fetching for DCL:`, url2);
         try {
           const timeoutMs = options?.timeout ?? DEFAULT_DCL_TIMEOUT;
@@ -109261,13 +109261,13 @@ var init_DclClient = __esm({
             signal: AbortSignal.timeout(timeoutMs)
           });
           if (!response.ok) {
-            throw new MatterDclResponseError(path8, await response.json());
+            throw new MatterDclResponseError(path9, await response.json());
           }
           return await response.json();
         } catch (error) {
           MatterDclResponseError.reject(error);
           throw new MatterDclResponseError(
-            path8,
+            path9,
             {
               code: 500,
               message: error.message ?? error,
@@ -109287,8 +109287,8 @@ var init_DclClient = __esm({
         return certList.approvedRootCertificates.certs;
       }
       async fetchRootCertificateBySubject(subject, options) {
-        const path8 = `/dcl/pki/certificates/${encodeURIComponent(subject.subject)}/${encodeURIComponent(subject.subjectKeyId)}`;
-        const response = await this.#fetchJson(path8, options);
+        const path9 = `/dcl/pki/certificates/${encodeURIComponent(subject.subject)}/${encodeURIComponent(subject.subjectKeyId)}`;
+        const response = await this.#fetchJson(path9, options);
         if (!response || !response.approvedCertificates || response.approvedCertificates.subject !== subject.subject || response.approvedCertificates.subjectKeyId !== subject.subjectKeyId || response.approvedCertificates.schemaVersion !== 0) {
           throw new MatterDclError(
             `Root certificate not found for subject: ${subject.subject}, subjectKeyId: ${subject.subjectKeyId}`
@@ -109297,24 +109297,24 @@ var init_DclClient = __esm({
         return response.approvedCertificates.certs;
       }
       async fetchModelByVidPid(vid, pid, options) {
-        const path8 = `/dcl/model/models/${encodeURIComponent(vid)}/${encodeURIComponent(pid)}`;
-        const response = await this.#fetchJson(path8, options);
+        const path9 = `/dcl/model/models/${encodeURIComponent(vid)}/${encodeURIComponent(pid)}`;
+        const response = await this.#fetchJson(path9, options);
         if (!response || !response.model || response.model.vid !== vid || response.model.pid !== pid || response.model.schemaVersion !== 0) {
           throw new MatterDclError(`Model not found for VID: ${vid}, PID: ${pid}`);
         }
         return response.model;
       }
       async fetchModelVersionsByVidPid(vid, pid, options) {
-        const path8 = `/dcl/model/versions/${encodeURIComponent(vid)}/${encodeURIComponent(pid)}`;
-        const response = await this.#fetchJson(path8, options);
+        const path9 = `/dcl/model/versions/${encodeURIComponent(vid)}/${encodeURIComponent(pid)}`;
+        const response = await this.#fetchJson(path9, options);
         if (!response || !response.modelVersions || response.modelVersions.vid !== vid || response.modelVersions.pid !== pid || response.modelVersions.schemaVersion !== 0) {
           throw new MatterDclError(`Model versions not found for VID: ${vid}, PID: ${pid}`);
         }
         return response.modelVersions.softwareVersions;
       }
       async fetchModelVersionByVidPidSoftwareVersion(vid, pid, softwareVersion, options) {
-        const path8 = `/dcl/model/versions/${encodeURIComponent(vid)}/${encodeURIComponent(pid)}/${encodeURIComponent(softwareVersion)}`;
-        const response = await this.#fetchJson(path8, options);
+        const path9 = `/dcl/model/versions/${encodeURIComponent(vid)}/${encodeURIComponent(pid)}/${encodeURIComponent(softwareVersion)}`;
+        const response = await this.#fetchJson(path9, options);
         if (!response || !response.modelVersion || response.modelVersion.vid !== vid || response.modelVersion.pid !== pid || response.modelVersion.softwareVersion !== softwareVersion || response.modelVersion.schemaVersion !== 0) {
           throw new MatterDclError(
             `Model version not found for VID: ${vid}, PID: ${pid}, Software Version: ${softwareVersion}`
@@ -116101,51 +116101,51 @@ var init_ValueCaster = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+node@0.16.10/node_modules/@matter/node/dist/esm/behavior/state/validation/assertions.js
-function assertNumber(value, path8) {
+function assertNumber(value, path9) {
   if (Number.isFinite(value)) {
     return;
   }
-  throw new DatatypeError(path8, "a number", value);
+  throw new DatatypeError(path9, "a number", value);
 }
-function assertBoolean(value, path8) {
+function assertBoolean(value, path9) {
   if (typeof value === "boolean" || value === 0 || value === 1) {
     return;
   }
-  throw new DatatypeError(path8, "a boolean", value);
+  throw new DatatypeError(path9, "a boolean", value);
 }
-function assertObject(value, path8) {
+function assertObject(value, path9) {
   if (isObject(value)) {
     return;
   }
-  throw new DatatypeError(path8, "an object", value);
+  throw new DatatypeError(path9, "an object", value);
 }
-function assertNumeric(value, path8) {
+function assertNumeric(value, path9) {
   if (typeof value === "number" || typeof value === "bigint") {
     return;
   }
-  throw new DatatypeError(path8, "a number or bigint", value);
+  throw new DatatypeError(path9, "a number or bigint", value);
 }
-function assertString(value, path8) {
+function assertString(value, path9) {
   if (typeof value === "string") {
     return;
   }
-  throw new DatatypeError(path8, "a string", value);
+  throw new DatatypeError(path9, "a string", value);
 }
-function assertBytes(value, path8) {
+function assertBytes(value, path9) {
   if (Bytes.isBytes(value)) {
     return;
   }
-  throw new DatatypeError(path8, "a byte array", value);
+  throw new DatatypeError(path9, "a byte array", value);
 }
-function assertSequence(value, path8) {
+function assertSequence(value, path9) {
   if (typeof value === "string" || Bytes.isBytes(value)) {
     return;
   }
-  throw new DatatypeError(path8, "a string or byte array", value);
+  throw new DatatypeError(path9, "a string or byte array", value);
 }
-function assertArray(value, path8) {
+function assertArray(value, path9) {
   if (!Array.isArray(value)) {
-    throw new DatatypeError(path8, "an array", value);
+    throw new DatatypeError(path9, "an array", value);
   }
 }
 function createIntAssertion(name, lowerBoundInclusive, upperBoundExclusive) {
@@ -116155,13 +116155,13 @@ function createIntAssertion(name, lowerBoundInclusive, upperBoundExclusive) {
   return createVarIntAssertion(name, Number(lowerBoundInclusive), Number(upperBoundExclusive));
 }
 function createVarIntAssertion(name, min, max) {
-  return function assertInt2(value, path8) {
-    assertNumeric(value, path8);
+  return function assertInt2(value, path9) {
+    assertNumeric(value, path9);
     if (value < min) {
-      throw new IntegerRangeError(path8, `Value ${value} is below the ${name} minimum of ${min}`);
+      throw new IntegerRangeError(path9, `Value ${value} is below the ${name} minimum of ${min}`);
     }
     if (value > max) {
-      throw new IntegerRangeError(path8, `Value ${value} is above the ${name} maximum of ${max}`);
+      throw new IntegerRangeError(path9, `Value ${value} is above the ${name} maximum of ${max}`);
     }
   };
 }
@@ -117266,18 +117266,18 @@ function StructPatcher(schema6, supervisor) {
       memberArrays[key] = true;
     }
   }
-  return (changes, target, path8) => {
+  return (changes, target, path9) => {
     if (typeof changes !== "object" || changes === null || Array.isArray(changes)) {
-      throw new WriteError(path8, `patch definition ${changes} is not an object`);
+      throw new WriteError(path9, `patch definition ${changes} is not an object`);
     }
     if (typeof target !== "object" || target === null || Array.isArray(target)) {
-      throw new WriteError(path8, `cannot patch ${target} because it is not an object`);
+      throw new WriteError(path9, `cannot patch ${target} because it is not an object`);
     }
     for (let key in changes) {
       let newValue = changes[key];
       if (!(key in memberPatchers)) {
         if (!(key in memberAltKeys)) {
-          throw new WriteError(path8, `${key} is not a property of ${schema6.name}`);
+          throw new WriteError(path9, `${key} is not a property of ${schema6.name}`);
         }
         key = memberAltKeys[key];
       }
@@ -117288,17 +117288,17 @@ function StructPatcher(schema6, supervisor) {
       }
       if (memberArrays[key]) {
         if (target[key] === void 0 || target[key] === null) {
-          newValue = subpatch(newValue, [], path8.at(key));
+          newValue = subpatch(newValue, [], path9.at(key));
           target[key] = newValue;
           continue;
         }
       }
       if (target[key] === void 0 || target[key] === null) {
-        newValue = subpatch(newValue, { ...memberDefaults[key] }, path8.at(key));
+        newValue = subpatch(newValue, { ...memberDefaults[key] }, path9.at(key));
         target[key] = newValue;
         continue;
       }
-      subpatch(newValue, target[key], path8.at(key));
+      subpatch(newValue, target[key], path9.at(key));
     }
     return target;
   };
@@ -117317,28 +117317,28 @@ function ListPatcher(schema6, supervisor) {
   if (entryMetatype === Metatype.object) {
     entryDefaults = getDefaults(supervisor, entry);
   }
-  return (changes, target, path8) => {
+  return (changes, target, path9) => {
     if (typeof changes !== "object" || changes === null) {
-      throw new WriteError(path8, `patch definition ${changes} is not an object`);
+      throw new WriteError(path9, `patch definition ${changes} is not an object`);
     }
     if (!Array.isArray(target)) {
-      throw new WriteError(path8, `patch definition ${changes} is not an object`);
+      throw new WriteError(path9, `patch definition ${changes} is not an object`);
     }
     for (const indexStr in changes) {
       const index = Number.parseInt(indexStr);
       if (index < 0 || !Number.isFinite(index)) {
-        throw new WriteError(path8, `key ${index} is not a valid array index`);
+        throw new WriteError(path9, `key ${index} is not a valid array index`);
       }
       let newValue = changes[indexStr];
       if (patchEntry) {
         const oldValue = index < target.length ? target[index] : void 0;
         if (newValue === void 0 || newValue === null || oldValue === void 0 || oldValue === null) {
           if (entryDefaults && isObject(newValue)) {
-            newValue = patchEntry(newValue, { ...entryDefaults }, path8.at(index));
+            newValue = patchEntry(newValue, { ...entryDefaults }, path9.at(index));
           }
           target[index] = newValue;
         } else {
-          patchEntry(newValue, target[index], path8.at(index));
+          patchEntry(newValue, target[index], path9.at(index));
         }
       } else {
         target[index] = newValue;
@@ -117351,8 +117351,8 @@ function ListPatcher(schema6, supervisor) {
   };
 }
 function PrimitivePatcher() {
-  return (_changes, _target, path8) => {
-    throw new ImplementationError(`Cannot generate patch ${path8} because it does not define not a collection`);
+  return (_changes, _target, path9) => {
+    throw new ImplementationError(`Cannot generate patch ${path9} because it does not define not a collection`);
   };
 }
 var defaultsCache;
@@ -121501,12 +121501,12 @@ function invokeCommand(backing, command, request, session) {
   } else {
     requestDiagnostic = Diagnostic.weak("(no payload)");
   }
-  const { path: path8, endpoint } = backing;
+  const { path: path9, endpoint } = backing;
   const context = session;
   logger93.info(
     "Invoke",
     Mark.INBOUND,
-    Diagnostic.strong(`${path8.toString()}.${command.name}`),
+    Diagnostic.strong(`${path9.toString()}.${command.name}`),
     session.transaction.via,
     requestDiagnostic
   );
@@ -121544,7 +121544,7 @@ function invokeCommand(backing, command, request, session) {
           logger93.info(
             "Invoke",
             Mark.OUTBOUND,
-            Diagnostic.strong(`${path8.toString()}.${command.name}`),
+            Diagnostic.strong(`${path9.toString()}.${command.name}`),
             session.transaction.via,
             Diagnostic.dict(result2)
           );
@@ -121556,7 +121556,7 @@ function invokeCommand(backing, command, request, session) {
         logger93.info(
           "Invoke",
           Mark.OUTBOUND,
-          Diagnostic.strong(`${path8.toString()}.${command.name}`),
+          Diagnostic.strong(`${path9.toString()}.${command.name}`),
           session.transaction.via,
           Diagnostic.dict(result)
         );
@@ -121569,12 +121569,12 @@ function invokeCommand(backing, command, request, session) {
   }
   return result;
 }
-function resolvePathForNode(node, path8) {
-  const { endpointId, clusterId: clusterId3 } = path8;
-  const isUrgentString = "isUrgent" in path8 && path8.isUrgent ? "!" : "";
-  const listIndexString = "listIndex" in path8 && path8.listIndex === null ? "[ADD]" : "";
+function resolvePathForNode(node, path9) {
+  const { endpointId, clusterId: clusterId3 } = path9;
+  const isUrgentString = "isUrgent" in path9 && path9.isUrgent ? "!" : "";
+  const listIndexString = "listIndex" in path9 && path9.listIndex === null ? "[ADD]" : "";
   const postString = `${listIndexString}${isUrgentString}`;
-  const elementId = "attributeId" in path8 ? path8.attributeId : "eventId" in path8 ? path8.eventId : "commandId" in path8 ? path8.commandId : void 0;
+  const elementId = "attributeId" in path9 ? path9.attributeId : "eventId" in path9 ? path9.eventId : "commandId" in path9 ? path9.commandId : void 0;
   if (endpointId === void 0) {
     return `*.${toWildcardOrHexPath("", clusterId3)}.${toWildcardOrHexPath("", elementId)}${postString}`;
   }
@@ -121592,13 +121592,13 @@ function resolvePathForNode(node, path8) {
   }
   const clusterName = toWildcardOrHexPath(cluster2.type.name, clusterId3);
   if (elementId !== void 0) {
-    if ("eventId" in path8) {
+    if ("eventId" in path9) {
       const event3 = cluster2.type.events[elementId];
       return `${endpointName}.${clusterName}.${toWildcardOrHexPath(event3?.name ?? "?", elementId)}${postString}`;
-    } else if ("attributeId" in path8) {
+    } else if ("attributeId" in path9) {
       const attribute2 = cluster2.type.attributes[elementId];
       return `${endpointName}.${clusterName}.${toWildcardOrHexPath(attribute2?.name ?? "?", elementId)}${postString}`;
-    } else if ("commandId" in path8) {
+    } else if ("commandId" in path9) {
       const command = cluster2.type.commands[elementId];
       return `${endpointName}.${clusterName}.${toWildcardOrHexPath(command?.name ?? "?", elementId)}${postString}`;
     } else {
@@ -121699,8 +121699,8 @@ var init_ProtocolService = __esm({
           inspect() {
             return this.toString();
           },
-          inspectPath(path8) {
-            return resolvePathForNode(this, path8);
+          inspectPath(path9) {
+            return resolvePathForNode(this, path9);
           }
         };
       }
@@ -124169,11 +124169,11 @@ var init_ServerSubscription = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+node@0.16.10/node_modules/@matter/node/dist/esm/node/server/InteractionServer.js
-function validateReadAttributesPath(path8, isGroupSession = false) {
+function validateReadAttributesPath(path9, isGroupSession = false) {
   if (isGroupSession) {
     throw new StatusResponseError("Illegal read request with group session", StatusCode.InvalidAction);
   }
-  const { clusterId: clusterId3, attributeId } = path8;
+  const { clusterId: clusterId3, attributeId } = path9;
   if (clusterId3 === void 0 && attributeId !== void 0) {
     if (!GLOBAL_IDS2.has(attributeId)) {
       throw new StatusResponseError(
@@ -124183,8 +124183,8 @@ function validateReadAttributesPath(path8, isGroupSession = false) {
     }
   }
 }
-function validateReadEventPath(path8, isGroupSession = false) {
-  const { clusterId: clusterId3, eventId: eventId3 } = path8;
+function validateReadEventPath(path9, isGroupSession = false) {
+  const { clusterId: clusterId3, eventId: eventId3 } = path9;
   if (clusterId3 === void 0 && eventId3 !== void 0) {
     throw new StatusResponseError("Illegal read request with wildcard cluster ID", StatusCode.InvalidAction);
   }
@@ -124366,8 +124366,8 @@ var init_InteractionServer = __esm({
           exchange.via,
           Diagnostic.asFlags({ fabricFiltered: isFabricFiltered }),
           Diagnostic.dict({
-            attributes: `${attributeRequests?.map((path8) => this.#node.protocol.inspectPath(path8)).join(", ") ?? "none"}${dataVersionFilters?.length ? ` with ${dataVersionFilters?.length} filters` : ""}`,
-            events: `${eventRequests?.map((path8) => this.#node.protocol.inspectPath(path8)).join(", ") ?? "none"}${eventFilters?.length ? `, ${eventFilters?.length} filters` : ""}`
+            attributes: `${attributeRequests?.map((path9) => this.#node.protocol.inspectPath(path9)).join(", ") ?? "none"}${dataVersionFilters?.length ? ` with ${dataVersionFilters?.length} filters` : ""}`,
+            events: `${eventRequests?.map((path9) => this.#node.protocol.inspectPath(path9)).join(", ") ?? "none"}${eventFilters?.length ? `, ${eventFilters?.length} filters` : ""}`
           })
         ]);
         if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
@@ -124476,22 +124476,22 @@ var init_InteractionServer = __esm({
             currentBatch = [];
           };
           for (const request of writeRequests) {
-            const { path: path8 } = request;
-            const listIndex = path8.listIndex;
+            const { path: path9 } = request;
+            const listIndex = path9.listIndex;
             if (listIndex === null) {
-              if (previousProcessedAttributePath?.endpointId !== path8.endpointId || previousProcessedAttributePath?.clusterId !== path8.clusterId || previousProcessedAttributePath?.attributeId !== path8.attributeId) {
+              if (previousProcessedAttributePath?.endpointId !== path9.endpointId || previousProcessedAttributePath?.clusterId !== path9.clusterId || previousProcessedAttributePath?.attributeId !== path9.attributeId) {
                 await processBatch();
                 allResponses.push({
                   kind: "attr-status",
-                  path: path8,
+                  path: path9,
                   status: Status2.Busy
                 });
                 continue;
               }
             }
             currentBatch.push(request);
-            if (path8.endpointId !== void 0 && path8.clusterId !== void 0 && path8.attributeId !== void 0) {
-              previousProcessedAttributePath = path8;
+            if (path9.endpointId !== void 0 && path9.clusterId !== void 0 && path9.attributeId !== void 0) {
+              previousProcessedAttributePath = path9;
             }
           }
           await processBatch();
@@ -124499,8 +124499,8 @@ var init_InteractionServer = __esm({
             break;
           }
           const chunkResponse = {
-            writeResponses: allResponses.map(({ path: path8, status: status3, clusterStatus }) => ({
-              path: path8,
+            writeResponses: allResponses.map(({ path: path9, status: status3, clusterStatus }) => ({
+              path: path9,
               status: { status: status3, clusterStatus }
             })),
             interactionModelRevision: Specification.INTERACTION_MODEL_REVISION
@@ -124590,16 +124590,16 @@ var init_InteractionServer = __esm({
           Mark.INBOUND,
           exchange.via,
           Diagnostic.dict({
-            attributes: attributeRequests?.length ? attributeRequests?.map((path8) => this.#node.protocol.inspectPath(path8)).join(", ") : void 0,
+            attributes: attributeRequests?.length ? attributeRequests?.map((path9) => this.#node.protocol.inspectPath(path9)).join(", ") : void 0,
             dataVersionFilters: dataVersionFilters?.length ? dataVersionFilters.map(
               ({ path: { nodeId: nodeId3, endpointId, clusterId: clusterId3 }, dataVersion }) => `${clusterPathToId({ nodeId: nodeId3, endpointId, clusterId: clusterId3 })}=${dataVersion}`
             ).join(", ") : void 0,
-            events: eventRequests?.length ? eventRequests.map((path8) => this.#node.protocol.inspectPath(path8)).join(", ") : void 0,
+            events: eventRequests?.length ? eventRequests.map((path9) => this.#node.protocol.inspectPath(path9)).join(", ") : void 0,
             eventFilters: eventFilters?.length ? eventFilters.map((filter) => `${filter.nodeId}/${filter.eventMin}`).join(", ") : void 0
           })
         ]);
-        attributeRequests?.forEach((path8) => validateReadAttributesPath(path8));
-        eventRequests?.forEach((path8) => validateReadEventPath(path8));
+        attributeRequests?.forEach((path9) => validateReadAttributesPath(path9));
+        eventRequests?.forEach((path9) => validateReadEventPath(path9));
         if (minIntervalFloorSeconds < 0) {
           throw new StatusResponseError(
             "minIntervalFloorSeconds should be greater or equal to 0",
@@ -124881,9 +124881,9 @@ var init_InteractionServer = __esm({
                 break;
               }
               case "cmd-status": {
-                const { path: path8, commandRef, status: status3, clusterStatus } = data;
+                const { path: path9, commandRef, status: status3, clusterStatus } = data;
                 await sendChunkIfNeeded({
-                  status: { commandPath: path8, status: { status: status3, clusterStatus }, commandRef }
+                  status: { commandPath: path9, status: { status: status3, clusterStatus }, commandRef }
                 });
                 break;
               }
@@ -134966,14 +134966,14 @@ var init_ApiPath = __esm({
        *
        * So generally normal UNIX/URL semantics.
        */
-      constructor(path8) {
-        if (path8 instanceof URL) {
-          path8 = path8.pathname;
+      constructor(path9) {
+        if (path9 instanceof URL) {
+          path9 = path9.pathname;
         }
-        if (!Array.isArray(path8)) {
-          path8 = path8.split("/").map(decodeURIComponent);
+        if (!Array.isArray(path9)) {
+          path9 = path9.split("/").map(decodeURIComponent);
         }
-        for (const segment of path8) {
+        for (const segment of path9) {
           if (segment === "" || segment === ".") {
             continue;
           }
@@ -134993,20 +134993,20 @@ var init_ApiPath = __esm({
       slice(start, end) {
         return new _ApiPath(this.#segments.slice(start, end));
       }
-      at(path8) {
+      at(path9) {
         if (this.isEmpty) {
-          return new _ApiPath(path8);
+          return new _ApiPath(path9);
         }
-        if (path8 instanceof URL) {
-          path8 = path8.pathname;
+        if (path9 instanceof URL) {
+          path9 = path9.pathname;
         }
-        if (Array.isArray(path8)) {
-          path8 = path8.map(encodeURIComponent).join("/");
+        if (Array.isArray(path9)) {
+          path9 = path9.map(encodeURIComponent).join("/");
         }
-        if (path8.startsWith("/")) {
-          return new _ApiPath(path8);
+        if (path9.startsWith("/")) {
+          return new _ApiPath(path9);
         }
-        return new _ApiPath(`${this.toString()}/${path8}`);
+        return new _ApiPath(`${this.toString()}/${path9}`);
       }
       toString() {
         return `${this.#segments.map(encodeURIComponent).join("/")}`;
@@ -135091,12 +135091,12 @@ var init_Envelope = __esm({
       /**
        * Validate against the schema.  Casts to appropriate types if necessary.
        */
-      validate(path8) {
-        if (!path8) {
-          path8 = DataModelPath(this.#supervisor.schema.path);
+      validate(path9) {
+        if (!path9) {
+          path9 = DataModelPath(this.#supervisor.schema.path);
         }
         this.#js = this.#supervisor.cast(this.#js);
-        this.#supervisor.validate?.(this.js, LocalActorContext.ReadOnly, { path: path8 });
+        this.#supervisor.validate?.(this.js, LocalActorContext.ReadOnly, { path: path9 });
       }
       /**
        * Convert a {@link js} value to {@link JSON}.
@@ -135336,11 +135336,11 @@ var init_PropertyResource = __esm({
         }
         return "field";
       }
-      constructor(parent, id, supervisor, path8) {
+      constructor(parent, id, supervisor, path9) {
         super(parent);
         this.id = id;
         this.supervisor = supervisor;
-        this.dataModelPath = path8;
+        this.dataModelPath = path9;
       }
       get schema() {
         return this.supervisor.schema;
@@ -135976,7 +135976,7 @@ var init_Api = __esm({
     init_ServerNodeResource();
     loggers = /* @__PURE__ */ new Map();
     ((Api2) => {
-      async function resourceFor(agent, path8) {
+      async function resourceFor(agent, path9) {
         let item;
         if ("peers" in agent.endpoint) {
           item = new ServerNodeResource(agent, void 0);
@@ -135986,7 +135986,7 @@ var init_Api = __esm({
           item = new EndpointResource(agent, void 0);
         }
         const breadcrumb = [item];
-        for (const segment of path8) {
+        for (const segment of path9) {
           const parent = breadcrumb[breadcrumb.length - 1];
           const item2 = await parent.childFor(segment);
           if (!item2) {
@@ -136401,12 +136401,12 @@ var init_HttpInterface = __esm({
         let response;
         try {
           const address = new AppAddress(request.url);
-          const path8 = this.root.subpathFor(new ApiPath(address));
-          if (!path8) {
+          const path9 = this.root.subpathFor(new ApiPath(address));
+          if (!path9) {
             return;
           }
           response = await this.node.act("http", async (agent) => {
-            const resource = await Api.resourceFor(agent, path8);
+            const resource = await Api.resourceFor(agent, path9);
             if (resource === void 0) {
               throw new StatusResponse.NotFoundError(`Path "${address.pathname}" not found`);
             }
@@ -138200,8 +138200,8 @@ var init_WebSocketInterface = __esm({
         var _stack = [];
         try {
           const address = new AppAddress(request.url);
-          const path8 = new ApiPath(address).toString();
-          if (path8 !== this.root.toString()) {
+          const path9 = new ApiPath(address).toString();
+          if (path9 !== this.root.toString()) {
             return;
           }
           const ws2 = await Abort.race(this.abort, await upgrade());
@@ -138880,8 +138880,8 @@ var init_endpoint = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+node@0.16.10/node_modules/@matter/node/dist/esm/loader/load.mjs
-function load(path8) {
-  return import(path8);
+function load(path9) {
+  return import(path9);
 }
 var init_load = __esm({
   "../../node_modules/.pnpm/@matter+node@0.16.10/node_modules/@matter/node/dist/esm/loader/load.mjs"() {
@@ -138889,8 +138889,8 @@ var init_load = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+node@0.16.10/node_modules/@matter/node/dist/esm/loader/loader.js
-function doLoad(description, exportName, path8) {
-  const cachedResult = cache5[path8];
+function doLoad(description, exportName, path9) {
+  const cachedResult = cache5[path9];
   if (cachedResult) {
     return cachedResult;
   }
@@ -138901,7 +138901,7 @@ function doLoad(description, exportName, path8) {
     failure();
   }
   try {
-    const module = load(path8);
+    const module = load(path9);
     if (MaybePromise.is(module)) {
       return module.then(extractExport, failure);
     }
@@ -143435,11 +143435,11 @@ var init_NodeJsHttpEndpoint = __esm({
             }
             break;
           case "unix":
-            const path8 = decodeURIComponent(address.hostname);
+            const path9 = decodeURIComponent(address.hostname);
             if (options.basePathForUnixSockets) {
-              opts.path = resolve(options.basePathForUnixSockets, normalize(path8));
+              opts.path = resolve(options.basePathForUnixSockets, normalize(path9));
             } else {
-              opts.path = normalize(path8);
+              opts.path = normalize(path9);
             }
             if (existsSync(opts.path)) {
               if (statSync(opts.path).isSocket()) {
@@ -143643,9 +143643,9 @@ var init_StorageBackendDisk = __esm({
       isInitialized = false;
       #writeFileBlocker = /* @__PURE__ */ new Map();
       #index = {};
-      constructor(path8, clear = false) {
+      constructor(path9, clear = false) {
         super();
-        this.#path = path8;
+        this.#path = path9;
         this.#clear = clear;
       }
       get initialized() {
@@ -143908,9 +143908,9 @@ var init_StorageBackendJsonFile = __esm({
   "../../node_modules/.pnpm/@matter+nodejs@0.16.10/node_modules/@matter/nodejs/dist/esm/storage/fs/StorageBackendJsonFile.js"() {
     init_esm();
     StorageBackendJsonFile = class _StorageBackendJsonFile extends StorageBackendMemory {
-      constructor(path8) {
+      constructor(path9) {
         super();
-        this.path = path8;
+        this.path = path9;
       }
       /** We store changes after a value was set to the storage, but not more often than this setting (in ms). */
       static commitDelay = Seconds.one;
@@ -143922,8 +143922,8 @@ var init_StorageBackendJsonFile = __esm({
       );
       closed = false;
       resolveCommitted;
-      static async create(path8) {
-        const storage2 = new this(path8);
+      static async create(path9) {
+        const storage2 = new this(path9);
         storage2.initialize();
         return storage2;
       }
@@ -144128,8 +144128,8 @@ var init_SqliteStorage = __esm({
        */
       constructor(args) {
         super();
-        const { databaseCreator, path: path8, tableName, clear } = args;
-        this.dbPath = path8 === null ? _SqliteStorage.memoryPath : path8;
+        const { databaseCreator, path: path9, tableName, clear } = args;
+        this.dbPath = path9 === null ? _SqliteStorage.memoryPath : path9;
         this.databaseCreator = databaseCreator;
         this.database = databaseCreator(this.dbPath);
         this.tableName = tableName ?? _SqliteStorage.defaultTableName;
@@ -144513,10 +144513,10 @@ var init_NodeJsSqlite = __esm({
   "../../node_modules/.pnpm/@matter+nodejs@0.16.10/node_modules/@matter/nodejs/dist/esm/storage/sqlite/platform/NodeJsSqlite.js"() {
     init_SqliteStorage();
     NodeJsSqlite = class extends SqliteStorage {
-      constructor(path8, clear = false) {
+      constructor(path9, clear = false) {
         super({
           databaseCreator: (path22) => new DatabaseSync(path22),
-          path: path8,
+          path: path9,
           clear
         });
       }
@@ -144561,13 +144561,13 @@ var init_BunSqlite = __esm({
     init_bun_sqlite();
     init_bun();
     BunSqlite = class extends SqliteStorage {
-      constructor(path8, clear = false) {
+      constructor(path9, clear = false) {
         super({
           databaseCreator: (path22) => new Database(path22, {
             strict: true,
             create: true
           }),
-          path: path8,
+          path: path9,
           clear
         });
       }
@@ -144584,16 +144584,16 @@ var init_BunSqlite = __esm({
 });
 
 // ../../node_modules/.pnpm/@matter+nodejs@0.16.10/node_modules/@matter/nodejs/dist/esm/storage/sqlite/platform/PlatformSqlite.js
-async function PlatformSqlite(path8, clear = false) {
+async function PlatformSqlite(path9, clear = false) {
   const isBun = isBunjs();
   if (!isBun) {
     const module2 = await Promise.resolve().then(() => (init_NodeJsSqlite(), NodeJsSqlite_exports));
     const NodeJsSqlite2 = findDefaultExport(module2, "NodeJsSqlite");
-    return new NodeJsSqlite2(path8, clear);
+    return new NodeJsSqlite2(path9, clear);
   }
   const module = await Promise.resolve().then(() => (init_BunSqlite(), BunSqlite_exports));
   const BunSqlite2 = findDefaultExport(module, "BunSqlite");
-  return new BunSqlite2(path8, clear);
+  return new BunSqlite2(path9, clear);
 }
 function findDefaultExport(moduleLike, name) {
   return moduleLike[name] || moduleLike.default?.[name] || moduleLike.default;
@@ -144638,11 +144638,11 @@ var init_StorageFactory = __esm({
         if (!await exists(rootDir)) {
           await mkdir2(rootDir, { recursive: true });
         }
-        const path8 = getRealPath(type, rootDir, namespace3);
-        if (clear || await exists(path8)) {
-          return await createRawInit(type, path8, clear);
+        const path9 = getRealPath(type, rootDir, namespace3);
+        if (clear || await exists(path9)) {
+          return await createRawInit(type, path9, clear);
         }
-        const storage2 = await createRawInit(type, path8, false);
+        const storage2 = await createRawInit(type, path9, false);
         const migrationRootDir = resolve2(rootDir, ".migrations", getResultDirName(namespace3));
         for (const otherType of StorageTypes) {
           if (type === otherType) {
@@ -144669,7 +144669,7 @@ var init_StorageFactory = __esm({
                   fromType: otherType,
                   fromPath: otherPath,
                   toType: type,
-                  toPath: path8,
+                  toPath: path9,
                   result: migrationResult
                 }),
                 4
@@ -144692,14 +144692,14 @@ Error: ${errorMessage}`
         const { driver, namespace: namespace3 } = args;
         const rootDir = resolve2(args.rootDir);
         const type = getStorageType(driver);
-        const path8 = getRealPath(type, rootDir, namespace3);
-        if (!await exists(path8)) {
+        const path9 = getRealPath(type, rootDir, namespace3);
+        if (!await exists(path9)) {
           return;
         }
-        await rm3(path8, { recursive: true, force: true });
+        await rm3(path9, { recursive: true, force: true });
       }
       StorageFactory2.remove = remove;
-      async function createRaw(type, path8, clear) {
+      async function createRaw(type, path9, clear) {
         const normalizedType = type.toLowerCase();
         if (normalizedType === "sqlite") {
           if (!supportsSqlite()) {
@@ -144710,21 +144710,21 @@ Error: ${errorMessage}`
           `.replace(/\n\s+/g, "\n")
             );
           }
-          return await PlatformSqlite(path8, clear);
+          return await PlatformSqlite(path9, clear);
         }
         if (normalizedType === "file") {
-          return new StorageBackendDisk(path8, clear);
+          return new StorageBackendDisk(path9, clear);
         }
         throw new Error(`'${type}' storage type is not implemented.`);
       }
-      async function createRawInit(type, path8, clear) {
-        const storage2 = await createRaw(type, path8, clear);
+      async function createRawInit(type, path9, clear) {
+        const storage2 = await createRaw(type, path9, clear);
         await storage2.initialize();
         return storage2;
       }
-      async function hasStorage(type, path8) {
+      async function hasStorage(type, path9) {
         try {
-          const pathStat = await lstat(path8);
+          const pathStat = await lstat(path9);
           switch (type) {
             case "file":
               return pathStat.isDirectory();
@@ -144791,9 +144791,9 @@ Error: ${errorMessage}`
         }
         return result;
       }
-      async function exists(path8) {
+      async function exists(path9) {
         try {
-          await lstat(resolve2(path8));
+          await lstat(resolve2(path9));
           return true;
         } catch (err) {
           return false;
@@ -147419,7 +147419,7 @@ BigInt.prototype.toJSON = function() {
 };
 
 // src/cli.ts
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import * as url from "node:url";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -147432,7 +147432,7 @@ import * as ws from "ws";
 
 // src/api/web-api.ts
 init_service();
-import express13 from "express";
+import express14 from "express";
 import basicAuth from "express-basic-auth";
 import AccessControl5 from "express-ip-access-control";
 import nocache from "nocache";
@@ -148057,12 +148057,153 @@ function bridgeIconApi(storageLocation) {
   return router;
 }
 
+// src/api/device-image-api.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import express4 from "express";
+import multer3 from "multer";
+var ALLOWED_EXTENSIONS2 = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
+var MAX_FILE_SIZE2 = 5 * 1024 * 1024;
+var Z2M_IMAGE_BASE = "https://www.zigbee2mqtt.io/images/devices";
+function sanitizeEntityId(entityId) {
+  return entityId.replace(/[^a-z0-9._-]/gi, "_");
+}
+function findCustomImage(imagesDir, entityId) {
+  const sanitized = sanitizeEntityId(entityId);
+  if (!fs3.existsSync(imagesDir)) return void 0;
+  const files = fs3.readdirSync(imagesDir);
+  const imageFile = files.find((f) => path3.parse(f).name === sanitized);
+  return imageFile ? path3.join(imagesDir, imageFile) : void 0;
+}
+function resolveZ2mImageUrl(haRegistry, entityId) {
+  const entity = haRegistry.entities[entityId];
+  if (!entity?.device_id) return void 0;
+  const device = haRegistry.devices[entity.device_id];
+  if (!device?.model) return void 0;
+  return `${Z2M_IMAGE_BASE}/${encodeURIComponent(device.model)}.png`;
+}
+function deviceImageApi(storageLocation, haRegistry) {
+  const imagesDir = path3.join(storageLocation, "device-images");
+  if (!fs3.existsSync(imagesDir)) {
+    fs3.mkdirSync(imagesDir, { recursive: true });
+  }
+  const storage2 = multer3.diskStorage({
+    destination: (_req, _file, cb) => {
+      cb(null, imagesDir);
+    },
+    filename: (req, file, cb) => {
+      const entityId = sanitizeEntityId(req.params.entityId);
+      const ext = path3.extname(file.originalname).toLowerCase();
+      cb(null, `${entityId}${ext}`);
+    }
+  });
+  const fileFilter = (_req, file, cb) => {
+    const ext = path3.extname(file.originalname).toLowerCase();
+    if (ALLOWED_EXTENSIONS2.includes(ext)) {
+      cb(null, true);
+    } else {
+      cb(
+        new Error(
+          `Invalid file type. Allowed: ${ALLOWED_EXTENSIONS2.join(", ")}`
+        )
+      );
+    }
+  };
+  const upload2 = multer3({
+    storage: storage2,
+    fileFilter,
+    limits: { fileSize: MAX_FILE_SIZE2 }
+  });
+  const router = express4.Router();
+  router.post("/resolve", (req, res) => {
+    const { entityIds } = req.body;
+    if (!entityIds || !Array.isArray(entityIds)) {
+      res.status(400).json({ error: "entityIds array required" });
+      return;
+    }
+    const result = {};
+    for (const entityId of entityIds) {
+      const custom = findCustomImage(imagesDir, entityId);
+      if (custom) {
+        result[entityId] = { source: "custom" };
+      } else {
+        const z2mUrl = resolveZ2mImageUrl(haRegistry, entityId);
+        if (z2mUrl) {
+          result[entityId] = { source: "z2m", z2mUrl };
+        } else {
+          result[entityId] = { source: "none" };
+        }
+      }
+    }
+    res.json(result);
+  });
+  router.post(
+    "/:entityId",
+    upload2.single("image"),
+    (req, res) => {
+      if (!req.file) {
+        res.status(400).json({ error: "No file uploaded" });
+        return;
+      }
+      const sanitized = sanitizeEntityId(req.params.entityId);
+      const files = fs3.readdirSync(imagesDir);
+      for (const f of files) {
+        if (path3.parse(f).name === sanitized && f !== req.file.filename) {
+          fs3.unlinkSync(path3.join(imagesDir, f));
+        }
+      }
+      res.json({ success: true });
+    }
+  );
+  router.get("/:entityId", (req, res) => {
+    const entityId = req.params.entityId;
+    const customImage = findCustomImage(imagesDir, entityId);
+    if (customImage) {
+      res.sendFile(customImage);
+      return;
+    }
+    const z2mUrl = resolveZ2mImageUrl(haRegistry, entityId);
+    if (z2mUrl) {
+      res.redirect(z2mUrl);
+      return;
+    }
+    res.status(404).json({ error: "No image available" });
+  });
+  router.delete("/:entityId", (req, res) => {
+    const entityId = req.params.entityId;
+    const customImage = findCustomImage(imagesDir, entityId);
+    if (!customImage) {
+      res.status(404).json({ error: "No custom image found" });
+      return;
+    }
+    fs3.unlinkSync(customImage);
+    res.json({ success: true });
+  });
+  router.head("/:entityId", (req, res) => {
+    const entityId = req.params.entityId;
+    const customImage = findCustomImage(imagesDir, entityId);
+    if (customImage) {
+      res.setHeader("X-Image-Source", "custom");
+      res.status(200).end();
+      return;
+    }
+    const z2mUrl = resolveZ2mImageUrl(haRegistry, entityId);
+    if (z2mUrl) {
+      res.setHeader("X-Image-Source", "z2m");
+      res.status(200).end();
+      return;
+    }
+    res.status(404).end();
+  });
+  return router;
+}
+
 // src/api/diagnostic-api.ts
 import os from "node:os";
-import express5 from "express";
+import express6 from "express";
 
 // src/api/logs-api.ts
-import express4 from "express";
+import express5 from "express";
 var logBuffer = {
   entries: [],
   maxSize: 1e3
@@ -148074,7 +148215,7 @@ function addLogEntry(entry) {
   }
 }
 function logsApi(_logger) {
-  const router = express4.Router();
+  const router = express5.Router();
   router.get("/", (req, res) => {
     const { level, search, limit = "100", offset = "0" } = req.query;
     const limitNum = Math.min(
@@ -148178,7 +148319,7 @@ function anonymizeLogMessage(message) {
   return result;
 }
 function diagnosticApi(bridgeService, haClient, haRegistry, version, startTime) {
-  const router = express5.Router();
+  const router = express6.Router();
   router.get("/export", (req, res) => {
     const anonymize = req.query.anonymize !== "false";
     const logLimit = Math.min(
@@ -148257,9 +148398,9 @@ function diagnosticApi(bridgeService, haClient, haRegistry, version, startTime)
 }
 
 // src/api/entity-mapping-api.ts
-import express6 from "express";
+import express7 from "express";
 function entityMappingApi(mappingStorage) {
-  const router = express6.Router();
+  const router = express7.Router();
   router.get("/:bridgeId", (req, res) => {
     const { bridgeId } = req.params;
     const mappings = mappingStorage.getMappingsForBridge(bridgeId);
@@ -148313,9 +148454,9 @@ function entityMappingApi(mappingStorage) {
 }
 
 // src/api/health-api.ts
-import express7 from "express";
+import express8 from "express";
 function healthApi(bridgeService, haClient, version, startTime) {
-  const router = express7.Router();
+  const router = express8.Router();
   const getBridgeStats = () => {
     const bridges = bridgeService.bridges;
     return {
@@ -148405,9 +148546,9 @@ function healthApi(bridgeService, haClient, version, startTime) {
 }
 
 // src/api/home-assistant-api.ts
-import express8 from "express";
+import express9 from "express";
 function homeAssistantApi(haRegistry, haClient) {
-  const router = express8.Router();
+  const router = express9.Router();
   router.get("/stats", (_, res) => {
     const entities = Object.values(haRegistry.entities);
     const devices = Object.values(haRegistry.devices);
@@ -148731,7 +148872,7 @@ function lockCredentialApi(lockCredentialStorage) {
 // src/api/matter-api.ts
 init_dist();
 import { Ajv } from "ajv";
-import express9 from "express";
+import express10 from "express";
 
 // src/services/bridges/matcher/matches-entity-filter.ts
 function testMatchers(matchers, device, entity, mode = "any", entityState, labels) {
@@ -148877,7 +149018,7 @@ function endpointToJson(endpoint, parentId) {
 // src/api/matter-api.ts
 var ajv = new Ajv();
 function matterApi(bridgeService, haRegistry) {
-  const router = express9.Router();
+  const router = express10.Router();
   router.get("/", (_, res) => {
     res.status(200).json({});
   });
@@ -149249,9 +149390,9 @@ function matterApi(bridgeService, haRegistry) {
 }
 
 // src/api/metrics-api.ts
-import express10 from "express";
+import express11 from "express";
 function metricsApi(bridgeService, haClient, haRegistry, startTime) {
-  const router = express10.Router();
+  const router = express11.Router();
   router.get("/", (_, res) => {
     const memoryUsage = process.memoryUsage();
     const bridges = bridgeService.bridges;
@@ -149381,7 +149522,7 @@ function metricsApi(bridgeService, haClient, haRegistry, startTime) {
 }
 
 // src/api/proxy-support.ts
-import path3 from "node:path";
+import path4 from "node:path";
 var ingressPath = "x-ingress-path";
 var forwardedPrefix = "x-forwarded-prefix";
 function supportIngress(req, _, next) {
@@ -149420,7 +149561,7 @@ function supportProxyLocation(req, res, next) {
   next();
 }
 function buildPath(...paths) {
-  let result = path3.posix.join(...paths);
+  let result = path4.posix.join(...paths);
   if (!result.startsWith("/")) {
     result = `/${result}`;
   }
@@ -149494,7 +149635,7 @@ import { exec } from "node:child_process";
 import os2 from "node:os";
 import { promisify } from "node:util";
 import v8 from "node:v8";
-import express11 from "express";
+import express12 from "express";
 var execAsync = promisify(exec);
 function detectEnvironment2() {
   if (process.env.SUPERVISOR_TOKEN || process.env.HASSIO_TOKEN) {
@@ -149504,8 +149645,8 @@ function detectEnvironment2() {
     return "Docker";
   }
   try {
-    const fs7 = __require("node:fs");
-    if (fs7.existsSync("/.dockerenv")) {
+    const fs8 = __require("node:fs");
+    if (fs8.existsSync("/.dockerenv")) {
       return "Docker";
     }
   } catch {
@@ -149513,7 +149654,7 @@ function detectEnvironment2() {
   return "Standalone";
 }
 function systemApi(version) {
-  const router = express11.Router();
+  const router = express12.Router();
   router.get("/info", async (_req, res) => {
     try {
       const totalMem = os2.totalmem();
@@ -149622,9 +149763,9 @@ function getDataPath() {
   }
   return process.cwd();
 }
-async function getWindowsStorageInfo(path8) {
+async function getWindowsStorageInfo(path9) {
   try {
-    const drive = `${path8.split(":")[0]}:`;
+    const drive = `${path9.split(":")[0]}:`;
     const { stdout } = await execAsync(
       `powershell -Command "Get-PSDrive -Name '${drive.replace(":", "")}' | Select-Object Used,Free | ConvertTo-Json"`
     );
@@ -149635,7 +149776,7 @@ async function getWindowsStorageInfo(path8) {
     return { total, used, free };
   } catch {
     try {
-      const drive = `${path8.split(":")[0]}:`;
+      const drive = `${path9.split(":")[0]}:`;
       const { stdout } = await execAsync(
         `wmic logicaldisk where "DeviceID='${drive}'" get Size,FreeSpace /format:csv`
       );
@@ -149652,9 +149793,9 @@ async function getWindowsStorageInfo(path8) {
     return { total: 0, used: 0, free: 0 };
   }
 }
-async function getUnixStorageInfo(path8) {
+async function getUnixStorageInfo(path9) {
   try {
-    const { stdout } = await execAsync(`df -Pk "${path8}" 2>/dev/null`);
+    const { stdout } = await execAsync(`df -Pk "${path9}" 2>/dev/null`);
     const lines = stdout.trim().split("\n");
     if (lines.length >= 2) {
       const parts = lines[1].split(/\s+/);
@@ -149671,16 +149812,16 @@ async function getUnixStorageInfo(path8) {
 }
 
 // src/api/web-ui.ts
-import fs3 from "node:fs";
-import path4 from "node:path";
-import express12 from "express";
+import fs4 from "node:fs";
+import path5 from "node:path";
+import express13 from "express";
 function webUi(dist) {
-  const router = express12.Router();
+  const router = express13.Router();
   if (dist) {
     const index = replaceBase(dist);
     router.get("/", index);
     router.get("/index.html", index);
-    router.use(express12.static(dist));
+    router.use(express13.static(dist));
     router.get(/.*/, index);
   }
   return router;
@@ -149691,7 +149832,7 @@ function replaceBase(dist) {
     if (!baseUrl.endsWith("/")) {
       baseUrl += "/";
     }
-    const content = fs3.readFileSync(path4.join(dist, "index.html"), "utf8").replace(
+    const content = fs4.readFileSync(path5.join(dist, "index.html"), "utf8").replace(
       /<!-- BASE -->[\s\S]*<!-- \/BASE -->/,
       `<base href='${baseUrl}' />`
     );
@@ -149859,8 +150000,8 @@ var WebApi = class extends Service {
     return this.wsApi;
   }
   async initialize() {
-    const api = express13.Router();
-    api.use(express13.json()).use(nocache()).use("/matter", matterApi(this.bridgeService, this.haRegistry)).use(
+    const api = express14.Router();
+    api.use(express14.json()).use(nocache()).use("/matter", matterApi(this.bridgeService, this.haRegistry)).use(
       "/health",
       healthApi(
         this.bridgeService,
@@ -149868,7 +150009,10 @@ var WebApi = class extends Service {
         this.props.version,
         this.startTime
       )
-    ).use("/bridges", bridgeExportApi(this.bridgeStorage)).use("/bridge-icons", bridgeIconApi(this.props.storageLocation)).use("/entity-mappings", entityMappingApi(this.mappingStorage)).use("/lock-credentials", lockCredentialApi(this.lockCredentialStorage)).use("/settings", settingsApi(this.settingsStorage, this.props.auth)).use(
+    ).use("/bridges", bridgeExportApi(this.bridgeStorage)).use("/bridge-icons", bridgeIconApi(this.props.storageLocation)).use(
+      "/device-images",
+      deviceImageApi(this.props.storageLocation, this.haRegistry)
+    ).use("/entity-mappings", entityMappingApi(this.mappingStorage)).use("/lock-credentials", lockCredentialApi(this.lockCredentialStorage)).use("/settings", settingsApi(this.settingsStorage, this.props.auth)).use(
       "/backup",
       backupApi(
         this.bridgeStorage,
@@ -149917,7 +150061,7 @@ var WebApi = class extends Service {
         })
       );
     }
-    this.app = express13().use(...middlewares).use("/api", api).use(webUi(this.props.webUiDist));
+    this.app = express14().use(...middlewares).use("/api", api).use(webUi(this.props.webUiDist));
   }
   async dispose() {
     this.wsApi.close();
@@ -150161,14 +150305,14 @@ function mdns(env, options) {
 
 // src/core/app/storage.ts
 init_esm7();
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import os3 from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // src/core/app/storage/custom-storage.ts
 init_dist();
 init_esm6();
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import { forEach } from "lodash-es";
 
 // src/core/app/storage/legacy-custom-storage.ts
@@ -150176,8 +150320,8 @@ init_dist();
 init_esm6();
 import { pickBy } from "lodash-es";
 var LegacyCustomStorage = class extends StorageBackendJsonFile {
-  constructor(log, path8) {
-    super(path8);
+  constructor(log, path9) {
+    super(path9);
     this.log = log;
     const parser = this;
     const serialize2 = parser.toJson.bind(parser);
@@ -150191,7 +150335,7 @@ var LegacyCustomStorage = class extends StorageBackendJsonFile {
         return this.removeClusters(object, Object.values(ClusterId2));
       } catch (e) {
         this.log.error(
-          `Failed to parse json file '${path8}' with content: 
+          `Failed to parse json file '${path9}' with content: 
 
 ${json}
 
@@ -150205,7 +150349,7 @@ ${json}
         this.removeClusters(object, [ClusterId2.homeAssistantEntity])
       );
       if (json.trim().length === 0) {
-        throw new Error(`Tried to write empty storage to ${path8}`);
+        throw new Error(`Tried to write empty storage to ${path9}`);
       }
       return json;
     };
@@ -150223,14 +150367,14 @@ ${json}
 
 // src/core/app/storage/custom-storage.ts
 var CustomStorage = class extends StorageBackendDisk {
-  constructor(log, path8) {
-    super(path8);
+  constructor(log, path9) {
+    super(path9);
     this.log = log;
-    this.path = path8;
+    this.path = path9;
   }
   async initialize() {
     await super.initialize();
-    if (fs4.existsSync(`${this.path}.json`)) {
+    if (fs5.existsSync(`${this.path}.json`)) {
       await this.migrateLegacyStorage();
     }
   }
@@ -150243,11 +150387,11 @@ var CustomStorage = class extends StorageBackendDisk {
     return await super.keys(contexts);
   }
   async migrateLegacyStorage() {
-    const path8 = this.path;
+    const path9 = this.path;
     this.log.warn(
-      `Migrating legacy storage (JSON file) to new storage (directory): ${path8}`
+      `Migrating legacy storage (JSON file) to new storage (directory): ${path9}`
     );
-    const legacyStorage = new LegacyCustomStorage(this.log, `${path8}.json`);
+    const legacyStorage = new LegacyCustomStorage(this.log, `${path9}.json`);
     legacyStorage.initialize();
     forEach(legacyStorage.data, (values4, context) => {
       forEach(values4, (value, key) => {
@@ -150255,7 +150399,7 @@ var CustomStorage = class extends StorageBackendDisk {
       });
     });
     await legacyStorage.close();
-    fs4.renameSync(`${path8}.json`, `${path8}/backup.alpha-69.json`);
+    fs5.renameSync(`${path9}.json`, `${path9}/backup.alpha-69.json`);
   }
 };
 
@@ -150263,14 +150407,14 @@ var CustomStorage = class extends StorageBackendDisk {
 function storage(environment, options) {
   const logger192 = environment.get(LoggerService).get("CustomStorage");
   const location2 = resolveStorageLocation(options.location);
-  fs5.mkdirSync(location2, { recursive: true });
+  fs6.mkdirSync(location2, { recursive: true });
   const storageService = environment.get(StorageService);
   storageService.location = location2;
-  storageService.factory = (ns) => new CustomStorage(logger192, path5.resolve(location2, ns));
+  storageService.factory = (ns) => new CustomStorage(logger192, path6.resolve(location2, ns));
 }
 function resolveStorageLocation(storageLocation) {
   const homedir = os3.homedir();
-  return storageLocation ? path5.resolve(storageLocation.replace(/^~\//, `${homedir}/`)) : path5.join(homedir, ".home-assistant-matter-hub");
+  return storageLocation ? path6.resolve(storageLocation.replace(/^~\//, `${homedir}/`)) : path6.join(homedir, ".home-assistant-matter-hub");
 }
 
 // src/core/app/configure-default-environment.ts
@@ -150290,7 +150434,7 @@ function configureDefaultEnvironment(options) {
 init_esm7();
 import { createRequire } from "node:module";
 import os4 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 function resolveAppVersion() {
   if (process.env.APP_VERSION) {
     return process.env.APP_VERSION;
@@ -150353,7 +150497,7 @@ var Options = class {
   resolveStorageLocation() {
     const storageLocation = notEmpty(this.startOptions.storageLocation);
     const homedir = os4.homedir();
-    return storageLocation ? path6.resolve(storageLocation.replace(/^~\//, `${homedir}/`)) : path6.join(homedir, ".home-assistant-matter-hub");
+    return storageLocation ? path7.resolve(storageLocation.replace(/^~\//, `${homedir}/`)) : path7.join(homedir, ".home-assistant-matter-hub");
   }
   get bridgeService() {
     return {
@@ -165960,6 +166104,7 @@ var LevelControlServerBase = class extends FeaturedBase4 {
     if (this.state.maxLevel == null) {
       this.state.maxLevel = 254;
     }
+    this.state.onLevel = null;
     logger157.debug(`initialize: calling super.initialize()`);
     try {
       await super.initialize();
@@ -176715,7 +176860,7 @@ async function startHandler(startOptions, webUiDist) {
 }
 
 // src/commands/start/start-options-builder.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 function startOptionsBuilder(yargs2) {
   return yargs2.env("HAMH").version(false).config(
     "config",
@@ -176724,10 +176869,10 @@ function startOptionsBuilder(yargs2) {
       if (configPath.trim() === "") {
         return {};
       }
-      if (!fs6.existsSync(configPath)) {
+      if (!fs7.existsSync(configPath)) {
         throw new Error(`Config file '${configPath}' does not exist!`);
       }
-      return JSON.parse(fs6.readFileSync(configPath, "utf-8"));
+      return JSON.parse(fs7.readFileSync(configPath, "utf-8"));
     }
   ).option("log-level", {
     type: "string",
@@ -176786,7 +176931,7 @@ function startCommand(webDist) {
 // src/cli.ts
 var dirname = import.meta.dirname ?? url.fileURLToPath(new URL(".", import.meta.url));
 async function cli(argv) {
-  const webDist = process.env.NODE_ENV === "development" ? void 0 : path7.join(dirname, "../frontend");
+  const webDist = process.env.NODE_ENV === "development" ? void 0 : path8.join(dirname, "../frontend");
   const cli2 = yargs(hideBin(argv));
   cli2.scriptName("home-assistant-matter-hub").version().strict().recommendCommands().detectLocale(false).help().command(startCommand(webDist)).demandCommand().wrap(Math.min(140, cli2.terminalWidth())).parse();
 }