@matter/protocol 0.16.0-alpha.0-20251001-7eb06da95 → 0.16.0-alpha.0-20251004-92135c7df

package/src/interaction/InteractionMessenger.ts

@@ -16,14 +16,20 @@ import {
     NoResponseTimeoutError,
     UnexpectedDataError,
 } from "#general";
+import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
+import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
 import { Specification } from "#model";
 import { ChannelNotConnectedError } from "#protocol/MessageChannel.js";
 import {
+    AttributeId,
+    ClusterId,
+    EndpointNumber,
     ReceivedStatusResponseError,
     Status,
     StatusCode,
     StatusResponseError,
     TlvAny,
+    TlvAttributeReport,
     TlvDataReport,
     TlvDataReportForSend,
     TlvDataVersionFilter,
@@ -799,8 +805,105 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
         return message;
     }
 
-    async readAggregateDataReport(expectedSubscriptionIds?: number[]): Promise<DataReport> {
-        let result: DataReport | undefined;
+    /**
+     * Reads data report stream and aggregates them into a single report.
+     * Additionally, a callback can be provided that is called for each cluster chunk received.
+     */
+    async readAggregateDataReport(
+        chunkListener?: (chunk: DecodedAttributeReportValue<any>[]) => Promise<void>,
+        expectedSubscriptionIds?: number[],
+    ): Promise<DecodedDataReport> {
+        let result: DecodedDataReport | undefined = undefined;
+        let currentEndpointId: EndpointNumber | undefined = undefined;
+        let currentClusterId: ClusterId | undefined = undefined;
+        const currentClusterChunk = new Array<DecodedAttributeReportValue<any>>();
+        let pendingAttributeReports: TypeFromSchema<typeof TlvAttributeReport>[] | undefined = undefined;
+
+        const handleAttributeReportEntries = (
+            attributeReports: TypeFromSchema<typeof TlvAttributeReport>[] | undefined,
+            previousPendingAttributeReports: TypeFromSchema<typeof TlvAttributeReport>[] | undefined,
+        ) => {
+            if (previousPendingAttributeReports?.length) {
+                attributeReports = attributeReports ?? [];
+                attributeReports.unshift(...previousPendingAttributeReports);
+            }
+
+            let lastAttributeDataIndex = -1;
+            if (attributeReports?.length) {
+                let lastEndpointId: EndpointNumber | undefined = undefined;
+                let lastClusterId: ClusterId | undefined = undefined;
+                let lastAttributeId: AttributeId | undefined = undefined;
+                for (let i = attributeReports.length - 1; i >= 0; i--) {
+                    const attributeReport = attributeReports[i];
+                    if (attributeReport.attributeData === undefined) {
+                        break; // No data report, so nothing more to search for
+                    }
+                    const {
+                        path: { endpointId, clusterId, attributeId },
+                    } = attributeReport.attributeData;
+                    if (lastEndpointId === undefined && lastClusterId === undefined && lastAttributeId === undefined) {
+                        // Remember path of the last attribute data entry and check if previous entries match
+                        lastEndpointId = endpointId;
+                        lastClusterId = clusterId;
+                        lastAttributeId = attributeId;
+                    }
+                    if (
+                        endpointId === lastEndpointId &&
+                        clusterId === lastClusterId &&
+                        attributeId === lastAttributeId
+                    ) {
+                        lastAttributeDataIndex = i;
+                        continue;
+                    }
+                    break; // We found an attribute that does not match the last one, so we are done
+                }
+
+                if (lastAttributeDataIndex > 0) {
+                    return attributeReports.splice(lastAttributeDataIndex);
+                }
+            }
+        };
+
+        const processDecodedReport = async (
+            decodedReport: DecodedDataReport,
+            result: DecodedDataReport | undefined,
+        ) => {
+            if (!result) {
+                result = decodedReport;
+            } else {
+                if (!result.attributeReports) {
+                    result.attributeReports = decodedReport.attributeReports;
+                } else {
+                    result.attributeReports.push(...decodedReport.attributeReports);
+                }
+                if (Array.isArray(decodedReport.eventReports)) {
+                    if (!result.eventReports) {
+                        result.eventReports = decodedReport.eventReports;
+                    } else {
+                        result.eventReports.push(...decodedReport.eventReports);
+                    }
+                }
+            }
+
+            if (chunkListener !== undefined && decodedReport.attributeReports) {
+                for (const data of decodedReport.attributeReports) {
+                    const {
+                        path: { endpointId, clusterId },
+                    } = data;
+                    if (currentEndpointId !== endpointId || currentClusterId !== clusterId) {
+                        // We switched the cluster, so we need to send the current chunk first
+                        if (currentClusterChunk.length > 0) {
+                            await chunkListener(currentClusterChunk);
+                            currentClusterChunk.length = 0;
+                        }
+                        currentEndpointId = endpointId;
+                        currentClusterId = clusterId;
+                    }
+                    currentClusterChunk.push(data);
+                }
+            }
+            return result;
+        };
 
         for await (const report of this.readDataReports()) {
             if (expectedSubscriptionIds !== undefined) {
@@ -823,24 +926,25 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
                 throw new UnexpectedDataError(`Invalid subscription ID ${report.subscriptionId} received`);
             }
 
-            if (!result) {
-                result = report;
-            } else {
-                if (Array.isArray(report.attributeReports)) {
-                    if (!result.attributeReports) {
-                        result.attributeReports = report.attributeReports;
-                    } else {
-                        result.attributeReports.push(...report.attributeReports);
-                    }
-                }
-                if (Array.isArray(report.eventReports)) {
-                    if (!result.eventReports) {
-                        result.eventReports = report.eventReports;
-                    } else {
-                        result.eventReports.push(...report.eventReports);
-                    }
-                }
-            }
+            report.attributeReports = report.attributeReports ?? [];
+            pendingAttributeReports = handleAttributeReportEntries(report.attributeReports, pendingAttributeReports);
+
+            result = await processDecodedReport(DecodedDataReport(report), result);
+        }
+
+        if (pendingAttributeReports?.length && result !== undefined) {
+            result = await processDecodedReport(
+                DecodedDataReport({
+                    interactionModelRevision: result.interactionModelRevision,
+                    attributeReports: pendingAttributeReports,
+                }),
+                result,
+            );
+        }
+
+        if (chunkListener !== undefined && currentClusterChunk.length > 0) {
+            await chunkListener(currentClusterChunk);
+            currentClusterChunk.length = 0;
         }
 
         if (result === undefined) {
@@ -1010,8 +1114,8 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
         await this.send(MessageType.SubscribeRequest, request);
     }
 
-    async readAggregateSubscribeResponse() {
-        const report = await this.readAggregateDataReport();
+    async readAggregateSubscribeResponse(chunkListener?: (chunk: DecodedAttributeReportValue<any>[]) => Promise<void>) {
+        const report = await this.readAggregateDataReport(chunkListener);
         const { subscriptionId } = report;
 
         if (subscriptionId === undefined) {

package/src/interaction/SubscriptionClient.ts

@@ -5,10 +5,11 @@
  */
 
 import { Duration, Environment, Environmental, Logger, MaybePromise, Millis, Time, Timer } from "#general";
+import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
 import { INTERACTION_PROTOCOL_ID } from "#types";
-import { DataReport, IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
+import { IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
 
 const logger = Logger.get("SubscriptionClient");
 
@@ -16,7 +17,7 @@ export interface RegisteredSubscription {
     id: number;
     maximumPeerResponseTime: Duration;
     maxInterval: Duration;
-    onData: (dataReport: DataReport) => MaybePromise<void>;
+    onData: (dataReport: DecodedDataReport) => MaybePromise<void>;
     onTimeout?: () => void;
 }
 
@@ -28,7 +29,7 @@ export interface RegisteredSubscription {
 export class SubscriptionClient implements ProtocolHandler {
     readonly id = INTERACTION_PROTOCOL_ID;
     readonly requiresSecureSession = true;
-    readonly #listeners = new Map<number, (dataReport: DataReport) => MaybePromise<void>>();
+    readonly #listeners = new Map<number, (dataReport: DecodedDataReport) => MaybePromise<void>>();
     readonly #timeouts = new Map<number, Timer>();
 
     constructor() {}
@@ -80,10 +81,10 @@ export class SubscriptionClient implements ProtocolHandler {
     async onNewExchange(exchange: MessageExchange) {
         const messenger = new IncomingInteractionClientMessenger(exchange);
 
-        let dataReport: DataReport;
+        let dataReport: DecodedDataReport;
         try {
             // TODO Adjust this to getting packages as callback when received to handle error cases and checks outside
-            dataReport = await messenger.readAggregateDataReport([...this.#listeners.keys()]);
+            dataReport = await messenger.readAggregateDataReport(undefined, [...this.#listeners.keys()]);
         } finally {
             messenger.close().catch(error => logger.info("Error closing client messenger", error));
         }

package/src/mdns/MdnsClient.ts

@@ -26,7 +26,7 @@ import {
     ObserverGroup,
     Seconds,
     ServerAddress,
-    ServerAddressIp,
+    ServerAddressUdp,
     SrvRecordValue,
     Time,
     Timer,
@@ -60,7 +60,7 @@ const logger = Logger.get("MdnsClient");
 
 const MDNS_EXPIRY_GRACE_PERIOD_FACTOR = 1.05;
 
-type MatterServerRecordWithExpire = ServerAddressIp & Lifespan;
+type MatterServerRecordWithExpire = ServerAddressUdp & Lifespan;
 
 /** Type for commissionable Device records including Lifespan details. */
 type CommissionableDeviceRecordWithExpire = Omit<CommissionableDevice, "addresses"> &
@@ -140,7 +140,8 @@ export class MdnsClient implements Scanner {
     readonly #recordWaiters = new Map<
         string,
         {
-            resolver: () => void;
+            resolver: (value: any) => void;
+            responder?: () => any;
             timer?: Timer;
             resolveOnUpdatedRecords: boolean;
             cancelResolver?: (value: void) => void;
@@ -354,7 +355,7 @@ export class MdnsClient implements Scanner {
                 ip,
                 port,
                 type: "udp",
-            })) as ServerAddressIp[],
+            })) as ServerAddressUdp[],
         };
     }
 
@@ -400,14 +401,15 @@ export class MdnsClient 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(
+    async #registerWaiterPromise<T = void>(
         queryId: string,
         commissionable: boolean,
-        timeout?: Duration,
+        timeout: Duration | undefined,
+        responder?: () => T,
         resolveOnUpdatedRecords = true,
         cancelResolver?: (value: void) => void,
-    ) {
-        const { promise, resolver } = createPromise<void>();
+    ): Promise<T> {
+        const { promise, resolver } = createPromise<T>();
         const timer =
             timeout !== undefined
                 ? Time.getTimer("MDNS timeout", timeout, () => {
@@ -416,7 +418,14 @@ export class MdnsClient implements Scanner {
                   }).start()
                 : undefined;
         this.#listening = true;
-        this.#recordWaiters.set(queryId, { resolver, timer, resolveOnUpdatedRecords, cancelResolver, commissionable });
+        this.#recordWaiters.set(queryId, {
+            resolver,
+            responder,
+            timer,
+            resolveOnUpdatedRecords,
+            cancelResolver,
+            commissionable,
+        });
         this.#hasCommissionableWaiters = this.#hasCommissionableWaiters || commissionable;
         if (!commissionable) {
             this.#registerOperationalQuery(queryId);
@@ -426,7 +435,7 @@ export class MdnsClient implements Scanner {
                 timeout !== undefined ? `timeout ${timeout}` : "no timeout"
             }${resolveOnUpdatedRecords ? "" : " (not resolving on updated records)"}`,
         );
-        await promise;
+        return await promise;
     }
 
     /**
@@ -436,12 +445,12 @@ export class MdnsClient implements Scanner {
     #finishWaiter(queryId: string, resolvePromise: boolean, isUpdatedRecord = false) {
         const waiter = this.#recordWaiters.get(queryId);
         if (waiter === undefined) return;
-        const { timer, resolver, resolveOnUpdatedRecords, commissionable } = waiter;
+        const { timer, resolver, responder, resolveOnUpdatedRecords, commissionable } = waiter;
         if (isUpdatedRecord && !resolveOnUpdatedRecords) return;
         logger.debug(`Finishing waiter for query ${queryId}, resolving: ${resolvePromise}`);
         timer?.stop();
         if (resolvePromise) {
-            resolver();
+            resolver(responder?.());
         }
         this.#recordWaiters.delete(queryId);
         this.#removeQuery(queryId);
@@ -500,7 +509,9 @@ export class MdnsClient implements Scanner {
 
         let storedDevice = ignoreExistingRecords ? undefined : this.#getOperationalDeviceRecords(deviceMatterQname);
         if (storedDevice === undefined) {
-            const promise = this.#registerWaiterPromise(deviceMatterQname, false, timeout);
+            const promise = this.#registerWaiterPromise(deviceMatterQname, false, timeout, () =>
+                this.#getOperationalDeviceRecords(deviceMatterQname),
+            );
 
             this.#setQueryRecords(deviceMatterQname, [
                 {
@@ -510,8 +521,7 @@ export class MdnsClient implements Scanner {
                 },
             ]);
 
-            await promise;
-            storedDevice = this.#getOperationalDeviceRecords(deviceMatterQname);
+            storedDevice = await promise;
         }
         return storedDevice;
     }
@@ -570,7 +580,7 @@ export class MdnsClient implements Scanner {
                         ip,
                         port,
                         type: "udp",
-                    })) as ServerAddressIp[],
+                    })) as ServerAddressUdp[],
                     discoveredAt: undefined,
                     ttl: undefined,
                 };
@@ -727,12 +737,13 @@ export class MdnsClient implements Scanner {
             : this.#getCommissionableDeviceRecords(identifier).filter(({ addresses }) => addresses.length > 0);
         if (storedRecords.length === 0) {
             const queryId = this.#buildCommissionableQueryIdentifier(identifier);
-            const promise = this.#registerWaiterPromise(queryId, true, timeout);
+            const promise = this.#registerWaiterPromise(queryId, true, timeout, () =>
+                this.#getCommissionableDeviceRecords(identifier),
+            );
 
             this.#setQueryRecords(queryId, this.#getCommissionableQueryRecords(identifier));
 
-            await promise;
-            storedRecords = this.#getCommissionableDeviceRecords(identifier);
+            storedRecords = await promise;
         }
 
         return storedRecords;
@@ -791,7 +802,7 @@ export class MdnsClient implements Scanner {
                     break;
                 }
             }
-            await this.#registerWaiterPromise(queryId, true, remainingTime, false, queryResolver);
+            await this.#registerWaiterPromise(queryId, true, remainingTime, undefined, false, queryResolver);
         }
         return this.#getCommissionableDeviceRecords(identifier);
     }
@@ -981,8 +992,7 @@ export class MdnsClient implements Scanner {
         if (this.#closing) return;
 
         if (message === undefined) return; // The message cannot be parsed
-        if (message.messageType !== DnsMessageType.Response && message.messageType !== DnsMessageType.TruncatedResponse)
-            return;
+        if (!DnsMessageType.isResponse(message.messageType)) return;
 
         const answers = this.#structureAnswers([...message.answers, ...message.additionalRecords]);
 
@@ -1458,7 +1468,7 @@ export class MdnsClient implements Scanner {
                 });
             }
             if (now > expires && !addresses.size) {
-                // device expired and also has no adresses anymore
+                // device expired and also has no addresses anymore
                 this.#operationalDeviceRecords.delete(recordKey);
             }
         });

package/src/mdns/MdnsServer.ts

@@ -7,6 +7,7 @@
 import {
     AsyncCache,
     DnsMessageType,
+    DnsMessageTypeFlag,
     DnsRecord,
     DnsRecordType,
     Instant,
@@ -18,6 +19,7 @@ import {
     NetworkInterfaceDetails,
     ObserverGroup,
     Time,
+    Timer,
 } from "#general";
 import { MdnsSocket } from "./MdnsSocket.js";
 
@@ -44,6 +46,7 @@ export class MdnsServer {
         Minutes(15) /* matches maximum standard commissioning window time */,
     );
     readonly #recordLastSentAsMulticastAnswer = new Map<string, number>();
+    readonly #truncatedQueryCache = new Map<string, { message: MdnsSocket.Message; timer: Timer }>();
 
     readonly #socket: MdnsSocket;
 
@@ -64,15 +67,19 @@ export class MdnsServer {
         return `${record.name}-${record.recordClass}-${record.recordType}-${netInterface}-${unicastTarget}`;
     }
 
-    async #handleMessage(message: MdnsSocket.Message) {
-        const records = await this.#records.get(message.sourceIntf);
+    async #handleMessage(incomingMessage: MdnsSocket.Message) {
+        const records = await this.#records.get(incomingMessage.sourceIntf);
 
         // Ignore if we have no records for interface
         if (records.size === 0) return;
 
-        const { sourceIntf, sourceIp, transactionId, messageType, queries, answers: knownAnswers } = message;
-        if (messageType !== DnsMessageType.Query && messageType !== DnsMessageType.TruncatedQuery) return;
-        if (queries.length === 0) return; // No queries to answer, can happen in a TruncatedQuery, let's ignore for now
+        const message = this.#prepareMessage(incomingMessage);
+        if (message === undefined) {
+            return;
+        }
+
+        const { sourceIntf, sourceIp, transactionId, queries, answers: knownAnswers } = message;
+
         for (const portRecords of records.values()) {
             let answers = queries.flatMap(query => this.#queryRecords(query, portRecords));
             if (answers.length === 0) continue;
@@ -213,6 +220,10 @@ export class MdnsServer {
     async close() {
         this.#observers.close();
         await this.#records.close();
+        for (const { timer } of this.#truncatedQueryCache.values()) {
+            timer.stop();
+        }
+        this.#truncatedQueryCache.clear();
         this.#recordLastSentAsMulticastAnswer.clear();
     }
 
@@ -228,6 +239,65 @@ export class MdnsServer {
             return records.filter(record => record.name === name && record.recordType === recordType);
         }
     }
+
+    async #processTruncatedQuery(key: string) {
+        const { message, timer } = this.#truncatedQueryCache.get(key) ?? {};
+        this.#truncatedQueryCache.delete(key);
+        timer?.stop();
+        if (message) {
+            if (message.queries.length === 0) {
+                // Should not happen but ignore if it does
+                return;
+            }
+            message.messageType &= ~DnsMessageTypeFlag.TC; // Clear TC flag
+            await this.#handleMessage(message);
+        }
+    }
+
+    /**
+     * Delays processing of truncated messages to allow combining multiple parts or combines them if possible
+     */
+    #prepareMessage(newMessage: MdnsSocket.Message): MdnsSocket.Message | undefined {
+        const { messageType, transactionId, sourceIntf, sourceIp } = newMessage;
+
+        if (!DnsMessageType.isQuery(messageType)) {
+            // We are only interested in queries
+            return;
+        }
+
+        const key = `${transactionId}-${sourceIntf}-${sourceIp}`;
+        const { message: existingMessage, timer } = this.#truncatedQueryCache.get(key) ?? {};
+        this.#truncatedQueryCache.delete(key);
+        timer?.stop();
+
+        const message = existingMessage
+            ? {
+                  ...existingMessage,
+                  queries: [...existingMessage.queries, ...newMessage.queries],
+                  answers: [...existingMessage.answers, ...newMessage.answers],
+                  additionalRecords: [...existingMessage.additionalRecords, ...newMessage.additionalRecords],
+                  messageType: newMessage.messageType, // Keep TC flag as is from the latest message
+              }
+            : newMessage;
+
+        // Message was not truncated, or we have now received all details, process it
+        if ((messageType & DnsMessageTypeFlag.TC) === 0) {
+            if (message.queries.length === 0) {
+                // Should not happen but ignore if it does
+                return;
+            }
+            return message;
+        }
+
+        // We have stored a new or updated truncated message - store and wait for next part
+        // Delay should be max 400-500ms as per RFC 6762 section 7.2
+        this.#truncatedQueryCache.set(key, {
+            message,
+            timer: Time.getTimer(`Truncated MDNS message ${key}`, Millis(400 + Math.floor(Math.random() * 100)), () =>
+                this.#processTruncatedQuery(key),
+            ).start(),
+        });
+    }
 }
 
 export namespace MdnsServer {

package/src/mdns/MdnsSocket.ts

@@ -12,6 +12,7 @@ import {
     DnsMessage,
     DnsMessagePartiallyPreEncoded,
     DnsMessageType,
+    DnsMessageTypeFlag,
     Logger,
     MatterAggregateError,
     MAX_MDNS_MESSAGE_SIZE,
@@ -71,6 +72,12 @@ export class MdnsSocket {
     }
 
     async send(message: Partial<DnsMessage> & { messageType: DnsMessageType }, intf?: string, unicastDest?: string) {
+        const { messageType } = message;
+        // When we send Queries that are too long they need to have the Truncated flag set
+        const truncatedMessageType = DnsMessageType.isQuery(messageType)
+            ? messageType | DnsMessageTypeFlag.TC
+            : messageType;
+
         const chunk: DnsMessagePartiallyPreEncoded = {
             transactionId: 0,
             queries: [],
@@ -101,7 +108,15 @@ export class MdnsSocket {
                 }
 
                 // New answer does not fit anymore, send out the message
-                await this.#send(chunk, intf, unicastDest);
+                // When sending a query, we set the Truncated flag to indicate more answers are available
+                await this.#send(
+                    {
+                        ...chunk,
+                        messageType: truncatedMessageType,
+                    },
+                    intf,
+                    unicastDest,
+                );
 
                 // Reset the message, length counter and included answers to count for next message
                 if (chunk.queries.length) {

package/src/peer/ControllerCommissioner.ts

@@ -13,15 +13,16 @@ import {
     Channel,
     ChannelType,
     ClassExtends,
+    ConnectionlessTransportSet,
     Diagnostic,
     Duration,
     Environment,
     Environmental,
+    ImplementationError,
     isIPv6,
     Logger,
     Millis,
     Minutes,
-    NetInterfaceSet,
     NoResponseTimeoutError,
     Seconds,
     ServerAddress,
@@ -129,7 +130,7 @@ export interface ControllerCommissionerContext {
     peers: PeerSet;
     clients: InteractionClientProvider;
     scanners: ScannerSet;
-    netInterfaces: NetInterfaceSet;
+    transports: ConnectionlessTransportSet;
     sessions: SessionManager;
     exchanges: ExchangeManager;
     ca: CertificateAuthority;
@@ -152,7 +153,7 @@ export class ControllerCommissioner {
             peers: env.get(PeerSet),
             clients: env.get(InteractionClientProvider),
             scanners: env.get(ScannerSet),
-            netInterfaces: env.get(NetInterfaceSet),
+            transports: env.get(ConnectionlessTransportSet),
             sessions: env.get(SessionManager),
             exchanges: env.get(ExchangeManager),
             ca: env.get(CertificateAuthority),
@@ -213,7 +214,7 @@ export class ControllerCommissioner {
 
         if (
             this.#context.scanners.hasScannerFor(ChannelType.UDP) &&
-            this.#context.netInterfaces.hasInterfaceFor(ChannelType.UDP, "::") !== undefined
+            this.#context.transports.hasInterfaceFor(ChannelType.UDP, "::") !== undefined
         ) {
             discoveryCapabilities.onIpNetwork = true; // We always discover on network as defined by specs
         }
@@ -316,7 +317,7 @@ export class ControllerCommissioner {
             const { ip } = address;
 
             const isIpv6Address = isIPv6(ip);
-            const paseInterface = this.#context.netInterfaces.interfaceFor(
+            const paseInterface = this.#context.transports.interfaceFor(
                 ChannelType.UDP,
                 isIpv6Address ? "::" : "0.0.0.0",
             );
@@ -327,8 +328,8 @@ export class ControllerCommissioner {
                 );
             }
             paseChannel = await paseInterface.openChannel(address);
-        } else {
-            const ble = this.#context.netInterfaces.interfaceFor(ChannelType.BLE);
+        } 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.`,
@@ -336,6 +337,8 @@ export class ControllerCommissioner {
             }
             // 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/OperationalPeer.ts

@@ -5,7 +5,7 @@
  */
 
 import { DiscoveryData } from "#common/Scanner.js";
-import { ServerAddressIp } from "#general";
+import { ServerAddressUdp } from "#general";
 import type { PeerDataStore } from "#peer/PeerAddressStore.js";
 import { SessionParameters } from "#session/Session.js";
 import { PeerAddress } from "./PeerAddress.js";
@@ -24,7 +24,7 @@ export interface OperationalPeer {
     /**
      * A physical address the peer may be accessed at, if known.
      */
-    operationalAddress?: ServerAddressIp;
+    operationalAddress?: ServerAddressUdp;
 
     /**
      * The peer's session parameters reported during discovery.

package/src/peer/PeerAddressStore.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ReadScope } from "#action/client/ReadScope.js";
 import { Construction, MaybePromise } from "#general";
 import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
 import { AttributeId, ClusterId, EndpointNumber, EventNumber } from "#types";
@@ -27,7 +28,7 @@ export abstract class PeerDataStore {
     abstract maxEventNumber: EventNumber;
     abstract updateLastEventNumber(eventNumber: EventNumber): MaybePromise<void>;
 
-    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[]): MaybePromise<void>;
+    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[], scope: ReadScope): MaybePromise<void>;
 
     // TODO: Find a maybe better way to achieve this without functions
     abstract retrieveAttribute(
@@ -41,4 +42,5 @@ export abstract class PeerDataStore {
         filterEndpointId?: EndpointNumber,
         filterClusterId?: ClusterId,
     ): { endpointId: EndpointNumber; clusterId: ClusterId; dataVersion: number }[];
+    abstract cleanupAttributeData(endpointId: EndpointNumber, clusterIds?: ClusterId[]): MaybePromise<void>;
 }