@matter/protocol 0.12.0-alpha.0-20250108-7ae2a767d → 0.12.0-alpha.0-20250110-6349da2f0

package/src/mdns/MdnsScanner.ts

@@ -56,6 +56,7 @@ const MDNS_EXPIRY_GRACE_PERIOD_FACTOR = 1.05;
 
 type MatterServerRecordWithExpire = ServerAddressIp & Lifespan;
 
+/** Type for commissionable Device records including Lifespan details. */
 type CommissionableDeviceRecordWithExpire = Omit<CommissionableDevice, "addresses"> &
     Lifespan & {
         addresses: Map<string, MatterServerRecordWithExpire>; // Override addresses type to include expiration
@@ -65,17 +66,27 @@ type CommissionableDeviceRecordWithExpire = Omit<CommissionableDevice, "addresse
         P?: number; // Additional Field for Product ID
     };
 
+/** Type for operational Device records including Lifespan details. */
 type OperationalDeviceRecordWithExpire = Omit<OperationalDevice, "addresses"> &
     Lifespan & {
         addresses: Map<string, MatterServerRecordWithExpire>; // Override addresses type to include expiration
     };
 
-type StructuredDnsAnswers = {
-    operational?: Record<number, DnsRecord<any>[]>; // Operational Matter device records by recordType
-    commissionable?: Record<number, DnsRecord<any>[]>; // Commissionable Matter device records by recordType
-    addresses?: Record<string, DnsRecord<any>[]>; // IP Address records by name
+/** Type for any DNS record with Lifespan (discoveredAt and ttl) details. */
+type AnyDnsRecordWithExpiry = DnsRecord<any> & Lifespan;
+
+/** Type for DNS answers with Address details structured for better direct access performance. */
+type StructuredDnsAddressAnswers = {
+    addressesV4?: Record<string, Map<string, AnyDnsRecordWithExpiry>>; // IPv4 Address record by name and value (IP)
+    addressesV6?: Record<string, Map<string, AnyDnsRecordWithExpiry>>; // IPv6 Address record by name and value (IP)
 };
 
+/** Type for DNS answers with Lifespan details  structured for better direct access performance. */
+type StructuredDnsAnswers = {
+    operational?: Record<number, AnyDnsRecordWithExpiry[]>; // Operational Matter device records by recordType
+    commissionable?: Record<number, AnyDnsRecordWithExpiry[]>; // Commissionable Matter device records by recordType
+} & StructuredDnsAddressAnswers;
+
 /** The initial number of seconds between two announcements. MDNS specs require 1-2 seconds, so lets use the middle. */
 const START_ANNOUNCE_INTERVAL_SECONDS = 1.5;
 
@@ -102,12 +113,19 @@ export class MdnsScanner implements Scanner {
         );
     }
 
+    /** Active announces by queryId with queries and known answers */
     readonly #activeAnnounceQueries = new Map<string, { queries: DnsQuery[]; answers: StructuredDnsAnswers }>();
-    #queryTimer?: Timer;
-    #nextAnnounceIntervalSeconds = START_ANNOUNCE_INTERVAL_SECONDS;
 
+    /** Known IP addresses by network interface */
+    readonly #discoveredIpRecords = new Map<string, StructuredDnsAddressAnswers>();
+
+    /** Known operational device records by Matter Qname */
     readonly #operationalDeviceRecords = new Map<string, OperationalDeviceRecordWithExpire>();
+
+    /** Known commissionable device records by queryId */
     readonly #commissionableDeviceRecords = new Map<string, CommissionableDeviceRecordWithExpire>();
+
+    /** Waiters for specific queryIds to resolve a promise when a record is discovered */
     readonly #recordWaiters = new Map<
         string,
         {
@@ -117,9 +135,11 @@ export class MdnsScanner implements Scanner {
             cancelResolver?: (value: void) => void;
         }
     >();
+
+    #queryTimer?: Timer;
+    #nextAnnounceIntervalSeconds = START_ANNOUNCE_INTERVAL_SECONDS;
     readonly #periodicTimer: Timer;
     #closing = false;
-
     readonly #multicastServer: UdpMulticastServer;
     readonly #enableIpv4?: boolean;
 
@@ -149,7 +169,9 @@ export class MdnsScanner implements Scanner {
         const allQueries = Array.from(this.#activeAnnounceQueries.values());
         const queries = allQueries.flatMap(({ queries }) => queries);
         const answers = allQueries.flatMap(({ answers }) =>
-            Object.values(answers).flatMap(answer => Object.values(answer).flatMap(records => records)),
+            Object.values(answers).flatMap(answer =>
+                Object.values(answer).flatMap(records => (Array.isArray(records) ? records : records.values())),
+            ),
         );
 
         this.#queryTimer = Time.getTimer("MDNS discovery", this.#nextAnnounceIntervalSeconds * 1000, () =>
@@ -249,9 +271,14 @@ export class MdnsScanner implements Scanner {
         this.#queryTimer = Time.getTimer("MDNS discovery", 0, () => this.#sendQueries()).start();
     }
 
-    #getActiveQueryEarlierAnswers() {
+    /**
+     * Combines the known answers from all active queries and the known IP addresses from the network
+     * interface into one data package
+     */
+    #getActiveQueryEarlierAnswers(netInterface: string) {
         return this.#combineStructuredAnswers(
             ...[...this.#activeAnnounceQueries.values()].map(({ answers }) => answers),
+            this.#discoveredIpRecords.get(netInterface) ?? {},
         );
     }
 
@@ -714,21 +741,38 @@ export class MdnsScanner implements Scanner {
     #structureAnswers(...answersList: DnsRecord<any>[][]): StructuredDnsAnswers {
         const structuredAnswers: StructuredDnsAnswers = {};
 
+        const discoveredAt = Time.nowMs();
         answersList.forEach(answers =>
             answers.forEach(answer => {
                 const { name, recordType } = answer;
                 if (name.endsWith(MATTER_SERVICE_QNAME)) {
                     structuredAnswers.operational = structuredAnswers.operational ?? {};
                     structuredAnswers.operational[recordType] = structuredAnswers.operational[recordType] ?? [];
-                    structuredAnswers.operational[recordType].push(answer);
+                    structuredAnswers.operational[recordType].push({
+                        discoveredAt,
+                        ...answer,
+                    });
                 } else if (name.endsWith(MATTER_COMMISSION_SERVICE_QNAME)) {
                     structuredAnswers.commissionable = structuredAnswers.commissionable ?? {};
                     structuredAnswers.commissionable[recordType] = structuredAnswers.commissionable[recordType] ?? [];
-                    structuredAnswers.commissionable[recordType].push(answer);
-                } else if (recordType === DnsRecordType.A || recordType === DnsRecordType.AAAA) {
-                    structuredAnswers.addresses = structuredAnswers.addresses ?? {};
-                    structuredAnswers.addresses[name] = structuredAnswers.addresses[name] ?? [];
-                    structuredAnswers.addresses[name].push(answer);
+                    structuredAnswers.commissionable[recordType].push({
+                        discoveredAt,
+                        ...answer,
+                    });
+                } else if (recordType === DnsRecordType.AAAA) {
+                    structuredAnswers.addressesV6 = structuredAnswers.addressesV6 ?? {};
+                    structuredAnswers.addressesV6[name] = structuredAnswers.addressesV6[name] ?? new Map();
+                    structuredAnswers.addressesV6[name].set(answer.value, {
+                        discoveredAt,
+                        ...answer,
+                    });
+                } else if (this.#enableIpv4 && recordType === DnsRecordType.A) {
+                    structuredAnswers.addressesV4 = structuredAnswers.addressesV4 ?? {};
+                    structuredAnswers.addressesV4[name] = structuredAnswers.addressesV4[name] ?? new Map();
+                    structuredAnswers.addressesV4[name].set(answer.value, {
+                        discoveredAt,
+                        ...answer,
+                    });
                 }
             }),
         );
@@ -737,10 +781,12 @@ export class MdnsScanner implements Scanner {
     }
 
     #combineStructuredAnswers(...answersList: StructuredDnsAnswers[]): StructuredDnsAnswers {
+        // Special type for easier combination of answers
         const combinedAnswers: {
-            operational?: Record<number, Map<string, DnsRecord<any>>>;
-            commissionable?: Record<number, Map<string, DnsRecord<any>>>;
-            addresses?: Record<string, DnsRecord<any>[]>;
+            operational?: Record<number, Map<string, AnyDnsRecordWithExpiry>>;
+            commissionable?: Record<number, Map<string, AnyDnsRecordWithExpiry>>;
+            addressesV4?: Record<string, Map<string, AnyDnsRecordWithExpiry>>;
+            addressesV6?: Record<string, Map<string, AnyDnsRecordWithExpiry>>;
         } = {};
 
         for (const answers of answersList) {
@@ -748,11 +794,18 @@ export class MdnsScanner implements Scanner {
                 combinedAnswers.operational = combinedAnswers.operational ?? {};
                 for (const [recordType, records] of Object.entries(answers.operational) as unknown as [
                     number,
-                    DnsRecord<any>[],
+                    AnyDnsRecordWithExpiry[],
                 ][]) {
                     combinedAnswers.operational[recordType] = combinedAnswers.operational[recordType] ?? new Map();
                     records.forEach(record => {
-                        combinedAnswers.operational![recordType].set(record.name, record);
+                        const existingRecord = combinedAnswers.operational![recordType].get(record.name);
+                        if (existingRecord && existingRecord.discoveredAt < record.discoveredAt) {
+                            if (record.ttl === 0) {
+                                combinedAnswers.operational![recordType].delete(record.name);
+                            } else {
+                                combinedAnswers.operational![recordType].set(record.name, record);
+                            }
+                        }
                     });
                 }
             }
@@ -760,24 +813,58 @@ export class MdnsScanner implements Scanner {
                 combinedAnswers.commissionable = combinedAnswers.commissionable ?? {};
                 for (const [recordType, records] of Object.entries(answers.commissionable) as unknown as [
                     number,
-                    DnsRecord<any>[],
+                    AnyDnsRecordWithExpiry[],
                 ][]) {
                     combinedAnswers.commissionable[recordType] =
                         combinedAnswers.commissionable[recordType] ?? new Map();
                     records.forEach(record => {
-                        combinedAnswers.commissionable![recordType].set(record.name, record);
+                        const existingRecord = combinedAnswers.commissionable![recordType].get(record.name);
+                        if (existingRecord && existingRecord.discoveredAt < record.discoveredAt) {
+                            if (record.ttl === 0) {
+                                combinedAnswers.commissionable![recordType].delete(record.name);
+                            } else {
+                                combinedAnswers.commissionable![recordType].set(record.name, record);
+                            }
+                        }
                     });
                 }
             }
-            if (answers.addresses) {
-                combinedAnswers.addresses = combinedAnswers.addresses ?? {};
-                for (const [name, records] of Object.entries(answers.addresses) as unknown as [
+            if (answers.addressesV6) {
+                combinedAnswers.addressesV6 = combinedAnswers.addressesV6 ?? {};
+                for (const [name, records] of Object.entries(answers.addressesV6) as unknown as [
                     string,
-                    DnsRecord<any>[],
+                    Map<string, AnyDnsRecordWithExpiry>,
                 ][]) {
-                    combinedAnswers.addresses[name] = combinedAnswers.addresses[name] ?? [];
-                    // IP address consolidation happens when they are selected for a device
-                    combinedAnswers.addresses[name].push(...records);
+                    combinedAnswers.addressesV6[name] = combinedAnswers.addressesV6[name] ?? new Map();
+                    Object.values(records).forEach(record => {
+                        const existingRecord = combinedAnswers.addressesV6![name].get(record.value);
+                        if (existingRecord && existingRecord.discoveredAt < record.discoveredAt) {
+                            if (record.ttl === 0) {
+                                combinedAnswers.addressesV6![name].delete(name);
+                            } else {
+                                combinedAnswers.addressesV6![name].set(name, record);
+                            }
+                        }
+                    });
+                }
+            }
+            if (this.#enableIpv4 && answers.addressesV4) {
+                combinedAnswers.addressesV4 = combinedAnswers.addressesV4 ?? {};
+                for (const [name, records] of Object.entries(answers.addressesV4) as unknown as [
+                    string,
+                    Map<string, AnyDnsRecordWithExpiry>,
+                ][]) {
+                    combinedAnswers.addressesV4[name] = combinedAnswers.addressesV4[name] ?? new Map();
+                    Object.values(records).forEach(record => {
+                        const existingRecord = combinedAnswers.addressesV4![name].get(record.value);
+                        if (existingRecord && existingRecord.discoveredAt < record.discoveredAt) {
+                            if (record.ttl === 0) {
+                                combinedAnswers.addressesV4![name].delete(name);
+                            } else {
+                                combinedAnswers.addressesV4![name].set(name, record);
+                            }
+                        }
+                    });
                 }
             }
         }
@@ -799,8 +886,11 @@ export class MdnsScanner implements Scanner {
                 ]),
             );
         }
-        if (combinedAnswers.addresses) {
-            result.addresses = combinedAnswers.addresses;
+        if (combinedAnswers.addressesV6) {
+            result.addressesV6 = combinedAnswers.addressesV6;
+        }
+        if (this.#enableIpv4 && combinedAnswers.addressesV4) {
+            result.addressesV4 = combinedAnswers.addressesV4;
         }
 
         return result;
@@ -819,12 +909,77 @@ export class MdnsScanner implements Scanner {
 
         const answers = this.#structureAnswers([...message.answers, ...message.additionalRecords]);
 
-        const formerAnswers = this.#getActiveQueryEarlierAnswers();
+        const formerAnswers = this.#getActiveQueryEarlierAnswers(netInterface);
         // Check if we got operational discovery records and handle them
         this.#handleOperationalRecords(answers, formerAnswers, netInterface);
 
         // Else check if we got commissionable discovery records and handle them
         this.#handleCommissionableRecords(answers, formerAnswers, netInterface);
+
+        this.#updateIpRecords(answers, netInterface);
+    }
+
+    /**
+     * Update the discovered matter relevant IP records with the new data from the DNS message.
+     */
+    #updateIpRecords(answers: StructuredDnsAnswers, netInterface: string) {
+        const interfaceRecords = this.#discoveredIpRecords.get(netInterface);
+        if (interfaceRecords === undefined) {
+            return;
+        }
+        let updated = false;
+        if (answers.addressesV6) {
+            for (const [target, ipAddresses] of Object.entries(answers.addressesV6)) {
+                if (interfaceRecords.addressesV6?.[target] !== undefined) {
+                    for (const [ip, record] of Object.entries(ipAddresses)) {
+                        if (record.ttl === 0) {
+                            interfaceRecords.addressesV6[target].delete(ip);
+                        } else {
+                            interfaceRecords.addressesV6[target].set(ip, record);
+                        }
+                        updated = true;
+                    }
+                }
+            }
+        }
+        if (this.#enableIpv4 && answers.addressesV4) {
+            for (const [target, ipAddresses] of Object.entries(answers.addressesV4)) {
+                if (interfaceRecords.addressesV4?.[target] !== undefined) {
+                    for (const [ip, record] of Object.entries(ipAddresses)) {
+                        if (record.ttl === 0) {
+                            interfaceRecords.addressesV4[target].delete(ip);
+                        } else {
+                            interfaceRecords.addressesV4[target].set(ip, record);
+                        }
+                        updated = true;
+                    }
+                }
+            }
+        }
+        if (updated) {
+            this.#discoveredIpRecords.set(netInterface, interfaceRecords);
+        }
+    }
+
+    /**
+     * Register Matter relevant IP records for later usage.
+     */
+    #registerIpRecords(ipAddresses: AnyDnsRecordWithExpiry[], netInterface: string) {
+        const interfaceRecords = this.#discoveredIpRecords.get(netInterface) ?? {};
+        for (const record of ipAddresses) {
+            const { recordType, name, value: ip, ttl } = record as DnsRecord<string>;
+            if (ttl === 0) continue; // Skip records with ttl=0
+            if (recordType === DnsRecordType.AAAA) {
+                interfaceRecords.addressesV6 = interfaceRecords.addressesV6 ?? {};
+                interfaceRecords.addressesV6[name] = interfaceRecords.addressesV6[name] ?? new Map();
+                interfaceRecords.addressesV6[name].set(ip, record);
+            } else if (this.#enableIpv4 && recordType === DnsRecordType.A) {
+                interfaceRecords.addressesV4 = interfaceRecords.addressesV4 ?? {};
+                interfaceRecords.addressesV4[name] = interfaceRecords.addressesV4[name] ?? new Map();
+                interfaceRecords.addressesV4[name].set(ip, record);
+            }
+        }
+        this.#discoveredIpRecords.set(netInterface, interfaceRecords);
     }
 
     #handleIpRecords(
@@ -832,12 +987,21 @@ export class MdnsScanner implements Scanner {
         target: string,
         netInterface: string,
     ): { value: string; ttl: number }[] {
-        const ipRecords = answers
-            .flatMap(answer => answer.addresses?.[target] ?? [])
-            .filter(
-                ({ recordType }) =>
-                    recordType === DnsRecordType.AAAA || (recordType === DnsRecordType.A && this.#enableIpv4),
-            );
+        const ipRecords = new Array<AnyDnsRecordWithExpiry>();
+        answers.forEach(answer => {
+            if (answer.addressesV6?.[target]) {
+                ipRecords.push(...answer.addressesV6[target].values());
+            }
+            if (this.#enableIpv4 && answer.addressesV4?.[target]) {
+                ipRecords.push(...answer.addressesV4[target].values());
+            }
+        });
+        if (ipRecords.length === 0) {
+            return [];
+        }
+
+        // Remember the IP records for later Matter usage
+        this.#registerIpRecords(ipRecords, netInterface); // Register for potential later usage
 
         // If an IP is included multiple times we only keep the latest record
         const collectedIps = new Map<string, { value: string; ttl: number }>();
@@ -950,6 +1114,7 @@ export class MdnsScanner implements Scanner {
             discoveredAt,
             ttl: ttl * 1000,
         };
+        const ipsInitiallyEmpty = device.addresses.size === 0;
         const { addresses } = device;
         if (ips.length > 0) {
             for (const { value: ip, ttl } of ips) {
@@ -967,9 +1132,9 @@ export class MdnsScanner implements Scanner {
                 addresses.set(address.ip, address);
             }
             device.addresses = addresses;
-            if (!this.#operationalDeviceRecords.has(matterName)) {
+            if (ipsInitiallyEmpty) {
                 logger.debug(
-                    `Added IPs for operational device ${matterName} to cache (interface ${netInterface}):`,
+                    `Added ${addresses.size} IPs for operational device ${matterName} to cache (interface ${netInterface}):`,
                     ...MdnsScanner.deviceAddressDiagnostics(addresses),
                 );
             }
@@ -1066,7 +1231,7 @@ export class MdnsScanner implements Scanner {
                 continue;
             }
 
-            const recordExisting = storedRecord.addresses.size > 0;
+            const recordAddressesKnown = storedRecord.addresses.size > 0;
 
             const ips = this.#handleIpRecords([formerAnswers, answers], target, netInterface);
             if (ips.length > 0) {
@@ -1099,6 +1264,11 @@ export class MdnsScanner implements Scanner {
                     `Requesting IP addresses for commissionable device ${record.name} (interface ${netInterface}).`,
                 );
                 this.#setQueryRecords(queryId, queries, answers);
+            } else if (!recordAddressesKnown) {
+                logger.debug(
+                    `Added ${storedRecord.addresses.size} IPs for commissionable device ${record.name} to cache (interface ${netInterface}):`,
+                    ...MdnsScanner.deviceAddressDiagnostics(storedRecord.addresses),
+                );
             }
             if (storedRecord.addresses.size === 0) continue;
 
@@ -1106,7 +1276,7 @@ export class MdnsScanner implements Scanner {
             if (queryId === undefined) continue;
 
             queryMissingDataForInstances.delete(record.name); // No need to query anymore, we have anything we need
-            this.#finishWaiter(queryId, true, recordExisting);
+            this.#finishWaiter(queryId, true, recordAddressesKnown);
         }
 
         // We have to query for the SRV records for the missing commissionable devices where we only had TXT records
@@ -1199,10 +1369,61 @@ export class MdnsScanner implements Scanner {
                 });
             }
             if (now > expires && !addresses.size) {
-                // device expired and also has no adresses anymore
+                // device expired and also has no addresses anymore
                 this.#commissionableDeviceRecords.delete(recordKey);
             }
         });
+
+        [...this.#activeAnnounceQueries.values()].forEach(({ answers }) => this.#expireStructuredAnswers(answers, now));
+
+        this.#discoveredIpRecords.forEach(answers => this.#expireStructuredAnswers(answers, now));
+    }
+
+    #expireStructuredAnswers(data: StructuredDnsAnswers, now: number) {
+        if (data.operational) {
+            Object.keys(data.operational).forEach(recordType => {
+                const type = parseInt(recordType);
+                data.operational![type] = data.operational![type].filter(
+                    ({ discoveredAt, ttl }) => now < discoveredAt + this.#effectiveTTL(ttl * 1000),
+                );
+                if (data.operational![type].length === 0) {
+                    delete data.operational![type];
+                }
+            });
+        }
+        if (data.commissionable) {
+            Object.keys(data.commissionable).forEach(recordType => {
+                const type = parseInt(recordType);
+                data.commissionable![type] = data.commissionable![type].filter(
+                    ({ discoveredAt, ttl }) => now < discoveredAt + this.#effectiveTTL(ttl * 1000),
+                );
+                if (data.commissionable![type].length === 0) {
+                    delete data.commissionable![type];
+                }
+            });
+        }
+        if (data.addressesV6) {
+            Object.keys(data.addressesV6).forEach(name => {
+                for (const [ip, { discoveredAt, ttl }] of data.addressesV6![name].entries()) {
+                    if (now < discoveredAt + this.#effectiveTTL(ttl * 1000)) continue; // not expired yet
+                    data.addressesV6![name].delete(ip);
+                }
+                if (data.addressesV6![name].size === 0) {
+                    delete data.addressesV6![name];
+                }
+            });
+        }
+        if (data.addressesV4) {
+            Object.keys(data.addressesV4).forEach(name => {
+                for (const [ip, { discoveredAt, ttl }] of data.addressesV4![name].entries()) {
+                    if (now < discoveredAt + this.#effectiveTTL(ttl * 1000)) continue; // not expired yet
+                    data.addressesV4![name].delete(ip);
+                }
+                if (data.addressesV4![name].size === 0) {
+                    delete data.addressesV4![name];
+                }
+            });
+        }
     }
 
     static discoveryDataDiagnostics(data: DiscoveryData) {

package/src/mdns/MdnsServer.ts

@@ -115,14 +115,14 @@ export class MdnsServer {
                     : [];
             if (knownAnswers.length > 0) {
                 for (const knownAnswersRecord of knownAnswers) {
-                    answers = answers.filter(record => !isDeepEqual(record, knownAnswersRecord));
+                    answers = answers.filter(record => !isDeepEqual(record, knownAnswersRecord, true));
                     if (answers.length === 0) break; // Nothing to send
                 }
                 if (answers.length === 0) continue; // Nothing to send
                 if (additionalRecords.length > 0) {
                     for (const knownAnswersRecord of knownAnswers) {
                         additionalRecords = additionalRecords.filter(
-                            record => !isDeepEqual(record, knownAnswersRecord),
+                            record => !isDeepEqual(record, knownAnswersRecord, true),
                         );
                     }
                 }
@@ -268,7 +268,8 @@ export class MdnsServer {
         ).catch(error => logger.error(error));
     }
 
-    async expireAnnouncements(announcedNetPort?: number, type?: AnnouncementType) {
+    async expireAnnouncements(options?: { announcedNetPort?: number; type?: AnnouncementType; forInstance?: string }) {
+        const { announcedNetPort, type, forInstance: instanceToExpire } = options ?? {};
         await MatterAggregateError.allSettled(
             this.#records.keys().map(async netInterface => {
                 const records = await this.#records.get(netInterface);
@@ -280,13 +281,25 @@ export class MdnsServer {
                         portType !== this.buildTypePortKey(type, announcedNetPort)
                     )
                         continue;
-                    let instanceName: string | undefined;
-                    portTypeRecords.forEach(record => {
+                    const recordsToProcess =
+                        instanceToExpire !== undefined
+                            ? portTypeRecords.filter(
+                                  ({ forInstance }) => forInstance !== undefined && instanceToExpire === forInstance,
+                              )
+                            : portTypeRecords;
+                    const instanceSet = new Set<string>();
+                    recordsToProcess.forEach(record => {
                         record.ttl = 0;
-                        if (instanceName === undefined && record.recordType === DnsRecordType.TXT) {
-                            instanceName = record.name;
+                        if (record.recordType === DnsRecordType.TXT) {
+                            instanceSet.add(record.name);
                         }
                     });
+                    const instanceName =
+                        instanceSet.size > 1
+                            ? "multiple"
+                            : instanceSet.size === 1
+                              ? Array.from(instanceSet.values())[0]
+                              : "";
                     logger.debug(
                         `Expiring records`,
                         Diagnostic.dict({

package/src/peer/ControllerCommissioningFlow.ts

@@ -10,7 +10,7 @@ import { GeneralCommissioning } from "#clusters/general-commissioning";
 import { NetworkCommissioning } from "#clusters/network-commissioning";
 import { OperationalCredentials } from "#clusters/operational-credentials";
 import { TimeSynchronizationCluster } from "#clusters/time-synchronization";
-import { Bytes, ChannelType, Crypto, Logger, MatterError, Time, UnexpectedDataError, repackErrorAs } from "#general";
+import { Bytes, ChannelType, Crypto, Logger, MatterError, repackErrorAs, Time, UnexpectedDataError } from "#general";
 import {
     ClusterId,
     ClusterType,
@@ -107,6 +107,9 @@ type CommissioningStep = {
 
     /** Logic function to execute */
     stepLogic: () => Promise<CommissioningStepResult>;
+
+    /** Optional flag to indicate that the failsafe timer should be rearmed in any case before this step. */
+    reArmFailsafe?: boolean;
 };
 
 /** Data that are collected initially or through the commissioning process and can be used also by other steps. */
@@ -194,9 +197,15 @@ export class ControllerCommissioningFlow {
     async executeCommissioning() {
         this.#sortSteps();
 
+        let failSafeTimerReArmedAfterPreviousStep = false;
         for (const step of this.#commissioningSteps) {
             logger.info(`Executing commissioning step ${step.stepNumber}.${step.subStepNumber}: ${step.name}`);
             try {
+                if (step.reArmFailsafe && !failSafeTimerReArmedAfterPreviousStep) {
+                    logger.debug(`Re-Arming failsafe timer before executing step`);
+                    await this.#armFailsafe();
+                }
+                failSafeTimerReArmedAfterPreviousStep = false;
                 const result = await step.stepLogic();
                 this.#setCommissioningStepResult(step, result);
 
@@ -222,6 +231,7 @@ export class ControllerCommissioningFlow {
                             )}s elapsed since last arm failsafe, re-arming failsafe`,
                         );
                         await this.#armFailsafe();
+                        failSafeTimerReArmedAfterPreviousStep = true;
                     }
                 }
 
@@ -369,6 +379,7 @@ export class ControllerCommissioningFlow {
                     stepNumber: 12, // includes step 13
                     subStepNumber: 2,
                     name: "NetworkCommissioning.Wifi",
+                    reArmFailsafe: true,
                     stepLogic: () => this.#configureNetworkWifi(),
                 });
             }
@@ -377,6 +388,7 @@ export class ControllerCommissioningFlow {
                     stepNumber: 12, // includes step 13
                     subStepNumber: 3,
                     name: "NetworkCommissioning.Thread",
+                    reArmFailsafe: true,
                     stepLogic: () => this.#configureNetworkThread(),
                 });
             }
@@ -390,6 +402,7 @@ export class ControllerCommissioningFlow {
             stepNumber: 14, // includes step 15 (CASE connection)
             subStepNumber: 1,
             name: "Reconnect",
+            reArmFailsafe: true,
             stepLogic: () => this.#reconnectWithDevice(),
         });
 
@@ -1149,13 +1162,45 @@ export class ControllerCommissioningFlow {
      *
      */
     async #reconnectWithDevice() {
-        logger.debug("Reconnecting with device ...");
+        const isConcurrentFlow = this.#collectedCommissioningData.supportsConcurrentConnection !== false;
+
+        logger.debug(`Reconnecting with device with ${isConcurrentFlow ? "concurrent" : "non-concurrent"} flow ...`);
+
+        // Reconnection with discovery could take longer then the default failsafe time, so we need to
+        // re-arm the failsafe when we are in a concurrent commissioning flow also in parallel to
+        // the operative reconnection
+        // TODO: Check whats needed for non-concurrent commissioning flows (maybe arm initially longer?)
+        const reArmFailsafeInterval = Time.getPeriodicTimer(
+            "Re-Arm Failsafe during reconnect",
+            this.#failSafeTimeMs / 2,
+            () => {
+                const now = Time.nowMs();
+                if (this.#commissioningExpiryTime !== undefined && now < this.#commissioningExpiryTime) {
+                    logger.error(
+                        `Re-Arm Failsafe Timer during reconnect with device. Time left: ${Math.round((this.#commissioningExpiryTime - now) / 1000)}s`,
+                    );
+                    this.#armFailsafe().catch(error => {
+                        logger.error("Error while re-arming failsafe during reconnect", error);
+                        reArmFailsafeInterval.stop();
+                    });
+                } else {
+                    // Stop as soon as we are over the maximum commissioning time
+                    reArmFailsafeInterval.stop();
+                }
+            },
+        );
+        if (isConcurrentFlow) {
+            reArmFailsafeInterval.start();
+        }
+
         const transitionResult = await this.#transitionToCase(
             this.#interactionClient.address,
             // Assume concurrent connections are supported if not know (which should not be the case when we came here)
-            this.#collectedCommissioningData.supportsConcurrentConnection ?? true,
+            isConcurrentFlow,
         );
 
+        reArmFailsafeInterval.stop();
+
         if (transitionResult === undefined) {
             logger.debug("CASE commissioning handled externally, terminating commissioning flow");
             return {