@matter/protocol 0.12.4-alpha.0-20250224-e0964a795 → 0.12.4-alpha.0-20250225-52ac4166b

package/src/interaction/ServerSubscription.ts

@@ -175,41 +175,58 @@ export class ServerSubscription extends Subscription {
         }
     >();
     #sendUpdatesActivated = false;
-    readonly #maxIntervalMs: number;
     readonly #sendIntervalMs: number;
-    private readonly minIntervalFloorMs: number;
-    private readonly maxIntervalCeilingMs: number;
-    private readonly peerAddress: PeerAddress;
+    readonly #minIntervalFloorMs: number;
+    readonly #maxIntervalCeilingMs: number;
+    readonly #peerAddress: PeerAddress;
 
-    private sendNextUpdateImmediately = false;
-    private sendUpdateErrorCounter = 0;
-    private attributeUpdatePromises = new Set<PromiseLike<void>>();
-    private currentUpdatePromise?: Promise<void>;
+    #sendNextUpdateImmediately = false;
+    #sendUpdateErrorCounter = 0;
+    readonly #attributeUpdatePromises = new Set<PromiseLike<void>>();
+    #currentUpdatePromise?: Promise<void>;
 
     constructor(options: {
         id: number;
         context: ServerSubscriptionContext;
         criteria: SubscriptionCriteria;
-        minIntervalFloor: number;
-        maxIntervalCeiling: number;
+        minIntervalFloorSeconds: number;
+        maxIntervalCeilingSeconds: number;
         subscriptionOptions: ServerSubscriptionConfig;
+        useAsMaxInterval?: number;
+        useAsSendInterval?: number;
     }) {
-        const { id, context, criteria, minIntervalFloor, maxIntervalCeiling, subscriptionOptions } = options;
+        const {
+            id,
+            context,
+            criteria,
+            minIntervalFloorSeconds,
+            maxIntervalCeilingSeconds,
+            subscriptionOptions,
+            useAsMaxInterval,
+            useAsSendInterval,
+        } = options;
 
         super(context.session, id, criteria);
         this.#context = context;
         this.#structure = context.structure;
 
-        this.peerAddress = this.session.peerAddress;
-        this.minIntervalFloorMs = minIntervalFloor * 1000;
-        this.maxIntervalCeilingMs = maxIntervalCeiling * 1000;
-
-        const { maxInterval, sendInterval } = this.determineSendingIntervals(
-            subscriptionOptions.minIntervalSeconds * 1000,
-            subscriptionOptions.maxIntervalSeconds * 1000,
-            subscriptionOptions.randomizationWindowSeconds * 1000,
-        );
-        this.#maxIntervalMs = maxInterval;
+        this.#peerAddress = this.session.peerAddress;
+        this.#minIntervalFloorMs = minIntervalFloorSeconds * 1000;
+        this.#maxIntervalCeilingMs = maxIntervalCeilingSeconds * 1000;
+
+        let maxInterval: number;
+        let sendInterval: number;
+        if (useAsMaxInterval !== undefined && useAsSendInterval !== undefined) {
+            maxInterval = useAsMaxInterval * 1000;
+            sendInterval = useAsSendInterval * 1000;
+        } else {
+            ({ maxInterval, sendInterval } = this.#determineSendingIntervals(
+                subscriptionOptions.minIntervalSeconds * 1000,
+                subscriptionOptions.maxIntervalSeconds * 1000,
+                subscriptionOptions.randomizationWindowSeconds * 1000,
+            ));
+        }
+        this.maxIntervalMs = maxInterval;
         this.#sendIntervalMs = sendInterval;
 
         this.#updateTimer = Time.getTimer(`Subscription ${this.id} update`, this.#sendIntervalMs, () =>
@@ -217,7 +234,7 @@ export class ServerSubscription extends Subscription {
         ); // will be started later
     }
 
-    private determineSendingIntervals(
+    #determineSendingIntervals(
         subscriptionMinIntervalMs: number,
         subscriptionMaxIntervalMs: number,
         subscriptionRandomizationWindowMs: number,
@@ -230,7 +247,7 @@ export class ServerSubscription extends Subscription {
         const maxInterval = Math.min(
             Math.max(
                 subscriptionMinIntervalMs,
-                Math.max(this.minIntervalFloorMs, Math.min(subscriptionMaxIntervalMs, this.maxIntervalCeilingMs)),
+                Math.max(this.#minIntervalFloorMs, Math.min(subscriptionMaxIntervalMs, this.#maxIntervalCeilingMs)),
             ) + Math.floor(subscriptionRandomizationWindowMs * Math.random()),
             MAX_INTERVAL_PUBLISHER_LIMIT_S * 1000,
         );
@@ -239,7 +256,7 @@ export class ServerSubscription extends Subscription {
             // But if we have no chance of at least one full resubmission process we do like chip-tool.
             // One full resubmission process takes 33-45 seconds. So 60s means we reach at least first 2 retries of a
             // second subscription report after first failed.
-            sendInterval = Math.max(this.minIntervalFloorMs, Math.floor(maxInterval * 0.8));
+            sendInterval = Math.max(this.#minIntervalFloorMs, Math.floor(maxInterval * 0.8));
         }
         if (sendInterval < subscriptionMinIntervalMs) {
             // But not faster than once every 2s
@@ -251,7 +268,7 @@ export class ServerSubscription extends Subscription {
         return { maxInterval, sendInterval };
     }
 
-    private registerNewAttributes() {
+    #registerNewAttributes() {
         const newAttributes = new Array<AttributeWithPath>();
         const attributeErrors = new Array<TypeFromSchema<typeof TlvAttributeStatus>>();
         const formerAttributes = new Set<string>(this.#attributeListeners.keys());
@@ -426,7 +443,7 @@ export class ServerSubscription extends Subscription {
      * controller. The data of newly added events are not sent automatically.
      */
     async updateSubscription() {
-        const { newAttributes } = this.registerNewAttributes();
+        const { newAttributes } = this.#registerNewAttributes();
 
         for (const { path, attribute } of newAttributes) {
             const { version, value } = this.#context.readAttribute(path, attribute);
@@ -485,15 +502,21 @@ export class ServerSubscription extends Subscription {
         this.#prepareDataUpdate();
     }
 
-    get maxInterval(): number {
-        return Math.ceil(this.#maxIntervalMs / 1000);
-    }
-
     get sendInterval(): number {
         return Math.ceil(this.#sendIntervalMs / 1000);
     }
 
-    activateSendingUpdates() {
+    get minIntervalFloorSeconds(): number {
+        return Math.ceil(this.#minIntervalFloorMs / 1000);
+    }
+
+    get maxIntervalCeilingSeconds(): number {
+        return Math.ceil(this.#maxIntervalCeilingMs / 1000);
+    }
+
+    override activate() {
+        super.activate();
+
         // We do not need these data anymore, so we can free some memory
         if (this.criteria.eventFilters !== undefined) this.criteria.eventFilters.length = 0;
         if (this.criteria.dataVersionFilters !== undefined) this.criteria.dataVersionFilters.length = 0;
@@ -533,11 +556,11 @@ export class ServerSubscription extends Subscription {
         this.#updateTimer.stop();
         const now = Time.nowMs();
         const timeSinceLastUpdateMs = now - this.#lastUpdateTimeMs;
-        if (timeSinceLastUpdateMs < this.minIntervalFloorMs) {
+        if (timeSinceLastUpdateMs < this.#minIntervalFloorMs) {
             // Respect minimum delay time between updates
             this.#updateTimer = Time.getTimer(
                 "Subscription update",
-                this.minIntervalFloorMs - timeSinceLastUpdateMs,
+                this.#minIntervalFloorMs - timeSinceLastUpdateMs,
                 () => this.#prepareDataUpdate(),
             ).start();
             return;
@@ -550,14 +573,14 @@ export class ServerSubscription extends Subscription {
     }
 
     #triggerSendUpdate() {
-        if (this.currentUpdatePromise !== undefined) {
+        if (this.#currentUpdatePromise !== undefined) {
             logger.debug("Sending update already in progress, delaying update ...");
-            this.sendNextUpdateImmediately = true;
+            this.#sendNextUpdateImmediately = true;
             return;
         }
-        this.currentUpdatePromise = this.#sendUpdate()
+        this.#currentUpdatePromise = this.#sendUpdate()
             .catch(error => logger.warn("Sending subscription update failed:", error))
-            .finally(() => (this.currentUpdatePromise = undefined));
+            .finally(() => (this.#currentUpdatePromise = undefined));
     }
 
     /**
@@ -593,20 +616,20 @@ export class ServerSubscription extends Subscription {
         this.#lastUpdateTimeMs = Time.nowMs();
 
         try {
-            await this.sendUpdateMessage(attributeUpdatesToSend, eventUpdatesToSend);
-            this.sendUpdateErrorCounter = 0;
+            await this.#sendUpdateMessage(attributeUpdatesToSend, eventUpdatesToSend);
+            this.#sendUpdateErrorCounter = 0;
         } catch (error) {
             if (this.isClosed) {
                 // No need to care about resubmissions when the server is closing
                 return;
             }
 
-            this.sendUpdateErrorCounter++;
+            this.#sendUpdateErrorCounter++;
             logger.info(
-                `Error sending subscription update message (error count=${this.sendUpdateErrorCounter}):`,
+                `Error sending subscription update message (error count=${this.#sendUpdateErrorCounter}):`,
                 (error instanceof MatterError && error.message) || error,
             );
-            if (this.sendUpdateErrorCounter <= 2) {
+            if (this.#sendUpdateErrorCounter <= 2) {
                 // fill the data back in the queue to resend with next try
                 const newAttributeUpdatesToSend = Array.from(this.#outstandingAttributeUpdates.values());
                 this.#outstandingAttributeUpdates.clear();
@@ -622,13 +645,14 @@ export class ServerSubscription extends Subscription {
                 logger.info(
                     `Sending update failed 3 times in a row, canceling subscription ${this.id} and let controller subscribe again.`,
                 );
-                this.sendNextUpdateImmediately = false;
+                this.#sendNextUpdateImmediately = false;
                 if (
                     error instanceof NoResponseTimeoutError ||
                     error instanceof NetworkError ||
                     error instanceof NoChannelError
                 ) {
                     // Let's consider this subscription as dead and wait for a reconnect
+                    this.isCanceledByPeer = true; // We handle this case like  if the controller canceled the subscription
                     await this.destroy();
                     return;
                 } else {
@@ -637,9 +661,9 @@ export class ServerSubscription extends Subscription {
             }
         }
 
-        if (this.sendNextUpdateImmediately) {
+        if (this.#sendNextUpdateImmediately) {
             logger.debug("Sending delayed update immediately after last one was sent.");
-            this.sendNextUpdateImmediately = false;
+            this.#sendNextUpdateImmediately = false;
             await this.#sendUpdate(true); // Send but only if non-empty
         }
     }
@@ -799,7 +823,7 @@ export class ServerSubscription extends Subscription {
     async sendInitialReport(messenger: InteractionServerMessenger) {
         this.#updateTimer.stop();
 
-        const { newAttributes, attributeErrors } = this.registerNewAttributes();
+        const { newAttributes, attributeErrors } = this.#registerNewAttributes();
         const { newEvents, eventErrors } = this.#registerNewEvents();
         const { eventReportsPayload, eventsFiltered } = await this.#collectInitialEventReportPayloads(newEvents);
 
@@ -822,8 +846,8 @@ export class ServerSubscription extends Subscription {
         if (MaybePromise.is(changeResult)) {
             const resolver = Promise.resolve(changeResult)
                 .catch(error => logger.error(`Error handling attribute change:`, error))
-                .finally(() => this.attributeUpdatePromises.delete(resolver));
-            this.attributeUpdatePromises.add(resolver);
+                .finally(() => this.#attributeUpdatePromises.delete(resolver));
+            this.#attributeUpdatePromises.add(resolver);
         }
     }
 
@@ -877,15 +901,15 @@ export class ServerSubscription extends Subscription {
         }
     }
 
-    async flush() {
+    async #flush() {
         this.#sendDelayTimer.stop();
         if (this.#outstandingAttributeUpdates.size > 0 || this.#outstandingEventUpdates.size > 0) {
             logger.debug(
                 `Flushing subscription ${this.id} with ${this.#outstandingAttributeUpdates.size} attributes and ${this.#outstandingEventUpdates.size} events${this.isClosed ? " (for closing)" : ""}`,
             );
             this.#triggerSendUpdate();
-            if (this.currentUpdatePromise) {
-                await this.currentUpdatePromise;
+            if (this.#currentUpdatePromise) {
+                await this.#currentUpdatePromise;
             }
         }
     }
@@ -894,9 +918,9 @@ export class ServerSubscription extends Subscription {
         this.#sendUpdatesActivated = false;
         this.unregisterAttributeListeners(Array.from(this.#attributeListeners.keys()));
         this.unregisterEventListeners(Array.from(this.#eventListeners.keys()));
-        if (this.attributeUpdatePromises.size) {
-            const resolvers = [...this.attributeUpdatePromises.values()];
-            this.attributeUpdatePromises.clear();
+        if (this.#attributeUpdatePromises.size) {
+            const resolvers = [...this.#attributeUpdatePromises.values()];
+            this.#attributeUpdatePromises.clear();
             await MatterAggregateError.allSettled(resolvers, "Error receiving all outstanding attribute values").catch(
                 error => logger.error(error),
             );
@@ -909,16 +933,19 @@ export class ServerSubscription extends Subscription {
     /**
      * Closes the subscription and flushes all outstanding data updates if requested.
      */
-    override async close(graceful = false) {
+    override async close(graceful = false, cancelledByPeer = false) {
         if (this.isClosed) {
             return;
         }
+        if (cancelledByPeer) {
+            this.isCanceledByPeer = true;
+        }
         await this.destroy();
         if (graceful) {
-            await this.flush();
+            await this.#flush();
         }
-        if (this.currentUpdatePromise) {
-            await this.currentUpdatePromise;
+        if (this.#currentUpdatePromise) {
+            await this.#currentUpdatePromise;
         }
     }
 
@@ -954,11 +981,8 @@ export class ServerSubscription extends Subscription {
         }
     }
 
-    private async sendUpdateMessage(
-        attributes: AttributePathWithValueVersion<any>[],
-        events: EventPathWithEventData<any>[],
-    ) {
-        const exchange = this.#context.initiateExchange(this.peerAddress, INTERACTION_PROTOCOL_ID);
+    async #sendUpdateMessage(attributes: AttributePathWithValueVersion<any>[], events: EventPathWithEventData<any>[]) {
+        const exchange = this.#context.initiateExchange(this.#peerAddress, INTERACTION_PROTOCOL_ID);
         if (exchange === undefined) return;
         if (attributes.length) {
             logger.debug(

package/src/interaction/Subscription.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Logger } from "#general";
+import { InternalError, Logger, Observable } from "#general";
 import { type SecureSession } from "#session/SecureSession.js";
 import { TlvAttributePath, TlvDataVersionFilter, TlvEventFilter, TlvEventPath, TypeFromSchema } from "#types";
 
@@ -29,15 +29,13 @@ export abstract class Subscription {
     #isClosed?: boolean;
     #isCanceledByPeer?: boolean;
     #criteria: SubscriptionCriteria;
+    #cancelled = Observable<[subscription: Subscription]>();
+    #maxIntervalMs?: number;
 
     constructor(session: SecureSession, id: SubscriptionId, criteria: SubscriptionCriteria) {
         this.#session = session;
         this.#id = id;
         this.#criteria = criteria;
-
-        // TODO Do not add to session but to node/peer
-        this.#session.subscriptions.add(this);
-        logger.debug(`Added subscription ${this.#id} to ${this.#session.name}`);
     }
 
     get id() {
@@ -60,6 +58,28 @@ export abstract class Subscription {
         return this.#session;
     }
 
+    get cancelled() {
+        return this.#cancelled;
+    }
+
+    get maxIntervalMs(): number {
+        if (this.#maxIntervalMs === undefined) {
+            throw new InternalError("Subscription MaxIntervalMs accessed before it was set");
+        }
+        return this.#maxIntervalMs;
+    }
+
+    set maxIntervalMs(value: number) {
+        if (this.#maxIntervalMs !== undefined) {
+            throw new InternalError("Subscription MaxIntervalMs set twice. This should never happen.");
+        }
+        this.#maxIntervalMs = value;
+    }
+
+    get maxInterval(): number {
+        return Math.ceil(this.maxIntervalMs / 1000);
+    }
+
     /**
      * Update session state.  This probably is meaningless except in a server context.
      */
@@ -77,7 +97,7 @@ export abstract class Subscription {
     }
 
     /** Close the subscription with the option to gracefully flush outstanding data. */
-    abstract close(graceful: boolean): Promise<void>;
+    abstract close(graceful: boolean, cancelledByPeer?: boolean): Promise<void>;
 
     /**
      * Destroy the subscription. Unsubscribe from all attributes and events and stop all timers.
@@ -86,5 +106,13 @@ export abstract class Subscription {
         this.#isClosed = true;
         this.#session.subscriptions.delete(this);
         logger.debug(`Removed subscription ${this.id} from ${this.#session.name}`);
+
+        this.#cancelled.emit(this);
+    }
+
+    protected activate() {
+        // TODO Do not add to session but to node/peer
+        this.#session.subscriptions.add(this);
+        logger.debug(`Added subscription ${this.#id} to ${this.#session.name}`);
     }
 }

package/src/peer/ControllerCommissioner.ts

@@ -407,15 +407,14 @@ export class ControllerCommissioner {
                 }
 
                 // Look for the device broadcast over MDNS and do CASE pairing
-                return await this.#context.clients.connect(
-                    address,
-                    {
+                return await this.#context.clients.connect(address, {
+                    discoveryOptions: {
                         discoveryType: NodeDiscoveryType.TimedDiscovery,
                         timeoutSeconds: 120,
                         discoveryData,
                     },
-                    true,
-                ); // Wait maximum 120s to find the operational device for commissioning process
+                    allowUnknownPeer: true,
+                }); // Wait maximum 120s to find the operational device for commissioning process
             },
         );
 

package/src/peer/PeerAddress.ts

@@ -86,3 +86,17 @@ export class PeerAddressMap<T> extends Map<PeerAddress, T> {
         return super.get(PeerAddress(key));
     }
 }
+
+export class PeerAddressSet extends Set<PeerAddress> {
+    override add(value: PeerAddress) {
+        return super.add(PeerAddress(value));
+    }
+
+    override has(value: PeerAddress) {
+        return super.has(PeerAddress(value));
+    }
+
+    override delete(value: PeerAddress) {
+        return super.delete(PeerAddress(value));
+    }
+}

package/src/peer/PeerSet.ts

@@ -144,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
@@ -230,7 +231,15 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     /**
      * Ensure there is a channel to the designated peer.
      */
-    async ensureConnection(address: PeerAddress, discoveryOptions: DiscoveryOptions, allowUnknownPeer = false) {
+    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)}`);
         }
@@ -246,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);
@@ -268,7 +277,9 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         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, { discoveryType: NodeDiscoveryType.None });
+                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;
@@ -366,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
@@ -432,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;
             }
@@ -567,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}${
@@ -585,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/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/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,11 +378,12 @@ 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);
@@ -564,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;
     }