@matter/protocol 0.13.0-alpha.0-20250311-3eb0af5f2 → 0.13.0-alpha.0-20250322-f085fa576

package/src/peer/PeerSet.ts

@@ -36,7 +36,7 @@ import { SessionManager } from "#session/SessionManager.js";
 import { SECURE_CHANNEL_PROTOCOL_ID } from "@matter/types";
 import { ChannelManager } from "../protocol/ChannelManager.js";
 import { ChannelNotConnectedError, ExchangeManager, MessageChannel } from "../protocol/ExchangeManager.js";
-import { ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
+import { DedicatedChannelExchangeProvider, ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
 import { RetransmissionLimitReachedError } from "../protocol/MessageExchange.js";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
 import { InteractionQueue } from "./InteractionQueue.js";
@@ -272,7 +272,11 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     /**
      * Obtain an exchange provider for the designated peer.
      */
-    async exchangeProviderFor(address: PeerAddress, discoveryOptions?: DiscoveryOptions) {
+    async exchangeProviderFor(addressOrChannel: PeerAddress | MessageChannel, discoveryOptions?: DiscoveryOptions) {
+        if (addressOrChannel instanceof MessageChannel) {
+            return new DedicatedChannelExchangeProvider(this.#exchanges, addressOrChannel);
+        }
+        const address: PeerAddress = addressOrChannel;
         let initiallyConnected = this.#channels.hasChannel(address);
         return new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
             if (!initiallyConnected && !this.#channels.hasChannel(address)) {
@@ -622,6 +626,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         discoveryData?: DiscoveryData,
         expectedProcessingTimeMs?: number,
     ) {
+        logger.debug(`Pair with ${address} at ${serverAddressToString(operationalServerAddress)}`);
         const { ip, port } = operationalServerAddress;
         // Do CASE pairing
         const isIpv6Address = isIPv6(ip);

package/src/protocol/ChannelManager.ts

@@ -69,7 +69,9 @@ export class ChannelManager {
     }
 
     hasChannel(address: PeerAddress) {
-        return !!this.#channels.get(address)?.length;
+        return !!this.#channels
+            .get(address)
+            ?.filter(channel => !channel.closed && !channel.session.closingAfterExchangeFinished).length;
     }
 
     getChannel(address: PeerAddress, session?: Session) {
@@ -77,6 +79,7 @@ export class ChannelManager {
         if (session !== undefined) {
             results = results.filter(channel => channel.session.id === session.id);
         }
+        results = results.filter(channel => !channel.closed && !channel.session.closingAfterExchangeFinished);
         if (results.length === 0)
             throw new NoChannelError(
                 `Can't find a channel to ${PeerAddress(address)}${session !== undefined ? ` session ${session.id}` : ""}`,
@@ -131,6 +134,7 @@ export class ChannelManager {
             async () => void this.#paseChannels.delete(session),
         );
         this.#paseChannels.set(session, msgChannel);
+        session.destroyed.on(() => msgChannel.close());
         return msgChannel;
     }
 
@@ -154,9 +158,12 @@ export class ChannelManager {
         }
 
         // Need to create
-        const result = new MessageChannel(byteArrayChannel, session, async () => this.removeChannel(address, session));
-        await this.setChannel(address, result);
-        return result;
+        const msgChannel = new MessageChannel(byteArrayChannel, session, async () =>
+            this.removeChannel(address, session),
+        );
+        await this.setChannel(address, msgChannel);
+        session.destroyed.on(() => msgChannel.close());
+        return msgChannel;
     }
 
     async close() {

package/src/protocol/ExchangeManager.ts

@@ -48,7 +48,6 @@ export class MessageChannel implements Channel<Message> {
         closeCallback?: () => Promise<void>,
     ) {
         this.#closeCallback = closeCallback;
-        this.session.destroyed.on(() => this.close());
     }
 
     set closeCallback(callback: () => Promise<void>) {