@matter/protocol 0.16.0-alpha.0-20251205-dfb1e1556 → 0.16.0-alpha.0-20251209-d6072d23e

package/src/fabric/FabricManager.ts

@@ -5,6 +5,7 @@
  */
 
 import {
+    AsyncObservable,
     Bytes,
     Construction,
     Crypto,
@@ -17,6 +18,7 @@ import {
     MatterFlowError,
     MaybePromise,
     Observable,
+    Observer,
     StorageContext,
     StorageManager,
 } from "#general";
@@ -30,12 +32,6 @@ const logger = Logger.get("FabricManager");
 export class FabricNotFoundError extends MatterError {}
 export class FabricTableFullError extends MatterError {}
 
-export enum FabricAction {
-    Added,
-    Removed,
-    Updated,
-}
-
 export class FabricManager {
     #crypto: Crypto;
     #nextFabricIndex = 1;
@@ -44,8 +40,10 @@ export class FabricManager {
     #storage?: StorageContext;
     #events = {
         added: Observable<[fabric: Fabric]>(),
-        updated: Observable<[fabric: Fabric]>(),
-        deleted: Observable<[fabric: Fabric]>(),
+        replaced: Observable<[fabric: Fabric]>(unhandled("replacing")),
+        leaving: Observable<[fabric: Fabric]>(unhandled("leaving")),
+        deleting: AsyncObservable<[fabric: Fabric]>(unhandled("deleting")),
+        deleted: AsyncObservable<[fabric: Fabric]>(unhandled("deleted")),
         failsafeClosed: Observable<[]>(),
     };
     #construction: Construction<FabricManager>;
@@ -111,7 +109,8 @@ export class FabricManager {
         if (typeof address === "object") {
             address = address.fabricIndex;
         }
-        return this.#fabrics.has(address);
+        const fabric = this.maybeForIndex(address);
+        return fabric && !fabric.isDeleting;
     }
 
     for(address: FabricIndex | PeerAddress) {
@@ -149,7 +148,7 @@ export class FabricManager {
 
         const storeResult = this.#storage.set(
             "fabrics",
-            Array.from(this.#fabrics.values()).map(fabric => fabric.config),
+            this.fabrics.map(fabric => fabric.config),
         );
         if (MaybePromise.is(storeResult)) {
             return storeResult.then(() => this.#storage!.set("nextFabricIndex", this.#nextFabricIndex));
@@ -179,20 +178,22 @@ export class FabricManager {
     #addOrUpdateFabricEntry(fabric: Fabric) {
         const { fabricIndex } = fabric;
         this.#fabrics.set(fabricIndex, fabric);
-        fabric.addRemoveCallback(async () => this.removeFabric(fabricIndex));
+
+        fabric.leaving.on(() => this.events.leaving.emit(fabric));
+        fabric.deleting.on(() => this.events.deleting.emit(fabric));
+        fabric.deleted.on(() => this.#handleFabricDeleted(fabric));
+
         fabric.persistCallback = (isUpdate = true) => {
             if (!this.#storage) {
                 if (isUpdate) {
-                    logger.warn(
-                        "Fabric can not be persisted because FabricManager has no storage but it is a fabric update.",
-                    );
+                    logger.warn(`Fabric ${fabricIndex} cannot persist because FabricManager has no storage`);
                 }
                 return;
             }
             const persistResult = this.persistFabrics();
             return MaybePromise.then(persistResult, () => {
                 if (isUpdate) {
-                    this.#events.updated.emit(fabric); // Assume Fabric got updated when persist callback is called
+                    this.#events.replaced.emit(fabric); // Assume Fabric got updated when persist callback is called
                 }
             });
         };
@@ -201,32 +202,26 @@ export class FabricManager {
         }
     }
 
-    async removeFabric(fabricIndex: FabricIndex) {
+    async #handleFabricDeleted(fabric: Fabric) {
         await this.#construction;
 
-        const fabric = this.#fabrics.get(fabricIndex);
-        if (fabric === undefined)
-            throw new FabricNotFoundError(
-                `Fabric with index ${fabricIndex} cannot be removed because it does not exist.`,
-            );
-        this.#fabrics.delete(fabricIndex);
+        this.#fabrics.delete(fabric.fabricIndex);
         if (this.#storage) {
             await this.persistFabrics();
         }
         await fabric.storage?.clearAll();
-        this.#events.deleted.emit(fabric);
     }
 
     [Symbol.iterator]() {
         this.#construction.assert();
 
-        return this.#fabrics.values();
+        return this.fabrics[Symbol.iterator]();
     }
 
     get fabrics() {
         this.#construction.assert();
 
-        return Array.from(this.#fabrics.values());
+        return Array.from(this.#fabrics.values()).filter(fabric => !fabric.isDeleting);
     }
 
     get length() {
@@ -247,6 +242,10 @@ export class FabricManager {
         for (const fabric of this.#fabrics.values()) {
             const candidateDestinationIds = await fabric.destinationIdsFor(fabric.nodeId, initiatorRandom);
             if (candidateDestinationIds.some(candidate => Bytes.areEqual(candidate, destinationId))) {
+                if (fabric.isDeleting) {
+                    throw new FabricNotFoundError("Fabric is deleting");
+                }
+
                 return fabric;
             }
         }
@@ -257,7 +256,7 @@ export class FabricManager {
     findByKeypair(keypair: Key) {
         this.#construction.assert();
 
-        for (const fabric of this.#fabrics.values()) {
+        for (const fabric of this.fabrics) {
             if (fabric.matchesKeyPair(keypair)) {
                 return fabric;
             }
@@ -265,10 +264,26 @@ export class FabricManager {
         return undefined;
     }
 
-    findByIndex(index: FabricIndex) {
+    maybeForIndex(index: FabricIndex) {
         this.#construction.assert();
 
-        return this.#fabrics.get(index);
+        const fabric = this.#fabrics.get(index);
+        if (fabric && !fabric.isDeleting) {
+            return fabric;
+        }
+    }
+
+    forIndex(index: FabricIndex) {
+        this.#construction.assert();
+
+        const fabric = this.#fabrics.get(index);
+        if (fabric === undefined) {
+            throw new FabricNotFoundError(`Fabric index ${index} does not exist`);
+        }
+        if (fabric.isDeleting) {
+            throw new FabricNotFoundError(`Fabric index ${index} is deleting`);
+        }
+        return fabric;
     }
 
     forDescriptor(descriptor: { rootPublicKey: Bytes; fabricId: FabricId }) {
@@ -281,14 +296,14 @@ export class FabricManager {
         );
     }
 
-    async updateFabric(fabric: Fabric) {
+    async replaceFabric(fabric: Fabric) {
         await this.#construction;
 
         const { fabricIndex } = fabric;
         const existingFabric = this.#fabrics.get(fabricIndex);
         if (existingFabric === undefined) {
             throw new FabricNotFoundError(
-                `Fabric with index ${fabricIndex} cannot be updated because it does not exist.`,
+                `Fabric with index ${fabricIndex} cannot be replaced because it does not exist.`,
             );
         }
         if (existingFabric === fabric) {
@@ -301,16 +316,14 @@ export class FabricManager {
         if (this.#storage) {
             await this.persistFabrics();
         }
-        this.#events.updated.emit(fabric);
+        this.#events.replaced.emit(fabric);
     }
+}
 
-    async revokeFabric(fabricIndex: FabricIndex) {
-        await this.#construction;
-
-        const fabric = this.#fabrics.get(fabricIndex);
-        if (fabric === undefined) {
-            throw new MatterFlowError(`Fabric with index ${fabricIndex} does not exist to revoke.`);
-        }
-        await fabric.remove();
-    }
+// Log unhandled errors but do not abort deletion.  We will still likely end up with inconsistent state but should be
+// less harmful (and more secure) if we allow other observers to proceed
+function unhandled(what: string) {
+    return (e: Error, observer: Observer) => {
+        logger.error(`Unhandled error in fabric ${what} observer ${observer.name || "(anon)"}`, e);
+    };
 }

package/src/index.ts

@@ -4,6 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+// Must import first to avoid ESM load issues
+export * from "./session/index.js";
+
 export * from "./action/index.js";
 export * from "./advertisement/index.js";
 export * from "./bdx/index.js";
@@ -21,4 +24,3 @@ export * from "./mdns/index.js";
 export * from "./peer/index.js";
 export * from "./protocol/index.js";
 export * from "./securechannel/index.js";
-export * from "./session/index.js";

package/src/interaction/InteractionClient.ts

@@ -6,6 +6,7 @@
 
 import { ReadScope } from "#action/client/ReadScope.js";
 import { AccessControl } from "#clusters/access-control";
+import { Mark } from "#common/Mark.js";
 import {
     Diagnostic,
     Duration,
@@ -27,6 +28,7 @@ import { Specification } from "#model";
 import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
 import { PeerDataStore } from "#peer/PeerAddressStore.js";
 import { PeerConnectionOptions, PeerSet } from "#peer/PeerSet.js";
+import { SecureSession } from "#session/SecureSession.js";
 import {
     ArraySchema,
     Attribute,
@@ -57,11 +59,11 @@ import {
     resolveEventName,
 } from "#types";
 import { ExchangeProvider, ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
-import { MessageChannel } from "../protocol/MessageChannel.js";
 import { DecodedAttributeReportStatus, DecodedAttributeReportValue } from "./AttributeDataDecoder.js";
 import { DecodedDataReport } from "./DecodedDataReport.js";
 import { DecodedEventData, DecodedEventReportStatus, DecodedEventReportValue } from "./EventDataDecoder.js";
 import { InteractionClientMessenger, ReadRequest } from "./InteractionMessenger.js";
+import { Subscription } from "./Subscription.js";
 import { RegisteredSubscription, SubscriptionClient } from "./SubscriptionClient.js";
 
 const logger = Logger.get("InteractionClient");
@@ -97,7 +99,7 @@ export class InteractionClientProvider {
     constructor(peers: PeerSet) {
         this.#peers = peers;
         this.#peers.deleted.on(peer => this.#onPeerLoss(peer.address));
-        this.#peers.disconnected.on(address => this.#onPeerLoss(address));
+        this.#peers.disconnected.on(peer => this.#onPeerLoss(peer.address));
     }
 
     static [Environmental.create](env: Environment) {
@@ -126,8 +128,8 @@ export class InteractionClientProvider {
         return this.getInteractionClient(address, options);
     }
 
-    async getInteractionClientForChannel(channel: MessageChannel): Promise<InteractionClient> {
-        const exchangeProvider = await this.#peers.exchangeProviderFor(channel);
+    async interactionClientFor(session: SecureSession): Promise<InteractionClient> {
+        const exchangeProvider = await this.#peers.exchangeProviderFor(session);
 
         return new InteractionClient(
             exchangeProvider,
@@ -144,7 +146,7 @@ export class InteractionClientProvider {
         }
 
         const isGroupAddress = PeerAddress.isGroup(address);
-        const nodeStore = isGroupAddress ? undefined : this.#peers.get(address)?.dataStore;
+        const nodeStore = isGroupAddress ? undefined : this.#peers.get(address)?.descriptor.dataStore;
         await nodeStore?.construction; // Lazy initialize the data if not already done
 
         const exchangeProvider = await this.#peers.exchangeProviderFor(address, options);
@@ -554,7 +556,8 @@ export class InteractionClient {
     ): Promise<DecodedDataReport> {
         const { attributeRequests, eventRequests, dataVersionFilters, eventFilters, isFabricFiltered } = request;
         logger.debug(() => [
-            "Read »",
+            "Read",
+            Mark.OUTBOUND,
             messenger.exchange.via,
             Diagnostic.dict({
                 attributes: attributeRequests?.length
@@ -590,7 +593,8 @@ export class InteractionClient {
 
         if (attributeReports.length || eventReports.length || attributeStatus?.length || eventStatus?.length) {
             logger.debug(() => [
-                "Read «",
+                "Read",
+                Mark.INBOUND,
                 messenger.exchange.via,
                 Diagnostic.dict({
                     attributes: attributeReports.length
@@ -611,7 +615,7 @@ export class InteractionClient {
                 }),
             ]);
         } else {
-            logger.debug("Read «", messenger.exchange.via, "empty response");
+            logger.debug("Read", Mark.INBOUND, messenger.exchange.via, "empty response");
         }
 
         return response;
@@ -739,7 +743,8 @@ export class InteractionClient {
                 }
 
                 logger.debug(() => [
-                    "Write »",
+                    "Write",
+                    Mark.OUTBOUND,
                     messenger.exchange.via,
                     Diagnostic.dict({
                         attributes: attributes
@@ -818,7 +823,7 @@ export class InteractionClient {
         if (!keepSubscriptions) {
             for (const subscriptionId of this.#ownSubscriptionIds) {
                 logger.debug(
-                    `Removing subscription with ID ${subscriptionId} from InteractionClient because new subscription replaces it`,
+                    `Removing subscription ${Subscription.idStrOf(subscriptionId)} from InteractionClient because new subscription replaces it`,
                 );
                 this.removeSubscription(subscriptionId);
             }
@@ -848,7 +853,8 @@ export class InteractionClient {
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
             logger.debug(() => [
-                "Subscribe »",
+                "Subscribe",
+                Mark.OUTBOUND,
                 messenger.exchange.via,
                 Diagnostic.dict({
                     attributes: resolveAttributeName({ endpointId, clusterId, attributeId }),
@@ -953,7 +959,8 @@ export class InteractionClient {
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
             logger.debug(() => [
-                "Subscribe »",
+                "Subscribe",
+                Mark.OUTBOUND,
                 messenger.exchange.via,
                 Diagnostic.dict({
                     events: resolveEventName({ endpointId, clusterId, eventId }),
@@ -1091,7 +1098,7 @@ export class InteractionClient {
         if (!keepSubscriptions) {
             for (const subscriptionId of this.#ownSubscriptionIds) {
                 logger.debug(
-                    `Removing subscription with ID ${subscriptionId} from InteractionClient because new subscription replaces it`,
+                    `Removing subscription with ID ${Subscription.idStrOf(subscriptionId)} from InteractionClient because new subscription replaces it`,
                 );
                 this.removeSubscription(subscriptionId);
             }
@@ -1124,7 +1131,8 @@ export class InteractionClient {
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
             logger.debug(() => [
-                "Subscribe »",
+                "Subscribe",
+                Mark.OUTBOUND,
                 messenger.exchange.via,
                 Diagnostic.dict({
                     attributes: attributeRequests.length
@@ -1157,10 +1165,11 @@ export class InteractionClient {
             );
 
             logger.info(
-                "Subscription successful «",
+                "Subscription successful",
+                Mark.INBOUND,
                 messenger.exchange.via,
                 Diagnostic.dict({
-                    subId: subscribeResponse.subscriptionId,
+                    ...Subscription.diagnosticOf(subscribeResponse.subscriptionId),
                     maxInterval: Duration.format(Seconds(subscribeResponse.maxInterval)),
                 }),
             );
@@ -1187,10 +1196,12 @@ export class InteractionClient {
             const { attributeReports, eventReports } = dataReport;
 
             // We emit events first because events usually happened and lead to a new final attribute value
-            if (eventReports !== undefined) {
+            if (eventReports?.length) {
                 let maxEventNumber = this.#nodeStore?.maxEventNumber ?? eventReports[0].events[0].eventNumber;
                 eventReports.forEach(data => {
-                    logger.debug(`Event update « ${resolveEventName(data.path)}: ${Diagnostic.json(data.events)}`);
+                    logger.debug(
+                        `Event update ${Mark.INBOUND} ${resolveEventName(data.path)}: ${Diagnostic.json(data.events)}`,
+                    );
                     const { events } = data;
 
                     maxEventNumber =
@@ -1261,7 +1272,7 @@ export class InteractionClient {
                 await this.#nodeStore?.persistAttributes([data], scope);
             }
             logger.debug(
-                `Attribute update «${changed ? " (value changed)" : ""}: ${resolveAttributeName({
+                `Attribute update ${Mark.INBOUND}${changed ? " (value changed)" : ""}: ${resolveAttributeName({
                     endpointId,
                     clusterId,
                     attributeId,
@@ -1406,11 +1417,15 @@ export class InteractionClient {
             }
             const response = responseSchema.decodeTlv(commandFields);
             logger.debug(
-                `Invoke « ${resolveCommandName({
+                "Invoke",
+                Mark.INBOUND,
+                resolveCommandName({
                     endpointId,
                     clusterId,
                     commandId: requestId,
-                })} with ${Diagnostic.json(response)})}`,
+                }),
+                "with",
+                Diagnostic.json(response),
             );
             return response;
         }
@@ -1480,11 +1495,13 @@ export class InteractionClient {
         }, executeQueued);
 
         logger.debug(
-            `Invoke successful « ${resolveCommandName({
+            "Invoke successful",
+            Mark.INBOUND,
+            resolveCommandName({
                 endpointId,
                 clusterId,
                 commandId: requestId,
-            })}`,
+            }),
         );
     }
 

package/src/interaction/InteractionMessenger.ts

@@ -5,10 +5,12 @@
  */
 
 import { ReadResult } from "#action/response/ReadResult.js";
+import { Mark } from "#common/Mark.js";
 import {
     Bytes,
     Diagnostic,
     Duration,
+    hex,
     InternalError,
     Logger,
     MatterFlowError,
@@ -19,14 +21,13 @@ import {
 import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
 import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
 import { Specification } from "#model";
-import { ChannelNotConnectedError } from "#protocol/MessageChannel.js";
+import { RetransmissionLimitReachedError, SessionClosedError, UnexpectedMessageError } from "#protocol/errors.js";
 import {
     AttributeId,
     ClusterId,
     EndpointNumber,
     ReceivedStatusResponseError,
     Status,
-    StatusCode,
     StatusResponseError,
     TlvAny,
     TlvAttributeReport,
@@ -48,12 +49,7 @@ import {
 } from "#types";
 import { Message, SessionType } from "../codec/MessageCodec.js";
 import { ExchangeProvider } from "../protocol/ExchangeProvider.js";
-import {
-    ExchangeSendOptions,
-    MessageExchange,
-    RetransmissionLimitReachedError,
-    UnexpectedMessageError,
-} from "../protocol/MessageExchange.js";
+import { ExchangeSendOptions, MessageExchange } from "../protocol/MessageExchange.js";
 import {
     AttributeReportPayload,
     BaseDataReport,
@@ -65,6 +61,7 @@ import {
     encodeEventPayload,
     EventReportPayload,
 } from "./AttributeDataEncoder.js";
+import { Subscription } from "./Subscription.js";
 
 export enum MessageType {
     StatusResponse = 0x01,
@@ -123,7 +120,7 @@ class InteractionMessenger {
         return this.exchange.send(messageType, payload, options);
     }
 
-    sendStatus(status: StatusCode, options?: ExchangeSendOptions) {
+    sendStatus(status: Status, options?: ExchangeSendOptions) {
         return this.send(
             MessageType.StatusResponse,
             TlvStatusResponse.encode({ status, interactionModelRevision: Specification.INTERACTION_MODEL_REVISION }),
@@ -131,7 +128,7 @@ class InteractionMessenger {
                 ...options,
                 logContext: {
                     for: options?.logContext?.for ? `I/Status-${options?.logContext?.for}` : undefined,
-                    status: `${StatusCode[status] ?? "unknown"}(${Diagnostic.hex(status)})`,
+                    status: `${Status[status] ?? "unknown"}(${Diagnostic.hex(status)})`,
                     ...options?.logContext,
                 },
             },
@@ -202,7 +199,7 @@ class InteractionMessenger {
 
         if (messageType !== MessageType.StatusResponse) return;
         const { status } = TlvStatusResponse.decode(payload);
-        if (status !== StatusCode.Success)
+        if (status !== Status.Success)
             throw new ReceivedStatusResponseError(
                 `Received error status: ${status}${logHint ? ` (${logHint})` : ""}`,
                 status,
@@ -305,7 +302,7 @@ export class InteractionServerMessenger extends InteractionMessenger {
                         }
                         const timedRequest = TlvTimedRequest.decode(message.payload);
                         recipient.handleTimedRequest(this.exchange, timedRequest, message);
-                        await this.sendStatus(StatusCode.Success, {
+                        await this.sendStatus(Status.Success, {
                             logContext: { for: "TimedRequest" },
                         });
                         continueExchange = true;
@@ -321,17 +318,28 @@ export class InteractionServerMessenger extends InteractionMessenger {
                     break; // We do not support multiple messages in group sessions
                 }
             }
-        } catch (error: any) {
-            let errorStatusCode = StatusCode.Failure;
+        } catch (error) {
+            if (error instanceof NoResponseTimeoutError) {
+                logger.info(this.exchange.via, error);
+                return;
+            }
+
+            let errorStatusCode = Status.Failure;
             if (error instanceof StatusResponseError) {
-                logger.info(`Sending status response ${error.code} for interaction error: ${error.message}`);
+                logger.info(
+                    this.exchange.via,
+                    "Status response",
+                    Mark.OUTBOUND,
+                    Diagnostic.strong(`${Status[error.code]}#${error.code}`),
+                    "due to error:",
+                    Diagnostic.errorMessage(error),
+                );
                 errorStatusCode = error.code;
-            } else if (error instanceof NoResponseTimeoutError) {
-                logger.info(error);
             } else {
-                logger.warn(error);
+                logger.warn(this.exchange.via, error);
             }
-            if (!isGroupSession && !(error instanceof NoResponseTimeoutError)) {
+
+            if (!isGroupSession) {
                 await this.sendStatus(errorStatusCode);
             }
         } finally {
@@ -687,7 +695,7 @@ export class InteractionServerMessenger extends InteractionMessenger {
         }
 
         const logContext = {
-            subId: dataReportToSend.subscriptionId,
+            ...Subscription.diagnosticOf(dataReportToSend),
             interactionFlags: Diagnostic.asFlags({
                 empty: !dataReportToSend.attributeReports?.length && !dataReportToSend.eventReports?.length,
                 suppressResponse: dataReportToSend.suppressResponse,
@@ -920,22 +928,20 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
         for await (const report of this.readDataReports()) {
             if (expectedSubscriptionIds !== undefined) {
                 if (report.subscriptionId === undefined || !expectedSubscriptionIds.includes(report.subscriptionId)) {
-                    await this.sendStatus(StatusCode.InvalidSubscription, {
+                    await this.sendStatus(Status.InvalidSubscription, {
                         multipleMessageInteraction: true,
-                        logContext: {
-                            subId: report.subscriptionId,
-                        },
+                        logContext: Subscription.diagnosticOf(report),
                     });
                     throw new UnexpectedDataError(
                         report.subscriptionId === undefined
                             ? "Invalid Data report without Subscription ID"
-                            : `Invalid Data report with unexpected subscription ID ${report.subscriptionId}`,
+                            : `Invalid Data report with unexpected subscription ID ${Subscription.idStrOf(report)}`,
                     );
                 }
             }
 
             if (result?.subscriptionId !== undefined && report.subscriptionId !== result.subscriptionId) {
-                throw new UnexpectedDataError(`Invalid subscription ID ${report.subscriptionId} received`);
+                throw new UnexpectedDataError(`Invalid subscription ID ${Subscription.idStrOf(report)} received`);
             }
 
             report.attributeReports = report.attributeReports ?? [];
@@ -987,14 +993,14 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
             yield report;
 
             if (report.moreChunkedMessages) {
-                await this.sendStatus(StatusCode.Success, {
+                await this.sendStatus(Status.Success, {
                     multipleMessageInteraction: true,
                     logContext: this.#logContextOf(report),
                 });
             } else if (!report.suppressResponse) {
                 // We received the last message and need to send a final success, but we do not need to wait for it and
                 // also don't care if it fails
-                this.sendStatus(StatusCode.Success, {
+                this.sendStatus(Status.Success, {
                     multipleMessageInteraction: true,
                     logContext: this.#logContextOf(report),
                 }).catch(error => logger.info("Error sending success after final data report chunk", error));
@@ -1008,7 +1014,7 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
 
     #logContextOf(report: DataReport) {
         return {
-            subId: report.subscriptionId,
+            subId: report.subscriptionId === undefined ? undefined : hex.fixed(report.subscriptionId, 8),
             dataReportFlags: Diagnostic.asFlags({
                 empty: !report.attributeReports?.length && !report.eventReports?.length,
                 suppressResponse: report.suppressResponse,
@@ -1037,14 +1043,14 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
     override async send(messageType: number, payload: Bytes, options?: ExchangeSendOptions) {
         try {
             if (this.exchange.channel.closed) {
-                throw new ChannelNotConnectedError("The exchange channel is closed. Please connect the device first.");
+                throw new SessionClosedError("The exchange channel is closed. Please connect the device first.");
             }
 
             return await this.exchange.send(messageType, payload, options);
         } catch (error) {
             if (
                 this.#exchangeProvider.supportsReconnect &&
-                (error instanceof RetransmissionLimitReachedError || error instanceof ChannelNotConnectedError) &&
+                (error instanceof RetransmissionLimitReachedError || error instanceof SessionClosedError) &&
                 !options?.multipleMessageInteraction
             ) {
                 // When retransmission failed (most likely due to a lost connection or invalid session),
@@ -1139,7 +1145,7 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
 
         if (subscribeResponse.subscriptionId !== subscriptionId) {
             throw new MatterFlowError(
-                `Received subscription ID ${subscribeResponse.subscriptionId} instead of ${subscriptionId}`,
+                `Received subscription ID ${Subscription.idStrOf(subscribeResponse.subscriptionId)} instead of ${Subscription.idStrOf(subscriptionId)}`,
             );
         }