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

package/dist/cjs/protocol/ExchangeManager.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,6 +20,47 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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();
+};
 var ExchangeManager_exports = {};
 __export(ExchangeManager_exports, {
   ExchangeCounter: () => ExchangeCounter,
@@ -23,14 +68,15 @@ __export(ExchangeManager_exports, {
 });
 module.exports = __toCommonJS(ExchangeManager_exports);
 var import_MessageCodec = require("#codec/MessageCodec.js");
+var import_Mark = require("#common/Mark.js");
 var import_general = require("#general");
 var import_MessageChannel = require("#protocol/MessageChannel.js");
 var import_SecureChannelMessenger = require("#securechannel/SecureChannelMessenger.js");
-var import_InsecureSession = require("#session/InsecureSession.js");
 var import_NodeSession = require("#session/NodeSession.js");
+var import_Session = require("#session/Session.js");
 var import_SessionManager = require("#session/SessionManager.js");
+var import_UnsecuredSession = require("#session/UnsecuredSession.js");
 var import_types = require("#types");
-var import_ChannelManager = require("./ChannelManager.js");
 var import_MessageExchange = require("./MessageExchange.js");
 var import_MessageReceptionState = require("./MessageReceptionState.js");
 /**
@@ -41,45 +87,41 @@ var import_MessageReceptionState = require("./MessageReceptionState.js");
 const logger = import_general.Logger.get("ExchangeManager");
 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 import_general.ObserverGroup(this);
-  #closing = false;
+  #sessionObservers = /* @__PURE__ */ new Map();
+  #isClosing = false;
   constructor(context) {
+    this.#lifetime = context.lifetime.join("exchanges");
+    this.#workers = new import_general.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 [import_general.Environmental.create](env) {
     const instance = new ExchangeManager({
+      lifetime: env,
       entropy: env.get(import_general.Entropy),
       netInterface: env.get(import_general.ConnectionlessTransportSet),
-      sessionManager: env.get(import_SessionManager.SessionManager),
-      channelManager: env.get(import_ChannelManager.ChannelManager)
+      sessions: env.get(import_SessionManager.SessionManager)
     });
     env.set(ExchangeManager, instance);
     return instance;
   }
-  get channels() {
-    return this.#channelManager;
-  }
   hasProtocolHandler(protocolId) {
     return this.#protocols.has(protocolId);
   }
@@ -93,226 +135,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 = import_MessageExchange.MessageExchange.initiate(this.#messageExchangeContextFor(channel), exchangeId, protocolId);
+    const exchange = import_MessageExchange.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 import_general.MatterAggregateError.allSettled(this.#closers, "Error closing exchanges").catch(
-      (error) => logger.error(error)
-    );
-    await import_general.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 = import_MessageCodec.MessageCodec.decodePacket(messageBytes);
-    const bytes = import_general.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 === import_MessageCodec.SessionType.Unicast) {
-      if (packet.header.sessionId === import_InsecureSession.UNICAST_UNSECURE_SESSION_ID) {
-        if (this.#closing) return;
-        const initiatorNodeId = packet.header.sourceNodeId ?? import_types.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 import_general.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 import_general.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) {
-        import_MessageReceptionState.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 === import_MessageCodec.SessionType.Group) {
-      if (this.#closing) return;
-      if (packet.header.sourceNodeId === void 0) {
-        throw new import_general.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) {
-        import_MessageReceptionState.DuplicateMessageError.accept(e);
-        isDuplicate = true;
+      for (const protocol of this.#protocols.values()) {
+        this.#workers.add(protocol.close());
       }
-    } else {
-      throw new import_general.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 = import_types.SecureMessageType.isStandaloneAck(
-      message.payloadHeader.protocolId,
-      message.payloadHeader.messageType
-    );
-    const messageDiagnostics = import_general.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(import_types.SecureMessageType.StandaloneAck, new Uint8Array(0), {
-          includeAcknowledgeMessageId: message.packetHeader.messageId,
-          protocolId: import_types.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 import_general.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", import_general.Diagnostic.strong(channel.name)));
+      const packet = import_MessageCodec.MessageCodec.decodePacket(messageBytes);
+      const bytes = import_general.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 === import_MessageCodec.SessionType.Unicast) {
+        if (packet.header.sessionId === import_UnsecuredSession.UNICAST_UNSECURE_SESSION_ID) {
+          if (this.#isClosing) return;
+          const initiatorNodeId = packet.header.sourceNodeId ?? import_types.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 ${import_Session.Session.idStrOf(packet)}${packet.header.sourceNodeId !== void 0 ? ` from node ${import_general.hex.fixed(packet.header.sourceNodeId, 16)}` : ""}`
+          );
+          return;
+        }
+        message = session.decode(packet, aad);
+        try {
+          session.updateMessageCounter(messageId);
+          isDuplicate = false;
+        } catch (e) {
+          import_MessageReceptionState.DuplicateMessageError.accept(e);
+          isDuplicate = true;
+        }
+      } else if (packet.header.sessionType === import_MessageCodec.SessionType.Group) {
+        if (this.#isClosing) return;
+        if (packet.header.sourceNodeId === void 0) {
+          throw new import_general.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) {
+          import_MessageReceptionState.DuplicateMessageError.accept(e);
+          isDuplicate = true;
+        }
+      } else {
+        throw new import_general.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 = import_types.SecureMessageType.isStandaloneAck(
+        message.payloadHeader.protocolId,
+        message.payloadHeader.messageType
+      );
+      const messageDiagnostics = import_general.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",
+            import_Mark.Mark.INBOUND,
+            "message because",
+            exchange.isClosing ? "exchange is closing" : `session ID mismatch (header session is ${import_Session.Session.idStrOf(packet)}`,
+            messageDiagnostics
+          );
+          await exchange.send(import_types.SecureMessageType.StandaloneAck, new Uint8Array(0), {
+            includeAcknowledgeMessageId: message.packetHeader.messageId,
+            protocolId: import_types.SECURE_CHANNEL_PROTOCOL_ID
+          });
+          await exchange.close();
           return;
         }
-        const exchange2 = import_MessageExchange.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 = import_MessageExchange.MessageExchange.fromInitialMessage(
-          this.#messageExchangeContextFor(await this.#channelManager.getOrCreateChannel(channel, session)),
-          message
-        );
-        this.#addExchange(exchangeIndex, exchange2);
-        await exchange2.send(import_types.SecureMessageType.StandaloneAck, new Uint8Array(0), {
-          includeAcknowledgeMessageId: message.packetHeader.messageId,
-          protocolId: import_types.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 import_general.MatterFlowError(`Unsupported protocol ${message.payloadHeader.protocolId}`);
+        if (this.#isClosing) return;
+        if (session.isClosing) {
+          throw new import_general.MatterFlowError(
+            `Declining new exchange because session ${import_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",
+            import_Mark.Mark.INBOUND,
+            `message because not matching the security requirements (${protocolHandler.requiresSecureSession} vs. ${session.isSecure})`,
+            messageDiagnostics
+          );
         }
-        if (!isStandaloneAck) {
-          logger.info("Discard \xAB unexpected message", messageDiagnostics, import_general.Diagnostic.json(message));
+        if (protocolHandler !== void 0 && message.payloadHeader.isInitiatorMessage && !isDuplicate && !handlerSecurityMismatch) {
+          if (isStandaloneAck && !message.payloadHeader.requiresAck) {
+            logger.debug("Ignore", import_Mark.Mark.INBOUND, "unsolicited standalone ack message", messageDiagnostics);
+            return;
+          }
+          const exchange2 = import_MessageExchange.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 = import_MessageExchange.MessageExchange.fromInitialMessage(this.#messageExchangeContextFor(session), message);
+          this.#lifetime.details.exchange = exchange2.idStr;
+          this.#addExchange(exchangeIndex, exchange2);
+          await exchange2.send(import_types.SecureMessageType.StandaloneAck, new Uint8Array(0), {
+            includeAcknowledgeMessageId: message.packetHeader.messageId,
+            protocolId: import_types.SECURE_CHANNEL_PROTOCOL_ID
+          });
+          await exchange2.close();
+          logger.debug("Ignore", import_Mark.Mark.INBOUND, "unsolicited message", messageDiagnostics);
+        } else {
+          if (protocolHandler === void 0) {
+            throw new import_general.MatterFlowError(`Unsupported protocol ${message.payloadHeader.protocolId}`);
+          }
+          if (isDuplicate) {
+            if (message.packetHeader.destGroupId === void 0) {
+              logger.debug("Ignore", import_Mark.Mark.INBOUND, "duplicate message", messageDiagnostics);
+            }
+            return;
+          }
+          if (!isStandaloneAck) {
+            logger.info(
+              "Discard",
+              import_Mark.Mark.INBOUND,
+              "unexpected message",
+              messageDiagnostics,
+              import_general.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 (import_NodeSession.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, import_types.SECURE_CHANNEL_PROTOCOL_ID);
-        logger.debug(`Initiated exchange ${exchange.id} to close session ${sessionName}`);
-        try {
-          const messenger = new import_SecureChannelMessenger.SecureChannelMessenger(exchange);
-          await messenger.sendCloseSession();
-          await messenger.close();
-        } catch (error) {
-          if (error instanceof import_MessageChannel.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));
@@ -320,7 +352,7 @@ class ExchangeManager {
     this.#cleanupSessionExchanges(exchange.session.id);
   }
   #cleanupSessionExchanges(sessionId) {
-    if (sessionId === import_InsecureSession.UNICAST_UNSECURE_SESSION_ID) {
+    if (sessionId === import_UnsecuredSession.UNICAST_UNSECURE_SESSION_ID) {
       return;
     }
     const sessionExchanges = Array.from(this.#exchanges.values()).filter(
@@ -331,25 +363,27 @@ class ExchangeManager {
     }
     const exchangeToClose = sessionExchanges[0];
     logger.info(
-      `Closing oldest exchange ${exchangeToClose.id} for session ${sessionId} because of too many concurrent outgoing exchanges. Ensure to not send that many parallel messages to one peer.`
+      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.`
     );
-    exchangeToClose.close().catch((error) => logger.error("Error closing exchange", error));
+    logger.debug(exchangeToClose.via, "Closing oldest exchange");
+    this.#workers.add(exchangeToClose.close());
   }
-  calculateMaximumPeerResponseTimeMsFor(channel, expectedProcessingTime = import_MessageChannel.DEFAULT_EXPECTED_PROCESSING_TIME) {
-    return channel.calculateMaximumPeerResponseTime(
-      channel.session.parameters,
-      this.#sessionManager.sessionParameters,
+  calculateMaximumPeerResponseTimeMsFor(session, expectedProcessingTime = import_MessageChannel.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 import_general.UdpInterface;
     this.#listeners.set(
       netInterface,
@@ -360,30 +394,54 @@ class ExchangeManager {
           );
           return;
         }
-        try {
-          this.onMessage(socket, data).catch(
-            (error) => logger.info(
-              `Error on channel ${socket.name}:`,
-              error instanceof import_general.MatterError ? error.message : error
-            )
-          );
-        } catch (error) {
-          logger.info(
-            `Ignoring UDP message on channel ${socket.name} with error`,
-            error instanceof import_general.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 import_NodeSession.NodeSession)) {
+      return;
+    }
+    let observers = this.#sessionObservers.get(session);
+    if (!observers) {
+      this.#sessionObservers.set(session, observers = new import_general.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, import_types.SECURE_CHANNEL_PROTOCOL_ID), true);
+      logger.debug(exchange.via, "Closing session");
+      try {
+        const messenger = new import_SecureChannelMessenger.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 {