@matter/protocol 0.16.0-alpha.0-20251203-aaf94bca8 → 0.16.0-alpha.0-20251207-37e501b18

package/dist/esm/protocol/ExchangeManager.js

@@ -1,78 +1,117 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
 /**
  * @license
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
 import { MessageCodec, SessionType } from "#codec/MessageCodec.js";
+import { Mark } from "#common/Mark.js";
 import {
+  BasicMultiplex,
   Bytes,
   ConnectionlessTransportSet,
   Diagnostic,
   Entropy,
   Environmental,
+  hex,
   ImplementationError,
   Logger,
-  MatterAggregateError,
-  MatterError,
   MatterFlowError,
   ObserverGroup,
   UdpInterface,
   UnexpectedDataError
 } from "#general";
-import {
-  ChannelNotConnectedError,
-  DEFAULT_EXPECTED_PROCESSING_TIME
-} from "#protocol/MessageChannel.js";
+import { DEFAULT_EXPECTED_PROCESSING_TIME } from "#protocol/MessageChannel.js";
 import { SecureChannelMessenger } from "#securechannel/SecureChannelMessenger.js";
-import { UNICAST_UNSECURE_SESSION_ID } from "#session/InsecureSession.js";
 import { NodeSession } from "#session/NodeSession.js";
+import { Session } from "#session/Session.js";
 import { SessionManager } from "#session/SessionManager.js";
+import { UNICAST_UNSECURE_SESSION_ID } from "#session/UnsecuredSession.js";
 import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureMessageType } from "#types";
-import { ChannelManager } from "./ChannelManager.js";
 import { MessageExchange } from "./MessageExchange.js";
 import { DuplicateMessageError } from "./MessageReceptionState.js";
 const logger = Logger.get("ExchangeManager");
-const MAXIMUM_CONCURRENT_EXCHANGES_PER_SESSION = 5;
+const MAXIMUM_CONCURRENT_OUTGOING_EXCHANGES_PER_SESSION = 30;
 class ExchangeManager {
+  #lifetime;
   #transports;
-  #sessionManager;
-  #channelManager;
+  #sessions;
   #exchangeCounter;
   #exchanges = /* @__PURE__ */ new Map();
   #protocols = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Map();
-  #closers = /* @__PURE__ */ new Set();
+  #workers;
   #observers = new ObserverGroup(this);
-  #closing = false;
+  #sessionObservers = /* @__PURE__ */ new Map();
+  #isClosing = false;
   constructor(context) {
+    this.#lifetime = context.lifetime.join("exchanges");
+    this.#workers = new BasicMultiplex();
     this.#transports = context.netInterface;
-    this.#sessionManager = context.sessionManager;
-    this.#channelManager = context.channelManager;
+    this.#sessions = context.sessions;
     this.#exchangeCounter = new ExchangeCounter(context.entropy);
     for (const netInterface of this.#transports) {
-      this.#addListener(netInterface);
+      this.#addTransport(netInterface);
     }
-    this.#observers.on(this.#transports.added, this.#addListener);
-    this.#observers.on(this.#transports.deleted, this.#deleteListener);
-    this.#observers.on(this.#sessionManager.sessions.deleted, (session) => {
-      if (!session.closingAfterExchangeFinished) {
-        session.closer = this.#closeSession(session);
-      }
-    });
+    this.#observers.on(this.#transports.added, this.#addTransport);
+    this.#observers.on(this.#transports.deleted, this.#deleteTransport);
+    this.#observers.on(this.#sessions.sessions.added, this.#addSession);
+    this.#observers.on(this.#sessions.sessions.deleted, this.#deleteSession);
   }
   static [Environmental.create](env) {
     const instance = new ExchangeManager({
+      lifetime: env,
       entropy: env.get(Entropy),
       netInterface: env.get(ConnectionlessTransportSet),
-      sessionManager: env.get(SessionManager),
-      channelManager: env.get(ChannelManager)
+      sessions: env.get(SessionManager)
     });
     env.set(ExchangeManager, instance);
     return instance;
   }
-  get channels() {
-    return this.#channelManager;
-  }
   hasProtocolHandler(protocolId) {
     return this.#protocols.has(protocolId);
   }
@@ -86,226 +125,216 @@ class ExchangeManager {
     this.#protocols.set(protocol.id, protocol);
   }
   initiateExchange(address, protocolId) {
-    return this.initiateExchangeWithChannel(this.#channelManager.getChannel(address), protocolId);
+    return this.initiateExchangeForSession(this.#sessions.sessionFor(address), protocolId);
   }
-  initiateExchangeWithChannel(channel, protocolId) {
+  initiateExchangeForSession(session, protocolId) {
     const exchangeId = this.#exchangeCounter.getIncrementedCounter();
     const exchangeIndex = exchangeId | 65536;
-    const exchange = MessageExchange.initiate(this.#messageExchangeContextFor(channel), exchangeId, protocolId);
+    const exchange = MessageExchange.initiate(this.#messageExchangeContextFor(session), exchangeId, protocolId);
     this.#addExchange(exchangeIndex, exchange);
     return exchange;
   }
   async close() {
-    this.#closing = true;
-    for (const protocol of this.#protocols.values()) {
-      await protocol.close();
-    }
-    for (const listeners of this.#listeners.keys()) {
-      this.#deleteListener(listeners);
-    }
-    await MatterAggregateError.allSettled(this.#closers, "Error closing exchanges").catch(
-      (error) => logger.error(error)
-    );
-    await MatterAggregateError.allSettled(
-      Array.from(this.#exchanges.values()).map((exchange) => exchange.close(true)),
-      "Error closing exchanges"
-    ).catch((error) => logger.error(error));
-    this.#exchanges.clear();
-  }
-  async onMessage(channel, messageBytes) {
-    const packet = MessageCodec.decodePacket(messageBytes);
-    const bytes = Bytes.of(messageBytes);
-    const aad = bytes.slice(0, bytes.length - packet.applicationPayload.byteLength);
-    const messageId = packet.header.messageId;
-    let isDuplicate;
-    let session;
-    let message;
-    if (packet.header.sessionType === SessionType.Unicast) {
-      if (packet.header.sessionId === UNICAST_UNSECURE_SESSION_ID) {
-        if (this.#closing) return;
-        const initiatorNodeId = packet.header.sourceNodeId ?? NodeId.UNSPECIFIED_NODE_ID;
-        session = this.#sessionManager.getUnsecureSession(initiatorNodeId) ?? this.#sessionManager.createInsecureSession({
-          initiatorNodeId
-        });
-      } else {
-        session = this.#sessionManager.getSession(packet.header.sessionId);
+    var _stack3 = [];
+    try {
+      if (this.#isClosing) {
+        return;
       }
-      if (session === void 0) {
-        throw new MatterFlowError(
-          `Cannot find a session for ID ${packet.header.sessionId}${packet.header.sourceNodeId !== void 0 ? ` and source NodeId ${packet.header.sourceNodeId}` : ""}`
-        );
+      const closing = __using(_stack3, this.#lifetime.closing());
+      this.#isClosing = true;
+      const exchangesClosed = new BasicMultiplex();
+      for (const exchange of this.#exchanges.values()) {
+        exchangesClosed.add(exchange.close(true));
       }
-      message = session.decode(packet, aad);
-      try {
-        session.updateMessageCounter(messageId);
-        isDuplicate = false;
-      } catch (e) {
-        DuplicateMessageError.accept(e);
-        isDuplicate = true;
+      {
+        var _stack = [];
+        try {
+          const _closing = __using(_stack, closing.join("exchanges"));
+          await exchangesClosed;
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
       }
-    } else if (packet.header.sessionType === SessionType.Group) {
-      if (this.#closing) return;
-      if (packet.header.sourceNodeId === void 0) {
-        throw new UnexpectedDataError("Group session message must include a source NodeId");
+      for (const listener of this.#listeners.keys()) {
+        this.#deleteTransport(listener);
       }
-      let key;
-      ({ session, message, key } = this.#sessionManager.groupSessionFromPacket(packet, aad));
-      try {
-        session.updateMessageCounter(messageId, packet.header.sourceNodeId, key);
-        isDuplicate = false;
-      } catch (e) {
-        DuplicateMessageError.accept(e);
-        isDuplicate = true;
+      for (const protocol of this.#protocols.values()) {
+        this.#workers.add(protocol.close());
       }
-    } else {
-      throw new MatterFlowError(`Unsupported session type: ${packet.header.sessionType}`);
-    }
-    const exchangeIndex = message.payloadHeader.isInitiatorMessage ? message.payloadHeader.exchangeId : message.payloadHeader.exchangeId | 65536;
-    let exchange = this.#exchanges.get(exchangeIndex);
-    if (exchange !== void 0 && (exchange.session.id !== session.id || exchange.isInitiator === message.payloadHeader.isInitiatorMessage)) {
-      exchange = void 0;
-    }
-    const isStandaloneAck = SecureMessageType.isStandaloneAck(
-      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 !== void 0) {
-      if (exchange.requiresSecureSession !== session.isSecure || exchange.session.id !== packet.header.sessionId || exchange.isClosing && !isStandaloneAck) {
-        logger.debug(
-          "Ignore \xAB 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
-        });
-        await exchange.close();
-        return;
+      {
+        var _stack2 = [];
+        try {
+          const _closing = __using(_stack2, closing.join("workers"));
+          await this.#workers;
+        } catch (_2) {
+          var _error2 = _2, _hasError2 = true;
+        } finally {
+          __callDispose(_stack2, _error2, _hasError2);
+        }
       }
-      await exchange.onMessageReceived(message, isDuplicate);
-    } else {
-      if (this.#closing) return;
-      if (session.closingAfterExchangeFinished) {
-        throw new MatterFlowError(
-          `Session with ID ${packet.header.sessionId} marked for closure, decline new exchange creation.`
-        );
+      this.#exchanges.clear();
+      this.#observers.close();
+    } catch (_3) {
+      var _error3 = _3, _hasError3 = true;
+    } finally {
+      __callDispose(_stack3, _error3, _hasError3);
+    }
+  }
+  async #onMessage(channel, messageBytes) {
+    var _stack = [];
+    try {
+      const _lifetime = __using(_stack, this.#lifetime.join("receiving from", Diagnostic.strong(channel.name)));
+      const packet = MessageCodec.decodePacket(messageBytes);
+      const bytes = Bytes.of(messageBytes);
+      const aad = bytes.slice(0, bytes.length - packet.applicationPayload.byteLength);
+      const messageId = packet.header.messageId;
+      let isDuplicate;
+      let session;
+      let message;
+      if (packet.header.sessionType === SessionType.Unicast) {
+        if (packet.header.sessionId === UNICAST_UNSECURE_SESSION_ID) {
+          if (this.#isClosing) return;
+          const initiatorNodeId = packet.header.sourceNodeId ?? NodeId.UNSPECIFIED_NODE_ID;
+          session = this.#sessions.getUnsecuredSession(initiatorNodeId) ?? this.#sessions.createUnsecuredSession({
+            channel,
+            initiatorNodeId
+          });
+        } else {
+          session = this.#sessions.getSession(packet.header.sessionId);
+        }
+        if (session === void 0) {
+          logger.warn(
+            `Ignoring message for unknown session ${Session.idStrOf(packet)}${packet.header.sourceNodeId !== void 0 ? ` from node ${hex.fixed(packet.header.sourceNodeId, 16)}` : ""}`
+          );
+          return;
+        }
+        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.#isClosing) return;
+        if (packet.header.sourceNodeId === void 0) {
+          throw new UnexpectedDataError("Group session message must include a source NodeId");
+        }
+        let key;
+        ({ session, message, key } = this.#sessions.groupSessionFromPacket(packet, aad));
+        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 protocolHandler = this.#protocols.get(message.payloadHeader.protocolId);
-      const handlerSecurityMismatch = protocolHandler?.requiresSecureSession !== void 0 && protocolHandler.requiresSecureSession !== session.isSecure;
-      if (handlerSecurityMismatch) {
-        logger.debug(
-          `Ignore \xAB message because not matching the security requirements (${protocolHandler.requiresSecureSession} vs. ${session.isSecure})`,
-          messageDiagnostics
-        );
+      const exchangeIndex = message.payloadHeader.isInitiatorMessage ? message.payloadHeader.exchangeId : message.payloadHeader.exchangeId | 65536;
+      let exchange = this.#exchanges.get(exchangeIndex);
+      if (exchange !== void 0 && (exchange.session.id !== session.id || exchange.isInitiator === message.payloadHeader.isInitiatorMessage)) {
+        exchange = void 0;
       }
-      if (protocolHandler !== void 0 && message.payloadHeader.isInitiatorMessage && !isDuplicate && !handlerSecurityMismatch) {
-        if (isStandaloneAck && !message.payloadHeader.requiresAck) {
-          logger.debug("Ignore \xAB unsolicited standalone ack message", messageDiagnostics);
+      const isStandaloneAck = SecureMessageType.isStandaloneAck(
+        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 !== void 0) {
+        this.#lifetime.details.exchange = exchange.idStr;
+        if (exchange.session.id !== packet.header.sessionId || exchange.isClosing && !isStandaloneAck) {
+          logger.debug(
+            exchange.via,
+            "Ignore",
+            Mark.INBOUND,
+            "message because",
+            exchange.isClosing ? "exchange is closing" : `session ID mismatch (header session is ${Session.idStrOf(packet)}`,
+            messageDiagnostics
+          );
+          await exchange.send(SecureMessageType.StandaloneAck, new Uint8Array(0), {
+            includeAcknowledgeMessageId: message.packetHeader.messageId,
+            protocolId: SECURE_CHANNEL_PROTOCOL_ID
+          });
+          await exchange.close();
           return;
         }
-        const exchange2 = MessageExchange.fromInitialMessage(
-          this.#messageExchangeContextFor(await this.#channelManager.getOrCreateChannel(channel, session)),
-          message
-        );
-        this.#addExchange(exchangeIndex, exchange2);
-        await exchange2.onMessageReceived(message);
-        await protocolHandler.onNewExchange(exchange2, message);
-      } else if (message.payloadHeader.requiresAck) {
-        const exchange2 = MessageExchange.fromInitialMessage(
-          this.#messageExchangeContextFor(await this.#channelManager.getOrCreateChannel(channel, session)),
-          message
-        );
-        this.#addExchange(exchangeIndex, exchange2);
-        await exchange2.send(SecureMessageType.StandaloneAck, new Uint8Array(0), {
-          includeAcknowledgeMessageId: message.packetHeader.messageId,
-          protocolId: SECURE_CHANNEL_PROTOCOL_ID
-        });
-        await exchange2.close();
-        logger.debug("Ignore \xAB unsolicited message", messageDiagnostics);
+        await exchange.onMessageReceived(message, isDuplicate);
       } else {
-        if (protocolHandler === void 0) {
-          throw new MatterFlowError(`Unsupported protocol ${message.payloadHeader.protocolId}`);
+        if (this.#isClosing) return;
+        if (session.isClosing) {
+          throw new MatterFlowError(
+            `Declining new exchange because session ${Session.idStrOf(packet)} is closing`
+          );
         }
-        if (isDuplicate) {
-          if (message.packetHeader.destGroupId === void 0) {
-            logger.debug("Ignore \xAB duplicate message", messageDiagnostics);
-          }
-          return;
+        const protocolHandler = this.#protocols.get(message.payloadHeader.protocolId);
+        const handlerSecurityMismatch = protocolHandler?.requiresSecureSession !== void 0 && protocolHandler.requiresSecureSession !== session.isSecure;
+        if (handlerSecurityMismatch) {
+          logger.debug(
+            "Ignore",
+            Mark.INBOUND,
+            `message because not matching the security requirements (${protocolHandler.requiresSecureSession} vs. ${session.isSecure})`,
+            messageDiagnostics
+          );
         }
-        if (!isStandaloneAck) {
-          logger.info("Discard \xAB unexpected message", messageDiagnostics, Diagnostic.json(message));
+        if (protocolHandler !== void 0 && message.payloadHeader.isInitiatorMessage && !isDuplicate && !handlerSecurityMismatch) {
+          if (isStandaloneAck && !message.payloadHeader.requiresAck) {
+            logger.debug("Ignore", Mark.INBOUND, "unsolicited standalone ack message", messageDiagnostics);
+            return;
+          }
+          const exchange2 = MessageExchange.fromInitialMessage(this.#messageExchangeContextFor(session), message);
+          this.#lifetime.details.exchange = exchange2.idStr;
+          this.#addExchange(exchangeIndex, exchange2);
+          await exchange2.onMessageReceived(message);
+          await protocolHandler.onNewExchange(exchange2, message);
+        } else if (message.payloadHeader.requiresAck) {
+          const exchange2 = MessageExchange.fromInitialMessage(this.#messageExchangeContextFor(session), message);
+          this.#lifetime.details.exchange = exchange2.idStr;
+          this.#addExchange(exchangeIndex, exchange2);
+          await exchange2.send(SecureMessageType.StandaloneAck, new Uint8Array(0), {
+            includeAcknowledgeMessageId: message.packetHeader.messageId,
+            protocolId: SECURE_CHANNEL_PROTOCOL_ID
+          });
+          await exchange2.close();
+          logger.debug("Ignore", Mark.INBOUND, "unsolicited message", messageDiagnostics);
+        } else {
+          if (protocolHandler === void 0) {
+            throw new MatterFlowError(`Unsupported protocol ${message.payloadHeader.protocolId}`);
+          }
+          if (isDuplicate) {
+            if (message.packetHeader.destGroupId === void 0) {
+              logger.debug("Ignore", Mark.INBOUND, "duplicate message", messageDiagnostics);
+            }
+            return;
+          }
+          if (!isStandaloneAck) {
+            logger.info(
+              "Discard",
+              Mark.INBOUND,
+              "unexpected message",
+              messageDiagnostics,
+              Diagnostic.json(message)
+            );
+          }
         }
       }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
     }
   }
   async deleteExchange(exchangeIndex) {
-    const exchange = this.#exchanges.get(exchangeIndex);
-    if (exchange === void 0) {
-      logger.info(`Exchange with index ${exchangeIndex} to delete not found or already deleted.`);
-      return;
-    }
-    const { session } = exchange;
     this.#exchanges.delete(exchangeIndex);
-    if (NodeSession.is(session) && session.closingAfterExchangeFinished) {
-      logger.debug(
-        `Exchange index ${exchangeIndex} on Session ${session.name} is already marked for closure. Close session now.`
-      );
-      try {
-        await this.#closeSession(session);
-      } catch (error) {
-        logger.error(`Error closing session ${session.name}. Ignoring.`, error);
-      }
-    }
-  }
-  async #closeSession(session) {
-    const sessionId = session.id;
-    const sessionName = session.name;
-    const asExchangeSession = session;
-    if (asExchangeSession.closedByExchange) {
-      return;
-    }
-    asExchangeSession.closedByExchange = true;
-    for (const [_exchangeIndex, exchange] of this.#exchanges.entries()) {
-      if (exchange.session.id === sessionId) {
-        await exchange.destroy();
-      }
-    }
-    if (session.sendCloseMessageWhenClosing) {
-      let channel;
-      try {
-        channel = this.#channelManager.getChannelForSession(session);
-      } catch (e) {
-        logger.debug(`Not sending close for session ${sessionName}:`, e);
-        return;
-      }
-      logger.debug(`Channel for session ${sessionName} is ${channel?.name}`);
-      if (channel !== void 0) {
-        const exchange = this.initiateExchangeWithChannel(channel, SECURE_CHANNEL_PROTOCOL_ID);
-        logger.debug(`Initiated exchange ${exchange.id} to close session ${sessionName}`);
-        try {
-          const messenger = new SecureChannelMessenger(exchange);
-          await messenger.sendCloseSession();
-          await messenger.close();
-        } catch (error) {
-          if (error instanceof ChannelNotConnectedError) {
-            logger.debug("Session already closed because channel is disconnected.");
-          } else {
-            logger.error("Error closing session", error);
-          }
-        }
-        await exchange.destroy();
-      }
-    }
-    if (session.closingAfterExchangeFinished) {
-      await session.destroy(false, false);
-    }
   }
   #addExchange(exchangeIndex, exchange) {
     exchange.closed.on(() => this.deleteExchange(exchangeIndex));
@@ -317,30 +346,34 @@ class ExchangeManager {
       return;
     }
     const sessionExchanges = Array.from(this.#exchanges.values()).filter(
-      (exchange) => exchange.session.id === sessionId && !exchange.isClosing
+      (exchange) => exchange.session.id === sessionId && !exchange.isClosing && exchange.isInitiator
     );
-    if (sessionExchanges.length <= MAXIMUM_CONCURRENT_EXCHANGES_PER_SESSION) {
+    if (sessionExchanges.length <= MAXIMUM_CONCURRENT_OUTGOING_EXCHANGES_PER_SESSION) {
       return;
     }
     const exchangeToClose = sessionExchanges[0];
-    logger.debug(`Closing oldest exchange ${exchangeToClose.id} for session ${sessionId}`);
-    exchangeToClose.close().catch((error) => logger.error("Error closing exchange", error));
+    logger.info(
+      exchangeToClose.via,
+      `Closing oldest exchange for session because of too many concurrent outgoing exchanges. Ensure to not send that many parallel messages to one peer.`
+    );
+    logger.debug(exchangeToClose.via, "Closing oldest exchange");
+    this.#workers.add(exchangeToClose.close());
   }
-  calculateMaximumPeerResponseTimeMsFor(channel, expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME) {
-    return channel.calculateMaximumPeerResponseTime(
-      channel.session.parameters,
-      this.#sessionManager.sessionParameters,
+  calculateMaximumPeerResponseTimeMsFor(session, expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME) {
+    return session.channel.calculateMaximumPeerResponseTime(
+      session.parameters,
+      this.#sessions.sessionParameters,
       expectedProcessingTime
     );
   }
-  #messageExchangeContextFor(channel) {
+  #messageExchangeContextFor(session) {
     return {
-      channel,
-      localSessionParameters: this.#sessionManager.sessionParameters,
-      retry: (number) => this.#sessionManager.retry.emit(channel.session, number)
+      session,
+      localSessionParameters: this.#sessions.sessionParameters,
+      retry: (number) => this.#sessions.retry.emit(session, number)
     };
   }
-  #addListener(netInterface) {
+  #addTransport(netInterface) {
     const udpInterface = netInterface instanceof UdpInterface;
     this.#listeners.set(
       netInterface,
@@ -351,30 +384,54 @@ class ExchangeManager {
           );
           return;
         }
-        try {
-          this.onMessage(socket, data).catch(
-            (error) => logger.info(
-              `Error on channel ${socket.name}:`,
-              error instanceof MatterError ? error.message : error
-            )
-          );
-        } catch (error) {
-          logger.info(
-            `Ignoring UDP message on channel ${socket.name} with error`,
-            error instanceof MatterError ? error.message : error
-          );
-        }
+        this.#workers.add(this.#onMessage(socket, data));
       })
     );
   }
-  #deleteListener(netInterface) {
+  #deleteTransport(netInterface) {
     const listener = this.#listeners.get(netInterface);
     if (listener === void 0) {
       return;
     }
     this.#listeners.delete(netInterface);
-    const closer = listener.close().catch((e) => logger.error("Error closing network listener", e)).finally(() => this.#closers.delete(closer));
-    this.#closers.add(closer);
+    this.#workers.add(listener.close());
+  }
+  #addSession(session) {
+    if (!(session instanceof NodeSession)) {
+      return;
+    }
+    let observers = this.#sessionObservers.get(session);
+    if (!observers) {
+      this.#sessionObservers.set(session, observers = new ObserverGroup());
+    }
+    observers.on(session.gracefulClose, () => this.#sendCloseSession(session));
+  }
+  #deleteSession(session) {
+    const observers = this.#sessionObservers.get(session);
+    if (!observers) {
+      return;
+    }
+    observers.close();
+    this.#sessionObservers.delete(session);
+  }
+  async #sendCloseSession(session) {
+    var _stack = [];
+    try {
+      const exchange = __using(_stack, this.initiateExchangeForSession(session, SECURE_CHANNEL_PROTOCOL_ID), true);
+      logger.debug(exchange.via, "Closing session");
+      try {
+        const messenger = new SecureChannelMessenger(exchange);
+        await messenger.sendCloseSession();
+        await messenger.close();
+      } catch (error) {
+        logger.error(exchange.via, "Error closing session:", error);
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
   }
 }
 class ExchangeCounter {