@matter/protocol 0.16.0-alpha.0-20251016-b56cf5683 → 0.16.0-alpha.0-20251020-3f6e46245

package/src/interaction/InteractionClient.ts

@@ -383,26 +383,6 @@ export class InteractionClient {
             );
         }
 
-        logger.debug(
-            `Sending read request: attributes: ${attributeRequests
-                ?.map(path => resolveAttributeName(path))
-                .join(", ")} and events: ${eventRequests?.map(path => resolveEventName(path)).join(", ")}`,
-        );
-        if (dataVersionFilters !== undefined && dataVersionFilters?.length > 0) {
-            logger.debug(
-                `Using DataVersionFilters: ${dataVersionFilters
-                    .map(({ endpointId, clusterId, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`)
-                    .join(", ")}`,
-            );
-        }
-        if (eventFilters !== undefined && eventFilters?.length > 0) {
-            logger.debug(
-                `Using event filters: ${eventFilters
-                    .map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`)
-                    .join(", ")}`,
-            );
-        }
-
         const result = await this.withMessenger(async messenger => {
             return await this.processReadRequest(
                 messenger,
@@ -560,12 +540,32 @@ export class InteractionClient {
             oldValue?: any,
         ) => void,
     ): Promise<DecodedDataReport> {
-        const { attributeRequests, eventRequests } = request;
-        logger.debug(
-            `Sending read request to ${messenger.getExchangeChannelName()} for attributes ${attributeRequests
-                ?.map(path => resolveAttributeName(path))
-                .join(", ")} and events ${eventRequests?.map(path => resolveEventName(path)).join(", ")}`,
-        );
+        const { attributeRequests, eventRequests, dataVersionFilters, eventFilters, isFabricFiltered } = request;
+        logger.debug(() => [
+            "Read »",
+            messenger.exchange.via,
+            Diagnostic.dict({
+                attributes: attributeRequests?.length
+                    ? attributeRequests?.map(path => resolveAttributeName(path)).join(", ")
+                    : undefined,
+                events: eventRequests?.length
+                    ? eventRequests?.map(path => resolveEventName(path)).join(", ")
+                    : undefined,
+                dataVersionFilters: dataVersionFilters?.length
+                    ? dataVersionFilters
+                          .map(
+                              ({ path: { endpointId, clusterId }, dataVersion }) =>
+                                  `${endpointId}/${clusterId}=${dataVersion}`,
+                          )
+                          .join(", ")
+                    : undefined,
+                eventFilters: eventFilters?.length
+                    ? eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ")
+                    : undefined,
+                fabricFiltered: isFabricFiltered,
+            }),
+        ]);
+
         // Send read request and combine all (potentially chunked) responses
         await messenger.sendReadRequest(request);
         const scope = ReadScope(request);
@@ -576,24 +576,32 @@ export class InteractionClient {
         // Normalize and decode the response
         const { attributeReports, attributeStatus, eventReports, eventStatus } = response;
 
-        const logData = Array<string>();
-        if (attributeReports.length > 0) {
-            logData.push(
-                `attributes ${attributeReports.map(({ path, value }) => `${resolveAttributeName(path)}=${serialize(value)}`).join(", ")}`,
-            );
-        }
-        if (eventReports.length > 0) {
-            logData.push(`events ${eventReports.map(({ path }) => resolveEventName(path)).join(", ")}`);
+        if (attributeReports.length || eventReports.length || attributeStatus?.length || eventStatus?.length) {
+            logger.debug(() => [
+                "Read «",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    attributes: attributeReports.length
+                        ? attributeReports
+                              .map(({ path, value }) => `${resolveAttributeName(path)}=${serialize(value)}`)
+                              .join(", ")
+                        : undefined,
+                    events: eventReports.length
+                        ? eventReports.map(({ path }) => resolveEventName(path)).join(", ")
+                        : undefined,
+                    attributeStatus: attributeStatus?.length
+                        ? attributeStatus.map(({ path }) => resolveAttributeName(path)).join(", ")
+                        : undefined,
+                    eventStatus: eventStatus?.length
+                        ? eventStatus.map(({ path }) => resolveEventName(path)).join(", ")
+                        : undefined,
+                    fabricFiltered: isFabricFiltered,
+                }),
+            ]);
+        } else {
+            logger.debug("Read «", messenger.exchange.via, "empty response");
         }
-        if (attributeStatus !== undefined && attributeStatus.length > 0) {
-            logData.push(`attributeErrors ${attributeStatus.map(({ path }) => resolveAttributeName(path)).join(", ")}`);
-        }
-        if (eventStatus !== undefined && eventStatus.length > 0) {
-            logData.push(`eventErrors ${eventStatus.map(({ path }) => resolveEventName(path)).join(", ")}`);
-        }
-        logger.debug(
-            logData.length ? `Received read response with ${logData.join(", ")}` : "Received empty read response",
-        );
+
         return response;
     }
 
@@ -674,16 +682,7 @@ export class InteractionClient {
                 throw new ImplementationError("Not all attribute write paths are valid for group address writes.");
             }
         }
-        logger.debug(
-            `Sending write request: ${attributes
-                .map(
-                    ({ endpointId, clusterId, attribute: { id }, value, dataVersion }) =>
-                        `${resolveAttributeName({ endpointId, clusterId, attributeId: id })} = ${Diagnostic.json(
-                            value,
-                        )} (version=${dataVersion})`,
-                )
-                .join(", ")}`,
-        );
+
         // TODO Add multi message write handling with streamed encoding
         const writeRequests = attributes.flatMap(
             ({ endpointId, clusterId, attribute: { id, schema }, value, dataVersion }) => {
@@ -727,6 +726,21 @@ export class InteractionClient {
                     await messenger.sendTimedRequest(timedRequestTimeout);
                 }
 
+                logger.debug(() => [
+                    "Write »",
+                    messenger.exchange.via,
+                    Diagnostic.dict({
+                        attributes: attributes
+                            .map(
+                                ({ endpointId, clusterId, attribute: { id }, value, dataVersion }) =>
+                                    `${resolveAttributeName({ endpointId, clusterId, attributeId: id })} = ${Diagnostic.json(
+                                        value,
+                                    )} (version=${dataVersion})`,
+                            )
+                            .join(", "),
+                    }),
+                ]);
+
                 return await messenger.sendWriteCommand({
                     suppressResponse,
                     timedRequest,
@@ -798,14 +812,6 @@ export class InteractionClient {
             }
         }
 
-        logger.debug(
-            `Sending subscribe request for attribute: ${resolveAttributeName({
-                endpointId,
-                clusterId,
-                attributeId,
-            })}${knownDataVersion !== undefined ? ` (knownDataVersion=${knownDataVersion})` : ""} with minInterval=${minIntervalFloorSeconds}s/maxInterval=${maxIntervalCeilingSeconds}s`,
-        );
-
         const request: SubscribeRequest = {
             interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
             attributeRequests: [{ endpointId, clusterId, attributeId }],
@@ -829,6 +835,18 @@ export class InteractionClient {
             report: DecodedDataReport;
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
+            logger.debug(() => [
+                "Subscribe »",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    attributes: resolveAttributeName({ endpointId, clusterId, attributeId }),
+                    dataVersionFilter: knownDataVersion,
+                    fabricFiltered: isFabricFiltered,
+                    minInterval: Duration.format(Seconds(minIntervalFloorSeconds)),
+                    maxInterval: Duration.format(Seconds(maxIntervalCeilingSeconds)),
+                }),
+            ]);
+
             await messenger.sendSubscribeRequest(request);
             const { subscribeResponse, report } = await messenger.readAggregateSubscribeResponse();
             return {
@@ -913,10 +931,6 @@ export class InteractionClient {
         } = options;
         const { id: eventId } = event;
 
-        logger.debug(
-            `Sending subscribe request for event: ${resolveEventName({ endpointId, clusterId, eventId })} with minInterval=${minIntervalFloor}/maxInterval=${maxIntervalCeiling}`,
-        );
-
         const {
             report,
             subscribeResponse: { subscriptionId, maxInterval },
@@ -926,6 +940,17 @@ export class InteractionClient {
             report: DecodedDataReport;
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
+            logger.debug(() => [
+                "Subscribe »",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    events: resolveEventName({ endpointId, clusterId, eventId }),
+                    fabricFiltered: isFabricFiltered,
+                    minInterval: Duration.format(minIntervalFloor),
+                    maxInterval: Duration.format(maxIntervalCeiling),
+                }),
+            ]);
+
             await messenger.sendSubscribeRequest({
                 interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
                 eventRequests: [{ endpointId, clusterId, eventId, isUrgent }],
@@ -1060,28 +1085,6 @@ export class InteractionClient {
             }
         }
 
-        logger.debug(
-            `Sending subscribe request: attributes: ${attributeRequests
-                .map(path => resolveAttributeName(path))
-                .join(
-                    ", ",
-                )} and events: ${eventRequests.map(path => resolveEventName(path)).join(", ")}, keepSubscriptions=${keepSubscriptions} with minInterval=${minIntervalFloorSeconds}s/maxInterval=${maxIntervalCeilingSeconds}s`,
-        );
-        if (dataVersionFilters !== undefined && dataVersionFilters?.length > 0) {
-            logger.debug(
-                `Using DataVersionFilters: ${dataVersionFilters
-                    .map(({ endpointId, clusterId, dataVersion }) => `${endpointId}/${clusterId}=${dataVersion}`)
-                    .join(", ")}`,
-            );
-        }
-        if (eventFilters !== undefined && eventFilters?.length > 0) {
-            logger.debug(
-                `Using event filters: ${eventFilters
-                    .map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`)
-                    .join(", ")}`,
-            );
-        }
-
         const request: SubscribeRequest = {
             interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
             attributeRequests,
@@ -1108,10 +1111,48 @@ export class InteractionClient {
             report: DecodedDataReport;
             maximumPeerResponseTime: Duration;
         }>(async messenger => {
+            logger.debug(() => [
+                "Subscribe »",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    attributes: attributeRequests.length
+                        ? attributeRequests.map(path => resolveAttributeName(path)).join(", ")
+                        : undefined,
+                    events: eventRequests.length
+                        ? eventRequests.map(path => resolveEventName(path)).join(", ")
+                        : undefined,
+                    dataVersionFilter: dataVersionFilters?.length
+                        ? dataVersionFilters
+                              .map(
+                                  ({ endpointId, clusterId, dataVersion }) =>
+                                      `${endpointId}/${clusterId}=${dataVersion}`,
+                              )
+                              .join(", ")
+                        : undefined,
+                    eventFilters: eventFilters?.length
+                        ? eventFilters.map(({ nodeId, eventMin }) => `${nodeId}=${eventMin}`).join(", ")
+                        : undefined,
+                    fabricFiltered: isFabricFiltered,
+                    keepSubscriptions,
+                    minInterval: Duration.format(Seconds(minIntervalFloorSeconds)),
+                    maxInterval: Duration.format(Seconds(maxIntervalCeilingSeconds)),
+                }),
+            ]);
+
             await messenger.sendSubscribeRequest(request);
             const { subscribeResponse, report } = await messenger.readAggregateSubscribeResponse(attributeReports =>
                 this.processAttributeUpdates(scope, attributeReports, attributeListener),
             );
+
+            logger.info(
+                "Subscription successful «",
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    subId: subscribeResponse.subscriptionId,
+                    maxInterval: Duration.format(Seconds(subscribeResponse.maxInterval)),
+                }),
+            );
+
             return {
                 subscribeResponse,
                 report,
@@ -1119,8 +1160,6 @@ export class InteractionClient {
             };
         }, executeQueued);
 
-        logger.info(`Subscription successfully initialized with ID ${subscriptionId} and maxInterval ${maxInterval}s.`);
-
         const subscriptionListener = async (dataReport: {
             attributeReports?: DecodedAttributeReportValue<any>[];
             eventReports?: DecodedEventReportValue<any>[];
@@ -1139,9 +1178,7 @@ export class InteractionClient {
             if (eventReports !== undefined) {
                 let maxEventNumber = this.#nodeStore?.maxEventNumber ?? eventReports[0].events[0].eventNumber;
                 eventReports.forEach(data => {
-                    logger.debug(
-                        `Received event update: ${resolveEventName(data.path)}: ${Diagnostic.json(data.events)}`,
-                    );
+                    logger.debug(`Event update « ${resolveEventName(data.path)}: ${Diagnostic.json(data.events)}`);
                     const { events } = data;
 
                     maxEventNumber =
@@ -1202,7 +1239,9 @@ export class InteractionClient {
                 version,
             } = data;
 
-            if (value === undefined) throw new MatterFlowError("Received empty subscription result value.");
+            if (value === undefined) {
+                throw new MatterFlowError("Received empty subscription result value.");
+            }
             const { value: oldValue, version: oldVersion } =
                 this.#nodeStore?.retrieveAttribute(endpointId, clusterId, attributeId) ?? {};
             const changed = oldValue !== undefined ? !isDeepEqual(oldValue, value) : undefined;
@@ -1210,7 +1249,7 @@ export class InteractionClient {
                 await this.#nodeStore?.persistAttributes([data], scope);
             }
             logger.debug(
-                `Received attribute update${changed ? "(value changed)" : ""}: ${resolveAttributeName({
+                `Attribute update «${changed ? " (value changed)" : ""}: ${resolveAttributeName({
                     endpointId,
                     clusterId,
                     attributeId,
@@ -1355,7 +1394,7 @@ export class InteractionClient {
             }
             const response = responseSchema.decodeTlv(commandFields);
             logger.debug(
-                `Received invoke response: ${resolveCommandName({
+                `Invoke « ${resolveCommandName({
                     endpointId,
                     clusterId,
                     commandId: requestId,
@@ -1429,7 +1468,7 @@ export class InteractionClient {
         }, executeQueued);
 
         logger.debug(
-            `Invoke successful: ${resolveCommandName({
+            `Invoke successful « ${resolveCommandName({
                 endpointId,
                 clusterId,
                 commandId: requestId,

package/src/interaction/InteractionMessenger.ts

@@ -105,7 +105,19 @@ const DATA_REPORT_MAX_QUEUED_ATTRIBUTE_MESSAGES = 20;
 const DATA_REPORT_MIN_AVAILABLE_BYTES_BEFORE_SENDING = 40;
 
 class InteractionMessenger {
-    constructor(protected exchange: MessageExchange) {}
+    #exchange: MessageExchange;
+
+    constructor(exchange: MessageExchange) {
+        this.#exchange = exchange;
+    }
+
+    get exchange() {
+        return this.#exchange;
+    }
+
+    protected set exchange(value: MessageExchange) {
+        this.#exchange = value;
+    }
 
     send(messageType: number, payload: Bytes, options?: ExchangeSendOptions) {
         return this.exchange.send(messageType, payload, options);
@@ -197,8 +209,8 @@ class InteractionMessenger {
             );
     }
 
-    getExchangeChannelName() {
-        return this.exchange.channel.name;
+    get session() {
+        return this.exchange.session;
     }
 }
 

package/src/protocol/ExchangeManager.ts

@@ -225,6 +225,12 @@ export class ExchangeManager {
             message.payloadHeader.protocolId,
             message.payloadHeader.messageType,
         );
+        const messageDiagnostics = Diagnostic.dict({
+            message: messageId,
+            protocol: message.payloadHeader.protocolId,
+            exId: message.payloadHeader.exchangeId,
+            via: channel.name,
+        });
         if (exchange !== undefined) {
             if (
                 exchange.requiresSecureSession !== session.isSecure ||
@@ -232,14 +238,15 @@ export class ExchangeManager {
                 (exchange.isClosing && !isStandaloneAck)
             ) {
                 logger.debug(
-                    `Ignoring message ${messageId} for protocol ${message.payloadHeader.protocolId} and exchange id ${message.payloadHeader.exchangeId} on channel ${channel.name} because ${
-                        exchange.isClosing
-                            ? "exchange is closing"
-                            : exchange.session.id !== packet.header.sessionId
-                              ? `session ID mismatch ${exchange.session.id} vs ${packet.header.sessionId}`
-                              : `session security requirements (${exchange.requiresSecureSession}) not fulfilled`
-                    }`,
+                    "Ignore « message because",
+                    exchange.isClosing
+                        ? "exchange is closing"
+                        : exchange.session.id !== packet.header.sessionId
+                          ? `session ID mismatch ${exchange.session.id} vs ${packet.header.sessionId}`
+                          : `session security requirements (${exchange.requiresSecureSession}) not fulfilled`,
+                    messageDiagnostics,
                 );
+
                 await exchange.send(SecureMessageType.StandaloneAck, new Uint8Array(0), {
                     includeAcknowledgeMessageId: message.packetHeader.messageId,
                     protocolId: SECURE_CHANNEL_PROTOCOL_ID,
@@ -259,15 +266,15 @@ export class ExchangeManager {
 
             const protocolHandler = this.#protocols.get(message.payloadHeader.protocolId);
 
+            const handlerSecurityMismatch =
+                protocolHandler?.requiresSecureSession !== undefined &&
+                protocolHandler.requiresSecureSession !== session.isSecure;
             // Having a "Secure Session" means it is encrypted in our internal working
             // TODO When adding Group sessions, we need to check how to adjust that handling
-            if (
-                protocolHandler !== undefined &&
-                protocolHandler.requiresSecureSession !== session.isSecure &&
-                !isStandaloneAck
-            ) {
+            if (handlerSecurityMismatch) {
                 logger.debug(
-                    `Ignoring message ${messageId} for protocol ${message.payloadHeader.protocolId} and exchange id ${message.payloadHeader.exchangeId} on channel ${channel.name} because not matching the security requirements.`,
+                    `Ignore « message because not matching the security requirements (${protocolHandler.requiresSecureSession} vs. ${session.isSecure})`,
+                    messageDiagnostics,
                 );
             }
 
@@ -275,12 +282,10 @@ export class ExchangeManager {
                 protocolHandler !== undefined &&
                 message.payloadHeader.isInitiatorMessage &&
                 !isDuplicate &&
-                protocolHandler.requiresSecureSession === session.isSecure
+                !handlerSecurityMismatch
             ) {
                 if (isStandaloneAck && !message.payloadHeader.requiresAck) {
-                    logger.debug(
-                        `Ignoring unsolicited standalone ack message ${messageId} for protocol ${message.payloadHeader.protocolId} and exchange id ${message.payloadHeader.exchangeId} on channel ${channel.name}`,
-                    );
+                    logger.debug("Ignore « unsolicited standalone ack message", messageDiagnostics);
                     return;
                 }
 
@@ -302,9 +307,7 @@ export class ExchangeManager {
                     protocolId: SECURE_CHANNEL_PROTOCOL_ID,
                 });
                 await exchange.close();
-                logger.debug(
-                    `Ignoring unsolicited message ${messageId} for protocol ${message.payloadHeader.protocolId} on channel ${channel.name}`,
-                );
+                logger.debug("Ignore « unsolicited message", messageDiagnostics);
             } else {
                 if (protocolHandler === undefined) {
                     throw new MatterFlowError(`Unsupported protocol ${message.payloadHeader.protocolId}`);
@@ -312,17 +315,12 @@ export class ExchangeManager {
                 if (isDuplicate) {
                     if (message.packetHeader.destGroupId === undefined) {
                         // Duplicate Non-Group messages are still interesting to log to know them
-                        logger.info(
-                            `Ignoring duplicate message ${messageId} (requires no ack) for protocol ${message.payloadHeader.protocolId} on channel ${channel.name}`,
-                        );
+                        logger.debug("Ignore « duplicate message", messageDiagnostics);
                     }
                     return;
-                } else if (!isStandaloneAck) {
-                    logger.info(
-                        `Discarding unexpected message ${messageId} for protocol ${
-                            message.payloadHeader.protocolId
-                        }, exchangeIndex ${exchangeIndex} and sessionId ${session.id} on channel ${channel.name}: ${Diagnostic.json(message)}`,
-                    );
+                }
+                if (!isStandaloneAck) {
+                    logger.info("Discard « unexpected message", messageDiagnostics, Diagnostic.json(message));
                 }
             }
         }

package/src/protocol/MessageChannel.ts

@@ -5,7 +5,7 @@
  */
 
 import { Message, MessageCodec } from "#codec/MessageCodec.js";
-import { Bytes, Channel, Duration, Logger, MatterError, MatterFlowError, Millis, Seconds } from "#general";
+import { Bytes, Channel, Diagnostic, Duration, Logger, MatterError, MatterFlowError, Millis, Seconds } from "#general";
 import type { ExchangeLogContext } from "#protocol/MessageExchange.js";
 import { Session, SessionParameters } from "#session/Session.js";
 
@@ -101,7 +101,7 @@ export class MessageChannel implements Channel<Message> {
     }
 
     get name() {
-        return `${this.channel.name} on session ${this.session.name}`;
+        return Diagnostic.via(`${this.session.name}@${this.channel.name}`);
     }
 
     async close() {

package/src/protocol/MessageExchange.ts

@@ -30,6 +30,7 @@ import {
     MRP,
 } from "#protocol/MessageChannel.js";
 import { GroupSession } from "#session/GroupSession.js";
+import { SecureSession } from "#session/SecureSession.js";
 import { SessionParameters } from "#session/Session.js";
 import {
     GroupId,
@@ -199,8 +200,8 @@ export class MessageExchange {
         logger.debug(
             "New exchange",
             isInitiator ? "»" : "«",
+            channel.name,
             Diagnostic.dict({
-                channel: channel.name,
                 protocol: this.#protocolId,
                 exId: this.#exchangeId,
                 sess: session.name,
@@ -582,12 +583,16 @@ export class MessageExchange {
                 StatusCode.InvalidAction,
             );
         }
+
         logger.debug(
-            `Starting timed interaction with Transaction ID ${this.#exchangeId} for ${Duration.format(timeout)} from ${this.channel.name}`,
+            "Starting timed interaction «",
+            this.channel.name,
+            Diagnostic.dict({ exId: this.#exchangeId, timeout: Duration.format(timeout) }),
         );
         this.#timedInteractionTimer = Time.getTimer("Timed interaction", timeout, () => {
             logger.debug(
-                `Timed interaction with Transaction ID ${this.#exchangeId} from ${this.channel.name} timed out`,
+                "Timed interaction timeout!",
+                Diagnostic.dict({ exId: this.#exchangeId, via: this.channel.name }),
             );
         }).start();
     }
@@ -595,7 +600,8 @@ export class MessageExchange {
     clearTimedInteraction() {
         if (this.#timedInteractionTimer !== undefined) {
             logger.debug(
-                `Clearing timed interaction with Transaction ID ${this.#exchangeId} from ${this.channel.name}`,
+                "Clearing timed interaction",
+                Diagnostic.dict({ exId: this.#exchangeId, via: this.channel.name }),
             );
             this.#timedInteractionTimer.stop();
             this.#timedInteractionTimer = undefined;
@@ -679,4 +685,12 @@ export class MessageExchange {
         this.#messagesQueue.close();
         await this.#closed.emit();
     }
+
+    get via() {
+        if (this.session == undefined || !this.session.isSecure) {
+            return this.channel.name; // already formatted as "via"
+        }
+
+        return Diagnostic.via(`${(this.session as SecureSession).peerAddress.toString()}#${this.session.id}`);
+    }
 }

package/src/protocol/ProtocolHandler.ts

@@ -11,8 +11,13 @@ export interface ProtocolHandler {
     /** Protocol ID that this handler implements */
     readonly id: number;
 
-    /** Indicates whether this protocol requires a secure session to be established before it can be used */
-    readonly requiresSecureSession: boolean;
+    /**
+     * Indicates whether this protocol requires a secure session to be established before it can be used.
+     * When `true`, the protocol can only be used over secure sessions.
+     * When `false`, the protocol can only be used without a secure session.
+     * When `undefined`, the protocol can be used with or without a secure session and it is up to the handler to check
+     */
+    readonly requiresSecureSession: boolean | undefined;
 
     /** Called on a new exchange that uses this protocol. The message is the first message of the exchange. */
     onNewExchange(exchange: MessageExchange, message: Message): Promise<void>;

package/src/securechannel/SecureChannelProtocol.ts

@@ -7,6 +7,7 @@
 import { FabricManager } from "#fabric/FabricManager.js";
 import { AsyncObservable, Environment, Environmental, Logger, MatterFlowError } from "#general";
 import { ExchangeManager } from "#protocol/ExchangeManager.js";
+import { NodeSession } from "#session/NodeSession.js";
 import { SessionManager } from "#session/SessionManager.js";
 import {
     GeneralStatusCode,
@@ -19,7 +20,6 @@ import {
 import { Message } from "../codec/MessageCodec.js";
 import { MessageExchange } from "../protocol/MessageExchange.js";
 import { ProtocolHandler } from "../protocol/ProtocolHandler.js";
-import { SecureSession } from "../session/SecureSession.js";
 import { CaseServer } from "../session/case/CaseServer.js";
 import { MaximumPasePairingErrorsReachedError, PaseServer } from "../session/pase/PaseServer.js";
 import { ChannelStatusResponseError, SecureChannelMessenger } from "./SecureChannelMessenger.js";
@@ -29,7 +29,9 @@ const logger = Logger.get("SecureChannelProtocol");
 
 export class StatusReportOnlySecureChannelProtocol implements ProtocolHandler {
     readonly id = SECURE_CHANNEL_PROTOCOL_ID;
-    readonly requiresSecureSession = false;
+
+    // We need to check the message details to decide if ok or not, so we take them all
+    readonly requiresSecureSession = undefined;
 
     async onNewExchange(exchange: MessageExchange, message: Message) {
         const messageType = message.payloadHeader.messageType;
@@ -70,6 +72,8 @@ export class StatusReportOnlySecureChannelProtocol implements ProtocolHandler {
                 protocolStatus,
             );
         }
+
+        // CloseSession is the only case where a StatusReport comes as initial message
         if (protocolStatus !== SecureChannelStatusCode.CloseSession) {
             throw new ChannelStatusResponseError(
                 `Received general success status, but protocol status is not CloseSession`,
@@ -79,10 +83,9 @@ export class StatusReportOnlySecureChannelProtocol implements ProtocolHandler {
         }
 
         const { session } = exchange;
-        SecureSession.assert(session);
+        NodeSession.assert(session);
         logger.debug(`Peer requested to close session ${session.name}. Remove session now.`);
-        // TODO: and do more - see Core Specs 5.5
-        await session.destroy(false, false);
+        await session.closeByPeer();
     }
 
     async close() {

package/src/session/GroupSession.ts

@@ -16,8 +16,9 @@ import {
     MatterFlowError,
     UnexpectedDataError,
 } from "#general";
+import { PeerAddress } from "#peer/PeerAddress.js";
 import type { SessionManager } from "#session/SessionManager.js";
-import { GroupId, NodeId } from "#types";
+import { FabricIndex, GroupId, NodeId } from "#types";
 import { SecureSession } from "./SecureSession.js";
 import { Session } from "./Session.js";
 
@@ -92,6 +93,16 @@ export class GroupSession extends SecureSession {
         return this.#fabric;
     }
 
+    /**
+     * The peer group's address.
+     */
+    get peerAddress() {
+        return PeerAddress({
+            fabricIndex: this.#fabric?.fabricIndex ?? FabricIndex.NO_FABRIC,
+            nodeId: this.#peerNodeId,
+        });
+    }
+
     subjectFor(message?: Message): Subject {
         if (message === undefined || message.packetHeader.destGroupId === undefined) {
             throw new ImplementationError("GroupSession requires a message with destGroupId");