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

package/dist/esm/peer/PeerSet.js

@@ -1,3 +1,48 @@
+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
@@ -15,7 +60,6 @@ import {
   Duration,
   Environmental,
   ImplementationError,
-  isIpNetworkChannel,
   isIPv6,
   Logger,
   MatterError,
@@ -23,21 +67,20 @@ import {
   NoResponseTimeoutError,
   Seconds,
   ServerAddress,
-  STANDARD_MATTER_PORT,
   Time
 } from "#general";
 import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
-import { ChannelManager } from "#protocol/ChannelManager.js";
+import { RetransmissionLimitReachedError } from "#protocol/errors.js";
 import { ExchangeManager } from "#protocol/ExchangeManager.js";
 import { DedicatedChannelExchangeProvider, ReconnectableExchangeProvider } from "#protocol/ExchangeProvider.js";
-import { ChannelNotConnectedError, MessageChannel } from "#protocol/MessageChannel.js";
-import { RetransmissionLimitReachedError } from "#protocol/MessageExchange.js";
 import { ChannelStatusResponseError } from "#securechannel/SecureChannelMessenger.js";
 import { CaseClient } from "#session/case/CaseClient.js";
+import { SecureSession } from "#session/SecureSession.js";
 import { SessionManager } from "#session/SessionManager.js";
-import { GroupId, NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
+import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
 import { InteractionQueue } from "./InteractionQueue.js";
+import { Peer } from "./Peer.js";
 import { PeerAddressStore } from "./PeerAddressStore.js";
 const logger = Logger.get("PeerSet");
 const RECONNECTION_POLLING_INTERVAL = Minutes(10);
@@ -52,37 +95,42 @@ var NodeDiscoveryType = /* @__PURE__ */ ((NodeDiscoveryType2) => {
 class UnknownNodeError extends MatterError {
 }
 class PeerSet {
+  #lifetime;
   #sessions;
-  #channels;
   #exchanges;
   #scanners;
   #transports;
   #caseClient;
   #peers = new BasicSet();
-  #peersByAddress = new PeerAddressMap();
-  #runningPeerDiscoveries = new PeerAddressMap();
-  #runningPeerReconnections = new PeerAddressMap();
   #construction;
   #store;
   #interactionQueue = new InteractionQueue();
   #nodeCachedData = new PeerAddressMap();
   // Temporarily until we store it in new API
   #disconnected = AsyncObservable();
+  #peerContext;
   constructor(context) {
-    const { sessions, channels, exchanges, scanners, transports: netInterfaces, store } = context;
+    const { lifetime, sessions, exchanges, scanners, transports: netInterfaces, store } = context;
+    this.#lifetime = lifetime.join("peers");
     this.#sessions = sessions;
-    this.#channels = channels;
     this.#exchanges = exchanges;
     this.#scanners = scanners;
     this.#transports = netInterfaces;
     this.#store = store;
     this.#caseClient = new CaseClient(this.#sessions);
+    this.#peerContext = {
+      lifetime: this.#lifetime,
+      sessions,
+      savePeer: (peer) => this.#store.updatePeer(peer.descriptor),
+      deletePeer: (peer) => this.#store.deletePeer(peer.address),
+      closed: (peer) => this.#peers.delete(peer)
+    };
     this.#peers.added.on((peer) => {
-      peer.address = PeerAddress(peer.address);
-      this.#peersByAddress.set(peer.address, peer);
-    });
-    this.#peers.deleted.on((peer) => {
-      this.#peersByAddress.delete(peer.address);
+      peer.sessions.deleted.on(() => {
+        if (!peer.sessions.size) {
+          this.#disconnected.emit(peer);
+        }
+      });
     });
     this.#sessions.retry.on((session, count) => {
       if (count !== 1) {
@@ -90,14 +138,9 @@ class PeerSet {
       }
       this.#handleFirstRetry(session);
     });
-    this.#channels.added.on((address, msgChannel) => {
-      if (isIpNetworkChannel(msgChannel.channel)) {
-        return this.#addOrUpdatePeer(address, msgChannel.channel.networkAddress);
-      }
-    });
     this.#construction = Construction(this, async () => {
-      for (const peer of await this.#store.loadPeers()) {
-        this.#peers.add(peer);
+      for (const descriptor of await this.#store.loadPeers()) {
+        this.#peers.add(new Peer(descriptor, this.#peerContext));
       }
     });
   }
@@ -113,11 +156,22 @@ class PeerSet {
   get disconnected() {
     return this.#disconnected;
   }
-  has(item) {
-    if ("address" in item) {
-      return this.#peers.has(item);
+  /**
+   * Unconditional get.
+   *
+   * Creates the peer if not already present.
+   */
+  for(address) {
+    let peer = this.get(address);
+    if (peer) {
+      return peer;
     }
-    return this.#peersByAddress.has(item);
+    peer = new Peer({ address }, this.#peerContext);
+    this.#peers.add(peer);
+    return peer;
+  }
+  has(item) {
+    return !!this.get(item);
   }
   get size() {
     return this.#peers.size;
@@ -139,8 +193,8 @@ class PeerSet {
   }
   static [Environmental.create](env) {
     const instance = new PeerSet({
+      lifetime: env,
       sessions: env.get(SessionManager),
-      channels: env.get(ChannelManager),
       exchanges: env.get(ExchangeManager),
       scanners: env.get(ScannerSet),
       transports: env.get(ConnectionlessTransportSet),
@@ -163,29 +217,31 @@ class PeerSet {
    */
   async #ensureConnection(address, options) {
     address = PeerAddress(address);
-    const isGroupNode = PeerAddress.isGroup(address);
+    if (PeerAddress.isGroup(address)) {
+      return;
+    }
     const { allowUnknownPeer, operationalAddress } = options;
-    if (!this.#peersByAddress.has(address) && !allowUnknownPeer && !isGroupNode) {
+    if (!this.has(address) && !allowUnknownPeer) {
       throw new UnknownNodeError(`Cannot connect to unknown device ${PeerAddress(address)}`);
     }
-    if (!this.#channels.hasChannel(address)) {
-      if (isGroupNode) {
-        await this.#createGroupChannel(address);
-        return;
-      }
-      const { promise: existingReconnectPromise } = this.#runningPeerReconnections.get(address) ?? {};
-      if (existingReconnectPromise !== void 0) {
-        return existingReconnectPromise;
-      }
-      const { promise, resolver, rejecter } = createPromise();
-      this.#runningPeerReconnections.set(address, { promise, rejecter });
-      this.#resume(address, options, operationalAddress).then((channel) => {
-        this.#runningPeerReconnections.delete(address);
-        resolver(channel);
-      }).catch((error) => {
-        this.#runningPeerReconnections.delete(address);
-        rejecter(error);
-      });
+    const peer = this.for(address);
+    if (this.#sessions.maybeSessionFor(address) || peer.activeDiscovery?.type === 3 /* FullDiscovery */) {
+      return;
+    }
+    const { promise: existingReconnectPromise } = peer.activeReconnection ?? {};
+    if (existingReconnectPromise !== void 0) {
+      return existingReconnectPromise;
+    }
+    const { promise, resolver, rejecter } = createPromise();
+    peer.activeReconnection = { promise, rejecter };
+    this.#resume(address, options, operationalAddress).then((channel) => {
+      peer.activeReconnection = void 0;
+      resolver(channel);
+    }).catch((error) => {
+      peer.activeReconnection = void 0;
+      rejecter(error);
+    });
+    if (options.discoveryOptions?.discoveryType !== 3 /* FullDiscovery */) {
       return promise;
     }
   }
@@ -193,49 +249,46 @@ class PeerSet {
    * Obtain an exchange provider for the designated peer.
    * TODO enhance PeerConnectionOptions.discoveryOptions.discoveryData with "addresses" for known operational addresses
    */
-  async exchangeProviderFor(addressOrChannel, options = {}) {
-    if (addressOrChannel instanceof MessageChannel) {
-      return new DedicatedChannelExchangeProvider(this.#exchanges, addressOrChannel);
+  async exchangeProviderFor(addressOrSession, options = {}) {
+    if (addressOrSession instanceof SecureSession) {
+      return new DedicatedChannelExchangeProvider(this.#exchanges, addressOrSession);
     }
-    const address = addressOrChannel;
+    const address = addressOrSession;
     if (PeerAddress.isGroup(address)) {
-      if (!this.#channels.hasChannel(address)) {
-        await this.#createGroupChannel(address);
-      }
-      return new DedicatedChannelExchangeProvider(this.#exchanges, this.#channels.getChannel(address));
+      const session = await this.#sessions.groupSessionForAddress(address, this.#transports);
+      return new DedicatedChannelExchangeProvider(this.#exchanges, session);
     }
-    let initiallyConnected = this.#channels.hasChannel(address);
-    return new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
+    let initiallyConnected = !!this.#sessions.maybeSessionFor(address);
+    return new ReconnectableExchangeProvider(this.#exchanges, this.#sessions, address, async () => {
       const { caseAuthenticatedTags, discoveryOptions } = options;
-      if (!initiallyConnected && !this.#channels.hasChannel(address)) {
+      if (!initiallyConnected && !this.#sessions.maybeSessionFor(address)) {
         await this.#ensureConnection(address, {
           discoveryOptions: { discoveryType: 0 /* None */ },
           caseAuthenticatedTags
         });
         initiallyConnected = true;
-        if (this.#channels.hasChannel(address)) {
+        if (this.#sessions.maybeSessionFor(address)) {
           return;
         }
       }
-      if (!this.#channels.hasChannel(address)) {
-        throw new RetransmissionLimitReachedError(`Device ${PeerAddress(address)} is currently not reachable.`);
+      if (!this.#sessions.maybeSessionFor(address)) {
+        throw new RetransmissionLimitReachedError(`Device ${PeerAddress(address)} is unreachable`);
       }
-      await this.#channels.removeAllNodeChannels(address);
+      await this.#sessions.handlePeerLoss(address);
       const { discoveryData } = discoveryOptions ?? {
-        discoveryData: this.#peersByAddress.get(address)?.discoveryData
+        discoveryData: this.get(address)?.descriptor.discoveryData
       };
       const operationalAddress = this.#knownOperationalAddressFor(address, true);
       if (operationalAddress === void 0) {
         logger.info(
           `Re-discovering device failed (no address found), remove all sessions for ${PeerAddress(address)}`
         );
-        await this.#sessions.removeAllSessionsForNode(address);
         throw new RetransmissionLimitReachedError(`No operational address found for ${PeerAddress(address)}`);
       }
       if (await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, {
         expectedProcessingTime: Seconds(2)
       }) === void 0) {
-        throw new RetransmissionLimitReachedError(`${PeerAddress(address)} is not reachable.`);
+        throw new RetransmissionLimitReachedError(`${PeerAddress(address)} is not reachable`);
       }
     });
   }
@@ -244,55 +297,23 @@ class PeerSet {
    */
   get(peer) {
     if ("address" in peer) {
-      return this.#peersByAddress.get(peer.address);
-    }
-    return this.#peersByAddress.get(peer);
-  }
-  /**
-   * Terminate any active peer connection.
-   * Also handles unknown peers
-   */
-  async disconnect(peer, sendSessionClose = true) {
-    let address = this.get(peer)?.address;
-    if (address === void 0) {
-      if ("nodeId" in peer && "fabricIndex" in peer) {
-        address = peer;
-      } else {
-        return;
-      }
-    }
-    await this.#sessions.removeAllSessionsForNode(address, sendSessionClose);
-    await this.#channels.removeAllNodeChannels(address);
-    await this.#disconnected.emit(address);
-  }
-  /**
-   * Forget a known peer.
-   */
-  async delete(peer) {
-    const actual = this.get(peer);
-    if (actual === void 0) {
-      return;
+      return this.#peers.get("address", PeerAddress(peer.address));
     }
-    const { address } = actual;
-    logger.info(`Removing ${address}`);
-    this.#peers.delete(actual);
-    await this.#store.deletePeer(address);
-    await this.disconnect(address, false);
-    await this.#sessions.deleteResumptionRecord(address);
+    return this.#peers.get("address", PeerAddress(peer));
   }
   async close() {
-    for (const [address, { stopTimerFunc, mdnsClient: mdnsScanner }] of this.#runningPeerDiscoveries.entries()) {
-      stopTimerFunc?.();
-      mdnsScanner?.cancelOperationalDeviceDiscovery(this.#sessions.fabricFor(address), address.nodeId, false);
-    }
-    for (const { address } of this.#peers) {
-      await this.disconnect(address, false);
+    var _stack = [];
+    try {
+      const _closing = __using(_stack, this.#lifetime.closing());
+      for (const peer of this.#peers) {
+        await peer.close();
+      }
+      this.#interactionQueue.close();
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
     }
-    this.#interactionQueue.close();
-    this.#runningPeerReconnections.forEach(
-      ({ rejecter }) => rejecter(new ChannelNotConnectedError("PeerSet closed"))
-    );
-    this.#runningPeerReconnections.clear();
   }
   /**
    * Resume a device connection and establish a CASE session that was previously paired with the controller. This
@@ -306,9 +327,9 @@ class PeerSet {
     try {
       return await this.#connectOrDiscoverNode(address, operationalAddress, options);
     } catch (error) {
-      if ((error instanceof DiscoveryError || error instanceof NoResponseTimeoutError) && this.#peersByAddress.has(address) && tryOperationalAddress === void 0) {
+      if ((error instanceof DiscoveryError || error instanceof NoResponseTimeoutError) && this.has(address) && tryOperationalAddress === void 0) {
         logger.info(`Resume failed, remove all sessions for ${PeerAddress(address)}`);
-        await this.#sessions.removeAllSessionsForNode(address);
+        await this.#sessions.handlePeerLoss(address);
       }
       throw error;
     }
@@ -319,7 +340,7 @@ class PeerSet {
       discoveryOptions: {
         discoveryType: requestedDiscoveryType = 3 /* FullDiscovery */,
         timeout,
-        discoveryData = this.#peersByAddress.get(address)?.discoveryData
+        discoveryData = this.get(address)?.descriptor.discoveryData
       } = {},
       caseAuthenticatedTags
     } = options ?? {};
@@ -333,12 +354,13 @@ class PeerSet {
     if (!mdnsScanner) {
       throw new ImplementationError("Cannot discover device without mDNS scanner.");
     }
-    const existingDiscoveryDetails = this.#runningPeerDiscoveries.get(address) ?? {
+    const peer = this.for(address);
+    const existingDiscoveryDetails = peer.activeDiscovery ?? {
       type: 0 /* None */
     };
     if (existingDiscoveryDetails.type !== 0 /* None */ && existingDiscoveryDetails.type < requestedDiscoveryType) {
       mdnsScanner.cancelOperationalDeviceDiscovery(this.#sessions.fabricFor(address), address.nodeId);
-      this.#runningPeerDiscoveries.delete(address);
+      peer.activeDiscovery = void 0;
       existingDiscoveryDetails.type = 0 /* None */;
     }
     const { type: runningDiscoveryType, promises } = existingDiscoveryDetails;
@@ -395,7 +417,7 @@ class PeerSet {
                   this.#sessions.fabricFor(address),
                   address.nodeId
                 );
-                this.#runningPeerDiscoveries.delete(address);
+                peer.activeDiscovery = void 0;
                 resolver(result);
               }
             } catch (error) {
@@ -405,7 +427,7 @@ class PeerSet {
                   this.#sessions.fabricFor(address),
                   address.nodeId
                 );
-                this.#runningPeerDiscoveries.delete(address);
+                peer.activeDiscovery = void 0;
                 rejecter(error);
               }
             }
@@ -427,9 +449,9 @@ class PeerSet {
         timeout,
         timeout === void 0
       );
-      const { stopTimerFunc: stopTimerFunc2 } = this.#runningPeerDiscoveries.get(address) ?? {};
+      const { stopTimerFunc: stopTimerFunc2 } = peer.activeDiscovery ?? {};
       stopTimerFunc2?.();
-      this.#runningPeerDiscoveries.delete(address);
+      peer.activeDiscovery = void 0;
       const { result } = await ControllerDiscovery.iterateServerAddresses(
         [scanResult],
         NoResponseTimeoutError,
@@ -440,25 +462,25 @@ class PeerSet {
           );
           return device !== void 0 ? [device] : [];
         },
-        async (operationalAddress2, peer) => {
-          const result2 = await this.#pair(address, operationalAddress2, peer, { caseAuthenticatedTags });
+        async (operationalAddress2, peer2) => {
+          const result2 = await this.#pair(address, operationalAddress2, peer2, { caseAuthenticatedTags });
           await this.#addOrUpdatePeer(address, operationalAddress2, {
             ...discoveryData,
-            ...peer
+            ...peer2
           });
           return result2;
         }
       );
       return result;
     });
-    this.#runningPeerDiscoveries.set(address, {
+    peer.activeDiscovery = {
       type: requestedDiscoveryType,
       promises: discoveryPromises,
       stopTimerFunc,
       mdnsClient: mdnsScanner
-    });
+    };
     return await anyPromise(discoveryPromises).finally(() => {
-      this.#runningPeerDiscoveries.delete(address);
+      peer.activeDiscovery = void 0;
     });
   }
   async #reconnectKnownAddress(address, operationalAddress, discoveryData, options) {
@@ -470,40 +492,22 @@ class PeerSet {
       logger.debug(
         `Resuming connection to ${PeerAddress(address)} at ${ip}:${port}${expectedProcessingTime !== void 0 ? ` with expected processing time of ${Duration.format(expectedProcessingTime)}` : ""}`
       );
-      const channel = await this.#pair(address, operationalAddress, discoveryData, options);
+      const session = await this.#pair(address, operationalAddress, discoveryData, options);
       await this.#addOrUpdatePeer(address, operationalAddress);
-      return channel;
+      return session;
     } catch (error) {
-      if (error instanceof NoResponseTimeoutError) {
+      if (error instanceof NoResponseTimeoutError || error instanceof ChannelStatusResponseError) {
         logger.debug(
           `Failed to resume connection to ${address} connection with ${ip}:${port}, discovering the node now:`,
           error.message ? error.message : error
         );
-        await this.#sessions.removeAllSessionsForNode(address, false, startTime);
+        await this.#sessions.handlePeerLoss(address, startTime);
         return void 0;
       } else {
         throw error;
       }
     }
   }
-  async #createGroupChannel(address) {
-    const groupId = GroupId.fromNodeId(address.nodeId);
-    GroupId.assertGroupId(groupId);
-    const multicastAddress = this.#sessions.fabricFor(address).groups.multicastAddressFor(groupId);
-    const operationalInterface = this.#transports.interfaceFor(ChannelType.UDP, multicastAddress);
-    if (operationalInterface === void 0) {
-      throw new PairRetransmissionLimitReachedError(`IPv6 interface not initialized`);
-    }
-    const operationalChannel = await operationalInterface.openChannel({
-      type: ChannelType.UDP,
-      ip: multicastAddress,
-      port: STANDARD_MATTER_PORT
-    });
-    const session = this.#sessions.groupSessionForAddress(address);
-    const channel = new MessageChannel(operationalChannel, session);
-    await this.#channels.setChannel(address, channel);
-    return channel;
-  }
   /** Pair with an operational device (already commissioned) and establish a CASE session. */
   async #pair(address, operationalServerAddress, discoveryData, options) {
     logger.debug(`Pair with ${address} at ${ServerAddress.urlFor(operationalServerAddress)}`);
@@ -517,7 +521,8 @@ class PeerSet {
     }
     const operationalChannel = await operationalInterface.openChannel(operationalServerAddress);
     const { sessionParameters } = this.#sessions.findResumptionRecordByAddress(address) ?? {};
-    const unsecureSession = this.#sessions.createInsecureSession({
+    const unsecuredSession = this.#sessions.createUnsecuredSession({
+      channel: operationalChannel,
       // Use the session parameters from MDNS announcements when available and rest is assumed to be fallbacks
       sessionParameters: {
         ...sessionParameters,
@@ -528,26 +533,19 @@ class PeerSet {
       isInitiator: true
     });
     try {
-      const operationalSecureSession = await this.#doCasePair(
-        new MessageChannel(operationalChannel, unsecureSession),
-        address,
-        options
-      );
-      const channel = new MessageChannel(operationalChannel, operationalSecureSession);
-      await this.#channels.setChannel(address, channel);
-      return channel;
+      return await this.#doCasePair(unsecuredSession, address, options);
     } catch (error) {
       NoResponseTimeoutError.accept(error);
       throw new PairRetransmissionLimitReachedError(error.message);
     } finally {
-      await unsecureSession.destroy();
+      await unsecuredSession.initiateClose();
     }
   }
-  async #doCasePair(unsecureMessageChannel, address, options) {
+  async #doCasePair(paseSession, address, options) {
     const fabric = this.#sessions.fabricFor(address);
     let exchange;
     try {
-      exchange = this.#exchanges.initiateExchangeWithChannel(unsecureMessageChannel, SECURE_CHANNEL_PROTOCOL_ID);
+      exchange = this.#exchanges.initiateExchangeForSession(paseSession, SECURE_CHANNEL_PROTOCOL_ID);
       const { session, resumed } = await this.#caseClient.pair(exchange, fabric, address.nodeId, options);
       if (!resumed) {
         this.#nodeCachedData.delete(address);
@@ -560,7 +558,7 @@ class PeerSet {
           logger.info(
             `Case client: Resumption record seems outdated for Fabric ${NodeId.toHexString(fabric.nodeId)} (index ${fabric.fabricIndex}) and PeerNode ${NodeId.toHexString(address.nodeId)}. Retrying pairing without resumption...`
           );
-          return await this.#doCasePair(unsecureMessageChannel, address, options);
+          return await this.#doCasePair(paseSession, address, options);
         }
       }
       throw error;
@@ -587,22 +585,21 @@ class PeerSet {
     return discoveredAddresses?.addresses[0];
   }
   async #addOrUpdatePeer(address, operationalServerAddress, discoveryData) {
-    let peer = this.#peersByAddress.get(address);
+    let peer = this.get(address);
     if (peer === void 0) {
-      peer = { address, dataStore: await this.#store.createNodeStore(address) };
+      peer = new Peer({ address, dataStore: await this.#store.createNodeStore(address) }, this.#peerContext);
       this.#peers.add(peer);
     }
-    peer.operationalAddress = operationalServerAddress ?? peer.operationalAddress;
+    peer.descriptor.operationalAddress = operationalServerAddress ?? peer.descriptor.operationalAddress;
     if (discoveryData !== void 0) {
-      peer.discoveryData = {
-        ...peer.discoveryData,
+      peer.descriptor.discoveryData = {
+        ...peer.descriptor.discoveryData,
         ...discoveryData
       };
     }
-    await this.#store.updatePeer(peer);
-    if (peer.operationalAddress !== void 0 && this.#runningPeerDiscoveries.has(address)) {
+    if (peer.descriptor.operationalAddress !== void 0 && peer.activeDiscovery) {
       logger.info(`Found ${address} during discovery, cancel discovery.`);
-      const { mdnsClient: mdnsScanner } = this.#runningPeerDiscoveries.get(address) ?? {};
+      const { mdnsClient: mdnsScanner } = peer.activeDiscovery ?? {};
       mdnsScanner?.cancelOperationalDeviceDiscovery(this.#sessions.fabricFor(address), address.nodeId, true);
     }
   }
@@ -610,7 +607,7 @@ class PeerSet {
     return this.#addOrUpdatePeer(address, operationalServerAddress, discoveryData);
   }
   #getLastOperationalAddress(address) {
-    return this.#peersByAddress.get(address)?.operationalAddress;
+    return this.get(address)?.descriptor.operationalAddress;
   }
   #handleFirstRetry(session) {
     if (!session.isSecure || session.fabric === void 0) {
@@ -621,15 +618,16 @@ class PeerSet {
       return;
     }
     const address = fabric.addressOf(nodeId);
-    if (this.#runningPeerDiscoveries.has(address)) {
+    const peer = this.for(address);
+    if (peer.activeDiscovery) {
       return;
     }
-    this.#runningPeerDiscoveries.set(address, { type: 1 /* RetransmissionDiscovery */ });
+    peer.activeDiscovery = { type: 1 /* RetransmissionDiscovery */ };
     this.#scanners.scannerFor(ChannelType.UDP)?.findOperationalDevice(fabric, nodeId, RETRANSMISSION_DISCOVERY_TIMEOUT, true).catch((error) => {
       logger.error(`Failed to discover ${address} after resubmission started.`, error);
     }).finally(() => {
-      if (this.#runningPeerDiscoveries.get(address)?.type === 1 /* RetransmissionDiscovery */) {
-        this.#runningPeerDiscoveries.delete(address);
+      if (peer.activeDiscovery?.type === 1 /* RetransmissionDiscovery */) {
+        peer.activeDiscovery = void 0;
       }
     });
   }