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

package/dist/cjs/peer/PeerSet.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 : 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 PeerSet_exports = {};
 __export(PeerSet_exports, {
   NodeDiscoveryType: () => NodeDiscoveryType,
@@ -26,17 +71,17 @@ module.exports = __toCommonJS(PeerSet_exports);
 var import_Scanner = require("#common/Scanner.js");
 var import_general = require("#general");
 var import_PeerAddress = require("#peer/PeerAddress.js");
-var import_ChannelManager = require("#protocol/ChannelManager.js");
+var import_errors = require("#protocol/errors.js");
 var import_ExchangeManager = require("#protocol/ExchangeManager.js");
 var import_ExchangeProvider = require("#protocol/ExchangeProvider.js");
-var import_MessageChannel = require("#protocol/MessageChannel.js");
-var import_MessageExchange = require("#protocol/MessageExchange.js");
 var import_SecureChannelMessenger = require("#securechannel/SecureChannelMessenger.js");
 var import_CaseClient = require("#session/case/CaseClient.js");
+var import_SecureSession = require("#session/SecureSession.js");
 var import_SessionManager = require("#session/SessionManager.js");
 var import_types = require("#types");
 var import_ControllerDiscovery = require("./ControllerDiscovery.js");
 var import_InteractionQueue = require("./InteractionQueue.js");
+var import_Peer = require("./Peer.js");
 var import_PeerAddressStore = require("./PeerAddressStore.js");
 /**
  * @license
@@ -56,37 +101,42 @@ var NodeDiscoveryType = /* @__PURE__ */ ((NodeDiscoveryType2) => {
 class UnknownNodeError extends import_general.MatterError {
 }
 class PeerSet {
+  #lifetime;
   #sessions;
-  #channels;
   #exchanges;
   #scanners;
   #transports;
   #caseClient;
   #peers = new import_general.BasicSet();
-  #peersByAddress = new import_PeerAddress.PeerAddressMap();
-  #runningPeerDiscoveries = new import_PeerAddress.PeerAddressMap();
-  #runningPeerReconnections = new import_PeerAddress.PeerAddressMap();
   #construction;
   #store;
   #interactionQueue = new import_InteractionQueue.InteractionQueue();
   #nodeCachedData = new import_PeerAddress.PeerAddressMap();
   // Temporarily until we store it in new API
   #disconnected = (0, import_general.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 import_CaseClient.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 = (0, import_PeerAddress.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) {
@@ -94,14 +144,9 @@ class PeerSet {
       }
       this.#handleFirstRetry(session);
     });
-    this.#channels.added.on((address, msgChannel) => {
-      if ((0, import_general.isIpNetworkChannel)(msgChannel.channel)) {
-        return this.#addOrUpdatePeer(address, msgChannel.channel.networkAddress);
-      }
-    });
     this.#construction = (0, import_general.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 import_Peer.Peer(descriptor, this.#peerContext));
       }
     });
   }
@@ -117,11 +162,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 import_Peer.Peer({ address }, this.#peerContext);
+    this.#peers.add(peer);
+    return peer;
+  }
+  has(item) {
+    return !!this.get(item);
   }
   get size() {
     return this.#peers.size;
@@ -143,8 +199,8 @@ class PeerSet {
   }
   static [import_general.Environmental.create](env) {
     const instance = new PeerSet({
+      lifetime: env,
       sessions: env.get(import_SessionManager.SessionManager),
-      channels: env.get(import_ChannelManager.ChannelManager),
       exchanges: env.get(import_ExchangeManager.ExchangeManager),
       scanners: env.get(import_Scanner.ScannerSet),
       transports: env.get(import_general.ConnectionlessTransportSet),
@@ -167,29 +223,31 @@ class PeerSet {
    */
   async #ensureConnection(address, options) {
     address = (0, import_PeerAddress.PeerAddress)(address);
-    const isGroupNode = import_PeerAddress.PeerAddress.isGroup(address);
+    if (import_PeerAddress.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 ${(0, import_PeerAddress.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 } = (0, import_general.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 } = (0, import_general.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;
     }
   }
@@ -197,49 +255,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 import_MessageChannel.MessageChannel) {
-      return new import_ExchangeProvider.DedicatedChannelExchangeProvider(this.#exchanges, addressOrChannel);
+  async exchangeProviderFor(addressOrSession, options = {}) {
+    if (addressOrSession instanceof import_SecureSession.SecureSession) {
+      return new import_ExchangeProvider.DedicatedChannelExchangeProvider(this.#exchanges, addressOrSession);
     }
-    const address = addressOrChannel;
+    const address = addressOrSession;
     if (import_PeerAddress.PeerAddress.isGroup(address)) {
-      if (!this.#channels.hasChannel(address)) {
-        await this.#createGroupChannel(address);
-      }
-      return new import_ExchangeProvider.DedicatedChannelExchangeProvider(this.#exchanges, this.#channels.getChannel(address));
+      const session = await this.#sessions.groupSessionForAddress(address, this.#transports);
+      return new import_ExchangeProvider.DedicatedChannelExchangeProvider(this.#exchanges, session);
     }
-    let initiallyConnected = this.#channels.hasChannel(address);
-    return new import_ExchangeProvider.ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
+    let initiallyConnected = !!this.#sessions.maybeSessionFor(address);
+    return new import_ExchangeProvider.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 import_MessageExchange.RetransmissionLimitReachedError(`Device ${(0, import_PeerAddress.PeerAddress)(address)} is currently not reachable.`);
+      if (!this.#sessions.maybeSessionFor(address)) {
+        throw new import_errors.RetransmissionLimitReachedError(`Device ${(0, import_PeerAddress.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 ${(0, import_PeerAddress.PeerAddress)(address)}`
         );
-        await this.#sessions.removeAllSessionsForNode(address);
-        throw new import_MessageExchange.RetransmissionLimitReachedError(`No operational address found for ${(0, import_PeerAddress.PeerAddress)(address)}`);
+        throw new import_errors.RetransmissionLimitReachedError(`No operational address found for ${(0, import_PeerAddress.PeerAddress)(address)}`);
       }
       if (await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, {
         expectedProcessingTime: (0, import_general.Seconds)(2)
       }) === void 0) {
-        throw new import_MessageExchange.RetransmissionLimitReachedError(`${(0, import_PeerAddress.PeerAddress)(address)} is not reachable.`);
+        throw new import_errors.RetransmissionLimitReachedError(`${(0, import_PeerAddress.PeerAddress)(address)} is not reachable`);
       }
     });
   }
@@ -248,55 +303,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", (0, import_PeerAddress.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", (0, import_PeerAddress.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 import_MessageChannel.ChannelNotConnectedError("PeerSet closed"))
-    );
-    this.#runningPeerReconnections.clear();
   }
   /**
    * Resume a device connection and establish a CASE session that was previously paired with the controller. This
@@ -310,9 +333,9 @@ class PeerSet {
     try {
       return await this.#connectOrDiscoverNode(address, operationalAddress, options);
     } catch (error) {
-      if ((error instanceof import_ControllerDiscovery.DiscoveryError || error instanceof import_general.NoResponseTimeoutError) && this.#peersByAddress.has(address) && tryOperationalAddress === void 0) {
+      if ((error instanceof import_ControllerDiscovery.DiscoveryError || error instanceof import_general.NoResponseTimeoutError) && this.has(address) && tryOperationalAddress === void 0) {
         logger.info(`Resume failed, remove all sessions for ${(0, import_PeerAddress.PeerAddress)(address)}`);
-        await this.#sessions.removeAllSessionsForNode(address);
+        await this.#sessions.handlePeerLoss(address);
       }
       throw error;
     }
@@ -323,7 +346,7 @@ class PeerSet {
       discoveryOptions: {
         discoveryType: requestedDiscoveryType = 3 /* FullDiscovery */,
         timeout,
-        discoveryData = this.#peersByAddress.get(address)?.discoveryData
+        discoveryData = this.get(address)?.descriptor.discoveryData
       } = {},
       caseAuthenticatedTags
     } = options ?? {};
@@ -337,12 +360,13 @@ class PeerSet {
     if (!mdnsScanner) {
       throw new import_general.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;
@@ -399,7 +423,7 @@ class PeerSet {
                   this.#sessions.fabricFor(address),
                   address.nodeId
                 );
-                this.#runningPeerDiscoveries.delete(address);
+                peer.activeDiscovery = void 0;
                 resolver(result);
               }
             } catch (error) {
@@ -409,7 +433,7 @@ class PeerSet {
                   this.#sessions.fabricFor(address),
                   address.nodeId
                 );
-                this.#runningPeerDiscoveries.delete(address);
+                peer.activeDiscovery = void 0;
                 rejecter(error);
               }
             }
@@ -431,9 +455,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 import_ControllerDiscovery.ControllerDiscovery.iterateServerAddresses(
         [scanResult],
         import_general.NoResponseTimeoutError,
@@ -444,25 +468,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 (0, import_general.anyPromise)(discoveryPromises).finally(() => {
-      this.#runningPeerDiscoveries.delete(address);
+      peer.activeDiscovery = void 0;
     });
   }
   async #reconnectKnownAddress(address, operationalAddress, discoveryData, options) {
@@ -474,40 +498,22 @@ class PeerSet {
       logger.debug(
         `Resuming connection to ${(0, import_PeerAddress.PeerAddress)(address)} at ${ip}:${port}${expectedProcessingTime !== void 0 ? ` with expected processing time of ${import_general.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 import_general.NoResponseTimeoutError) {
+      if (error instanceof import_general.NoResponseTimeoutError || error instanceof import_SecureChannelMessenger.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 = import_types.GroupId.fromNodeId(address.nodeId);
-    import_types.GroupId.assertGroupId(groupId);
-    const multicastAddress = this.#sessions.fabricFor(address).groups.multicastAddressFor(groupId);
-    const operationalInterface = this.#transports.interfaceFor(import_general.ChannelType.UDP, multicastAddress);
-    if (operationalInterface === void 0) {
-      throw new import_ControllerDiscovery.PairRetransmissionLimitReachedError(`IPv6 interface not initialized`);
-    }
-    const operationalChannel = await operationalInterface.openChannel({
-      type: import_general.ChannelType.UDP,
-      ip: multicastAddress,
-      port: import_general.STANDARD_MATTER_PORT
-    });
-    const session = this.#sessions.groupSessionForAddress(address);
-    const channel = new import_MessageChannel.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 ${import_general.ServerAddress.urlFor(operationalServerAddress)}`);
@@ -521,7 +527,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,
@@ -532,26 +539,19 @@ class PeerSet {
       isInitiator: true
     });
     try {
-      const operationalSecureSession = await this.#doCasePair(
-        new import_MessageChannel.MessageChannel(operationalChannel, unsecureSession),
-        address,
-        options
-      );
-      const channel = new import_MessageChannel.MessageChannel(operationalChannel, operationalSecureSession);
-      await this.#channels.setChannel(address, channel);
-      return channel;
+      return await this.#doCasePair(unsecuredSession, address, options);
     } catch (error) {
       import_general.NoResponseTimeoutError.accept(error);
       throw new import_ControllerDiscovery.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, import_types.SECURE_CHANNEL_PROTOCOL_ID);
+      exchange = this.#exchanges.initiateExchangeForSession(paseSession, import_types.SECURE_CHANNEL_PROTOCOL_ID);
       const { session, resumed } = await this.#caseClient.pair(exchange, fabric, address.nodeId, options);
       if (!resumed) {
         this.#nodeCachedData.delete(address);
@@ -564,7 +564,7 @@ class PeerSet {
           logger.info(
             `Case client: Resumption record seems outdated for Fabric ${import_types.NodeId.toHexString(fabric.nodeId)} (index ${fabric.fabricIndex}) and PeerNode ${import_types.NodeId.toHexString(address.nodeId)}. Retrying pairing without resumption...`
           );
-          return await this.#doCasePair(unsecureMessageChannel, address, options);
+          return await this.#doCasePair(paseSession, address, options);
         }
       }
       throw error;
@@ -591,22 +591,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 import_Peer.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);
     }
   }
@@ -614,7 +613,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) {
@@ -625,15 +624,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(import_general.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;
       }
     });
   }