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

package/dist/esm/protocol/MessageExchange.js

@@ -1,31 +1,72 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ 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 { Message, SessionType } from "#codec/MessageCodec.js";
+import { Mark } from "#common/Mark.js";
 import {
-  AsyncObservable,
+  AsyncObservableValue,
   createPromise,
   CRYPTO_AEAD_MIC_LENGTH_BYTES,
   DataReadQueue,
   Diagnostic,
   Duration,
+  hex,
   Instant,
   InternalError,
   Logger,
-  MatterError,
   MatterFlowError,
   Millis,
-  NoResponseTimeoutError,
   Time
 } from "#general";
-import {
-  ChannelNotConnectedError,
-  DEFAULT_EXPECTED_PROCESSING_TIME,
-  MRP
-} from "#protocol/MessageChannel.js";
 import { GroupSession } from "#session/GroupSession.js";
+import { Session } from "#session/Session.js";
 import {
   GroupId,
   SECURE_CHANNEL_PROTOCOL_ID,
@@ -33,87 +74,45 @@ import {
   StatusCode,
   StatusResponseError
 } from "#types";
+import { RetransmissionLimitReachedError, SessionClosedError, UnexpectedMessageError } from "./errors.js";
+import { DEFAULT_EXPECTED_PROCESSING_TIME, MRP } from "./MessageChannel.js";
 const logger = Logger.get("MessageExchange");
-class RetransmissionLimitReachedError extends NoResponseTimeoutError {
-}
-class UnexpectedMessageError extends MatterError {
-  constructor(message, receivedMessage) {
-    super(`(${MessageCodec.messageDiagnostics(receivedMessage)}) ${message}`);
-    this.receivedMessage = receivedMessage;
-  }
-}
 const MATTER_MESSAGE_OVERHEAD = 26 + 12 + CRYPTO_AEAD_MIC_LENGTH_BYTES;
 class MessageExchange {
-  constructor(context, isInitiator, peerSessionId, nodeId, peerNodeId, exchangeId, protocolId, requiresSecureSession) {
-    this.context = context;
-    this.isInitiator = isInitiator;
-    this.requiresSecureSession = requiresSecureSession;
-    const { channel } = context;
-    const { session } = channel;
-    this.#peerSessionId = peerSessionId;
-    this.#nodeId = nodeId;
-    this.#peerNodeId = peerNodeId;
-    this.#exchangeId = exchangeId;
-    this.#protocolId = protocolId;
-    const { activeThreshold, activeInterval, idleInterval } = this.session.parameters;
-    this.#used = !isInitiator;
-    logger.debug(
-      "New exchange",
-      isInitiator ? "\xBB" : "\xAB",
-      channel.name,
-      Diagnostic.dict({
-        protocol: this.#protocolId,
-        exId: this.#exchangeId,
-        sess: session.name,
-        peerSess: this.#peerSessionId,
-        SAT: Duration.format(activeThreshold),
-        SAI: Duration.format(activeInterval),
-        SII: Duration.format(idleInterval),
-        maxTrans: MRP.MAX_TRANSMISSIONS,
-        exchangeFlags: Diagnostic.asFlags({
-          MRP: this.channel.usesMrp,
-          I: this.isInitiator
-        })
-      })
-    );
-  }
   static fromInitialMessage(context, initialMessage) {
-    const {
-      channel: { session }
-    } = context;
-    return new MessageExchange(
+    const { session } = context;
+    return new MessageExchange({
       context,
-      false,
-      session.id,
-      initialMessage.packetHeader.destNodeId,
-      initialMessage.packetHeader.sourceNodeId,
-      initialMessage.payloadHeader.exchangeId,
-      initialMessage.payloadHeader.protocolId,
-      session.isSecure
-    );
+      isInitiator: false,
+      peerSessionId: session.id,
+      nodeId: initialMessage.packetHeader.destNodeId,
+      peerNodeId: initialMessage.packetHeader.sourceNodeId,
+      exchangeId: initialMessage.payloadHeader.exchangeId,
+      protocolId: initialMessage.payloadHeader.protocolId
+    });
   }
   static initiate(context, exchangeId, protocolId) {
-    const {
-      channel: { session }
-    } = context;
-    return new MessageExchange(
+    const { session } = context;
+    return new MessageExchange({
       context,
-      true,
-      session.peerSessionId,
-      session.nodeId,
-      session.peerNodeId,
+      isInitiator: true,
+      peerSessionId: session.peerSessionId,
+      nodeId: session.nodeId,
+      peerNodeId: session.peerNodeId,
       exchangeId,
-      protocolId,
-      session.isSecure
-    );
+      protocolId
+    });
   }
+  #context;
+  #isInitiator;
   #messagesQueue = new DataReadQueue();
+  #lifetime;
   #receivedMessageToAck;
-  #receivedMessageAckTimer = Time.getTimer("Ack receipt timeout", MRP.STANDALONE_ACK_TIMEOUT, () => {
+  #receivedMessageAckTimer = Time.getTimer("ack receipt timeout", MRP.STANDALONE_ACK_TIMEOUT, () => {
     if (this.#receivedMessageToAck !== void 0) {
       const messageToAck = this.#receivedMessageToAck;
       this.#receivedMessageToAck = void 0;
-      this.sendStandaloneAckForMessage(messageToAck).catch(
+      this.#sendStandaloneAckForMessage(messageToAck).catch(
         (error) => logger.error("An error happened when sending a standalone ack", error)
       );
     }
@@ -124,7 +123,7 @@ class MessageExchange {
   #retransmissionTimer;
   #retransmissionCounter = 0;
   #closeTimer;
-  #isClosing = false;
+  #isDestroyed = false;
   #timedInteractionTimer;
   #used;
   #peerSessionId;
@@ -132,8 +131,46 @@ class MessageExchange {
   #peerNodeId;
   #exchangeId;
   #protocolId;
-  #closed = AsyncObservable();
-  #closing = AsyncObservable();
+  #closed = AsyncObservableValue();
+  #closing = AsyncObservableValue();
+  constructor(config) {
+    const { context, isInitiator, peerSessionId, nodeId, peerNodeId, exchangeId, protocolId } = config;
+    this.#context = context;
+    this.#isInitiator = isInitiator;
+    this.#peerSessionId = peerSessionId;
+    this.#nodeId = nodeId;
+    this.#peerNodeId = peerNodeId;
+    this.#exchangeId = exchangeId;
+    this.#protocolId = protocolId;
+    const { activeThreshold, activeInterval, idleInterval } = this.session.parameters;
+    this.#used = !isInitiator;
+    const { session } = context;
+    logger.debug(
+      "New exchange",
+      isInitiator ? Mark.OUTBOUND : Mark.INBOUND,
+      this.via,
+      Diagnostic.dict({
+        protocol: this.#protocolId,
+        peerSess: Session.idStrOf(this.#peerSessionId),
+        SAT: Duration.format(activeThreshold),
+        SAI: Duration.format(activeInterval),
+        SII: Duration.format(idleInterval),
+        maxTrans: MRP.MAX_TRANSMISSIONS,
+        exchangeFlags: Diagnostic.asFlags({
+          MRP: this.session.usesMrp,
+          I: this.isInitiator
+        })
+      })
+    );
+    session.addExchange(this);
+    this.#lifetime = this.#context.session.join("exchange", Diagnostic.via(hex.word(this.id)));
+  }
+  get context() {
+    return this.#context;
+  }
+  get isInitiator() {
+    return this.#isInitiator;
+  }
   /** Emits when the exchange is actually closed. This happens after all Retries and Communication are done. */
   get closed() {
     return this.#closed;
@@ -146,16 +183,19 @@ class MessageExchange {
     return this.#closing;
   }
   get isClosing() {
-    return this.#isClosing;
+    return this.#closing.value;
   }
   get id() {
     return this.#exchangeId;
   }
-  get channel() {
-    return this.context.channel;
+  get idStr() {
+    return hex.word(this.#exchangeId);
   }
   get session() {
-    return this.channel.session;
+    return this.context.session;
+  }
+  get channel() {
+    return this.session.channel;
   }
   /**
    * Max Payload size of the exchange which bases on the maximum payload size of the channel reduced by Matter
@@ -164,20 +204,12 @@ class MessageExchange {
   get maxPayloadSize() {
     return this.channel.maxPayloadSize - MATTER_MESSAGE_OVERHEAD;
   }
-  async sendStandaloneAckForMessage(message) {
-    const {
-      packetHeader: { messageId },
-      payloadHeader: { requiresAck }
-    } = message;
-    if (!requiresAck || !this.channel.usesMrp) return;
-    await this.send(SecureMessageType.StandaloneAck, new Uint8Array(0), {
-      includeAcknowledgeMessageId: messageId,
-      protocolId: SECURE_CHANNEL_PROTOCOL_ID
-    });
+  join(...name) {
+    return this.#lifetime.join(...name);
   }
   async onMessageReceived(message, duplicate = false) {
-    logger.debug("Message \xAB", MessageCodec.messageDiagnostics(message, { duplicate }));
-    if (message.payloadHeader.requiresAck && !this.channel.usesMrp) {
+    logger.debug("Message", Mark.INBOUND, Message.diagnosticsOf(this, message, { duplicate }));
+    if (message.payloadHeader.requiresAck && !this.session.usesMrp) {
       logger.debug("Ignoring ack-required flag because MRP is not used for this exchange");
       message.payloadHeader.requiresAck = false;
     }
@@ -194,13 +226,21 @@ class MessageExchange {
     this.session.notifyActivity(true);
     if (duplicate) {
       if (requiresAck) {
-        await this.sendStandaloneAckForMessage(message);
+        await this.#sendStandaloneAckForMessage(message);
       }
       return;
     }
     if (messageId === this.#sentMessageToAck?.payloadHeader.ackedMessageId) {
-      await this.channel.send(this.#sentMessageToAck);
-      return;
+      var _stack = [];
+      try {
+        const _acking = __using(_stack, this.join("resending ack"));
+        await this.channel.send(this.#sentMessageToAck);
+        return;
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
     }
     const sentMessageIdToAck = this.#sentMessageToAck?.packetHeader.messageId;
     if (sentMessageIdToAck !== void 0) {
@@ -231,126 +271,144 @@ class MessageExchange {
     if (requiresAck) {
       if (this.#receivedMessageToAck !== void 0) {
         this.#receivedMessageAckTimer.stop();
-        await this.sendStandaloneAckForMessage(this.#receivedMessageToAck);
+        await this.#sendStandaloneAckForMessage(this.#receivedMessageToAck);
         return;
       }
       this.#receivedMessageToAck = message;
       this.#receivedMessageAckTimer.start();
     }
-    await this.#messagesQueue.write(message);
+    this.#messagesQueue.write(message);
   }
-  async send(messageType, payload, options) {
-    if (options?.requiresAck && !this.channel.usesMrp) {
-      options.requiresAck = false;
-    }
-    const {
-      expectAckOnly = false,
-      disableMrpLogic,
-      expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
-      requiresAck,
-      includeAcknowledgeMessageId,
-      logContext,
-      protocolId = this.#protocolId
-    } = options ?? {};
-    if (!this.channel.usesMrp && includeAcknowledgeMessageId !== void 0) {
-      throw new InternalError("Cannot include an acknowledge message ID when MRP is not used");
-    }
-    const isStandaloneAck = SecureMessageType.isStandaloneAck(protocolId, messageType);
-    if (isStandaloneAck) {
-      if (!this.channel.usesMrp) {
-        return;
+  async send(messageType, payload, options = {}) {
+    var _stack2 = [];
+    try {
+      const {
+        expectAckOnly = false,
+        disableMrpLogic,
+        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
+        includeAcknowledgeMessageId,
+        logContext,
+        protocolId = this.#protocolId
+      } = options;
+      if (!this.session.usesMrp && includeAcknowledgeMessageId !== void 0) {
+        throw new InternalError("Cannot include an acknowledge message ID when MRP is not used");
       }
-      if (requiresAck) {
-        throw new MatterFlowError("A standalone ack may not require acknowledgement.");
+      let { requiresAck } = options;
+      if (requiresAck && !(this.session.usesMrp || this.session.isPeerLost)) {
+        requiresAck = false;
       }
-    }
-    if (this.#sentMessageToAck !== void 0 && !isStandaloneAck) {
-      throw new MatterFlowError("The previous message has not been acked yet, cannot send a new message.");
-    }
-    this.#used = true;
-    this.session.notifyActivity(false);
-    let ackedMessageId = includeAcknowledgeMessageId;
-    if (ackedMessageId === void 0 && this.channel.usesMrp) {
-      ackedMessageId = this.#receivedMessageToAck?.packetHeader.messageId;
-      if (ackedMessageId !== void 0) {
-        this.#receivedMessageAckTimer.stop();
-        this.#receivedMessageToAck = void 0;
+      const isStandaloneAck = SecureMessageType.isStandaloneAck(protocolId, messageType);
+      if (isStandaloneAck) {
+        if (!this.session.usesMrp) {
+          return;
+        }
+        if (requiresAck) {
+          throw new MatterFlowError("A standalone ack may not require acknowledgement.");
+        }
       }
-    }
-    let packetHeader;
-    if (this.session.type === SessionType.Unicast) {
-      packetHeader = {
-        sessionId: this.#peerSessionId,
-        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.");
+      if (this.#sentMessageToAck !== void 0 && !isStandaloneAck) {
+        throw new MatterFlowError("The previous message has not been acked yet, cannot send a new message.");
+      }
+      this.#used = true;
+      this.session.notifyActivity(false);
+      let ackedMessageId = includeAcknowledgeMessageId;
+      if (ackedMessageId === void 0 && this.session.usesMrp) {
+        ackedMessageId = this.#receivedMessageToAck?.packetHeader.messageId;
+        if (ackedMessageId !== void 0) {
+          this.#receivedMessageAckTimer.stop();
+          this.#receivedMessageToAck = void 0;
+        }
       }
-      const destGroupId = GroupId.fromNodeId(this.#peerNodeId);
-      if (destGroupId === 0) {
-        throw new InternalError(`Invalid GroupId extracted from NodeId ${this.#peerNodeId}`);
+      let packetHeader;
+      if (this.session.type === SessionType.Unicast) {
+        packetHeader = {
+          sessionId: this.#peerSessionId,
+          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);
+        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}`);
       }
-      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
+      const message = {
+        packetHeader,
+        payloadHeader: {
+          exchangeId: this.#exchangeId,
+          protocolId,
+          messageType,
+          isInitiatorMessage: this.isInitiator,
+          requiresAck: requiresAck ?? (this.session.usesMrp && !isStandaloneAck),
+          ackedMessageId,
+          hasSecuredExtension: false
+        },
+        payload
       };
-    } else {
-      throw new InternalError(`Unknown session type: ${this.session.type}`);
-    }
-    const message = {
-      packetHeader,
-      payloadHeader: {
-        exchangeId: this.#exchangeId,
-        protocolId,
-        messageType,
-        isInitiatorMessage: this.isInitiator,
-        requiresAck: requiresAck ?? (this.channel.usesMrp && !isStandaloneAck),
-        ackedMessageId,
-        hasSecuredExtension: false
-      },
-      payload
-    };
-    let ackPromise;
-    if (this.channel.usesMrp && message.payloadHeader.requiresAck && !disableMrpLogic) {
-      this.#sentMessageToAck = message;
-      this.#retransmissionTimer = Time.getTimer(
-        `Message retransmission ${message.packetHeader.messageId}`,
-        this.channel.getMrpResubmissionBackOffTime(0),
-        () => this.#retransmitMessage(message, expectedProcessingTime)
-      );
-      const { promise, resolver, rejecter } = createPromise();
-      ackPromise = promise;
-      this.#sentMessageAckSuccess = resolver;
-      this.#sentMessageAckFailure = rejecter;
-    }
-    await this.channel.send(message, logContext);
-    if (ackPromise !== void 0) {
-      this.#retransmissionCounter = 0;
-      this.#retransmissionTimer?.start();
-      const responseMessage = await ackPromise;
-      this.#sentMessageAckSuccess = void 0;
-      this.#sentMessageAckFailure = void 0;
-      const {
-        payloadHeader: { protocolId: protocolId2, messageType: messageType2 }
-      } = responseMessage;
-      if (expectAckOnly && !SecureMessageType.isStandaloneAck(protocolId2, messageType2)) {
-        throw new UnexpectedMessageError("Expected ack only", responseMessage);
+      let ackPromise;
+      if (this.session.usesMrp && message.payloadHeader.requiresAck && !disableMrpLogic) {
+        this.#sentMessageToAck = message;
+        this.#retransmissionTimer = Time.getTimer(
+          `retransmitting ${Message.via(this, message)}`,
+          this.channel.getMrpResubmissionBackOffTime(0),
+          () => this.#retransmitMessage(message, expectedProcessingTime)
+        );
+        const { promise, resolver, rejecter } = createPromise();
+        ackPromise = promise;
+        this.#sentMessageAckSuccess = resolver;
+        this.#sentMessageAckFailure = rejecter;
+      }
+      const sending = __using(_stack2, this.join("sending", Diagnostic.strong(Message.via(this, message))));
+      await this.channel.send(message, logContext);
+      if (ackPromise !== void 0) {
+        var _stack = [];
+        try {
+          this.#retransmissionCounter = 0;
+          this.#retransmissionTimer?.start();
+          const _waiting = __using(_stack, sending.join("waiting for ack"));
+          const responseMessage = await ackPromise;
+          this.#sentMessageAckSuccess = void 0;
+          this.#sentMessageAckFailure = void 0;
+          if (responseMessage) {
+            const {
+              payloadHeader: { protocolId: protocolId2, messageType: messageType2 }
+            } = responseMessage;
+            if (expectAckOnly && !SecureMessageType.isStandaloneAck(protocolId2, messageType2)) {
+              throw new UnexpectedMessageError("Expected ack only", this.session, responseMessage);
+            }
+          }
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
       }
+    } catch (_2) {
+      var _error2 = _2, _hasError2 = true;
+    } finally {
+      __callDispose(_stack2, _error2, _hasError2);
     }
   }
   nextMessage(options) {
@@ -368,10 +426,21 @@ class MessageExchange {
     }
     return this.#messagesQueue.read(timeout);
   }
+  async #sendStandaloneAckForMessage(message) {
+    const {
+      packetHeader: { messageId },
+      payloadHeader: { requiresAck }
+    } = message;
+    if (!requiresAck || !this.session.usesMrp) return;
+    await this.send(SecureMessageType.StandaloneAck, new Uint8Array(0), {
+      includeAcknowledgeMessageId: messageId,
+      protocolId: SECURE_CHANNEL_PROTOCOL_ID
+    });
+  }
   #retransmitMessage(message, expectedProcessingTime) {
     this.#retransmissionCounter++;
-    if (this.#isClosing || this.#retransmissionCounter >= MRP.MAX_TRANSMISSIONS) {
-      if (expectedProcessingTime && !this.#isClosing) {
+    if (this.isClosing || this.#retransmissionCounter >= MRP.MAX_TRANSMISSIONS) {
+      if (expectedProcessingTime && !this.isClosing) {
         const finalWaitTime = Millis(
           this.channel.calculateMaximumPeerResponseTime(
             this.session.parameters,
@@ -382,10 +451,10 @@ class MessageExchange {
         if (finalWaitTime > 0) {
           this.#retransmissionCounter--;
           logger.debug(
-            `Message ${message.packetHeader.messageId}: Wait additional ${Duration.format(finalWaitTime)} for processing time and peer resubmissions after all our resubmissions`
+            `Message ${Message.via(this, message)}: Wait additional ${Duration.format(finalWaitTime)} for processing time and peer resubmissions after all our resubmissions`
           );
           this.#retransmissionTimer = Time.getTimer(
-            `Message wait time after resubmissions ${message.packetHeader.messageId}`,
+            `waiting after resubmissions for ${Message.via(this, message)}`,
             finalWaitTime,
             () => this.#retransmitMessage(message)
           ).start();
@@ -399,7 +468,7 @@ class MessageExchange {
         this.#sentMessageAckSuccess = void 0;
       }
       if (this.#closeTimer !== void 0) {
-        this.#close().catch((error) => logger.error("An error happened when closing the exchange", error));
+        this.#close().catch((error) => logger.error("Error closing exchange", error));
       }
       return;
     }
@@ -407,11 +476,11 @@ class MessageExchange {
     this.context.retry(this.#retransmissionCounter);
     const resubmissionBackoffTime = this.channel.getMrpResubmissionBackOffTime(this.#retransmissionCounter);
     logger.debug(
-      `Resubmit message ${message.packetHeader.messageId} (retransmission attempt ${this.#retransmissionCounter}, backoff time ${Duration.format(resubmissionBackoffTime)}))`
+      `Resubmitting ${Message.via(this, message)} (retransmission attempt ${this.#retransmissionCounter}, backoff time ${Duration.format(resubmissionBackoffTime)}))`
     );
     this.channel.send(message).then(() => this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTime)).catch((error) => {
-      logger.error("An error happened when retransmitting a message", error);
-      if (error instanceof ChannelNotConnectedError) {
+      logger.error(`Error retransmitting ${Message.via(this, message)}:`, error);
+      if (error instanceof SessionClosedError) {
         this.#close().catch((error2) => logger.error("An error happened when closing the exchange", error2));
       } else {
         this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTime);
@@ -425,13 +494,20 @@ class MessageExchange {
       () => this.#retransmitMessage(message, expectedProcessingTimeMs)
     ).start();
   }
+  [Symbol.asyncDispose]() {
+    return this.destroy();
+  }
   async destroy() {
+    if (this.#isDestroyed) {
+      return;
+    }
+    this.#isDestroyed = true;
     if (this.#closeTimer === void 0 && this.#receivedMessageToAck !== void 0) {
       this.#receivedMessageAckTimer.stop();
       const messageToAck = this.#receivedMessageToAck;
       this.#receivedMessageToAck = void 0;
       try {
-        await this.sendStandaloneAckForMessage(messageToAck);
+        await this.#sendStandaloneAckForMessage(messageToAck);
       } catch (error) {
         logger.error("An error happened when closing the exchange", error);
       }
@@ -447,7 +523,8 @@ class MessageExchange {
       );
     }
     logger.debug(
-      "Starting timed interaction \xAB",
+      "Starting timed interaction",
+      Mark.INBOUND,
       this.channel.name,
       Diagnostic.dict({ exId: this.#exchangeId, timeout: Duration.format(timeout) })
     );
@@ -477,7 +554,11 @@ class MessageExchange {
   hasExpiredTimedInteraction() {
     return this.#timedInteractionTimer !== void 0 && !this.#timedInteractionTimer.isRunning;
   }
-  async close(force = false) {
+  async close(force = this.isInitiator) {
+    if (this.#isDestroyed) {
+      return;
+    }
+    this.#lifetime.closing();
     if (this.#closeTimer !== void 0) {
       if (force) {
         this.#closeTimer.stop();
@@ -486,22 +567,18 @@ class MessageExchange {
       return;
     }
     if (!this.#used) {
-      logger.info(`Exchange ${this.session.name} / ${this.#exchangeId} was never used, closing directly`);
+      logger.info(this.via, `Exchange never used, closing directly`);
       return this.#close();
     }
-    this.#isClosing = true;
-    this.#closing.emit();
+    await this.#closing.emit(true);
     if (this.#receivedMessageToAck !== void 0) {
       this.#receivedMessageAckTimer.stop();
       const messageToAck = this.#receivedMessageToAck;
       this.#receivedMessageToAck = void 0;
       try {
-        await this.sendStandaloneAckForMessage(messageToAck);
+        await this.#sendStandaloneAckForMessage(messageToAck);
       } catch (error) {
-        logger.error(
-          `An error happened when closing the exchange ${this.session.name} / ${this.#exchangeId}`,
-          error
-        );
+        logger.error(this.via, `Unhandled error closing exchange`, error);
       }
       if (force) {
         return this.#close();
@@ -514,33 +591,36 @@ class MessageExchange {
       maxResubmissionTime = Millis(maxResubmissionTime + this.channel.getMrpResubmissionBackOffTime(i));
     }
     this.#closeTimer = Time.getTimer(
-      `Message exchange cleanup ${this.session.name} / ${this.#exchangeId}`,
+      `Exchange ${this.via} close`,
       maxResubmissionTime,
       async () => await this.#close()
     ).start();
   }
   async #close() {
-    if (!this.#isClosing) {
-      this.#closing.emit();
+    var _stack = [];
+    try {
+      const _closing = __using(_stack, this.#lifetime.closing());
+      this.#retransmissionTimer?.stop();
+      this.#sentMessageAckSuccess?.(void 0);
+      this.#closeTimer?.stop();
+      this.#timedInteractionTimer?.stop();
+      this.#messagesQueue.close();
+      await this.#closed.emit(true);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
     }
-    this.#isClosing = true;
-    this.#retransmissionTimer?.stop();
-    this.#closeTimer?.stop();
-    this.#timedInteractionTimer?.stop();
-    this.#messagesQueue.close();
-    await this.#closed.emit();
   }
   get via() {
-    if (this.session === void 0 || !this.session.isSecure) {
-      return this.channel.name;
+    if (this.session === void 0) {
+      return Diagnostic.via(`${Mark.EXCHANGE}${this.idStr}`);
     }
-    return Diagnostic.via(`${this.session.peerAddress.toString()}#${this.session.id}`);
+    return Diagnostic.via(`${this.session.via}${Mark.EXCHANGE}${this.idStr}`);
   }
 }
 export {
   MATTER_MESSAGE_OVERHEAD,
-  MessageExchange,
-  RetransmissionLimitReachedError,
-  UnexpectedMessageError
+  MessageExchange
 };
 //# sourceMappingURL=MessageExchange.js.map