@matter/protocol 0.16.0-alpha.0-20251006-3fe1e7c57 → 0.16.0-alpha.0-20251013-89bb7099d

package/src/peer/PeerSet.ts

@@ -258,10 +258,14 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         return this.#interactionQueue;
     }
 
+    async connect(address: PeerAddress, options: PeerConnectionOptions & { operationalAddress?: ServerAddressUdp }) {
+        await this.#ensureConnection(address, { ...options, allowUnknownPeer: true });
+    }
+
     /**
      * Ensure there is a channel to the designated peer.
      */
-    async ensureConnection(
+    async #ensureConnection(
         address: PeerAddress,
         options: PeerConnectionOptions & {
             allowUnknownPeer?: boolean;
@@ -306,6 +310,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     /**
      * Obtain an exchange provider for the designated peer.
+     * TODO enhance PeerConnectionOptions.discoveryOptions.discoveryData with "addresses" for known operational addresses
      */
     async exchangeProviderFor(addressOrChannel: PeerAddress | MessageChannel, options: PeerConnectionOptions = {}) {
         if (addressOrChannel instanceof MessageChannel) {
@@ -325,7 +330,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
             if (!initiallyConnected && !this.#channels.hasChannel(address)) {
                 // We got an uninitialized node, so do the first connection as usual
-                await this.ensureConnection(address, {
+                await this.#ensureConnection(address, {
                     discoveryOptions: { discoveryType: NodeDiscoveryType.None },
                     caseAuthenticatedTags,
                 });
@@ -376,11 +381,17 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     /**
      * Terminate any active peer connection.
+     * Also handles unknown peers
      */
     async disconnect(peer: PeerAddress | OperationalPeer, sendSessionClose = true) {
-        const address = this.get(peer)?.address;
+        let address = this.get(peer)?.address; // Check known Peers
         if (address === undefined) {
-            return;
+            // We did not find a ClientNode for this peer, so check if it is a PeerAddress
+            if ("nodeId" in peer && "fabricIndex" in peer) {
+                address = peer;
+            } else {
+                return;
+            }
         }
 
         await this.#sessions.removeAllSessionsForNode(address, sendSessionClose);
@@ -818,7 +829,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     async #addOrUpdatePeer(
         address: PeerAddress,
-        operationalServerAddress: ServerAddressUdp,
+        operationalServerAddress?: ServerAddressUdp,
         discoveryData?: DiscoveryData,
     ) {
         let peer = this.#peersByAddress.get(address);
@@ -826,7 +837,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             peer = { address, dataStore: await this.#store.createNodeStore(address) };
             this.#peers.add(peer);
         }
-        peer.operationalAddress = operationalServerAddress;
+        peer.operationalAddress = operationalServerAddress ?? peer.operationalAddress;
         if (discoveryData !== undefined) {
             peer.discoveryData = {
                 ...peer.discoveryData,
@@ -836,7 +847,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         await this.#store.updatePeer(peer);
 
         // If we got a new channel and have a running discovery we can end it
-        if (this.#runningPeerDiscoveries.has(address)) {
+        if (peer.operationalAddress !== undefined && this.#runningPeerDiscoveries.has(address)) {
             logger.info(`Found ${address} during discovery, cancel discovery.`);
             // We are currently discovering this node, so we need to update the discovery data
             const { mdnsClient: mdnsScanner } = this.#runningPeerDiscoveries.get(address) ?? {};
@@ -846,6 +857,10 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         }
     }
 
+    addKnownPeer(address: PeerAddress, operationalServerAddress?: ServerAddressUdp, discoveryData?: DiscoveryData) {
+        return this.#addOrUpdatePeer(address, operationalServerAddress, discoveryData);
+    }
+
     #getLastOperationalAddress(address: PeerAddress) {
         return this.#peersByAddress.get(address)?.operationalAddress;
     }

package/src/protocol/ExchangeManager.ts

@@ -335,9 +335,10 @@ export class ExchangeManager {
             return;
         }
         const { session } = exchange;
+        this.#exchanges.delete(exchangeIndex);
         if (NodeSession.is(session) && session.closingAfterExchangeFinished) {
             logger.debug(
-                `Exchange index ${exchangeIndex} Session ${session.name} is already marked for closure. Close session now.`,
+                `Exchange index ${exchangeIndex} on Session ${session.name} is already marked for closure. Close session now.`,
             );
             try {
                 await this.#closeSession(session);
@@ -345,7 +346,6 @@ export class ExchangeManager {
                 logger.error(`Error closing session ${session.name}. Ignoring.`, error);
             }
         }
-        this.#exchanges.delete(exchangeIndex);
     }
 
     async #closeSession(session: NodeSession) {

package/src/protocol/MessageExchange.ts

@@ -198,6 +198,7 @@ export class MessageExchange {
 
         logger.debug(
             "New exchange",
+            isInitiator ? "»" : "«",
             Diagnostic.dict({
                 channel: channel.name,
                 protocol: this.#protocolId,