@matter/protocol 0.12.4-alpha.0-20250223-1e0341a1a → 0.12.4-alpha.0-20250224-46934b522

package/src/peer/PeerSet.ts

@@ -7,6 +7,7 @@
 import { DiscoveryData, ScannerSet } from "#common/Scanner.js";
 import {
     anyPromise,
+    AsyncObservable,
     BasicSet,
     ChannelType,
     Construction,
@@ -22,13 +23,12 @@ import {
     NetInterfaceSet,
     NoResponseTimeoutError,
     ObservableSet,
-    PromiseQueue,
     ServerAddressIp,
     serverAddressToString,
     Time,
     Timer,
 } from "#general";
-import { InteractionClient } from "#interaction/InteractionClient.js";
+import { SubscriptionClient } from "#interaction/SubscriptionClient.js";
 import { MdnsScanner } from "#mdns/MdnsScanner.js";
 import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
 import { CaseClient, SecureSession, Session } from "#session/index.js";
@@ -39,6 +39,7 @@ import { ChannelNotConnectedError, ExchangeManager, MessageChannel } from "../pr
 import { ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
 import { RetransmissionLimitReachedError } from "../protocol/MessageExchange.js";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
+import { InteractionQueue } from "./InteractionQueue.js";
 import { OperationalPeer } from "./OperationalPeer.js";
 import { PeerAddressStore, PeerDataStore } from "./PeerAddressStore.js";
 
@@ -47,9 +48,6 @@ const logger = Logger.get("PeerSet");
 const RECONNECTION_POLLING_INTERVAL_MS = 600_000; // 10 minutes
 const RETRANSMISSION_DISCOVERY_TIMEOUT_S = 5;
 
-const CONCURRENT_QUEUED_INTERACTIONS = 4;
-const INTERACTION_QUEUE_DELAY_MS = 100;
-
 /**
  * Types of discovery that may be performed when connecting operationally.
  */
@@ -93,6 +91,7 @@ export interface PeerSetContext {
     sessions: SessionManager;
     channels: ChannelManager;
     exchanges: ExchangeManager;
+    subscriptionClient: SubscriptionClient;
     scanners: ScannerSet;
     netInterfaces: NetInterfaceSet;
     store: PeerAddressStore;
@@ -105,6 +104,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     readonly #sessions: SessionManager;
     readonly #channels: ChannelManager;
     readonly #exchanges: ExchangeManager;
+    readonly #subscriptionClient: SubscriptionClient;
     readonly #scanners: ScannerSet;
     readonly #netInterfaces: NetInterfaceSet;
     readonly #caseClient: CaseClient;
@@ -117,16 +117,17 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     }>();
     readonly #construction: Construction<PeerSet>;
     readonly #store: PeerAddressStore;
-    readonly #interactionQueue = new PromiseQueue(CONCURRENT_QUEUED_INTERACTIONS, INTERACTION_QUEUE_DELAY_MS);
+    readonly #interactionQueue = new InteractionQueue();
     readonly #nodeCachedData = new PeerAddressMap<PeerDataStore>(); // Temporarily until we store it in new API
-    readonly #clients = new PeerAddressMap<InteractionClient>();
+    readonly #disconnected = AsyncObservable<[address: PeerAddress]>();
 
     constructor(context: PeerSetContext) {
-        const { sessions, channels, exchanges, scanners, netInterfaces, store } = context;
+        const { sessions, channels, exchanges, subscriptionClient, scanners, netInterfaces, store } = context;
 
         this.#sessions = sessions;
         this.#channels = channels;
         this.#exchanges = exchanges;
+        this.#subscriptionClient = subscriptionClient;
         this.#scanners = scanners;
         this.#netInterfaces = netInterfaces;
         this.#store = store;
@@ -143,6 +144,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
         this.#sessions.resubmissionStarted.on(this.#handleResubmissionStarted.bind(this));
 
+        /** A channel was added by ourselves */
         this.#channels.added.on((address, msgChannel) => {
             if (isIpNetworkChannel(msgChannel.channel)) {
                 // Update the channel address if it has one
@@ -165,6 +167,10 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         return this.#peers.deleted;
     }
 
+    get disconnected() {
+        return this.#disconnected;
+    }
+
     has(item: PeerAddress | OperationalPeer) {
         if ("address" in item) {
             return this.#peers.has(item);
@@ -201,6 +207,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             sessions: env.get(SessionManager),
             channels: env.get(ChannelManager),
             exchanges: env.get(ExchangeManager),
+            subscriptionClient: env.get(SubscriptionClient),
             scanners: env.get(ScannerSet),
             netInterfaces: env.get(NetInterfaceSet),
             store: env.get(PeerAddressStore),
@@ -213,20 +220,26 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         return this.#peers;
     }
 
-    /**
-     * Connect to a node on a fabric.
-     */
-    async connect(
-        address: PeerAddress,
-        discoveryOptions: DiscoveryOptions,
-        allowUnknownPeer = false,
-    ): Promise<InteractionClient> {
-        await this.#ensureConnection(address, discoveryOptions, allowUnknownPeer);
+    get subscriptionClient() {
+        return this.#subscriptionClient;
+    }
 
-        return this.initializeInteractionClient(address, discoveryOptions);
+    get interactionQueue() {
+        return this.#interactionQueue;
     }
 
-    async #ensureConnection(address: PeerAddress, discoveryOptions: DiscoveryOptions, allowUnknownPeer = false) {
+    /**
+     * Ensure there is a channel to the designated peer.
+     */
+    async ensureConnection(
+        address: PeerAddress,
+        options: {
+            discoveryOptions: DiscoveryOptions;
+            allowUnknownPeer?: boolean;
+            operationalAddress?: ServerAddressIp;
+        },
+    ) {
+        const { discoveryOptions, allowUnknownPeer, operationalAddress } = options;
         if (!this.#peersByAddress.has(address) && !allowUnknownPeer) {
             throw new UnknownNodeError(`Cannot connect to unknown device ${PeerAddress(address)}`);
         }
@@ -242,7 +255,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             const { promise, resolver, rejecter } = createPromise<MessageChannel>();
             this.#runningPeerReconnections.set(address, { promise, rejecter });
 
-            this.#resume(address, discoveryOptions)
+            this.#resume(address, discoveryOptions, operationalAddress)
                 .then(channel => {
                     this.#runningPeerReconnections.delete(address);
                     resolver(channel);
@@ -256,62 +269,46 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         }
     }
 
-    async initializeInteractionClient(address: PeerAddress, discoveryOptions?: DiscoveryOptions) {
-        const existingClient = this.#clients.get(address);
-        if (existingClient !== undefined) {
-            return existingClient;
-        }
-
-        const nodeStore = this.get(address)?.dataStore;
-        await nodeStore?.construction; // Lazy initialize the data if not already done
-
+    /**
+     * Obtain an exchange provider for the designated peer.
+     */
+    async exchangeProviderFor(address: PeerAddress, discoveryOptions?: DiscoveryOptions) {
         let initiallyConnected = this.#channels.hasChannel(address);
-        const client = new InteractionClient(
-            new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
-                if (!initiallyConnected && !this.#channels.hasChannel(address)) {
-                    // We got an uninitialized node, so do the first connection as usual
-                    await this.#ensureConnection(address, { discoveryType: NodeDiscoveryType.None });
-                    initiallyConnected = true; // We only do this connection once, rest is handled in following code
-                    if (this.#channels.hasChannel(address)) {
-                        return;
-                    }
+        return new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
+            if (!initiallyConnected && !this.#channels.hasChannel(address)) {
+                // We got an uninitialized node, so do the first connection as usual
+                await this.ensureConnection(address, {
+                    discoveryOptions: { discoveryType: NodeDiscoveryType.None },
+                });
+                initiallyConnected = true; // We only do this connection once, rest is handled in following code
+                if (this.#channels.hasChannel(address)) {
+                    return;
                 }
+            }
 
-                if (!this.#channels.hasChannel(address)) {
-                    throw new RetransmissionLimitReachedError(
-                        `Device ${PeerAddress(address)} is currently not reachable.`,
-                    );
-                }
-                await this.#channels.removeAllNodeChannels(address);
+            if (!this.#channels.hasChannel(address)) {
+                throw new RetransmissionLimitReachedError(`Device ${PeerAddress(address)} is currently not reachable.`);
+            }
+            await this.#channels.removeAllNodeChannels(address);
 
-                // Enrich discoveryData with data from the node store when not provided
-                const { discoveryData } = discoveryOptions ?? {
-                    discoveryData: this.#peersByAddress.get(address)?.discoveryData,
-                };
-                // Try to use first result for one last try before we need to reconnect
-                const operationalAddress = this.#knownOperationalAddressFor(address, true);
-                if (operationalAddress === undefined) {
-                    logger.info(
-                        `Re-discovering device failed (no address found), remove all sessions for ${PeerAddress(address)}`,
-                    );
-                    // We remove all sessions, this also informs the PairedNode class
-                    await this.#sessions.removeAllSessionsForNode(address);
-                    throw new RetransmissionLimitReachedError(
-                        `No operational address found for ${PeerAddress(address)}`,
-                    );
-                }
-                if (
-                    (await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, 2_000)) === undefined
-                ) {
-                    throw new RetransmissionLimitReachedError(`${PeerAddress(address)} is not reachable.`);
-                }
-            }),
-            address,
-            this.#interactionQueue,
-            nodeStore,
-        );
-        this.#clients.set(address, client);
-        return client;
+            // Enrich discoveryData with data from the node store when not provided
+            const { discoveryData } = discoveryOptions ?? {
+                discoveryData: this.#peersByAddress.get(address)?.discoveryData,
+            };
+            // Try to use first result for one last try before we need to reconnect
+            const operationalAddress = this.#knownOperationalAddressFor(address, true);
+            if (operationalAddress === undefined) {
+                logger.info(
+                    `Re-discovering device failed (no address found), remove all sessions for ${PeerAddress(address)}`,
+                );
+                // We remove all sessions, this also informs the PairedNode class
+                await this.#sessions.removeAllSessionsForNode(address);
+                throw new RetransmissionLimitReachedError(`No operational address found for ${PeerAddress(address)}`);
+            }
+            if ((await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, 2_000)) === undefined) {
+                throw new RetransmissionLimitReachedError(`${PeerAddress(address)} is not reachable.`);
+            }
+        });
     }
 
     /**
@@ -327,10 +324,15 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     /**
      * Terminate any active peer connection.
      */
-    async disconnect(address: PeerAddress, sendSessionClose = true) {
-        this.#clients.get(address)?.removeAllSubscriptions();
+    async disconnect(peer: PeerAddress | OperationalPeer, sendSessionClose = true) {
+        const address = this.get(peer)?.address;
+        if (address === undefined) {
+            return;
+        }
+
         await this.#sessions.removeAllSessionsForNode(address, sendSessionClose);
         await this.#channels.removeAllNodeChannels(address);
+        await this.#disconnected.emit(address);
     }
 
     /**
@@ -348,7 +350,6 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         await this.#store.deletePeer(address);
         await this.disconnect(address, false);
         await this.#sessions.deleteResumptionRecord(address);
-        this.#clients.delete(address);
     }
 
     async close() {
@@ -358,8 +359,11 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             // This ends discovery without triggering promises
             mdnsScanner?.cancelOperationalDeviceDiscovery(this.#sessions.fabricFor(address), address.nodeId, false);
         }
-        this.#clients.forEach(client => client.close());
-        this.#clients.clear();
+
+        for (const { address } of this.#peers) {
+            await this.disconnect(address, false);
+        }
+
         this.#interactionQueue.close();
         this.#runningPeerReconnections.forEach(({ rejecter }) =>
             rejecter(new ChannelNotConnectedError("PeerSet closed")),
@@ -373,18 +377,22 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
      * device is discovered again using its operational instance details.
      * It returns the operational MessageChannel on success.
      */
-    async #resume(address: PeerAddress, discoveryOptions?: DiscoveryOptions) {
+    async #resume(address: PeerAddress, discoveryOptions?: DiscoveryOptions, tryOperationalAddress?: ServerAddressIp) {
         const { discoveryType } = discoveryOptions ?? {};
+
         const operationalAddress =
-            discoveryType === NodeDiscoveryType.None
+            tryOperationalAddress ??
+            (discoveryType === NodeDiscoveryType.None
                 ? this.#getLastOperationalAddress(address)
-                : this.#knownOperationalAddressFor(address);
+                : this.#knownOperationalAddressFor(address));
+
         try {
             return await this.#connectOrDiscoverNode(address, operationalAddress, discoveryOptions);
         } catch (error) {
             if (
                 (error instanceof DiscoveryError || error instanceof NoResponseTimeoutError) &&
-                this.#peersByAddress.has(address)
+                this.#peersByAddress.has(address) &&
+                tryOperationalAddress === undefined
             ) {
                 logger.info(`Resume failed, remove all sessions for ${PeerAddress(address)}`);
                 // We remove all sessions, this also informs the PairedNode class
@@ -439,7 +447,13 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             operationalAddress !== undefined &&
             (runningDiscoveryType === NodeDiscoveryType.None || requestedDiscoveryType === NodeDiscoveryType.None)
         ) {
-            const directReconnection = await this.#reconnectKnownAddress(address, operationalAddress, discoveryData);
+            const directReconnection = await this.#reconnectKnownAddress(
+                address,
+                operationalAddress,
+                discoveryData,
+                // When we use a timeout for discovery also use this for reconnecting to the node
+                timeoutSeconds ? timeoutSeconds * 1000 : undefined,
+            );
             if (directReconnection !== undefined) {
                 return directReconnection;
             }
@@ -574,6 +588,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         address = PeerAddress(address);
 
         const { ip, port } = operationalAddress;
+        const startTime = Time.nowMs();
         try {
             logger.debug(
                 `Resuming connection to ${PeerAddress(address)} at ${ip}:${port}${
@@ -592,7 +607,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                     error,
                 );
                 // We remove all sessions, this also informs the PairedNode class
-                await this.#sessions.removeAllSessionsForNode(address);
+                await this.#sessions.removeAllSessionsForNode(address, false, startTime);
                 return undefined;
             } else {
                 throw error;

package/src/peer/PhysicalDeviceProperties.ts

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Logger } from "#general";
+
+const logger = Logger.get("PhysicalDeviceProperties");
+
+const DEFAULT_SUBSCRIPTION_FLOOR_DEFAULT_S = 1;
+const DEFAULT_SUBSCRIPTION_FLOOR_ICD_S = 0;
+const DEFAULT_SUBSCRIPTION_CEILING_WIFI_S = 60;
+const DEFAULT_SUBSCRIPTION_CEILING_THREAD_S = 60;
+const DEFAULT_SUBSCRIPTION_CEILING_THREAD_SLEEPY_S = 180;
+const DEFAULT_SUBSCRIPTION_CEILING_BATTERY_POWERED_S = 600;
+
+export interface PhysicalDeviceProperties {
+    threadConnected: boolean;
+    wifiConnected: boolean;
+    ethernetConnected: boolean;
+    rootEndpointServerList: number[];
+    isBatteryPowered: boolean;
+    isIntermittentlyConnected: boolean;
+    isThreadSleepyEndDevice: boolean;
+}
+
+export namespace PhysicalDeviceProperties {
+    export function determineSubscriptionParameters(options?: {
+        properties?: PhysicalDeviceProperties;
+        description?: string;
+        subscribeMinIntervalFloorSeconds?: number;
+        subscribeMaxIntervalCeilingSeconds?: number;
+    }) {
+        const { properties } = options ?? {};
+
+        let {
+            description,
+            subscribeMinIntervalFloorSeconds: minIntervalFloorSeconds,
+            subscribeMaxIntervalCeilingSeconds: maxIntervalCeilingSeconds,
+        } = options ?? {};
+
+        if (description === undefined) {
+            description = "Node";
+        }
+
+        const { isBatteryPowered, isIntermittentlyConnected, threadConnected, isThreadSleepyEndDevice } =
+            properties ?? {};
+
+        if (isIntermittentlyConnected) {
+            if (minIntervalFloorSeconds !== undefined && minIntervalFloorSeconds !== DEFAULT_SUBSCRIPTION_FLOOR_ICD_S) {
+                logger.info(
+                    `${description}: Overwriting minIntervalFloorSeconds for intermittently connected device to ${DEFAULT_SUBSCRIPTION_FLOOR_ICD_S}`,
+                );
+                minIntervalFloorSeconds = DEFAULT_SUBSCRIPTION_FLOOR_ICD_S;
+            }
+        }
+
+        const defaultCeiling = isBatteryPowered
+            ? DEFAULT_SUBSCRIPTION_CEILING_BATTERY_POWERED_S
+            : isThreadSleepyEndDevice
+              ? DEFAULT_SUBSCRIPTION_CEILING_THREAD_SLEEPY_S
+              : threadConnected
+                ? DEFAULT_SUBSCRIPTION_CEILING_THREAD_S
+                : DEFAULT_SUBSCRIPTION_CEILING_WIFI_S;
+        if (maxIntervalCeilingSeconds === undefined) {
+            maxIntervalCeilingSeconds = defaultCeiling;
+        }
+        if (maxIntervalCeilingSeconds < defaultCeiling) {
+            logger.debug(
+                `${description}: maxIntervalCeilingSeconds ideally is ${defaultCeiling}s instead of ${maxIntervalCeilingSeconds}s due to device type`,
+            );
+        }
+
+        return {
+            minIntervalFloorSeconds: minIntervalFloorSeconds ?? DEFAULT_SUBSCRIPTION_FLOOR_DEFAULT_S,
+            maxIntervalCeilingSeconds,
+        };
+    }
+}

package/src/peer/index.ts

@@ -11,3 +11,4 @@ export * from "./OperationalPeer.js";
 export * from "./PeerAddress.js";
 export * from "./PeerAddressStore.js";
 export * from "./PeerSet.js";
+export * from "./PhysicalDeviceProperties.js";

package/src/protocol/ExchangeManager.ts

@@ -150,6 +150,10 @@ export class ExchangeManager {
         return instance;
     }
 
+    get channels() {
+        return this.#channelManager;
+    }
+
     hasProtocolHandler(protocolId: number) {
         return this.#protocols.has(protocolId);
     }
@@ -159,10 +163,10 @@ export class ExchangeManager {
     }
 
     addProtocolHandler(protocol: ProtocolHandler) {
-        if (this.hasProtocolHandler(protocol.getId())) {
-            throw new ImplementationError(`Handler for protocol ${protocol.getId()} already registered.`);
+        if (this.hasProtocolHandler(protocol.id)) {
+            throw new ImplementationError(`Handler for protocol ${protocol.id} already registered.`);
         }
-        this.#protocols.set(protocol.getId(), protocol);
+        this.#protocols.set(protocol.id, protocol);
     }
 
     initiateExchange(address: PeerAddress, protocolId: number) {

package/src/protocol/ExchangeProvider.ts

@@ -12,8 +12,13 @@ import { MessageExchange } from "../protocol/MessageExchange.js";
 import { ProtocolHandler } from "../protocol/ProtocolHandler.js";
 import { Session } from "../session/Session.js";
 
+/**
+ * Interface for obtaining an exchange with a specific peer.
+ */
 export abstract class ExchangeProvider {
-    protected constructor(protected readonly exchangeManager: ExchangeManager) {}
+    abstract readonly supportsReconnect: boolean;
+
+    constructor(protected readonly exchangeManager: ExchangeManager) {}
 
     hasProtocolHandler(protocolId: number) {
         return this.exchangeManager.hasProtocolHandler(protocolId);
@@ -33,8 +38,12 @@ export abstract class ExchangeProvider {
     abstract channelType: ChannelType;
 }
 
+/**
+ * Manages an exchange over an established channel.
+ */
 export class DedicatedChannelExchangeProvider extends ExchangeProvider {
     #channel: MessageChannel;
+    readonly supportsReconnect = false;
 
     constructor(exchangeManager: ExchangeManager, channel: MessageChannel) {
         super(exchangeManager);
@@ -58,7 +67,11 @@ export class DedicatedChannelExchangeProvider extends ExchangeProvider {
     }
 }
 
+/**
+ * Manages peer exchange that will reestablish automatically in the case of communication failure.
+ */
 export class ReconnectableExchangeProvider extends ExchangeProvider {
+    readonly supportsReconnect = true;
     readonly #address: PeerAddress;
     readonly #reconnectChannelFunc: () => Promise<void>;
     readonly #channelUpdated = Observable<[void]>();

package/src/protocol/ProtocolHandler.ts

@@ -8,7 +8,7 @@ import { Message } from "../codec/MessageCodec.js";
 import { MessageExchange } from "./MessageExchange.js";
 
 export interface ProtocolHandler {
-    getId(): number;
+    readonly id: number;
     onNewExchange(exchange: MessageExchange, message: Message): Promise<void>;
     close(): Promise<void>;
 }

package/src/securechannel/SecureChannelMessenger.ts

@@ -43,6 +43,10 @@ export class SecureChannelMessenger {
         this.#defaultExpectedProcessingTimeMs = defaultExpectedProcessingTimeMs;
     }
 
+    get channel() {
+        return this.exchange.channel;
+    }
+
     async nextMessage(
         expectedMessageType: number,
         expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,

package/src/securechannel/SecureChannelProtocol.ts

@@ -28,9 +28,7 @@ import { TlvSecureChannelStatusMessage } from "./SecureChannelStatusMessageSchem
 const logger = Logger.get("SecureChannelProtocol");
 
 export class StatusReportOnlySecureChannelProtocol implements ProtocolHandler {
-    getId(): number {
-        return SECURE_CHANNEL_PROTOCOL_ID;
-    }
+    readonly id = SECURE_CHANNEL_PROTOCOL_ID;
 
     async onNewExchange(exchange: MessageExchange, message: Message) {
         const messageType = message.payloadHeader.messageType;

package/src/session/SecureSession.ts

@@ -292,11 +292,12 @@ export class SecureSession extends Session {
         return this.#fabric;
     }
 
-    async clearSubscriptions(flushSubscriptions = false) {
+    async clearSubscriptions(flushSubscriptions = false, cancelledByPeer = false) {
         const subscriptions = [...this.#subscriptions]; // get all values because subscriptions will remove themselves when cancelled
         for (const subscription of subscriptions) {
-            await subscription.close(flushSubscriptions);
+            await subscription.close(flushSubscriptions, cancelledByPeer);
         }
+        return subscriptions.length;
     }
 
     /** Ends a session. Outstanding subscription data will be flushed before the session is destroyed. */

package/src/session/Session.ts

@@ -62,6 +62,7 @@ export abstract class Session {
     abstract get closingAfterExchangeFinished(): boolean;
     #manager?: SessionManager;
     timestamp = Time.nowMs();
+    readonly createdAt = Time.nowMs();
     activeTimestamp = 0;
     protected readonly idleIntervalMs: number;
     protected readonly activeIntervalMs: number;

package/src/session/SessionManager.ts

@@ -378,14 +378,16 @@ export class SessionManager {
         });
     }
 
-    async removeAllSessionsForNode(address: PeerAddress, sendClose = false) {
+    async removeAllSessionsForNode(address: PeerAddress, sendClose = false, closeBeforeCreatedTimestamp?: number) {
         await this.#construction;
 
         for (const session of this.#sessions) {
             if (!session.isSecure) continue;
+            if (closeBeforeCreatedTimestamp !== undefined && session.createdAt >= closeBeforeCreatedTimestamp) continue;
             const secureSession = session;
             if (secureSession.peerIs(address)) {
                 await secureSession.destroy(sendClose, false);
+                this.#sessions.delete(session);
             }
         }
     }
@@ -563,17 +565,12 @@ export class SessionManager {
     }
 
     /** Clears all subscriptions for a given node and returns how many were cleared. */
-    async clearSubscriptionsForNode(fabricIndex: FabricIndex, nodeId: NodeId, flushSubscriptions?: boolean) {
+    async clearSubscriptionsForNode(peerAddress: PeerAddress, flushSubscriptions?: boolean) {
         let clearedCount = 0;
         for (const session of this.#sessions) {
-            if (session.fabric?.fabricIndex !== fabricIndex) {
-                continue;
+            if (PeerAddress.is(session.peerAddress, peerAddress)) {
+                clearedCount += await session.clearSubscriptions(flushSubscriptions, true);
             }
-            if (session.peerNodeId !== nodeId) {
-                continue;
-            }
-            await session.clearSubscriptions(flushSubscriptions);
-            clearedCount++;
         }
         return clearedCount;
     }

package/src/session/case/CaseServer.ts

@@ -30,6 +30,8 @@ import { CaseServerMessenger } from "./CaseMessenger.js";
 const logger = Logger.get("CaseServer");
 
 export class CaseServer implements ProtocolHandler {
+    readonly id = SECURE_CHANNEL_PROTOCOL_ID;
+
     #sessions: SessionManager;
     #fabrics: FabricManager;
 
@@ -58,10 +60,6 @@ export class CaseServer implements ProtocolHandler {
         }
     }
 
-    getId(): number {
-        return SECURE_CHANNEL_PROTOCOL_ID;
-    }
-
     private async handleSigma1(messenger: CaseServerMessenger) {
         logger.info(`Received pairing request from ${messenger.getChannelName()}`);
         // Generate pairing info