@matter/protocol 0.13.0-alpha.0-20250318-c1aa38b08 → 0.13.0-alpha.0-20250323-770919c6a

package/src/certificate/CertificateManager.ts

@@ -15,6 +15,7 @@ import {
     DerKey,
     DerObject,
     DerType,
+    Diagnostic,
     ImplementationError,
     Key,
     Logger,
@@ -788,13 +789,13 @@ export namespace CertificateManager {
         if (rootCert.subject.fabricId !== undefined) {
             if (Array.isArray(rootCert.subject.fabricId)) {
                 throw new CertificateError(
-                    `Invalid fabricId in NoC certificate: ${Logger.toJSON(rootCert.subject.fabricId)}`,
+                    `Invalid fabricId in NoC certificate: ${Diagnostic.json(rootCert.subject.fabricId)}`,
                 );
             }
             // If present, the matter-fabric-id attribute’s value SHALL NOT be 0
             if (rootCert.subject.fabricId === FabricId(0)) {
                 throw new CertificateError(
-                    `Invalid fabricId in NoC certificate: ${Logger.toJSON(rootCert.subject.fabricId)}`,
+                    `Invalid fabricId in NoC certificate: ${Diagnostic.json(rootCert.subject.fabricId)}`,
                 );
             }
         }
@@ -806,7 +807,9 @@ export namespace CertificateManager {
 
         // The subject DN SHALL encode exactly one matter-rcac-id attribute.
         if (rootCert.subject.rcacId === undefined || Array.isArray(rootCert.subject.rcacId)) {
-            throw new CertificateError(`Invalid rcacId in Root certificate: ${Logger.toJSON(rootCert.subject.rcacId)}`);
+            throw new CertificateError(
+                `Invalid rcacId in Root certificate: ${Diagnostic.json(rootCert.subject.rcacId)}`,
+            );
         }
 
         // The subject DN SHALL NOT encode any matter-noc-cat attribute.
@@ -874,23 +877,23 @@ export namespace CertificateManager {
 
         // The subject DN SHALL encode exactly one matter-node-id attribute.
         if (nocCert.subject.nodeId === undefined || Array.isArray(nocCert.subject.nodeId)) {
-            throw new CertificateError(`Invalid nodeId in NoC certificate: ${Logger.toJSON(nocCert.subject.nodeId)}`);
+            throw new CertificateError(`Invalid nodeId in NoC certificate: ${Diagnostic.json(nocCert.subject.nodeId)}`);
         }
         // The matter-node-id attribute’s value SHALL be in the Operational Node ID
         if (!NodeId.isOperationalNodeId(nocCert.subject.nodeId)) {
-            throw new CertificateError(`Invalid nodeId in NoC certificate: ${Logger.toJSON(nocCert.subject.nodeId)}`);
+            throw new CertificateError(`Invalid nodeId in NoC certificate: ${Diagnostic.json(nocCert.subject.nodeId)}`);
         }
 
         // The subject DN SHALL encode exactly one matter-fabric-id attribute.
         if (nocCert.subject.fabricId === undefined || Array.isArray(nocCert.subject.fabricId)) {
             throw new CertificateError(
-                `Invalid fabricId in NoC certificate: ${Logger.toJSON(nocCert.subject.fabricId)}`,
+                `Invalid fabricId in NoC certificate: ${Diagnostic.json(nocCert.subject.fabricId)}`,
             );
         }
         // The matter-fabric-id attribute’s value SHALL NOT be 0
         if (nocCert.subject.fabricId === FabricId(0)) {
             throw new CertificateError(
-                `Invalid fabricId in NoC certificate: ${Logger.toJSON(nocCert.subject.fabricId)}`,
+                `Invalid fabricId in NoC certificate: ${Diagnostic.json(nocCert.subject.fabricId)}`,
             );
         }
 
@@ -914,9 +917,9 @@ export namespace CertificateManager {
         // the same certificate chain.
         if (rootCert.subject.fabricId !== undefined && rootCert.subject.fabricId !== nocCert.subject.fabricId) {
             throw new CertificateError(
-                `FabricId in NoC certificate does not match the fabricId in the parent certificate. ${Logger.toJSON(
+                `FabricId in NoC certificate does not match the fabricId in the parent certificate. ${Diagnostic.json(
                     rootCert.subject.fabricId,
-                )} !== ${Logger.toJSON(nocCert.subject.fabricId)}`,
+                )} !== ${Diagnostic.json(nocCert.subject.fabricId)}`,
             );
         }
         if (
@@ -925,9 +928,9 @@ export namespace CertificateManager {
             icaCert.subject.fabricId !== nocCert.subject.fabricId
         ) {
             throw new CertificateError(
-                `FabricId in NoC certificate does not match the fabricId in the parent certificate. ${Logger.toJSON(
+                `FabricId in NoC certificate does not match the fabricId in the parent certificate. ${Diagnostic.json(
                     icaCert.subject.fabricId,
-                )} !== ${Logger.toJSON(nocCert.subject.fabricId)}`,
+                )} !== ${Diagnostic.json(nocCert.subject.fabricId)}`,
             );
         }
 
@@ -950,7 +953,7 @@ export namespace CertificateManager {
             (!nocCert.extensions.extendedKeyUsage.includes(1) && !nocCert.extensions.extendedKeyUsage.includes(2))
         ) {
             throw new CertificateError(
-                `Noc certificate must have extendedKeyUsage with serverAuth and clientAuth: ${Logger.toJSON(nocCert.extensions.extendedKeyUsage)}`,
+                `Noc certificate must have extendedKeyUsage with serverAuth and clientAuth: ${Diagnostic.json(nocCert.extensions.extendedKeyUsage)}`,
             );
         }
 
@@ -1005,20 +1008,20 @@ export namespace CertificateManager {
         if (icaCert.subject.fabricId !== undefined) {
             if (Array.isArray(icaCert.subject.fabricId)) {
                 throw new CertificateError(
-                    `Invalid fabricId in NoC certificate: ${Logger.toJSON(icaCert.subject.fabricId)}`,
+                    `Invalid fabricId in NoC certificate: ${Diagnostic.json(icaCert.subject.fabricId)}`,
                 );
             }
             // If present, the matter-fabric-id attribute’s value SHALL NOT be 0
             if (icaCert.subject.fabricId === FabricId(0)) {
                 throw new CertificateError(
-                    `Invalid fabricId in NoC certificate: ${Logger.toJSON(icaCert.subject.fabricId)}`,
+                    `Invalid fabricId in NoC certificate: ${Diagnostic.json(icaCert.subject.fabricId)}`,
                 );
             }
         }
 
         // The subject DN SHALL encode exactly one matter-icac-id attribute.
         if (icaCert.subject.icacId === undefined || Array.isArray(icaCert.subject.icacId)) {
-            throw new CertificateError(`Invalid icacId in Ica certificate: ${Logger.toJSON(icaCert.subject.icacId)}`);
+            throw new CertificateError(`Invalid icacId in Ica certificate: ${Diagnostic.json(icaCert.subject.icacId)}`);
         }
 
         // The subject DN SHALL NOT encode any matter-rcac-id attribute.
@@ -1041,18 +1044,18 @@ export namespace CertificateManager {
             rootCert.subject.fabricId !== icaCert.subject.fabricId
         ) {
             throw new CertificateError(
-                `FabricId in Ica certificate does not match the fabricId in the parent certificate. ${Logger.toJSON(
+                `FabricId in Ica certificate does not match the fabricId in the parent certificate. ${Diagnostic.json(
                     rootCert.subject.fabricId,
-                )} !== ${Logger.toJSON(icaCert.subject.fabricId)}`,
+                )} !== ${Diagnostic.json(icaCert.subject.fabricId)}`,
             );
         }
 
         // Verify the certificate chain by checking rcac ids in subject and issuer
         if (rootCert.subject.rcacId !== icaCert.issuer.rcacId) {
             throw new CertificateError(
-                `RcacId in Ica certificate does not match the rcacId in the parent certificate. ${Logger.toJSON(
+                `RcacId in Ica certificate does not match the rcacId in the parent certificate. ${Diagnostic.json(
                     rootCert.subject.rcacId,
-                )} !== ${Logger.toJSON(icaCert.issuer.rcacId)}`,
+                )} !== ${Diagnostic.json(icaCert.issuer.rcacId)}`,
             );
         }
 

package/src/cluster/client/ClusterClient.ts

@@ -52,6 +52,7 @@ export function ClusterClient<const T extends ClusterType>(
             interactionClient,
             !!globalAttributeValues?.attributeList?.includes(attribute.id),
         );
+        (attributes as any)[attribute.id] = (attributes as any)[attributeName];
         attributeToId[attribute.id] = attributeName;
         const capitalizedAttributeName = capitalize(attributeName);
         result[`get${capitalizedAttributeName}Attribute`] = async (
@@ -94,6 +95,7 @@ export function ClusterClient<const T extends ClusterType>(
 
     function addEventToResult(event: Event<any, any>, eventName: string) {
         (events as any)[eventName] = createEventClient(event, eventName, endpointId, clusterId, interactionClient);
+        (events as any)[event.id] = (events as any)[eventName];
         eventToId[event.id] = eventName;
         const capitalizedEventName = capitalize(eventName);
         result[`get${capitalizedEventName}Event`] = async (
@@ -316,6 +318,7 @@ export function ClusterClient<const T extends ClusterType>(
                 useExtendedFailSafeMessageResponseTimeout,
             });
         };
+        commands[requestId as unknown as keyof T["commands"]] = commands[commandName as keyof T["commands"]];
         result[commandName] = result.commands[commandName];
     }
     if (globalAttributeValues?.acceptedCommandList !== undefined) {

package/src/cluster/server/AttributeServer.ts

@@ -4,7 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ImplementationError, InternalError, Logger, MatterError, MaybePromise, camelize, isDeepEqual } from "#general";
+import {
+    Diagnostic,
+    ImplementationError,
+    InternalError,
+    Logger,
+    MatterError,
+    MaybePromise,
+    camelize,
+    isDeepEqual,
+} from "#general";
 import { AccessLevel, AttributeModel, ClusterModel, DatatypeModel, FabricIndex, MatterModel } from "#model";
 import {
     Attribute,
@@ -165,9 +174,9 @@ export abstract class BaseAttributeServer<T> {
             this.value = initValue;
         } catch (error) {
             logger.warn(
-                `Attribute value to initialize for ${name} has an invalid value ${Logger.toJSON(
+                `Attribute value to initialize for ${name} has an invalid value ${Diagnostic.json(
                     initValue,
-                )}. Restore to default ${Logger.toJSON(defaultValue)}`,
+                )}. Restore to default ${Diagnostic.json(defaultValue)}`,
             );
             if (defaultValue === undefined) {
                 throw new ImplementationError(`Attribute value to initialize for ${name} cannot be undefined.`);
@@ -524,7 +533,7 @@ export class AttributeServer<T> extends FixedAttributeServer<T> {
                 newValue: value,
                 changed: !!this.delayedChangeData?.changed || valueChanged, // We combine the changed flag
             };
-            logger.info(`Delay change for attribute "${this.name}" with value ${Logger.toJSON(value)}`);
+            logger.info(`Delay change for attribute "${this.name}" with value ${Diagnostic.json(value)}`);
         } else {
             this.handleVersionAndTriggerListeners(value, oldValue, valueChanged);
         }
@@ -534,7 +543,7 @@ export class AttributeServer<T> extends FixedAttributeServer<T> {
         if (this.delayedChangeData !== undefined) {
             const { oldValue, newValue, changed } = this.delayedChangeData;
             this.delayedChangeData = undefined;
-            logger.info(`Trigger delayed change for attribute "${this.name}" with value ${Logger.toJSON(newValue)}`);
+            logger.info(`Trigger delayed change for attribute "${this.name}" with value ${Diagnostic.json(newValue)}`);
             this.handleVersionAndTriggerListeners(newValue, oldValue, changed);
         }
     }
@@ -909,7 +918,7 @@ export class FabricScopedAttributeServer<T> extends AttributeServer<T> {
             () => !preserveFabricIndex, // No one should send any index and if we simply SHALL ignore it,  but internally we might need it
         );
         logger.info(
-            `Set remote value for fabric scoped attribute "${this.name}" to ${Logger.toJSON(value)} (delayed=${delayChangeEvents})`,
+            `Set remote value for fabric scoped attribute "${this.name}" to ${Diagnostic.json(value)} (delayed=${delayChangeEvents})`,
         );
 
         super.setRemote(value, session, message, delayChangeEvents);

package/src/cluster/server/CommandServer.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Logger } from "#general";
+import { Diagnostic, Logger } from "#general";
 import { AccessLevel, FabricIndex } from "#model";
 import { CommandId, StatusCode, TlvSchema, TlvStream } from "#types";
 import { Message } from "../../codec/MessageCodec.js";
@@ -69,9 +69,9 @@ export class CommandServer<RequestT = any, ResponseT = any> {
         }
 
         this.requestSchema.validate(request);
-        this.debug(`Invoke ${this.name} with data ${Logger.toJSON(request)}`);
+        this.debug(`Invoke ${this.name} with data ${Diagnostic.json(request)}`);
         const response = await this.handler(request, session, message, endpoint);
-        this.debug(`Invoke ${this.name} response : ${Logger.toJSON(response)}`);
+        this.debug(`Invoke ${this.name} response : ${Diagnostic.json(response)}`);
         return {
             code: StatusCode.Success,
             responseId: this.responseId,

package/src/common/FailsafeContext.ts

@@ -249,7 +249,7 @@ export abstract class FailsafeContext {
     }
 
     async #failSafeExpired() {
-        logger.info("Failsafe timer expired, Reset fabric builder.");
+        logger.info("Failsafe timer expired; resetting fabric builder");
 
         await this.close();
     }

package/src/endpoint/EndpointStructureLogger.ts

@@ -52,7 +52,7 @@ function getAttributeServerValue(attribute: AnyAttributeServer<any>, options: En
             attributeValue !== null &&
             options.logAttributeObjectValues !== false
         ) {
-            value = Logger.toJSON(attributeValue);
+            value = Diagnostic.json(attributeValue);
         }
     } catch (error) {
         if (error instanceof FabricScopeError) {

package/src/events/OccurrenceManager.ts

@@ -7,6 +7,7 @@
 import {
     asyncNew,
     Construction,
+    Diagnostic,
     ImplementationError,
     isObject,
     Logger,
@@ -151,7 +152,7 @@ export class OccurrenceManager {
 
         // TODO - log after fabric filtering and include fabric filter in log message?
         logger.debug(
-            `Got ${occurrences.length} events for ${resolveEventName(eventPath)} with filters: ${Logger.toJSON(filters)}`,
+            `Got ${occurrences.length} events for ${resolveEventName(eventPath)} with filters: ${Diagnostic.json(filters)}`,
         );
 
         // Convert from MaybePromise[] to MaybePromise<[]>
@@ -210,7 +211,7 @@ export class OccurrenceManager {
 
     add(occurrence: Occurrence): MaybePromise<NumberedOccurrence> {
         return MaybePromise.then(this.#store.add(occurrence), entry => {
-            logger.debug(`Recorded event #${entry.number}: ${Logger.toJSON(occurrence)}`);
+            logger.debug(`Recorded event #${entry.number}: ${Diagnostic.json(occurrence)}`);
             this.#occurrences[occurrence.priority].push(entry);
             this.#storedEventCount++;
             if (this.#storedEventCount > this.#bufferConfig.maxEventAllowance) {

package/src/interaction/AttributeDataDecoder.ts

@@ -16,17 +16,18 @@ import {
     getClusterAttributeById,
     getClusterById,
     NodeId,
+    Status,
     TlvAny,
     TlvAttributeData,
     TlvAttributeReport,
+    TlvAttributeStatus,
     TlvSchema,
     TypeFromSchema,
 } from "#types";
 
 const logger = Logger.get("AttributeDataDecoder");
 
-/** Represents a fully qualified and decoded attribute value from a received DataReport */
-export type DecodedAttributeReportValue<T> = {
+type DecodedAttributeReportEntry = {
     path: {
         nodeId?: NodeId;
         endpointId: EndpointNumber;
@@ -34,10 +35,20 @@ export type DecodedAttributeReportValue<T> = {
         attributeId: AttributeId;
         attributeName: string;
     };
+};
+
+/** Represents a fully qualified and decoded attribute value from a received DataReport */
+export type DecodedAttributeReportValue<T> = DecodedAttributeReportEntry & {
     version: number;
     value: T;
 };
 
+/** Represents a fully qualified and decoded attribute status from a received DataReport */
+export type DecodedAttributeReportStatus = DecodedAttributeReportEntry & {
+    status?: Status;
+    clusterStatus?: number;
+};
+
 /** Represents a decoded attribute value from a received DataReport where data version could be optional. */
 export type DecodedAttributeValue<T> = Omit<DecodedAttributeReportValue<T>, "version"> & {
     version?: number;
@@ -46,14 +57,20 @@ export type DecodedAttributeValue<T> = Omit<DecodedAttributeReportValue<T>, "ver
 /**
  * Parses, normalizes (e.g. un-chunk arrays and resolve Tag compression if used) and decodes the attribute data from
  * a received DataReport.
+ * TODO: Convert into a Generator function once we migrate Reading Data for controller to also be streaming
  */
-export function normalizeAndDecodeReadAttributeReport(
-    data: TypeFromSchema<typeof TlvAttributeReport>[],
-): DecodedAttributeReportValue<any>[] {
+export function normalizeAndDecodeReadAttributeReport(data: TypeFromSchema<typeof TlvAttributeReport>[]): {
+    attributeData: DecodedAttributeReportValue<any>[];
+    attributeStatus: DecodedAttributeReportStatus[];
+} {
     // TODO Decide how to handle the attribute report status field, right now we ignore it
     const dataValues = data.flatMap(({ attributeData }) => (attributeData !== undefined ? attributeData : []));
+    const dataStatus = data.flatMap(({ attributeStatus }) => (attributeStatus !== undefined ? attributeStatus : []));
 
-    return normalizeAndDecodeAttributeData(dataValues) as DecodedAttributeReportValue<any>[]; // dataVersion existing in incoming data, so must also in outgoing data
+    return {
+        attributeData: normalizeAndDecodeAttributeData(dataValues) as DecodedAttributeReportValue<any>[],
+        attributeStatus: normalizeAttributeStatus(dataStatus),
+    };
 }
 
 export function expandPathsInAttributeData(
@@ -90,7 +107,7 @@ export function expandPathsInAttributeData(
                 dataVersion: value.dataVersion,
             };
         } else if (!acceptWildcardPaths) {
-            throw new UnexpectedDataError("Tag compression disabled, but path is incomplete: " + Logger.toJSON(path));
+            throw new UnexpectedDataError("Tag compression disabled, but path is incomplete: " + Diagnostic.json(path));
         }
     });
     return data;
@@ -121,6 +138,49 @@ export function normalizeAttributeData(
     return Array.from(responseList.values());
 }
 
+/**
+ * Normalizes (e.g. un-chunk arrays and resolve Tag compression if used) and decodes the attribute data from a received
+ * DataReport.
+ */
+export function normalizeAttributeStatus(
+    data: TypeFromSchema<typeof TlvAttributeStatus>[],
+): DecodedAttributeReportStatus[] {
+    const result = new Array<DecodedAttributeReportStatus>();
+    data.forEach(entry => {
+        const {
+            path: { nodeId, endpointId, clusterId, attributeId },
+            status,
+        } = entry;
+
+        if (endpointId === undefined || clusterId === undefined || attributeId === undefined) {
+            throw new UnexpectedDataError(`Invalid attribute path ${endpointId}/${clusterId}/${attributeId}`);
+        }
+        const cluster = getClusterById(clusterId);
+        const attributeDetail = getClusterAttributeById(cluster, attributeId);
+        if (attributeDetail === undefined) {
+            result.push({
+                path: {
+                    nodeId,
+                    endpointId,
+                    clusterId,
+                    attributeId,
+                    attributeName: `Unknown (${Diagnostic.hex(attributeId)})`,
+                },
+                status: status.status,
+                clusterStatus: status.clusterStatus,
+            });
+
+            return;
+        }
+        result.push({
+            path: { nodeId, endpointId, clusterId, attributeId, attributeName: attributeDetail.name },
+            status: status.status,
+            clusterStatus: status.clusterStatus,
+        });
+    });
+    return result;
+}
+
 /**
  * Normalizes (e.g. un-chunk arrays and resolve Tag compression if used) and decodes the attribute data from a received
  * DataReport.

package/src/interaction/AttributeDataEncoder.ts

@@ -3,7 +3,7 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Logger, MatterFlowError } from "#general";
+import { Diagnostic, MatterFlowError } from "#general";
 import {
     ArraySchema,
     AttributeId,
@@ -77,7 +77,7 @@ export function encodeAttributePayloadData(
     const { attributeData } = attributePayload;
     if (attributeData === undefined) {
         throw new MatterFlowError(
-            `Cannot encode Attribute Payload data with just a attributeStatus: ${Logger.toJSON(attributePayload)}`,
+            `Cannot encode Attribute Payload data with just a attributeStatus: ${Diagnostic.json(attributePayload)}`,
         );
     }
 
@@ -152,13 +152,13 @@ export function chunkAttributePayload(attributePayload: AttributeReportPayload):
     const { hasFabricSensitiveData, attributeData } = attributePayload;
     if (attributeData === undefined) {
         throw new MatterFlowError(
-            `Cannot chunk an AttributePayload with just a attributeStatus: ${Logger.toJSON(attributePayload)}`,
+            `Cannot chunk an AttributePayload with just a attributeStatus: ${Diagnostic.json(attributePayload)}`,
         );
     }
     const { schema, path, dataVersion, payload } = attributeData;
     if (!(schema instanceof ArraySchema) || !Array.isArray(payload)) {
         throw new MatterFlowError(
-            `Cannot chunk an AttributePayload with attributeData that is not an array: ${Logger.toJSON(
+            `Cannot chunk an AttributePayload with attributeData that is not an array: ${Diagnostic.json(
                 attributePayload,
             )}`,
         );

package/src/interaction/DecodedDataReport.ts

@@ -5,13 +5,23 @@
  */
 
 import { DataReport } from "#types";
-import { DecodedAttributeReportValue, normalizeAndDecodeReadAttributeReport } from "./AttributeDataDecoder.js";
-import { DecodedEventReportValue, normalizeAndDecodeReadEventReport } from "./EventDataDecoder.js";
+import {
+    DecodedAttributeReportStatus,
+    DecodedAttributeReportValue,
+    normalizeAndDecodeReadAttributeReport,
+} from "./AttributeDataDecoder.js";
+import {
+    DecodedEventReportStatus,
+    DecodedEventReportValue,
+    normalizeAndDecodeReadEventReport,
+} from "./EventDataDecoder.js";
 
 export interface DecodedDataReport extends DataReport {
     isNormalized: true;
     attributeReports: DecodedAttributeReportValue<any>[];
+    attributeStatus?: DecodedAttributeReportStatus[];
     eventReports: DecodedEventReportValue<any>[];
+    eventStatus?: DecodedEventReportStatus[];
 }
 
 export function DecodedDataReport(report: DataReport): DecodedDataReport {
@@ -19,11 +29,20 @@ export function DecodedDataReport(report: DataReport): DecodedDataReport {
         return report as DecodedDataReport;
     }
 
+    const { attributeData: attributeReports, attributeStatus } =
+        report.attributeReports === undefined
+            ? { attributeData: [] }
+            : normalizeAndDecodeReadAttributeReport(report.attributeReports);
+
+    const { eventData: eventReports, eventStatus } =
+        report.eventReports === undefined ? { eventData: [] } : normalizeAndDecodeReadEventReport(report.eventReports);
+
     return {
         ...report,
         isNormalized: true,
-        attributeReports:
-            report.attributeReports === undefined ? [] : normalizeAndDecodeReadAttributeReport(report.attributeReports),
-        eventReports: report.eventReports === undefined ? [] : normalizeAndDecodeReadEventReport(report.eventReports),
+        attributeReports,
+        attributeStatus,
+        eventReports,
+        eventStatus,
     };
 }

package/src/interaction/EventDataDecoder.ts

@@ -14,9 +14,11 @@ import {
     getClusterById,
     getClusterEventById,
     NodeId,
+    Status,
     TlvAny,
     TlvEventData,
     TlvEventReport,
+    TlvEventStatus,
     TlvStream,
     TypeFromSchema,
 } from "#types";
@@ -33,7 +35,7 @@ export type DecodedEventData<T> = {
     data?: T;
 };
 
-export type DecodedEventReportValue<T> = {
+export type DecodedEventReportEntry = {
     path: {
         nodeId?: NodeId;
         endpointId: EndpointNumber;
@@ -41,16 +43,32 @@ export type DecodedEventReportValue<T> = {
         eventId: EventId;
         eventName: string;
     };
+};
+
+/** Represents a fully qualified and decoded attribute value from a received DataReport */
+export type DecodedEventReportValue<T> = DecodedEventReportEntry & {
     events: DecodedEventData<T>[];
 };
 
-export function normalizeAndDecodeReadEventReport(
-    data: TypeFromSchema<typeof TlvEventReport>[],
-): DecodedEventReportValue<any>[] {
+/** Represents a fully qualified and decoded attribute status from a received DataReport */
+export type DecodedEventReportStatus = DecodedEventReportEntry & {
+    status?: Status;
+    clusterStatus?: number;
+};
+
+// TODO: Convert into a Generator function once we migrate Reading Data for controller to also be streaming
+export function normalizeAndDecodeReadEventReport(data: TypeFromSchema<typeof TlvEventReport>[]): {
+    eventData: DecodedEventReportValue<any>[];
+    eventStatus: DecodedEventReportStatus[];
+} {
     // TODO Decide how to handle the attribute report status field, right now we ignore it
     const dataValues = data.flatMap(({ eventData }) => (eventData !== undefined ? eventData : []));
+    const dataStatus = data.flatMap(({ eventStatus }) => (eventStatus !== undefined ? eventStatus : []));
 
-    return normalizeAndDecodeEventData(dataValues);
+    return {
+        eventData: normalizeAndDecodeEventData(dataValues),
+        eventStatus: normalizeEventStatus(dataStatus),
+    };
 }
 
 export function normalizeEventData(
@@ -121,6 +139,40 @@ export function normalizeAndDecodeEventData(
     return result;
 }
 
+export function normalizeEventStatus(data: TypeFromSchema<typeof TlvEventStatus>[]): DecodedEventReportStatus[] {
+    const result = new Array<DecodedEventReportStatus>();
+    data.forEach(entry => {
+        const {
+            path: { nodeId, endpointId, clusterId, eventId },
+            status,
+        } = entry;
+
+        if (endpointId === undefined || clusterId === undefined || eventId === undefined) {
+            throw new UnexpectedDataError(`Invalid event path ${endpointId}/${clusterId}/${eventId}`);
+        }
+        try {
+            const cluster = getClusterById(clusterId);
+            const eventDetail = getClusterEventById(cluster, eventId);
+            if (eventDetail === undefined) {
+                result.push({
+                    path: { nodeId, endpointId, clusterId, eventId, eventName: `Unknown (${Diagnostic.hex(eventId)})` },
+                    status: status.status,
+                    clusterStatus: status.clusterStatus,
+                });
+                return;
+            }
+            result.push({
+                path: { nodeId, endpointId, clusterId, eventId, eventName: eventDetail.name },
+                status: status.status,
+                clusterStatus: status.clusterStatus,
+            });
+        } catch (error: any) {
+            logger.error(`Error decoding event ${endpointId}/${clusterId}/${eventId}: ${error.message}`);
+        }
+    });
+    return result;
+}
+
 export function decodeUnknownEventValue(data: TlvStream): any {
     const schema = TlvAny;