@matter/protocol 0.15.1 → 0.15.2-alpha.0-20250704-2715344f0

package/src/action/client/InputChunk.ts

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ReadResult } from "#action/response/ReadResult.js";
+import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
+import { DataReport, Status, TlvAny } from "#types";
+
+/**
+ * Converts a {@link DataReport} into a {@link ReadResult.Chunk}.
+ */
+export function* InputChunk(input: DataReport): ReadResult.Chunk {
+    const report = DecodedDataReport(input);
+
+    for (const attr of report.attributeReports) {
+        yield {
+            kind: "attr-value",
+            tlv: TlvAny,
+            ...attr,
+        };
+    }
+
+    if (report.attributeStatus) {
+        for (const attr of report.attributeStatus) {
+            yield {
+                kind: "attr-status",
+                path: attr.path,
+                status: attr.status ?? Status.Failure, // TODO - attr.status shouldn't be optional?
+                clusterStatus: attr.clusterStatus,
+            };
+        }
+    }
+
+    for (const event of report.eventReports) {
+        for (const occurrence of event.events) {
+            yield {
+                kind: "event-value",
+                path: event.path,
+                value: occurrence,
+                number: occurrence.eventNumber,
+                priority: occurrence.priority,
+                timestamp: Number(
+                    // TODO - this may not be useful, need to determine correct form
+                    occurrence.epochTimestamp ??
+                        occurrence.systemTimestamp ??
+                        occurrence.deltaEpochTimestamp ??
+                        occurrence.deltaSystemTimestamp ??
+                        0,
+                ),
+
+                // TODO - temporary, field will be removed
+                tlv: TlvAny,
+            };
+        }
+    }
+
+    if (report.eventStatus) {
+        for (const event of report.eventStatus) {
+            if (event.status !== undefined) {
+                yield {
+                    kind: "event-status",
+                    path: event.path,
+                    status: event.status,
+                    clusterStatus: event.clusterStatus,
+                };
+            }
+            if (event.clusterStatus !== undefined) {
+                yield {
+                    kind: "event-status",
+                    path: event.path,
+                    status: event.status ?? Status.Failure,
+                    clusterStatus: event.clusterStatus,
+                };
+            }
+        }
+    }
+}

package/src/action/client/ReadScope.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Read } from "#action/request/Read.js";
+import { ClusterId, EndpointNumber } from "#types";
+
+/**
+ * This utility tells you whether a given endpoint/cluster is in scope for a read.
+ */
+export interface ReadScope {
+    /**
+     * Is a cluster included in the read?
+     *
+     * This is useful to determine if the read should include a version filter.
+     */
+    isRelevant(endpoint: EndpointNumber, cluster: ClusterId): boolean;
+
+    /**
+     * Are all attributes in a cluster included in a read?
+     *
+     * This is useful to determine if the cluster's version should be updated in response to a read.
+     */
+    isWildcard(endpoint: EndpointNumber, cluster: ClusterId): boolean;
+}
+
+interface Check {
+    (endpoint: EndpointNumber, cluster: ClusterId): boolean;
+}
+
+export function ReadScope(read: Read): ReadScope {
+    return {
+        isRelevant(endpoint, cluster) {
+            this.isRelevant = generateScopeTester(read, "any");
+            return this.isRelevant(endpoint, cluster);
+        },
+
+        isWildcard(endpoint, cluster) {
+            this.isWildcard = generateScopeTester(read, "all");
+            return this.isWildcard(endpoint, cluster);
+        },
+    };
+}
+
+function generateScopeTester(read: Read, attrRequirement: "any" | "all"): Check {
+    if (!read.attributeRequests?.length) {
+        return isNever;
+    }
+
+    let wildcardEndpointClusters: undefined | Set<ClusterId>;
+    let specificEndpointClusters: undefined | Record<EndpointNumber, true | Set<ClusterId>>;
+
+    for (const { endpointId, clusterId, attributeId } of read.attributeRequests) {
+        // Ignore path if it addresses a specific attribute and we are only interested in wildcard attributes
+        if (attributeId !== undefined && attrRequirement === "all") {
+            continue;
+        }
+
+        // Wildcard endpoint
+        if (endpointId === undefined) {
+            // Full wildcard read; short-circuit all subsequent logic
+            if (clusterId === undefined) {
+                return isAlways;
+            }
+
+            // Wildcard cluster across all endpoints
+            (wildcardEndpointClusters ??= new Set()).add(clusterId);
+            continue;
+        }
+
+        // Specific endpoint with wildcard cluster cases
+        if (clusterId === undefined) {
+            (specificEndpointClusters ??= {})[endpointId] = true;
+            continue;
+        }
+
+        // Specific endpoint and cluster
+        if (attributeId === undefined) {
+            let ep = specificEndpointClusters?.[endpointId];
+            if (ep === true) {
+                continue;
+            }
+            if (ep === undefined) {
+                ep = (specificEndpointClusters ??= {})[endpointId] = new Set();
+            }
+            ep.add(clusterId);
+        }
+    }
+
+    return (endpoint, cluster) => {
+        if (wildcardEndpointClusters?.has(cluster)) {
+            return true;
+        }
+        const ep = specificEndpointClusters?.[endpoint];
+        return ep === true || !!ep?.has(cluster);
+    };
+}
+
+function isNever() {
+    return false;
+}
+
+function isAlways() {
+    return true;
+}

package/src/action/client/index.ts

@@ -5,3 +5,8 @@
  */
 
 export * from "./ClientInteraction.js";
+export * from "./ClientSubscription.js";
+export * from "./ClientSubscriptionHandler.js";
+export * from "./ClientSubscriptions.js";
+export * from "./InputChunk.js";
+export * from "./ReadScope.js";

package/src/action/request/Invoke.ts

@@ -5,7 +5,7 @@
  */
 
 import { FALLBACK_INTERACTIONMODEL_REVISION } from "#session/Session.js";
-import { ClusterType, CommandData, InvokeRequest, TlvSchema, TypeFromSchema } from "#types";
+import { ClusterType, CommandData, InvokeRequest, TlvSchema, TlvStream, TypeFromSchema } from "#types";
 import { MalformedRequestError } from "./MalformedRequestError.js";
 import { Specifier } from "./Specifier.js";
 
@@ -72,11 +72,20 @@ export namespace Invoke {
     }
 
     export function Command<const C extends ClusterType>(request: Invoke.CommandRequest<C>): CommandData {
+        const command = Invoke.commandOf(request);
+
+        let commandFields: TlvStream | undefined;
+
+        if ("fields" in request) {
+            commandFields = command.requestSchema.encodeTlv(request.fields, { forWriteInteraction: true });
+        }
+
         const result: CommandData = {
             commandPath: {
                 clusterId: Specifier.clusterFor(request.cluster).id,
-                commandId: Invoke.commandOf(request).requestId,
+                commandId: command.requestId,
             },
+            commandFields,
         };
 
         const endpointId = Specifier.endpointIdOf(request);

package/src/action/request/Read.ts

@@ -23,11 +23,6 @@ import { Specifier } from "./Specifier.js";
  */
 export interface Read extends ReadRequest {}
 
-/**
- * Formulate a read request using Matter numeric IDs.
- */
-export function Read(options: Read.Options): Read;
-
 /**
  * Formulate a read request with extended options and name-based IDs.
  */

package/src/action/request/Subscribe.ts

@@ -4,7 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { UINT16_MAX } from "#general";
+import type { ReadResult } from "#action/response/ReadResult.js";
+import { CanceledError, TimeoutError, UINT16_MAX } from "#general";
 import { MalformedRequestError } from "./MalformedRequestError.js";
 import { Read } from "./Read.js";
 
@@ -18,10 +19,21 @@ export interface Subscribe extends Read {
     keepSubscriptions: boolean;
     minIntervalFloorSeconds?: number;
     maxIntervalCeilingSeconds?: number;
+    maxPeerResponseTime?: number;
+
+    /**
+     * Invoked when subscribed data changes.
+     */
+    updated?: (data: ReadResult) => Promise<void>;
+
+    /**
+     * Invoked when the subscription is no longer active.
+     */
+    closed?: (cause: CanceledError | TimeoutError) => void;
 }
 
-export function Subscribe(options: Subscribe.Options): Subscribe {
-    const subscribe = Read(options) as unknown as Subscribe;
+export function Subscribe(options: Subscribe.Options, ...selectors: Read.Selector[]): Subscribe {
+    const subscribe = Read(options, ...selectors) as unknown as Subscribe;
 
     const { keepSubscriptions, minIntervalFloorSeconds, maxIntervalCeilingSeconds } = options;
     subscribe.keepSubscriptions = keepSubscriptions ?? true;
@@ -48,6 +60,8 @@ export namespace Subscribe {
         keepSubscriptions?: boolean;
         minIntervalFloorSeconds?: number;
         maxIntervalCeilingSeconds?: number;
+        update?: Subscribe["updated"];
+        closed?: Subscribe["closed"];
     }
 }
 

package/src/action/response/SubscribeResult.ts

@@ -5,10 +5,9 @@
  */
 
 import { SubscribeResponse } from "#types";
-import { ReadResult } from "./ReadResult.js";
 
-export interface SubscribeResult extends AsyncIterator<SubscribeResult.Chunk> {}
+export type SubscribeResult = Promise<ActiveSubscription>;
 
-export namespace SubscribeResult {
-    export type Chunk = ReadResult.Chunk | SubscribeResponse;
+export interface ActiveSubscription extends SubscribeResponse {
+    close(): void;
 }

package/src/action/server/AttributeReadResponse.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InteractionSession } from "#action/index.js";
+import { InteractionSession } from "#action/Interactable.js";
 import { AttributeTypeProtocol, ClusterProtocol, EndpointProtocol, NodeProtocol } from "#action/protocols.js";
 import { Read } from "#action/request/Read.js";
 import { ReadResult } from "#action/response/ReadResult.js";

package/src/action/server/AttributeSubscriptionResponse.ts

@@ -3,7 +3,8 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { InteractionSession } from "#action/index.js";
+
+import { InteractionSession } from "#action/Interactable.js";
 import { AttributeTypeProtocol, ClusterProtocol, EndpointProtocol, NodeProtocol } from "#action/protocols.js";
 import { ReadResult } from "#action/response/ReadResult.js";
 import { InternalError } from "#general";

package/src/action/server/CommandInvokeResponse.ts

@@ -4,9 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { CommandInvokeHandler, Invoke, InvokeResult, Subject } from "#action/index.js";
 import { InteractionSession } from "#action/Interactable.js";
-import { CommandTypeProtocol, EndpointProtocol, NodeProtocol } from "#action/protocols.js";
+import { CommandInvokeHandler, CommandTypeProtocol, EndpointProtocol, NodeProtocol } from "#action/protocols.js";
+import { Invoke } from "#action/request/Invoke.js";
+import { InvokeResult } from "#action/response/InvokeResult.js";
 import { AccessControl } from "#action/server/AccessControl.js";
 import { DataResponse, FallbackLimits } from "#action/server/DataResponse.js";
 import { Diagnostic, InternalError, Logger } from "#general";
@@ -22,6 +23,7 @@ import {
     TlvStream,
     ValidationError,
 } from "#types";
+import { Subject } from "./Subject.js";
 
 const logger = Logger.get("CommandInvokeResponse");
 

package/src/action/server/EventReadResponse.ts

@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InteractionSession } from "#action/index.js";
+import { InteractionSession } from "#action/Interactable.js";
 import { ClusterProtocol, EndpointProtocol, EventTypeProtocol, NodeProtocol } from "#action/protocols.js";
 import { Read } from "#action/request/Read.js";
 import { ReadResult } from "#action/response/ReadResult.js";
 import { AccessControl } from "#action/server/AccessControl.js";
 import { DataResponse, FallbackLimits } from "#action/server/DataResponse.js";
-import { NumberedOccurrence } from "#events/index.js";
+import { NumberedOccurrence } from "#events/Occurrence.js";
 import { InternalError, isObject, Logger } from "#general";
 import { DataModelPath, ElementTag, EventModel } from "#model";
 import {

package/src/codec/MessageCodec.ts

@@ -14,7 +14,7 @@ import {
     NotImplementedError,
     UnexpectedDataError,
 } from "#general";
-import { ExchangeLogContext } from "#protocol/index.js";
+import type { ExchangeLogContext } from "#protocol/MessageExchange.js";
 import { GroupId, INTERACTION_PROTOCOL_ID, NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureMessageType } from "#types";
 import { MessageType } from "../interaction/InteractionMessenger.js";
 

package/src/common/FailsafeContext.ts

@@ -183,7 +183,6 @@ export abstract class FailsafeContext {
     }
 
     async close() {
-        await this.#construction;
         await this.#construction.close(async () => {
             if (this.#failsafe) {
                 await this.#failsafe.close();

package/src/fabric/Fabric.ts

@@ -4,7 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Icac, Noc, Rcac, X509Base } from "#certificate/index.js";
+import { Icac } from "#certificate/kinds/Icac.js";
+import { Noc } from "#certificate/kinds/Noc.js";
+import { Rcac } from "#certificate/kinds/Rcac.js";
+import { X509Base } from "#certificate/kinds/X509Base.js";
 import {
     BinaryKeyPair,
     Bytes,

package/src/fabric/FabricAuthority.ts

@@ -5,7 +5,16 @@
  */
 
 import { CertificateAuthority } from "#certificate/CertificateAuthority.js";
-import { Bytes, CRYPTO_SYMMETRIC_KEY_LENGTH, Environment, Environmental, ImplementationError, Logger } from "#general";
+import {
+    Bytes,
+    Construction,
+    CRYPTO_SYMMETRIC_KEY_LENGTH,
+    Environment,
+    Environmental,
+    ImplementationError,
+    Logger,
+    Observable,
+} from "#general";
 import { CaseAuthenticatedTag, FabricId, FabricIndex, NodeId, VendorId } from "#types";
 import { Fabric, FabricBuilder } from "./Fabric.js";
 import { FabricManager } from "./FabricManager.js";
@@ -48,14 +57,25 @@ export const DEFAULT_FABRIC_ID = FabricId(1);
  * Manages fabrics controlled locally associated with a specific CA.
  */
 export class FabricAuthority {
+    #construction: Construction<FabricAuthority>;
     #ca: CertificateAuthority;
     #fabrics: FabricManager;
     #config: FabricAuthorityConfiguration;
+    #fabricAdded = new Observable<[Fabric]>();
 
     constructor({ ca, fabrics, config }: FabricAuthorityContext) {
         this.#ca = ca;
         this.#fabrics = fabrics;
         this.#config = config;
+
+        this.#construction = Construction(this, async () => {
+            await this.#ca.construction;
+            await this.#fabrics.construction;
+        });
+    }
+
+    get construction() {
+        return this.#construction;
     }
 
     /**
@@ -89,6 +109,13 @@ export class FabricAuthority {
         return Array.from(this.#fabrics).filter(this.hasControlOf.bind(this));
     }
 
+    /**
+     * Emits after creating a new fabric.
+     */
+    get fabricAdded() {
+        return this.#fabricAdded;
+    }
+
     /**
      * Determine whether a fabric belongs to this authority.
      */
@@ -137,6 +164,7 @@ export class FabricAuthority {
         this.#fabrics.addFabric(fabric);
 
         logger.debug(`Created new controller fabric ${index}`);
+        this.#fabricAdded.emit(fabric);
 
         return fabric;
     }

package/src/groups/FabricGroups.ts

@@ -3,7 +3,7 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Fabric } from "#fabric/Fabric.js";
+import type { Fabric } from "#fabric/Fabric.js";
 import { BasicMap, Bytes, InternalError, MatterFlowError, StorageContext } from "#general";
 import { GroupKeySet, KeySets, OperationalKeySet } from "#groups/KeySets.js";
 import { MessagingState } from "#groups/MessagingState.js";

package/src/groups/Groups.ts

@@ -3,8 +3,9 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Subject } from "#action/index.js";
-import { Fabric } from "#fabric/Fabric.js";
+
+import { Subject } from "#action/server/Subject.js";
+import type { Fabric } from "#fabric/Fabric.js";
 import { BasicMap, DataWriter, ImplementationError, ipv6BytesToString } from "#general";
 import { EndpointNumber, GroupId } from "#types";
 import { KeySets, OperationalKeySet } from "./KeySets.js";

package/src/interaction/FabricAccessControl.ts

@@ -5,7 +5,7 @@
  */
 import { Subject } from "#action/server/Subject.js";
 import { AccessControl } from "#clusters/access-control";
-import { Fabric } from "#fabric/Fabric.js";
+import type { Fabric } from "#fabric/Fabric.js";
 import { InternalError, Logger, MatterFlowError } from "#general";
 import { AccessLevel } from "#model";
 import {

package/src/interaction/InteractionClient.ts

@@ -509,7 +509,8 @@ export class InteractionClient {
                 .join(", ")} and events ${eventRequests?.map(path => resolveEventName(path)).join(", ")}`,
         );
         // Send read request and combine all (potentially chunked) responses
-        const response = await messenger.sendReadRequest(request);
+        await messenger.sendReadRequest(request);
+        const response = await messenger.readAggregateDataReport();
 
         // Normalize and decode the response
         const normalizedResult = DecodedDataReport(response);
@@ -752,7 +753,7 @@ export class InteractionClient {
             report: DataReport;
             maximumPeerResponseTimeMs: number;
         }>(async messenger => {
-            const { subscribeResponse, report } = await messenger.sendSubscribeRequest({
+            await messenger.sendSubscribeRequest({
                 interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
                 attributeRequests: [{ endpointId, clusterId, attributeId }],
                 dataVersionFilters:
@@ -764,6 +765,7 @@ export class InteractionClient {
                 maxIntervalCeilingSeconds,
                 isFabricFiltered,
             });
+            const { subscribeResponse, report } = await messenger.readAggregateSubscribeResponse();
             return {
                 subscribeResponse,
                 report,
@@ -863,7 +865,7 @@ export class InteractionClient {
             report: DataReport;
             maximumPeerResponseTimeMs: number;
         }>(async messenger => {
-            const { subscribeResponse, report } = await messenger.sendSubscribeRequest({
+            await messenger.sendSubscribeRequest({
                 interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
                 eventRequests: [{ endpointId, clusterId, eventId, isUrgent }],
                 eventFilters: minimumEventNumber !== undefined ? [{ eventMin: minimumEventNumber }] : undefined,
@@ -872,6 +874,7 @@ export class InteractionClient {
                 maxIntervalCeilingSeconds,
                 isFabricFiltered,
             });
+            const { subscribeResponse, report } = await messenger.readAggregateSubscribeResponse();
             return {
                 subscribeResponse,
                 report,
@@ -1030,7 +1033,7 @@ export class InteractionClient {
             report: DataReport;
             maximumPeerResponseTimeMs: number;
         }>(async messenger => {
-            const { subscribeResponse, report } = await messenger.sendSubscribeRequest({
+            await messenger.sendSubscribeRequest({
                 interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
                 attributeRequests,
                 eventRequests,
@@ -1044,6 +1047,7 @@ export class InteractionClient {
                     dataVersion,
                 })),
             });
+            const { subscribeResponse, report } = await messenger.readAggregateSubscribeResponse();
             return {
                 subscribeResponse,
                 report,

package/src/interaction/InteractionMessenger.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ReadResult } from "#action/index.js";
+import { ReadResult } from "#action/response/ReadResult.js";
 import {
     Diagnostic,
     InternalError,
@@ -14,6 +14,7 @@ import {
     UnexpectedDataError,
 } from "#general";
 import { Specification } from "#model";
+import { ChannelNotConnectedError } from "#protocol/MessageChannel.js";
 import {
     ReceivedStatusResponseError,
     Status,
@@ -37,7 +38,6 @@ import {
     TypeFromSchema,
 } from "#types";
 import { Message, SessionType } from "../codec/MessageCodec.js";
-import { ChannelNotConnectedError } from "../protocol/ExchangeManager.js";
 import { ExchangeProvider } from "../protocol/ExchangeProvider.js";
 import {
     ExchangeSendOptions,
@@ -848,6 +848,14 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
         return result;
     }
 
+    /**
+     * Read a single data report.
+     */
+    async readDataReport() {
+        const dataReportMessage = await this.waitFor("DataReport", MessageType.ReportData);
+        return TlvDataReport.decode(dataReportMessage.payload);
+    }
+
     /**
      * Read data reports as they come in on the wire.
      *
@@ -855,8 +863,7 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
      */
     async *readDataReports() {
         while (true) {
-            const dataReportMessage = await this.waitFor("DataReport", MessageType.ReportData);
-            const report = TlvDataReport.decode(dataReportMessage.payload);
+            const report = await this.readDataReport();
 
             yield report;
 
@@ -895,16 +902,16 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
 }
 
 export class InteractionClientMessenger extends IncomingInteractionClientMessenger {
+    #exchangeProvider: ExchangeProvider;
+
     static async create(exchangeProvider: ExchangeProvider) {
         const exchange = await exchangeProvider.initiateExchange();
         return new this(exchange, exchangeProvider);
     }
 
-    constructor(
-        exchange: MessageExchange,
-        private readonly exchangeProvider: ExchangeProvider,
-    ) {
+    constructor(exchange: MessageExchange, exchangeProvider: ExchangeProvider) {
         super(exchange);
+        this.#exchangeProvider = exchangeProvider;
     }
 
     /** Implements a send method with an automatic reconnection mechanism */
@@ -917,7 +924,7 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
             return await this.exchange.send(messageType, payload, options);
         } catch (error) {
             if (
-                this.exchangeProvider.supportsReconnect &&
+                this.#exchangeProvider.supportsReconnect &&
                 (error instanceof RetransmissionLimitReachedError || error instanceof ChannelNotConnectedError) &&
                 !options?.multipleMessageInteraction
             ) {
@@ -927,8 +934,8 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
                     `${error instanceof RetransmissionLimitReachedError ? "Retransmission limit reached" : "Channel not connected"}, trying to reconnect and resend the message.`,
                 );
                 await this.exchange.close();
-                if (await this.exchangeProvider.reconnectChannel()) {
-                    this.exchange = await this.exchangeProvider.initiateExchange();
+                if (await this.#exchangeProvider.reconnectChannel()) {
+                    this.exchange = await this.#exchangeProvider.initiateExchange();
                     return await this.exchange.send(messageType, payload, options);
                 }
             } else {
@@ -939,8 +946,6 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
 
     async sendReadRequest(readRequest: ReadRequest) {
         await this.send(MessageType.ReadRequest, this.#encodeReadingRequest(TlvReadRequest, readRequest));
-
-        return this.readAggregateDataReport();
     }
 
     #encodeReadingRequest<T extends TlvSchema<any>>(schema: T, request: TypeFromSchema<T>) {
@@ -1000,7 +1005,9 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
     async sendSubscribeRequest(subscribeRequest: SubscribeRequest) {
         const request = this.#encodeReadingRequest(TlvSubscribeRequest, subscribeRequest);
         await this.send(MessageType.SubscribeRequest, request);
+    }
 
+    async readAggregateSubscribeResponse() {
         const report = await this.readAggregateDataReport();
         const { subscriptionId } = report;