@matter/protocol 0.14.1-alpha.0-20250605-9fc134af0 → 0.14.1-alpha.0-20250607-a93593303

package/src/interaction/InteractionClient.ts

@@ -134,7 +134,8 @@ export class InteractionClientProvider {
             return client;
         }
 
-        const nodeStore = this.#peers.get(address)?.dataStore;
+        const isGroupAddress = PeerAddress.isGroup(address);
+        const nodeStore = isGroupAddress ? undefined : this.#peers.get(address)?.dataStore;
         await nodeStore?.construction; // Lazy initialize the data if not already done
 
         const exchangeProvider = await this.#peers.exchangeProviderFor(address, discoveryOptions);
@@ -167,6 +168,7 @@ export class InteractionClient {
     readonly #subscriptionClient: SubscriptionClient;
     readonly #queue?: PromiseQueue;
     readonly #address?: PeerAddress;
+    readonly isGroupAddress: boolean;
 
     constructor(
         exchangeProvider: ExchangeProvider,
@@ -180,6 +182,7 @@ export class InteractionClient {
         this.#subscriptionClient = subscriptionClient;
         this.#queue = queue;
         this.#address = address;
+        this.isGroupAddress = address !== undefined ? PeerAddress.isGroup(address) : false;
     }
 
     get address() {
@@ -321,6 +324,10 @@ export class InteractionClient {
             executeQueued?: boolean;
         } = {},
     ): Promise<DecodedDataReport> {
+        if (this.isGroupAddress) {
+            throw new ImplementationError("Reading data from group addresses is not supported.");
+        }
+
         const {
             attributes: attributeRequests,
             dataVersionFilters,
@@ -411,6 +418,10 @@ export class InteractionClient {
         clusterId: ClusterId;
         attribute: A;
     }): { value: AttributeJsType<A>; version: number } | undefined {
+        if (this.isGroupAddress) {
+            throw new ImplementationError("Reading data from group addresses is not supported.");
+        }
+
         const { endpointId, clusterId, attribute } = options;
         const { id: attributeId } = attribute;
         if (this.#nodeStore !== undefined) {
@@ -430,6 +441,10 @@ export class InteractionClient {
         requestFromRemote?: boolean;
         executeQueued?: boolean;
     }): Promise<{ value: AttributeJsType<A>; version: number } | undefined> {
+        if (this.isGroupAddress) {
+            throw new ImplementationError("Reading data from group addresses is not supported.");
+        }
+
         const { endpointId, clusterId, attribute, requestFromRemote, isFabricFiltered, executeQueued } = options;
         const { id: attributeId } = attribute;
         if (this.#nodeStore !== undefined) {
@@ -516,7 +531,7 @@ export class InteractionClient {
 
     async setAttribute<T>(options: {
         attributeData: {
-            endpointId: EndpointNumber;
+            endpointId?: EndpointNumber;
             clusterId: ClusterId;
             attribute: Attribute<T, any>;
             value: T;
@@ -557,7 +572,7 @@ export class InteractionClient {
 
     async setMultipleAttributes(options: {
         attributes: {
-            endpointId: EndpointNumber;
+            endpointId?: EndpointNumber;
             clusterId: ClusterId;
             attribute: Attribute<any, any>;
             value: any;
@@ -575,9 +590,22 @@ export class InteractionClient {
             attributes,
             asTimedRequest,
             timedRequestTimeoutMs = DEFAULT_TIMED_REQUEST_TIMEOUT_MS,
-            suppressResponse = false, // TODO needs to be TRUE for Group writes
+            suppressResponse = this.isGroupAddress,
             chunkLists = true, // Should be true currently to stay in sync with chip sdk
         } = options;
+        if (this.isGroupAddress) {
+            if (!suppressResponse) {
+                throw new ImplementationError("Writing attributes on a group address can not return a response.");
+            }
+            if (
+                attributes.some(
+                    ({ endpointId, clusterId, attribute }) =>
+                        endpointId !== undefined || clusterId === undefined || attribute.id === undefined,
+                )
+            ) {
+                throw new ImplementationError("Not all attribute write paths are valid for group address writes.");
+            }
+        }
         logger.debug(
             `Sending write request: ${attributes
                 .map(
@@ -621,6 +649,9 @@ export class InteractionClient {
             attributes.some(({ attribute: { timed } }) => timed) ||
             asTimedRequest === true ||
             options.timedRequestTimeoutMs !== undefined;
+        if (this.isGroupAddress && timedRequest) {
+            throw new ImplementationError("Timed requests are not supported for group address writes.");
+        }
 
         const response = await this.withMessenger<TypeFromSchema<typeof TlvWriteResponse> | undefined>(
             async messenger => {
@@ -671,6 +702,9 @@ export class InteractionClient {
     }): Promise<{
         maxInterval: number;
     }> {
+        if (this.isGroupAddress) {
+            throw new ImplementationError("Subscribing to attributes on a group address is not supported.");
+        }
         const {
             endpointId,
             clusterId,
@@ -792,6 +826,9 @@ export class InteractionClient {
     }): Promise<{
         maxInterval: number;
     }> {
+        if (this.isGroupAddress) {
+            throw new ImplementationError("Subscribing to events on a group address is not supported.");
+        }
         const {
             endpointId,
             clusterId,
@@ -923,6 +960,9 @@ export class InteractionClient {
         eventReports?: DecodedEventReportValue<any>[];
         maxInterval: number;
     }> {
+        if (this.isGroupAddress) {
+            throw new ImplementationError("Subscribing to attributes or events on a group address is not supported.");
+        }
         const {
             attributes: attributeRequests = [],
             events: eventRequests = [],
@@ -1097,7 +1137,7 @@ export class InteractionClient {
     }
 
     async invoke<C extends Command<any, any, any>>(options: {
-        endpointId: EndpointNumber;
+        endpointId?: EndpointNumber;
         clusterId: ClusterId;
         request: RequestType<C>;
         command: C;
@@ -1132,6 +1172,15 @@ export class InteractionClient {
         const timedRequest =
             (timed && !skipValidation) || asTimedRequest === true || options.timedRequestTimeoutMs !== undefined;
 
+        if (this.isGroupAddress) {
+            if (endpointId !== undefined) {
+                throw new ImplementationError("Invoking a concrete command on a group address is not supported.");
+            }
+            if (timedRequest) {
+                throw new ImplementationError("Timed requests are not supported for group address invokes.");
+            }
+        }
+
         if (requestSchema instanceof ObjectSchema) {
             if (request === undefined) {
                 // If developer did not provide a request object, create an empty one if it needs to be an object
@@ -1228,8 +1277,9 @@ export class InteractionClient {
     }
 
     // TODO Add to ClusterClient when needed/when Group communication is implemented
+    // TODO Additionally support it without endpoint
     async invokeWithSuppressedResponse<C extends Command<any, any, any>>(options: {
-        endpointId: EndpointNumber;
+        endpointId?: EndpointNumber;
         clusterId: ClusterId;
         request: RequestType<C>;
         command: C;
@@ -1248,6 +1298,16 @@ export class InteractionClient {
             timedRequestTimeoutMs = DEFAULT_TIMED_REQUEST_TIMEOUT_MS,
         } = options;
         const timedRequest = timed || asTimedRequest === true || options.timedRequestTimeoutMs !== undefined;
+
+        if (this.isGroupAddress) {
+            if (timed) {
+                throw new ImplementationError("Timed requests are not supported for group address invokes.");
+            }
+            if (endpointId !== undefined) {
+                throw new ImplementationError("Invoking a concrete command on a group address is not supported.");
+            }
+        }
+
         logger.debug(
             `Invoking command with suppressedResponse: ${resolveCommandName({
                 endpointId,

package/src/interaction/InteractionMessenger.ts

@@ -262,6 +262,12 @@ export class InteractionServerMessenger extends InteractionMessenger {
                         break;
                     }
                     case MessageType.SubscribeRequest: {
+                        if (isGroupSession) {
+                            throw new StatusResponseError(
+                                `SubscribeRequest is not supported in group sessions`,
+                                Status.InvalidAction,
+                            );
+                        }
                         const subscribeRequest = TlvSubscribeRequest.decode(message.payload);
                         await recipient.handleSubscribeRequest(this.exchange, subscribeRequest, this, message);
                         // response is sent by handler
@@ -274,6 +280,12 @@ export class InteractionServerMessenger extends InteractionMessenger {
                         break;
                     }
                     case MessageType.TimedRequest: {
+                        if (isGroupSession) {
+                            throw new StatusResponseError(
+                                `TimedRequest is not supported in group sessions`,
+                                Status.InvalidAction,
+                            );
+                        }
                         const timedRequest = TlvTimedRequest.decode(message.payload);
                         recipient.handleTimedRequest(this.exchange, timedRequest, message);
                         await this.sendStatus(StatusCode.Success, {
@@ -288,6 +300,9 @@ export class InteractionServerMessenger extends InteractionMessenger {
                             Status.InvalidAction,
                         );
                 }
+                if (isGroupSession) {
+                    break; // We do not support multiple messages in group sessions
+                }
             }
         } catch (error: any) {
             let errorStatusCode = StatusCode.Failure;

package/src/interaction/Subscription.ts

@@ -5,7 +5,7 @@
  */
 
 import { AsyncObservable, InternalError, Logger } from "#general";
-import { type SecureSession } from "#session/SecureSession.js";
+import { NodeSession } from "#session/NodeSession.js";
 import { TlvAttributePath, TlvDataVersionFilter, TlvEventFilter, TlvEventPath, TypeFromSchema } from "#types";
 
 const logger = Logger.get("Subscription");
@@ -24,7 +24,7 @@ export interface SubscriptionCriteria {
  * A single active subscription.
  */
 export abstract class Subscription {
-    #session: SecureSession;
+    #session: NodeSession;
     #id: SubscriptionId;
     #isClosed?: boolean;
     #isCanceledByPeer?: boolean;
@@ -32,7 +32,7 @@ export abstract class Subscription {
     #cancelled = AsyncObservable<[subscription: Subscription]>();
     #maxIntervalMs?: number;
 
-    constructor(session: SecureSession, id: SubscriptionId, criteria: SubscriptionCriteria) {
+    constructor(session: NodeSession, id: SubscriptionId, criteria: SubscriptionCriteria) {
         this.#session = session;
         this.#id = id;
         this.#criteria = criteria;

package/src/peer/PeerAddress.ts

@@ -64,6 +64,10 @@ export namespace PeerAddress {
 
         return addr1.fabricIndex === addr2.fabricIndex && addr1.nodeId === addr2.nodeId;
     }
+
+    export function isGroup(address: PeerAddress): boolean {
+        return NodeId.isGroupNodeId(address.nodeId);
+    }
 }
 
 /**

package/src/peer/PeerSet.ts

@@ -25,6 +25,7 @@ import {
     ObservableSet,
     ServerAddressIp,
     serverAddressToString,
+    STANDARD_MATTER_PORT,
     Time,
     Timer,
 } from "#general";
@@ -34,7 +35,7 @@ import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
 import { ChannelStatusResponseError } from "#securechannel/index.js";
 import { CaseClient, SecureSession, Session } from "#session/index.js";
 import { SessionManager } from "#session/SessionManager.js";
-import { NodeId, ProtocolStatusCode, SECURE_CHANNEL_PROTOCOL_ID } from "#types";
+import { GroupId, NodeId, ProtocolStatusCode, SECURE_CHANNEL_PROTOCOL_ID } from "#types";
 import { ChannelManager } from "../protocol/ChannelManager.js";
 import { ChannelNotConnectedError, ExchangeManager, MessageChannel } from "../protocol/ExchangeManager.js";
 import { DedicatedChannelExchangeProvider, ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
@@ -240,14 +241,20 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             operationalAddress?: ServerAddressIp;
         },
     ) {
+        address = PeerAddress(address);
+
+        const isGroupNode = PeerAddress.isGroup(address);
         const { discoveryOptions, allowUnknownPeer, operationalAddress } = options;
-        if (!this.#peersByAddress.has(address) && !allowUnknownPeer) {
+        if (!this.#peersByAddress.has(address) && !allowUnknownPeer && !isGroupNode) {
             throw new UnknownNodeError(`Cannot connect to unknown device ${PeerAddress(address)}`);
         }
 
-        address = PeerAddress(address);
-
         if (!this.#channels.hasChannel(address)) {
+            if (isGroupNode) {
+                await this.#createGroupChannel(address);
+                return;
+            }
+
             const { promise: existingReconnectPromise } = this.#runningPeerReconnections.get(address) ?? {};
             if (existingReconnectPromise !== undefined) {
                 return existingReconnectPromise;
@@ -278,6 +285,13 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             return new DedicatedChannelExchangeProvider(this.#exchanges, addressOrChannel);
         }
         const address: PeerAddress = addressOrChannel;
+        if (PeerAddress.isGroup(address)) {
+            if (!this.#channels.hasChannel(address)) {
+                // Ensure that we have a group channel
+                await this.#createGroupChannel(address);
+            }
+            return new DedicatedChannelExchangeProvider(this.#exchanges, this.#channels.getChannel(address));
+        }
         let initiallyConnected = this.#channels.hasChannel(address);
         return new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
             if (!initiallyConnected && !this.#channels.hasChannel(address)) {
@@ -620,6 +634,27 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         }
     }
 
+    async #createGroupChannel(address: PeerAddress) {
+        const groupId = GroupId.fromNodeId(address.nodeId);
+        GroupId.assertGroupId(groupId);
+        const multicastAddress = this.#sessions.fabricFor(address).groups.multicastAddressFor(groupId);
+
+        const operationalInterface = this.#netInterfaces.interfaceFor(ChannelType.UDP, multicastAddress);
+        if (operationalInterface === undefined) {
+            throw new PairRetransmissionLimitReachedError(`IPv6 interface not initialized`);
+        }
+        const operationalChannel = await operationalInterface.openChannel({
+            type: ChannelType.UDP,
+            ip: multicastAddress,
+            port: STANDARD_MATTER_PORT,
+        });
+
+        const session = this.#sessions.groupSessionForAddress(address);
+        const channel = new MessageChannel(operationalChannel, session);
+        await this.#channels.setChannel(address, channel);
+        return channel;
+    }
+
     /** Pair with an operational device (already commissioned) and establish a CASE session. */
     async #pair(
         address: PeerAddress,

package/src/protocol/ChannelManager.ts

@@ -6,7 +6,7 @@
 
 import { AsyncObservable, Channel, Environment, Environmental, Logger, MatterError } from "#general";
 import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
-import { SecureSession } from "../session/SecureSession.js";
+import { NodeSession } from "../session/NodeSession.js";
 import { Session } from "../session/Session.js";
 import { MessageChannel } from "./ExchangeManager.js";
 
@@ -91,10 +91,9 @@ export class ChannelManager {
      * Returns the last established session for a Fabric and Node
      */
     getChannelForSession(session: Session) {
-        if (session.isSecure && !session.isPase) {
-            const secureSession = session as SecureSession;
-            const fabric = secureSession.fabric;
-            const nodeId = secureSession.peerNodeId;
+        if (NodeSession.is(session) && !session.isPase) {
+            const fabric = session.fabric;
+            const nodeId = session.peerNodeId;
             if (fabric === undefined) {
                 return this.#paseChannels.get(session);
             }
@@ -142,12 +141,11 @@ export class ChannelManager {
     }
 
     async getOrCreateChannel(byteArrayChannel: Channel<Uint8Array>, session: Session) {
-        if (!session.isSecure) {
+        if (!NodeSession.is(session)) {
             return this.getOrCreateAsPaseChannel(byteArrayChannel, session);
         }
-        const secureSession = session as SecureSession;
-        const fabric = secureSession.fabric;
-        const nodeId = secureSession.peerNodeId;
+        const fabric = session.fabric;
+        const nodeId = session.peerNodeId;
         if (fabric === undefined) {
             return this.getOrCreateAsPaseChannel(byteArrayChannel, session);
         }

package/src/protocol/ExchangeManager.ts

@@ -15,18 +15,18 @@ import {
     MatterAggregateError,
     MatterError,
     MatterFlowError,
-    NotImplementedError,
     ObserverGroup,
     TransportInterface,
     TransportInterfaceSet,
     UdpInterface,
+    UnexpectedDataError,
 } from "#general";
 import { PeerAddress } from "#peer/PeerAddress.js";
 import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureMessageType } from "#types";
-import { Message, MessageCodec, SessionType } from "../codec/MessageCodec.js";
+import { DecodedMessage, Message, MessageCodec, SessionType } from "../codec/MessageCodec.js";
 import { SecureChannelMessenger } from "../securechannel/SecureChannelMessenger.js";
 import { SecureChannelProtocol } from "../securechannel/SecureChannelProtocol.js";
-import { SecureSession } from "../session/SecureSession.js";
+import { NodeSession } from "../session/NodeSession.js";
 import { Session } from "../session/Session.js";
 import { SessionManager, UNICAST_UNSECURE_SESSION_ID } from "../session/SessionManager.js";
 import { ChannelManager } from "./ChannelManager.js";
@@ -73,7 +73,7 @@ export class MessageChannel implements Channel<Message> {
         return this.channel.maxPayloadSize;
     }
 
-    send(message: Message, logContext?: ExchangeLogContext): Promise<void> {
+    async send(message: Message, logContext?: ExchangeLogContext) {
         logger.debug("Message »", MessageCodec.messageDiagnostics(message, logContext));
         const packet = this.session.encode(message);
         const bytes = MessageCodec.encodePacket(packet);
@@ -83,7 +83,7 @@ export class MessageChannel implements Channel<Message> {
             );
         }
 
-        return this.channel.send(bytes);
+        return await this.channel.send(bytes);
     }
 
     get name() {
@@ -202,11 +202,13 @@ export class ExchangeManager {
 
     private async onMessage(channel: Channel<Uint8Array>, messageBytes: Uint8Array) {
         const packet = MessageCodec.decodePacket(messageBytes);
+        const aad = messageBytes.slice(0, messageBytes.length - packet.applicationPayload.length); // Header+Extensions
 
-        if (packet.header.sessionType === SessionType.Group)
-            throw new NotImplementedError("Group messages are not supported");
+        const messageId = packet.header.messageId;
 
+        let isDuplicate: boolean;
         let session: Session | undefined;
+        let message: DecodedMessage | undefined;
         if (packet.header.sessionType === SessionType.Unicast) {
             if (packet.header.sessionId === UNICAST_UNSECURE_SESSION_ID) {
                 if (this.#closing) return;
@@ -219,35 +221,46 @@ export class ExchangeManager {
             } else {
                 session = this.#sessionManager.getSession(packet.header.sessionId);
             }
+
+            if (session === undefined) {
+                throw new MatterFlowError(
+                    `Cannot find a session for ID ${packet.header.sessionId}${
+                        packet.header.sourceNodeId !== undefined
+                            ? ` and source NodeId ${packet.header.sourceNodeId}`
+                            : ""
+                    }`,
+                );
+            }
+
+            message = session.decode(packet, aad);
+
+            try {
+                session.updateMessageCounter(messageId);
+                isDuplicate = false;
+            } catch (e) {
+                DuplicateMessageError.accept(e);
+                isDuplicate = true;
+            }
         } else if (packet.header.sessionType === SessionType.Group) {
             if (this.#closing) return;
-            if (packet.header.sourceNodeId !== undefined) {
-                //session = this.sessionManager.findGroupSession(packet.header.destGroupId, packet.header.sessionId);
+            if (packet.header.sourceNodeId === undefined) {
+                throw new UnexpectedDataError("Group session message must include a source NodeId");
             }
-            // if (packet.header.destGroupId !== undefined) { ???
-        }
 
-        if (session === undefined) {
-            throw new MatterFlowError(
-                `Cannot find a session for ID ${packet.header.sessionId}${
-                    packet.header.sourceNodeId !== undefined ? ` and source NodeId ${packet.header.sourceNodeId}` : ""
-                }`,
-            );
-        }
-
-        const messageId = packet.header.messageId;
+            let key: Uint8Array;
+            ({ session, message, key } = this.#sessionManager.groupSessionFromPacket(packet, aad));
 
-        let isDuplicate;
-        try {
-            session.updateMessageCounter(packet.header.messageId, packet.header.sourceNodeId);
-            isDuplicate = false;
-        } catch (e) {
-            DuplicateMessageError.accept(e);
-            isDuplicate = true;
+            try {
+                session.updateMessageCounter(messageId, packet.header.sourceNodeId, key);
+                isDuplicate = false;
+            } catch (e) {
+                DuplicateMessageError.accept(e);
+                isDuplicate = true;
+            }
+        } else {
+            throw new MatterFlowError(`Unsupported session type: ${packet.header.sessionType}`);
         }
 
-        const aad = messageBytes.slice(0, messageBytes.length - packet.applicationPayload.length); // Header+Extensions
-        const message = session.decode(packet, aad);
         const exchangeIndex = message.payloadHeader.isInitiatorMessage
             ? message.payloadHeader.exchangeId
             : message.payloadHeader.exchangeId | 0x10000;
@@ -343,9 +356,12 @@ export class ExchangeManager {
                     throw new MatterFlowError(`Unsupported protocol ${message.payloadHeader.protocolId}`);
                 }
                 if (isDuplicate) {
-                    logger.info(
-                        `Ignoring duplicate message ${messageId} (requires no ack) for protocol ${message.payloadHeader.protocolId} on channel ${channel.name}`,
-                    );
+                    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}`,
+                        );
+                    }
                     return;
                 } else {
                     logger.info(
@@ -365,12 +381,12 @@ export class ExchangeManager {
             return;
         }
         const { session } = exchange;
-        if (session.isSecure && session.closingAfterExchangeFinished) {
+        if (NodeSession.is(session) && session.closingAfterExchangeFinished) {
             logger.debug(
                 `Exchange index ${exchangeIndex} Session ${session.name} is already marked for closure. Close session now.`,
             );
             try {
-                await this.#closeSession(session as SecureSession);
+                await this.#closeSession(session);
             } catch (error) {
                 logger.error(`Error closing session ${session.name}. Ignoring.`, error);
             }
@@ -378,7 +394,7 @@ export class ExchangeManager {
         this.#exchanges.delete(exchangeIndex);
     }
 
-    async #closeSession(session: SecureSession) {
+    async #closeSession(session: NodeSession) {
         const sessionId = session.id;
         const sessionName = session.name;
 

package/src/protocol/MessageExchange.ts

@@ -18,8 +18,16 @@ import {
     Timer,
     createPromise,
 } from "#general";
-import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureMessageType, StatusCode, StatusResponseError } from "#types";
-import { Message, MessageCodec, SessionType } from "../codec/MessageCodec.js";
+import { GroupSession } from "#session/index.js";
+import {
+    GroupId,
+    NodeId,
+    SECURE_CHANNEL_PROTOCOL_ID,
+    SecureMessageType,
+    StatusCode,
+    StatusResponseError,
+} from "#types";
+import { Message, MessageCodec, PacketHeader, SessionType } from "../codec/MessageCodec.js";
 import { SecureChannelProtocol } from "../securechannel/SecureChannelProtocol.js";
 import {
     SESSION_ACTIVE_INTERVAL_MS,
@@ -404,18 +412,43 @@ export class MessageExchange {
             }
         }
 
-        // TODO Add support to also send controlMessages for Group messages, use different messagecounter!
-        const message: Message = {
-            packetHeader: {
+        let packetHeader: PacketHeader;
+        if (this.session.type === SessionType.Unicast) {
+            packetHeader = {
                 sessionId: this.#peerSessionId,
-                sessionType: SessionType.Unicast, // TODO: support multicast/groups
+                sessionType: SessionType.Unicast,
                 messageId: await this.session.getIncrementedMessageCounter(),
                 destNodeId: this.#peerNodeId,
                 sourceNodeId: this.#nodeId,
                 hasPrivacyEnhancements: false,
                 isControlMessage: false,
                 hasMessageExtensions: false,
-            },
+            };
+        } else if (this.session.type === SessionType.Group) {
+            const session = this.session;
+            if (!GroupSession.is(session)) {
+                throw new InternalError("Session is not a GroupSession, but session type is Group.");
+            }
+            const destGroupId = GroupId.fromNodeId(this.#peerNodeId!); // TODO !!! Where get from?
+            if (destGroupId === 0) {
+                throw new InternalError(`Invalid GroupId extracted from NodeId ${this.#peerNodeId}`);
+            }
+            packetHeader = {
+                sessionId: this.#peerSessionId,
+                sessionType: SessionType.Group,
+                messageId: await session.getIncrementedMessageCounter(),
+                destGroupId,
+                sourceNodeId: this.#nodeId, // We are the source node, so use our NodeId
+                hasPrivacyEnhancements: false,
+                isControlMessage: false,
+                hasMessageExtensions: false,
+            };
+        } else {
+            throw new InternalError(`Unknown session type: ${this.session.type}`);
+        }
+
+        const message: Message = {
+            packetHeader,
             payloadHeader: {
                 exchangeId: this.#exchangeId,
                 protocolId:
@@ -466,6 +499,8 @@ export class MessageExchange {
         let timeout: number;
         if (options?.timeoutMs !== undefined) {
             timeout = options.timeoutMs;
+        } else if (this.#messagesQueue.size > 0) {
+            timeout = 0; // If we have messages in the queue, we can return them immediately
         } else {
             switch (this.channel.type) {
                 case "tcp":

package/src/protocol/MessageReceptionState.ts

@@ -21,7 +21,7 @@ export abstract class MessageReceptionState {
 
 /**
  * Implements a message reception state for encrypted messages without rollover.
- * A counter in the range [(max_message_counter + 1) to (232 - 1)] SHALL be considered new, and cause the
+ * A counter in the range [(max_message_counter + 1) to (2^31 - 1)] SHALL be considered new, and cause the
  * max_message_counter value to be updated.
  * Message counters within the range of the bitmap SHALL be considered duplicate if the corresponding bit
  * offset is set to true. All other message counters SHALL be considered duplicate.
@@ -121,7 +121,7 @@ export class MessageReceptionStateEncryptedWithoutRollover extends MessageRecept
         }
 
         const diff = this.calculateDiff(messageCounter);
-        // A counter in the range [(max_message_counter + 1) to (232 - 1)] SHALL be considered new, and cause the
+        // A counter in the range [(max_message_counter + 1) to (2^31 - 1)] SHALL be considered new, and cause the
         // max_message_counter value to be updated.
         // Message counters within the range of the bitmap SHALL be considered duplicate if the corresponding bit
         // offset is set to true. All other message counters SHALL be considered duplicate.

package/src/securechannel/SecureChannelProtocol.ts

@@ -19,7 +19,7 @@ import {
 import { Message } from "../codec/MessageCodec.js";
 import { MessageExchange } from "../protocol/MessageExchange.js";
 import { ProtocolHandler } from "../protocol/ProtocolHandler.js";
-import { assertSecureSession } from "../session/SecureSession.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";
@@ -79,7 +79,7 @@ export class StatusReportOnlySecureChannelProtocol implements ProtocolHandler {
         }
 
         const { session } = exchange;
-        assertSecureSession(session);
+        SecureSession.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);