@matter/protocol 0.12.0-alpha.0-20241220-ad0dea627 → 0.12.0-alpha.0-20241220-c66941cd7

package/src/mdns/MdnsScanner.ts

@@ -70,6 +70,12 @@ type OperationalDeviceRecordWithExpire = Omit<OperationalDevice, "addresses"> &
         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
+};
+
 /** 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;
 
@@ -96,7 +102,7 @@ export class MdnsScanner implements Scanner {
         );
     }
 
-    readonly #activeAnnounceQueries = new Map<string, { queries: DnsQuery[]; answers: DnsRecord<any>[] }>();
+    readonly #activeAnnounceQueries = new Map<string, { queries: DnsQuery[]; answers: StructuredDnsAnswers }>();
     #queryTimer?: Timer;
     #nextAnnounceIntervalSeconds = START_ANNOUNCE_INTERVAL_SECONDS;
 
@@ -108,6 +114,7 @@ export class MdnsScanner implements Scanner {
             resolver: () => void;
             timer?: Timer;
             resolveOnUpdatedRecords: boolean;
+            cancelResolver?: (value: void) => void;
         }
     >();
     readonly #periodicTimer: Timer;
@@ -141,7 +148,9 @@ export class MdnsScanner implements Scanner {
         this.#queryTimer?.stop();
         const allQueries = Array.from(this.#activeAnnounceQueries.values());
         const queries = allQueries.flatMap(({ queries }) => queries);
-        const answers = allQueries.flatMap(({ answers }) => answers);
+        const answers = allQueries.flatMap(({ answers }) =>
+            Object.values(answers).flatMap(answer => Object.values(answer).flatMap(records => records)),
+        );
 
         this.#queryTimer = Time.getTimer("MDNS discovery", this.#nextAnnounceIntervalSeconds * 1000, () =>
             this.#sendQueries(),
@@ -210,7 +219,7 @@ export class MdnsScanner implements Scanner {
      * Set new DnsQuery records to the list of active queries to discover devices in the network and start sending them
      * out. When entry already exists the query is overwritten and answers are always added.
      */
-    #setQueryRecords(queryId: string, queries: DnsQuery[], answers: DnsRecord<any>[] = []) {
+    #setQueryRecords(queryId: string, queries: DnsQuery[], answers: StructuredDnsAnswers = {}) {
         const activeExistingQuery = this.#activeAnnounceQueries.get(queryId);
         if (activeExistingQuery) {
             const { queries: existingQueries } = activeExistingQuery;
@@ -231,7 +240,7 @@ export class MdnsScanner implements Scanner {
                 return;
             }
             queries = [...newQueries, ...existingQueries];
-            answers = [...activeExistingQuery.answers, ...answers];
+            answers = this.#combineStructuredAnswers(activeExistingQuery.answers, answers);
         }
         this.#activeAnnounceQueries.set(queryId, { queries, answers });
         logger.debug(`Set ${queries.length} query records for query ${queryId}: ${Logger.toJSON(queries)}`);
@@ -241,7 +250,9 @@ export class MdnsScanner implements Scanner {
     }
 
     #getActiveQueryEarlierAnswers() {
-        return Array.from(this.#activeAnnounceQueries.values()).flatMap(({ answers }) => answers);
+        return this.#combineStructuredAnswers(
+            ...[...this.#activeAnnounceQueries.values()].map(({ answers }) => answers),
+        );
     }
 
     /**
@@ -314,13 +325,21 @@ export class MdnsScanner implements Scanner {
      * Registers a deferred promise for a specific queryId together with a timeout and return the promise.
      * The promise will be resolved when the timer runs out latest.
      */
-    async #registerWaiterPromise(queryId: string, timeoutSeconds?: number, resolveOnUpdatedRecords = true) {
+    async #registerWaiterPromise(
+        queryId: string,
+        timeoutSeconds?: number,
+        resolveOnUpdatedRecords = true,
+        cancelResolver?: (value: void) => void,
+    ) {
         const { promise, resolver } = createPromise<void>();
         const timer =
             timeoutSeconds !== undefined
-                ? Time.getTimer("MDNS timeout", timeoutSeconds * 1000, () => this.#finishWaiter(queryId, true)).start()
+                ? Time.getTimer("MDNS timeout", timeoutSeconds * 1000, () => {
+                      cancelResolver?.();
+                      this.#finishWaiter(queryId, true);
+                  }).start()
                 : undefined;
-        this.#recordWaiters.set(queryId, { resolver, timer, resolveOnUpdatedRecords });
+        this.#recordWaiters.set(queryId, { resolver, timer, resolveOnUpdatedRecords, cancelResolver });
         logger.debug(
             `Registered waiter for query ${queryId} with ${
                 timeoutSeconds !== undefined ? `timeout ${timeoutSeconds} seconds` : "no timeout"
@@ -399,6 +418,9 @@ export class MdnsScanner implements Scanner {
 
     cancelCommissionableDeviceDiscovery(identifier: CommissionableDeviceIdentifiers, resolvePromise = true) {
         const queryId = this.#buildCommissionableQueryIdentifier(identifier);
+        const { cancelResolver } = this.#recordWaiters.get(queryId) ?? {};
+        // Mark as cancelled to not loop further in discovery, if cancel resolver is used
+        cancelResolver?.();
         this.#finishWaiter(queryId, resolvePromise);
     }
 
@@ -613,10 +635,8 @@ export class MdnsScanner implements Scanner {
     }
 
     /**
-     * Discovers commissionable devices based on a defined identifier and returns the first found entries. If already a
-     * @param identifier
-     * @param callback
-     * @param timeoutSeconds
+     * Discovers commissionable devices based on a defined identifier and returns the first found entries.
+     * If an own cancelSignal promise is used the discovery can only be cancelled via this signal!
      */
     async findCommissionableDevicesContinuously(
         identifier: CommissionableDeviceIdentifiers,
@@ -625,17 +645,26 @@ export class MdnsScanner implements Scanner {
         cancelSignal?: Promise<void>,
     ): Promise<CommissionableDevice[]> {
         const discoveredDevices = new Set<string>();
-        const now = Time.nowMs();
 
-        const discoveryEndTime = timeoutSeconds ? now + timeoutSeconds * 1000 : undefined;
+        const discoveryEndTime = timeoutSeconds ? Time.nowMs() + timeoutSeconds * 1000 : undefined;
         const queryId = this.#buildCommissionableQueryIdentifier(identifier);
         this.#setQueryRecords(queryId, this.#getCommissionableQueryRecords(identifier));
 
+        let queryResolver: ((value: void) => void) | undefined;
+        if (cancelSignal === undefined) {
+            const { promise, resolver } = createPromise<void>();
+            cancelSignal = promise;
+            queryResolver = resolver;
+        }
+
         let canceled = false;
         cancelSignal?.then(
             () => {
                 canceled = true;
-                this.#finishWaiter(queryId, true);
+                if (queryResolver === undefined) {
+                    // Always finish when cancelSignal parameter was used, else cancelling is done separately
+                    this.#finishWaiter(queryId, true);
+                }
             },
             cause => {
                 logger.error("Unexpected error canceling commissioning", cause);
@@ -653,12 +682,12 @@ export class MdnsScanner implements Scanner {
 
             let remainingTime;
             if (discoveryEndTime !== undefined) {
-                const remainingTime = Math.ceil((discoveryEndTime - now) / 1000);
+                remainingTime = discoveryEndTime - Time.nowMs();
                 if (remainingTime <= 0) {
                     break;
                 }
             }
-            await this.#registerWaiterPromise(queryId, remainingTime, false);
+            await this.#registerWaiterPromise(queryId, remainingTime, false, queryResolver);
         }
         return this.#getCommissionableDeviceRecords(identifier);
     }
@@ -681,6 +710,99 @@ export class MdnsScanner implements Scanner {
         );
     }
 
+    /** Converts the discovery data into a structured format for performant access. */
+    #structureAnswers(...answersList: DnsRecord<any>[][]): StructuredDnsAnswers {
+        const structuredAnswers: StructuredDnsAnswers = {};
+
+        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);
+                } 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);
+                }
+            }),
+        );
+
+        return structuredAnswers;
+    }
+
+    #combineStructuredAnswers(...answersList: StructuredDnsAnswers[]): StructuredDnsAnswers {
+        const combinedAnswers: {
+            operational?: Record<number, Map<string, DnsRecord<any>>>;
+            commissionable?: Record<number, Map<string, DnsRecord<any>>>;
+            addresses?: Record<string, DnsRecord<any>[]>;
+        } = {};
+
+        for (const answers of answersList) {
+            if (answers.operational) {
+                combinedAnswers.operational = combinedAnswers.operational ?? {};
+                for (const [recordType, records] of Object.entries(answers.operational) as unknown as [
+                    number,
+                    DnsRecord<any>[],
+                ][]) {
+                    combinedAnswers.operational[recordType] = combinedAnswers.operational[recordType] ?? new Map();
+                    records.forEach(record => {
+                        combinedAnswers.operational![recordType].set(record.name, record);
+                    });
+                }
+            }
+            if (answers.commissionable) {
+                combinedAnswers.commissionable = combinedAnswers.commissionable ?? {};
+                for (const [recordType, records] of Object.entries(answers.commissionable) as unknown as [
+                    number,
+                    DnsRecord<any>[],
+                ][]) {
+                    combinedAnswers.commissionable[recordType] =
+                        combinedAnswers.commissionable[recordType] ?? new Map();
+                    records.forEach(record => {
+                        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 [
+                    string,
+                    DnsRecord<any>[],
+                ][]) {
+                    combinedAnswers.addresses[name] = combinedAnswers.addresses[name] ?? [];
+                    // IP address consolidation happens when they are selected for a device
+                    combinedAnswers.addresses[name].push(...records);
+                }
+            }
+        }
+
+        return {
+            operational: combinedAnswers.operational
+                ? Object.fromEntries(
+                      Object.entries(combinedAnswers.operational).map(([recordType, records]) => [
+                          recordType,
+                          Array.from(records.values()),
+                      ]),
+                  )
+                : undefined,
+            commissionable: combinedAnswers.commissionable
+                ? Object.fromEntries(
+                      Object.entries(combinedAnswers.commissionable).map(([recordType, records]) => [
+                          recordType,
+                          Array.from(records.values()),
+                      ]),
+                  )
+                : undefined,
+            addresses: combinedAnswers.addresses,
+        };
+    }
+
     /**
      * Main method to handle all incoming DNS messages.
      * It will parse the message and check if it contains relevant discovery records.
@@ -692,58 +814,62 @@ export class MdnsScanner implements Scanner {
         if (message.messageType !== DnsMessageType.Response && message.messageType !== DnsMessageType.TruncatedResponse)
             return;
 
-        const answers = [...message.answers, ...message.additionalRecords];
+        const answers = this.#structureAnswers([...message.answers, ...message.additionalRecords]);
 
+        const formerAnswers = this.#getActiveQueryEarlierAnswers();
         // Check if we got operational discovery records and handle them
-        if (this.#handleOperationalRecords(answers, this.#getActiveQueryEarlierAnswers(), netInterface)) return;
+        this.#handleOperationalRecords(answers, formerAnswers, netInterface);
 
         // Else check if we got commissionable discovery records and handle them
-        this.#handleCommissionableRecords(answers, this.#getActiveQueryEarlierAnswers(), netInterface);
+        this.#handleCommissionableRecords(answers, formerAnswers, netInterface);
     }
 
     #handleIpRecords(
-        answers: DnsRecord<any>[],
+        answers: StructuredDnsAnswers[],
         target: string,
         netInterface: string,
     ): { value: string; ttl: number }[] {
-        const ipRecords = answers.filter(
-            ({ name, recordType }) =>
-                ((recordType === DnsRecordType.A && this.#enableIpv4) || recordType === DnsRecordType.AAAA) &&
-                name === target,
-        );
-        return (ipRecords as DnsRecord<string>[]).map(({ value, ttl }) => ({
-            value: value.startsWith("fe80::") ? `${value}%${netInterface}` : value,
-            ttl,
-        }));
+        const ipRecords = answers
+            .flatMap(answer => answer.addresses?.[target] ?? [])
+            .filter(
+                ({ recordType }) =>
+                    recordType === DnsRecordType.AAAA || (recordType === DnsRecordType.A && this.#enableIpv4),
+            );
+
+        // If an IP is included multiple times we only keep the latest record
+        const collectedIps = new Map<string, { value: string; ttl: number }>();
+        ipRecords.forEach(record => {
+            const { value, ttl } = record as DnsRecord<string>;
+            if (value.startsWith("fe80::")) {
+                collectedIps.set(value, { value: `${value}%${netInterface}`, ttl });
+            } else {
+                collectedIps.set(value, { value, ttl });
+            }
+        });
+        return [...collectedIps.values()];
     }
 
-    #handleOperationalRecords(answers: DnsRecord<any>[], formerAnswers: DnsRecord<any>[], netInterface: string) {
-        let recordsHandled = false;
+    #handleOperationalRecords(
+        answers: StructuredDnsAnswers,
+        formerAnswers: StructuredDnsAnswers,
+        netInterface: string,
+    ) {
         // Does the message contain data for an operational service?
-        const operationalTxtRecords = answers.filter(
-            ({ name, recordType }) => recordType === DnsRecordType.TXT && name.endsWith(MATTER_SERVICE_QNAME),
-        );
-        if (operationalTxtRecords.length) {
-            operationalTxtRecords.forEach(record => this.#handleOperationalTxtRecord(record, netInterface));
-            recordsHandled = true;
-        }
+        if (!answers.operational) return;
 
-        let operationalSrvRecords = answers.filter(
-            ({ name, recordType }) => recordType === DnsRecordType.SRV && name.endsWith(MATTER_SERVICE_QNAME),
-        );
-        if (!operationalSrvRecords.length) {
-            operationalSrvRecords = formerAnswers.filter(
-                ({ name, recordType }) => recordType === DnsRecordType.SRV && name.endsWith(MATTER_SERVICE_QNAME),
-            );
+        const operationalTxtRecords = answers.operational[DnsRecordType.TXT] ?? [];
+        operationalTxtRecords.forEach(record => this.#handleOperationalTxtRecord(record, netInterface));
+
+        let operationalSrvRecords = answers.operational[DnsRecordType.SRV] ?? [];
+        if (!operationalSrvRecords.length && formerAnswers.operational) {
+            operationalSrvRecords = formerAnswers.operational[DnsRecordType.SRV] ?? [];
         }
 
         if (operationalSrvRecords.length) {
             operationalSrvRecords.forEach(record =>
                 this.#handleOperationalSrvRecord(record, answers, formerAnswers, netInterface),
             );
-            recordsHandled = true;
         }
-        return recordsHandled;
     }
 
     #handleOperationalTxtRecord(record: DnsRecord<any>, netInterface: string) {
@@ -791,8 +917,8 @@ export class MdnsScanner implements Scanner {
 
     #handleOperationalSrvRecord(
         record: DnsRecord<any>,
-        answers: DnsRecord<any>[],
-        formerAnswers: DnsRecord<any>[],
+        answers: StructuredDnsAnswers,
+        formerAnswers: StructuredDnsAnswers,
         netInterface: string,
     ) {
         const {
@@ -813,7 +939,7 @@ export class MdnsScanner implements Scanner {
             return true;
         }
 
-        const ips = this.#handleIpRecords([...answers, ...formerAnswers], target, netInterface);
+        const ips = this.#handleIpRecords([formerAnswers, answers], target, netInterface);
         const deviceExisted = this.#operationalDeviceRecords.has(matterName);
         const device = this.#operationalDeviceRecords.get(matterName) ?? {
             deviceIdentifier: matterName,
@@ -861,18 +987,23 @@ export class MdnsScanner implements Scanner {
         return true;
     }
 
-    #handleCommissionableRecords(answers: DnsRecord<any>[], formerAnswers: DnsRecord<any>[], netInterface: string) {
+    #handleCommissionableRecords(
+        answers: StructuredDnsAnswers,
+        formerAnswers: StructuredDnsAnswers,
+        netInterface: string,
+    ) {
         // Does the message contain a SRV record for an operational service we are interested in?
-        let commissionableRecords = answers.filter(({ name }) => name.endsWith(MATTER_COMMISSION_SERVICE_QNAME));
-        if (!commissionableRecords.length) {
-            commissionableRecords = formerAnswers.filter(({ name }) => name.endsWith(MATTER_COMMISSION_SERVICE_QNAME));
-            if (!commissionableRecords.length) return;
+        let commissionableRecords = answers.commissionable ?? {};
+        if (!commissionableRecords[DnsRecordType.SRV]?.length && !commissionableRecords[DnsRecordType.TXT]?.length) {
+            commissionableRecords = formerAnswers.commissionable ?? {};
+            if (!commissionableRecords[DnsRecordType.SRV]?.length && !commissionableRecords[DnsRecordType.TXT]?.length)
+                return;
         }
 
         const queryMissingDataForInstances = new Set<string>();
 
         // First process the TXT records
-        const txtRecords = commissionableRecords.filter(({ recordType }) => recordType === DnsRecordType.TXT);
+        const txtRecords = commissionableRecords[DnsRecordType.TXT] ?? [];
         for (const record of txtRecords) {
             const { name, ttl } = record;
             if (ttl === 0) {
@@ -916,7 +1047,7 @@ export class MdnsScanner implements Scanner {
         }
 
         // We got SRV records for the instance ID, so we know the host name now and can collect the IP addresses
-        const srvRecords = commissionableRecords.filter(({ recordType }) => recordType === DnsRecordType.SRV);
+        const srvRecords = commissionableRecords[DnsRecordType.SRV] ?? [];
         for (const record of srvRecords) {
             const storedRecord = this.#commissionableDeviceRecords.get(record.name);
             if (storedRecord === undefined) continue;
@@ -934,7 +1065,7 @@ export class MdnsScanner implements Scanner {
 
             const recordExisting = storedRecord.addresses.size > 0;
 
-            const ips = this.#handleIpRecords([...answers, ...formerAnswers], target, netInterface);
+            const ips = this.#handleIpRecords([formerAnswers, answers], target, netInterface);
             if (ips.length > 0) {
                 for (const { value: ip, ttl } of ips) {
                     if (ttl === 0) {

package/src/mdns/MdnsServer.ts

@@ -61,6 +61,7 @@ export class MdnsServer {
         15 * 60 * 1000 /* 15mn - also matches maximum commissioning window time. */,
     );
     readonly #recordLastSentAsMulticastAnswer = new Map<string, number>();
+    readonly #recordLastSentAsUnicastAnswer = new Map<string, number>();
 
     readonly #network: Network;
     readonly #multicastServer: UdpMulticastServer;
@@ -75,8 +76,8 @@ export class MdnsServer {
         this.#netInterface = netInterface;
     }
 
-    buildDnsRecordKey(record: DnsRecord<any>, netInterface?: string) {
-        return `${record.name}-${record.recordClass}-${record.recordType}-${netInterface}`;
+    buildDnsRecordKey(record: DnsRecord<any>, netInterface?: string, unicastTarget?: string) {
+        return `${record.name}-${record.recordClass}-${record.recordType}-${netInterface}-${unicastTarget}`;
     }
 
     buildTypePortKey(type: AnnouncementType, port: number) {
@@ -128,30 +129,42 @@ export class MdnsServer {
 
             const now = Time.nowMs();
             let uniCastResponse = queries.filter(query => !query.uniCastResponse).length === 0;
-            const answersTimeSinceLastMultiCast = answers.map(answer => ({
+            const answersTimeSinceLastSent = answers.map(answer => ({
                 timeSinceLastMultiCast:
                     now -
                     (this.#recordLastSentAsMulticastAnswer.get(this.buildDnsRecordKey(answer, netInterface)) ?? 0),
+                timeSinceLastUniCast:
+                    now -
+                    (this.#recordLastSentAsUnicastAnswer.get(this.buildDnsRecordKey(answer, netInterface, remoteIp)) ??
+                        0),
                 ttl: answer.ttl,
             }));
             if (
                 uniCastResponse &&
-                answersTimeSinceLastMultiCast.filter(
+                answersTimeSinceLastSent.some(
                     ({ timeSinceLastMultiCast, ttl }) => timeSinceLastMultiCast > (ttl / 4) * 1000,
-                ).length > 0
+                )
             ) {
                 // If the query is for unicast response, still send as multicast if they were last sent as multicast longer then 1/4 of their ttl
                 uniCastResponse = false;
             }
             if (!uniCastResponse) {
-                answers = answers.filter(
-                    (_, index) => answersTimeSinceLastMultiCast[index].timeSinceLastMultiCast > 1000,
-                );
+                answers = answers.filter((_, index) => answersTimeSinceLastSent[index].timeSinceLastMultiCast > 1000);
                 if (answers.length === 0) continue; // Nothing to send
 
                 answers.forEach(answer =>
                     this.#recordLastSentAsMulticastAnswer.set(this.buildDnsRecordKey(answer, netInterface), now),
                 );
+            } else {
+                answers = answers.filter((_, index) => answersTimeSinceLastSent[index].timeSinceLastUniCast > 1000);
+                if (answers.length === 0) continue; // Nothing to send
+
+                answers.forEach(answer =>
+                    this.#recordLastSentAsUnicastAnswer.set(
+                        this.buildDnsRecordKey(answer, netInterface, remoteIp),
+                        now,
+                    ),
+                );
             }
 
             this.#sendRecords(
@@ -290,6 +303,7 @@ export class MdnsServer {
         );
         await this.#records.clear();
         this.#recordLastSentAsMulticastAnswer.clear();
+        this.#recordLastSentAsUnicastAnswer.clear();
     }
 
     async setRecordsGenerator(
@@ -299,12 +313,14 @@ export class MdnsServer {
     ) {
         await this.#records.clear();
         this.#recordLastSentAsMulticastAnswer.clear();
+        this.#recordLastSentAsUnicastAnswer.clear();
         this.#recordsGenerator.set(this.buildTypePortKey(type, hostPort), generator);
     }
 
     async close() {
         await this.#records.close();
         this.#recordLastSentAsMulticastAnswer.clear();
+        this.#recordLastSentAsUnicastAnswer.clear();
         await this.#multicastServer.close();
     }
 

package/src/peer/ControllerDiscovery.ts

@@ -193,7 +193,7 @@ export class ControllerDiscovery {
         while (true) {
             logger.debug(
                 `Server addresses to try: ${Array.from(addresses)
-                    .map(([addressString, { device }]) => `${device?.DN}: ${addressString}`)
+                    .map(([addressString, { device }]) => `${addressString}${device?.DN ? ` (${device.DN})` : ""}`)
                     .join(",")}`,
             );
 

package/src/peer/PeerSet.ts

@@ -82,7 +82,8 @@ export interface DiscoveryOptions {
 interface RunningDiscovery {
     type: NodeDiscoveryType;
     promises?: (() => Promise<MessageChannel>)[];
-    timer?: Timer;
+    stopTimerFunc?: (() => void) | undefined;
+    mdnsScanner?: MdnsScanner;
 }
 
 /**
@@ -356,9 +357,8 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     }
 
     async close() {
-        const mdnsScanner = this.#scanners.scannerFor(ChannelType.UDP) as MdnsScanner | undefined;
-        for (const [address, { timer }] of this.#runningPeerDiscoveries.entries()) {
-            timer?.stop();
+        for (const [address, { stopTimerFunc, mdnsScanner }] of this.#runningPeerDiscoveries.entries()) {
+            stopTimerFunc?.();
 
             // This ends discovery without triggering promises
             mdnsScanner?.cancelOperationalDeviceDiscovery(this.#sessions.fabricFor(address), address.nodeId, false);
@@ -469,21 +469,26 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
         const discoveryPromises = new Array<() => Promise<MessageChannel>>();
         let reconnectionPollingTimer: Timer | undefined;
+        let stopTimerFunc: (() => void) | undefined;
 
-        if (operationalAddress !== undefined) {
+        const lastOperationalAddress = this.#getLastOperationalAddress(address);
+        if (lastOperationalAddress !== undefined) {
             // Additionally to general discovery we also try to poll the formerly known operational address
             if (requestedDiscoveryType === NodeDiscoveryType.FullDiscovery) {
                 const { promise, resolver, rejecter } = createPromise<MessageChannel>();
 
+                logger.debug(
+                    `Starting reconnection polling for ${serverAddressToString(lastOperationalAddress)} (Interval ${RECONNECTION_POLLING_INTERVAL_MS / 1000}s)`,
+                );
                 reconnectionPollingTimer = Time.getPeriodicTimer(
                     "Controller reconnect",
                     RECONNECTION_POLLING_INTERVAL_MS,
                     async () => {
                         try {
-                            logger.debug(`Polling for device at ${serverAddressToString(operationalAddress)} ...`);
+                            logger.debug(`Polling for device at ${serverAddressToString(lastOperationalAddress)} ...`);
                             const result = await this.#reconnectKnownAddress(
                                 address,
-                                operationalAddress,
+                                lastOperationalAddress,
                                 discoveryData,
                             );
                             if (result !== undefined && reconnectionPollingTimer?.isRunning) {
@@ -509,6 +514,11 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                     },
                 ).start();
 
+                stopTimerFunc = () => {
+                    reconnectionPollingTimer?.stop();
+                    reconnectionPollingTimer = undefined;
+                    rejecter(new NoResponseTimeoutError("Reconnection polling cancelled"));
+                };
                 discoveryPromises.push(() => promise);
             }
         }
@@ -521,8 +531,8 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                 timeoutSeconds,
                 timeoutSeconds === undefined,
             );
-            const { timer } = this.#runningPeerDiscoveries.get(address) ?? {};
-            timer?.stop();
+            const { stopTimerFunc } = this.#runningPeerDiscoveries.get(address) ?? {};
+            stopTimerFunc?.();
             this.#runningPeerDiscoveries.delete(address);
 
             const { result } = await ControllerDiscovery.iterateServerAddresses(
@@ -551,10 +561,13 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         this.#runningPeerDiscoveries.set(address, {
             type: requestedDiscoveryType,
             promises: discoveryPromises,
-            timer: reconnectionPollingTimer,
+            stopTimerFunc,
+            mdnsScanner,
         });
 
-        return await anyPromise(discoveryPromises).finally(() => this.#runningPeerDiscoveries.delete(address));
+        return await anyPromise(discoveryPromises).finally(() => {
+            this.#runningPeerDiscoveries.delete(address);
+        });
     }
 
     async #reconnectKnownAddress(
@@ -713,6 +726,16 @@ 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)) {
+            logger.info(`Found ${address} during discovery, cancel discovery.`);
+            // We are currently discovering this node, so we need to update the discovery data
+            const { mdnsScanner } = this.#runningPeerDiscoveries.get(address) ?? {};
+
+            // This ends discovery and triggers the promises
+            mdnsScanner?.cancelOperationalDeviceDiscovery(this.#sessions.fabricFor(address), address.nodeId, true);
+        }
     }
 
     #getLastOperationalAddress(address: PeerAddress) {

package/src/protocol/MessageExchange.ts

@@ -49,6 +49,12 @@ export type ExchangeSendOptions = {
      */
     expectAckOnly?: boolean;
 
+    /**
+     * If the message is part of a multiple message interaction, this flag indicates that it is not allowed
+     * to establish a new exchange
+     */
+    multipleMessageInteraction?: boolean;
+
     /**
      * Defined an expected processing time by the responder for the message. This is used to calculate the final
      * timeout for responses together with the normal retransmission logic when MRP is used.