@matter/protocol 0.16.0-alpha.0-20251004-92135c7df → 0.16.0-alpha.0-20251011-d8942d7d5

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@matter/protocol",
-    "version": "0.16.0-alpha.0-20251004-92135c7df",
+    "version": "0.16.0-alpha.0-20251011-d8942d7d5",
     "description": "Low-level APIs for Matter interaction",
     "keywords": [
         "iot",
@@ -40,13 +40,13 @@
         "#*": "./src/*"
     },
     "dependencies": {
-        "@matter/general": "0.16.0-alpha.0-20251004-92135c7df",
-        "@matter/model": "0.16.0-alpha.0-20251004-92135c7df",
-        "@matter/types": "0.16.0-alpha.0-20251004-92135c7df"
+        "@matter/general": "0.16.0-alpha.0-20251011-d8942d7d5",
+        "@matter/model": "0.16.0-alpha.0-20251011-d8942d7d5",
+        "@matter/types": "0.16.0-alpha.0-20251011-d8942d7d5"
     },
     "devDependencies": {
-        "@matter/tools": "0.16.0-alpha.0-20251004-92135c7df",
-        "@matter/testing": "0.16.0-alpha.0-20251004-92135c7df"
+        "@matter/tools": "0.16.0-alpha.0-20251011-d8942d7d5",
+        "@matter/testing": "0.16.0-alpha.0-20251011-d8942d7d5"
     },
     "files": [
         "dist/**/*",

package/src/action/client/ClientInteraction.ts

@@ -194,9 +194,9 @@ export class ClientInteraction<SessionT extends InteractionSession = Interaction
             messenger = await InteractionClientMessenger.create(this.#exchanges);
 
             await messenger.sendSubscribeRequest({
-                ...request,
                 minIntervalFloorSeconds: Seconds.of(DEFAULT_MIN_INTERVAL_FLOOR),
-                maxIntervalCeilingSeconds: Seconds.of(DEFAULT_MIN_INTERVAL_FLOOR),
+                maxIntervalCeilingSeconds: Seconds.of(DEFAULT_MIN_INTERVAL_FLOOR), // TODO use better max fallback
+                ...request,
             });
 
             await this.#handleSubscriptionResponse(request, readChunks(messenger));
@@ -211,6 +211,10 @@ export class ClientInteraction<SessionT extends InteractionSession = Interaction
         }
     }
 
+    cancelSubscription(id: number) {
+        this.#subscriptions.get(id)?.close();
+    }
+
     async #handleSubscriptionResponse(request: Subscribe, result: ReadResult) {
         if (request.updated) {
             await request.updated(result);

package/src/action/protocols.ts

@@ -64,12 +64,9 @@ export interface NodeProtocol extends CollectionProtocol<EndpointProtocol> {
     eventHandler: OccurrenceManager;
 
     /**
-     * Event when data on the node changes.
+     * Emitted when attributes change.
      */
-    stateChanged: Observable<
-        [endpointId: EndpointNumber, clusterId: ClusterId, changes: AttributeId[], version: number],
-        MaybePromise
-    >;
+    attrsChanged: Observable<NodeProtocol.AttrChange, MaybePromise>;
 
     /**
      * Inspects an Attribute- or Event path and log in human-readable form if possible
@@ -77,6 +74,15 @@ export interface NodeProtocol extends CollectionProtocol<EndpointProtocol> {
     inspectPath(path: AttributePath | EventPath | CommandPath): string;
 }
 
+export namespace NodeProtocol {
+    export type AttrChange = [
+        endpointId: EndpointNumber,
+        clusterId: ClusterId,
+        changes: AttributeId[],
+        version: number,
+    ];
+}
+
 /**
  * Protocol contract for a specific endpoint.
  */
@@ -115,11 +121,6 @@ export interface ClusterProtocol {
      */
     location: AccessControl.Location;
 
-    /**
-     * The cluster datasource state change event
-     */
-    stateChanged: Observable<[changes: AttributeId[], version: number], MaybePromise>;
-
     /**
      * Read-only state of the cluster
      */

package/src/action/request/Invoke.ts

@@ -30,6 +30,10 @@ export function Invoke(options: Invoke.Definition, ...commands: CommandData[]):
 export function Invoke(...commands: CommandData[]): Invoke;
 
 export function Invoke(optionsOrData: Invoke.Definition | CommandData, ...commands: CommandData[]): Invoke {
+    if (optionsOrData === undefined) {
+        throw new MalformedRequestError(`Invocation requires at least one command`);
+    }
+
     let options;
     if ("commands" in optionsOrData) {
         options = optionsOrData;

package/src/action/request/Read.ts

@@ -34,6 +34,10 @@ export function Read(options: Read.Options, ...selectors: Read.Selector[]): Read
 export function Read(...selectors: Read.Selector[]): Read;
 
 export function Read(optionsOrSelector: Read.Options | Read.Selector, ...selectors: Read.Selector[]): Read {
+    if (optionsOrSelector === undefined) {
+        throw new MalformedRequestError(`Read action designates no attributes or events`);
+    }
+
     let options;
     if ("kind" in optionsOrSelector) {
         selectors = [optionsOrSelector, ...selectors];

package/src/action/request/Write.ts

@@ -30,6 +30,10 @@ export function Write(options: Write.Options, ...data: Write.Attribute[]): Write
 export function Write(...data: Write.Attribute[]): Write;
 
 export function Write(optionsOrData: Write.Options | Write.Attribute, ...data: Write.Attribute[]): Write {
+    if (optionsOrData === undefined) {
+        throw new MalformedRequestError(`Write action must have options or data`);
+    }
+
     let options;
     if ("kind" in optionsOrData) {
         data = [optionsOrData, ...data];

package/src/action/server/AttributeSubscriptionResponse.ts

@@ -11,75 +11,78 @@ import { InternalError } from "#general";
 import { AttributeId, AttributePath, ClusterId, EndpointNumber } from "#types";
 import { AttributeReadResponse } from "./AttributeReadResponse.js";
 
-type ClusterFilter = {
-    [clusterId: ClusterId]: Set<AttributeId>;
-};
-export type AttributeResponseFilter = {
-    [endpointId: EndpointNumber]: ClusterFilter;
-};
+export namespace DirtyState {
+    export type ForCluster = {
+        [clusterId: ClusterId]: Set<AttributeId>;
+    };
+
+    export type ForNode = {
+        [endpointId: EndpointNumber]: ForCluster;
+    };
+}
 
 /**
- * AttributeSubscriptionResponse is a specialized version of AttributeReadResponse that processes a read/subscribe request
- * with a filter applied to the attributes. Only the attributes that match the filter will be processed.
+ * A specialization of {@link AttributeReadResponse} that processes a read/subscribe request with a filter applied to
+ * the attributes. Only processes attributes that match the filter.
  */
 export class AttributeSubscriptionResponse<
     SessionT extends InteractionSession = InteractionSession,
 > extends AttributeReadResponse<SessionT> {
-    #filter: AttributeResponseFilter;
-    #currentEndpointFilter?: ClusterFilter;
-    #currentClusterFilter?: Set<number>;
+    #dirty: DirtyState.ForNode;
+    #currentEndpointDirty?: DirtyState.ForCluster;
+    #currentClusterDirty?: Set<number>;
 
-    constructor(node: NodeProtocol, session: SessionT, filter: AttributeResponseFilter) {
+    constructor(node: NodeProtocol, session: SessionT, filter: DirtyState.ForNode) {
         super(node, session);
-        this.#filter = filter;
+        this.#dirty = filter;
     }
 
-    get filter() {
-        return this.#filter;
+    get dirty() {
+        return this.#dirty;
     }
 
     /** Guarded accessor for this.#currentEndpointFilter.  This should never be undefined */
-    protected get currentEndpointFilter() {
-        if (!this.#currentEndpointFilter) {
+    protected get currentEndpointDirty() {
+        if (!this.#currentEndpointDirty) {
             throw new InternalError("currentEndpointFilter is not set. Should never happen");
         }
-        return this.#currentEndpointFilter;
+        return this.#currentEndpointDirty;
     }
 
     /** Guarded accessor for this.#currentCLusterFilter.  This should never be undefined */
-    protected get currentClusterFilter() {
-        if (!this.#currentClusterFilter) {
+    protected get currentClusterDirty() {
+        if (!this.#currentClusterDirty) {
             throw new InternalError("currentClusterFilter is not set. Should never happen");
         }
-        return this.#currentClusterFilter;
+        return this.#currentClusterDirty;
     }
 
     protected override addConcrete(path: ReadResult.ConcreteAttributePath) {
         const { endpointId, clusterId, attributeId } = path;
-        if (this.#filter[endpointId]?.[clusterId]?.has(attributeId) === undefined) {
+        if (this.#dirty[endpointId]?.[clusterId]?.has(attributeId) === undefined) {
             return;
         }
         super.addConcrete(path);
     }
 
     protected override *readEndpointForWildcard(endpoint: EndpointProtocol, path: AttributePath) {
-        this.#currentEndpointFilter = this.#filter[endpoint.id];
-        if (this.#currentEndpointFilter === undefined) {
+        this.#currentEndpointDirty = this.#dirty[endpoint.id];
+        if (this.#currentEndpointDirty === undefined) {
             return;
         }
         yield* super.readEndpointForWildcard(endpoint, path);
     }
 
     protected override readClusterForWildcard(cluster: ClusterProtocol, path: AttributePath) {
-        this.#currentClusterFilter = this.currentEndpointFilter[cluster.type.id];
-        if (this.#currentClusterFilter === undefined) {
+        this.#currentClusterDirty = this.currentEndpointDirty[cluster.type.id];
+        if (this.#currentClusterDirty === undefined) {
             return;
         }
         super.readClusterForWildcard(cluster, path);
     }
 
     protected override readAttributeForWildcard(attribute: AttributeTypeProtocol, path: AttributePath) {
-        if (!this.currentClusterFilter.has(attribute.id)) {
+        if (!this.currentClusterDirty.has(attribute.id)) {
             return;
         }
         super.readAttributeForWildcard(attribute, path);

package/src/action/server/ServerInteraction.ts

@@ -65,6 +65,11 @@ export class ServerInteraction<SessionT extends InteractionSession = Interaction
         throw new NotImplementedError();
     }
 
+    cancelSubscription(_id: number): void {
+        // TODO
+        throw new NotImplementedError();
+    }
+
     write<T extends Write>(request: T, session: SessionT): WriteResult<T> {
         // TODO - validate request
 

package/src/fabric/Fabric.ts

@@ -259,7 +259,7 @@ export class Fabric {
         };
     }
 
-    addressOf(nodeId: NodeId) {
+    addressOf(nodeId: NodeId): PeerAddress {
         return PeerAddress({ fabricIndex: this.fabricIndex, nodeId });
     }
 

package/src/fabric/FabricAuthority.ts

@@ -51,7 +51,6 @@ export interface FabricAuthorityContext {
 }
 
 export const DEFAULT_ADMIN_VENDOR_ID = VendorId(0xfff1);
-export const DEFAULT_FABRIC_ID = FabricId(1);
 
 /**
  * Manages fabrics controlled locally associated with a specific CA.
@@ -144,10 +143,11 @@ export class FabricAuthority {
             .setRootVendorId(this.#config.adminVendorId ?? DEFAULT_ADMIN_VENDOR_ID)
             .setLabel(this.#config.adminFabricLabel);
 
+        const fabricId = this.#config.fabricId ?? FabricId(this.#fabrics.crypto.randomBigInt(8));
         await fabricBuilder.setOperationalCert(
             await this.#ca.generateNoc(
                 fabricBuilder.publicKey,
-                this.#config.fabricId ?? DEFAULT_FABRIC_ID,
+                fabricId,
                 rootNodeId,
                 this.#config.caseAuthenticatedTags,
             ),

package/src/fabric/TestFabric.ts

@@ -6,7 +6,7 @@
 
 import { CertificateAuthority } from "#certificate/CertificateAuthority.js";
 import { ImplementationError, MockCrypto } from "#general";
-import { FabricIndex, VendorId } from "#types";
+import { FabricId, FabricIndex, VendorId } from "#types";
 import { FabricAuthority } from "./FabricAuthority.js";
 import { FabricManager } from "./FabricManager.js";
 
@@ -54,6 +54,7 @@ export namespace TestFabric {
                 adminFabricLabel: `mock-fabric-${index}`,
                 adminVendorId: VendorId(0xfff1),
                 fabricIndex: FabricIndex(index),
+                fabricId: FabricId(1),
             },
             fabrics,
         });

package/src/interaction/InteractionClient.ts

@@ -116,7 +116,7 @@ export class InteractionClientProvider {
             operationalAddress?: ServerAddressUdp;
         },
     ): Promise<InteractionClient> {
-        await this.#peers.ensureConnection(address, options);
+        await this.#peers.connect(address, options);
 
         return this.getInteractionClient(address, options);
     }

package/src/interaction/InteractionMessenger.ts

@@ -301,7 +301,7 @@ export class InteractionServerMessenger extends InteractionMessenger {
                     }
                     default:
                         throw new StatusResponseError(
-                            `Unsupported message type ${message.payloadHeader.messageType}`,
+                            `Unsupported message type ${MessageType[message.payloadHeader.messageType]} (${message.payloadHeader.messageType})`,
                             Status.InvalidAction,
                         );
                 }

package/src/mdns/MdnsService.ts

@@ -76,7 +76,7 @@ export class MdnsService {
         return this.#construction;
     }
 
-    async [Symbol.asyncDispose]() {
+    async close() {
         this.#env.delete(MdnsService, this);
 
         await this.#construction.close(async () => {

package/src/peer/ControllerCommissioner.ts

@@ -313,32 +313,40 @@ export class ControllerCommissioner {
         if (device !== undefined) {
             logger.info(`Establish PASE to device`, MdnsClient.discoveryDataDiagnostics(device));
         }
-        if (address.type === "udp") {
-            const { ip } = address;
 
-            const isIpv6Address = isIPv6(ip);
-            const paseInterface = this.#context.transports.interfaceFor(
-                ChannelType.UDP,
-                isIpv6Address ? "::" : "0.0.0.0",
-            );
-            if (paseInterface === undefined) {
-                // mainly IPv6 address when IPv4 is disabled
-                throw new PairRetransmissionLimitReachedError(
-                    `IPv${isIpv6Address ? "6" : "4"} interface not initialized. Cannot use ${ip} for commissioning.`,
+        switch (address.type) {
+            case "udp":
+                const { ip } = address;
+
+                const isIpv6Address = isIPv6(ip);
+                const paseInterface = this.#context.transports.interfaceFor(
+                    ChannelType.UDP,
+                    isIpv6Address ? "::" : "0.0.0.0",
                 );
-            }
-            paseChannel = await paseInterface.openChannel(address);
-        } else if (address.type === "ble") {
-            const ble = this.#context.transports.interfaceFor(ChannelType.BLE);
-            if (!ble) {
-                throw new PairRetransmissionLimitReachedError(
-                    `BLE interface not initialized. Cannot use ${address.peripheralAddress} for commissioning.`,
+                if (paseInterface === undefined) {
+                    // mainly IPv6 address when IPv4 is disabled
+                    throw new PairRetransmissionLimitReachedError(
+                        `IPv${isIpv6Address ? "6" : "4"} interface not initialized. Cannot use ${ip} for commissioning.`,
+                    );
+                }
+                paseChannel = await paseInterface.openChannel(address);
+                break;
+
+            case "ble":
+                const ble = this.#context.transports.interfaceFor(ChannelType.BLE);
+                if (!ble) {
+                    throw new PairRetransmissionLimitReachedError(
+                        `BLE interface not initialized. Cannot use ${address.peripheralAddress} for commissioning.`,
+                    );
+                }
+                // TODO Have a Timeout mechanism here for connections
+                paseChannel = await ble.openChannel(address);
+                break;
+
+            default:
+                throw new ImplementationError(
+                    `Unsupported address type ${(address as ServerAddress).type} for Matter protocol`,
                 );
-            }
-            // TODO Have a Timeout mechanism here for connections
-            paseChannel = await ble.openChannel(address);
-        } else {
-            throw new ImplementationError(`Unsupported PASE address type ${address.type}`);
         }
 
         // Do PASE paring

package/src/peer/PeerSet.ts

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

package/src/protocol/ExchangeManager.ts

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

package/src/protocol/MessageExchange.ts

@@ -198,6 +198,7 @@ export class MessageExchange {
 
         logger.debug(
             "New exchange",
+            isInitiator ? "»" : "«",
             Diagnostic.dict({
                 channel: channel.name,
                 protocol: this.#protocolId,
@@ -507,7 +508,7 @@ export class MessageExchange {
                 if (finalWaitTime > 0) {
                     this.#retransmissionCounter--; // We will not resubmit the message again
                     logger.debug(
-                        `Message ${message.packetHeader.messageId}: Wait additional ${finalWaitTime}ms for processing time and peer resubmissions after all our resubmissions`,
+                        `Message ${message.packetHeader.messageId}: Wait additional ${Duration.format(finalWaitTime)} for processing time and peer resubmissions after all our resubmissions`,
                     );
                     this.#retransmissionTimer = Time.getTimer(
                         `Message wait time after resubmissions ${message.packetHeader.messageId}`,
@@ -537,7 +538,7 @@ export class MessageExchange {
         this.context.retry(this.#retransmissionCounter);
         const resubmissionBackoffTime = this.channel.getMrpResubmissionBackOffTime(this.#retransmissionCounter);
         logger.debug(
-            `Resubmit message ${message.packetHeader.messageId} (retransmission attempt ${this.#retransmissionCounter}, backoff time ${resubmissionBackoffTime}ms))`,
+            `Resubmit message ${message.packetHeader.messageId} (retransmission attempt ${this.#retransmissionCounter}, backoff time ${Duration.format(resubmissionBackoffTime)}))`,
         );
 
         this.channel

package/src/session/SessionManager.ts

@@ -23,6 +23,7 @@ import {
     ObserverGroup,
     StorageContext,
     StorageManager,
+    toHex,
 } from "#general";
 import { Subscription } from "#interaction/Subscription.js";
 import { Specification } from "#model";
@@ -73,6 +74,7 @@ type ResumptionStorageRecord = {
     sharedSecret: Bytes;
     resumptionId: Bytes;
     fabricId: FabricId;
+    fabricIndex: FabricIndex;
     peerNodeId: NodeId;
     sessionParameters: {
         idleInterval: Duration;
@@ -557,21 +559,21 @@ export class SessionManager {
                 ([
                     address,
                     { sharedSecret, resumptionId, peerNodeId, fabric, sessionParameters, caseAuthenticatedTags },
-                ]) =>
-                    ({
-                        nodeId: address.nodeId,
-                        sharedSecret,
-                        resumptionId,
-                        fabricId: fabric.fabricId,
-                        peerNodeId: peerNodeId,
-                        sessionParameters: {
-                            ...sessionParameters,
-                            supportedTransports: sessionParameters.supportedTransports
-                                ? SupportedTransportsSchema.encode(sessionParameters.supportedTransports)
-                                : undefined,
-                        },
-                        caseAuthenticatedTags,
-                    }) as ResumptionStorageRecord,
+                ]): ResumptionStorageRecord => ({
+                    nodeId: address.nodeId,
+                    sharedSecret,
+                    resumptionId,
+                    fabricId: fabric.fabricId,
+                    fabricIndex: fabric.fabricIndex,
+                    peerNodeId: peerNodeId,
+                    sessionParameters: {
+                        ...sessionParameters,
+                        supportedTransports: sessionParameters.supportedTransports
+                            ? SupportedTransportsSchema.encode(sessionParameters.supportedTransports)
+                            : undefined,
+                    },
+                    caseAuthenticatedTags,
+                }),
             ),
         );
     }
@@ -590,6 +592,7 @@ export class SessionManager {
                 sharedSecret,
                 resumptionId,
                 fabricId,
+                fabricIndex,
                 peerNodeId,
                 sessionParameters: {
                     idleInterval,
@@ -604,19 +607,27 @@ export class SessionManager {
                 } = {},
                 caseAuthenticatedTags,
             }) => {
-                const fabric = this.#context.fabrics.find(fabric => fabric.fabricId === fabricId);
-                logger.info(
-                    "restoring resumption record for node",
-                    nodeId,
-                    "and peer node",
-                    peerNodeId,
-                    "for fabric index",
-                    fabric?.fabricIndex,
+                const fabric = this.#context.fabrics.find(
+                    fabric =>
+                        fabric.fabricId === fabricId &&
+                        // Backward compatibility logic: fabricIndex was added later (0.15.5), so it might be undefined in older records
+                        (fabricIndex === undefined || fabric.fabricIndex === fabricIndex),
                 );
                 if (!fabric) {
-                    logger.error("fabric not found for resumption record", fabricId);
+                    logger.warn(
+                        `Ignoring resumption record for fabric 0x${toHex(fabricId)} and index ${fabricIndex} because we cannot find a matching fabric`,
+                    );
                     return;
                 }
+                logger.info(
+                    "restoring resumption record for node",
+                    fabric.addressOf(nodeId).toString(),
+                    "and peer node",
+                    fabric.addressOf(peerNodeId).toString(),
+                    "for fabric id",
+                    `0x${toHex(fabric.fabricId)}`,
+                    `(0x${toHex(fabric.rootVendorId)}, "${fabric?.label}")`,
+                );
                 this.#resumptionRecords.set(fabric.addressOf(nodeId), {
                     sharedSecret,
                     resumptionId,