@matter/protocol 0.16.8-alpha.0-20260123-dff2cae52 → 0.16.8-alpha.0-20260127-65e1b40e2

package/src/action/client/ClientInteraction.ts

@@ -19,6 +19,7 @@ import { BdxMessenger } from "#bdx/BdxMessenger.js";
 import { Mark } from "#common/Mark.js";
 import {
     Abort,
+    AsyncIterator,
     BasicSet,
     Diagnostic,
     Duration,
@@ -38,6 +39,7 @@ import { InteractionClientMessenger, MessageType } from "#interaction/Interactio
 import { Subscription } from "#interaction/Subscription.js";
 import { PeerAddress } from "#peer/PeerAddress.js";
 import { ExchangeProvider } from "#protocol/ExchangeProvider.js";
+import { SessionClosedError } from "#protocol/index.js";
 import { SecureSession } from "#session/SecureSession.js";
 import { Status, TlvAttributeReport, TlvNoResponse, TlvSubscribeResponse, TypeFromSchema } from "#types";
 import { ClientWrite } from "./ClientWrite.js";
@@ -186,10 +188,7 @@ export class ClientInteraction<
     }
 
     /**
-     * Update node attributes.
-     *
-     * Writes with the Matter protocol are generally not atomic, so this method only throws if the entire action fails.
-     * You must check each {@link WriteResult.AttributeStatus} to determine whether individual updates failed.
+     * Write to node attributes.
      */
     async write<T extends ClientWrite>(request: T, session?: SessionT): WriteResult<T> {
         await using context = await this.#begin("writing", request, session);
@@ -253,9 +252,9 @@ export class ClientInteraction<
     }
 
     /**
-     * Invoke one or more commands.
+     * Invoke a single batch of commands (internal implementation).
      */
-    async *invoke(request: ClientInvoke, session?: SessionT): DecodedInvokeResult {
+    async *#invokeSingle(request: ClientInvoke, session?: SessionT): DecodedInvokeResult {
         await using context = await this.#begin("invoking", request, session);
         const { checkAbort, messenger } = context;
 
@@ -358,6 +357,63 @@ export class ClientInteraction<
         }
     }
 
+    /**
+     * Split commands across multiple parallel invoke-exchanges.
+     * Results are streamed as they arrive from any batch, not buffered.
+     */
+    async *#invokeWithSplitting(
+        request: ClientInvoke,
+        maxPathsPerInvoke: number,
+        session?: SessionT,
+    ): DecodedInvokeResult {
+        // Split commands into batches
+        const allCommands = [...request.commands.entries()];
+        const batches = new Array<ClientInvoke["commands"]>();
+
+        for (let i = 0; i < allCommands.length; i += maxPathsPerInvoke) {
+            const batchEntries = allCommands.slice(i, i + maxPathsPerInvoke);
+            batches.push(new Map(batchEntries));
+        }
+
+        // Create async iterators for each batch and merge results as they arrive
+        const iterators = batches.map(batchCommands => {
+            const batchRequest: ClientInvoke = {
+                ...request,
+                commands: batchCommands,
+            };
+            return this.#invokeSingle(batchRequest, session);
+        });
+
+        yield* AsyncIterator.merge(iterators, "One or more invoke batches failed");
+    }
+
+    /** Get the effective MaxPathsPerInvoke parameter from the session, or 1 as a fallback as defined by spec. */
+    get #maxPathsPerInvoke(): number {
+        try {
+            return this.session.parameters.maxPathsPerInvoke;
+        } catch (error) {
+            SessionClosedError.accept(error);
+            return 1;
+        }
+    }
+
+    /**
+     * Invoke one or more commands.
+     *
+     * When the number of commands exceeds the peer's MaxPathsPerInvoke limit (or 1 for older nodes),
+     * commands are split across multiple parallel exchanges automatically.
+     */
+    async *invoke(request: ClientInvoke, session?: SessionT): DecodedInvokeResult {
+        const maxPathsPerInvoke = this.#maxPathsPerInvoke;
+        const commandCount = request.commands.size;
+
+        if (commandCount > maxPathsPerInvoke) {
+            yield* this.#invokeWithSplitting(request, maxPathsPerInvoke, session);
+        } else {
+            yield* this.#invokeSingle(request, session);
+        }
+    }
+
     /**
      * Subscribe to attribute values and events.
      */

package/src/action/client/QueuedClientInteraction.ts

@@ -69,7 +69,6 @@ export class QueuedClientInteraction<
 
     /**
      * Write chosen attributes remotely to the node.
-     * The returned attribute writing status information is returned.
      */
     override async write<T extends ClientWrite>(request: T, session?: SessionT): WriteResult<T> {
         using _slot = await this.queue.obtainSlot();

package/src/action/client/subscription/ClientSubscriptionHandler.ts

@@ -44,7 +44,7 @@ export class ClientSubscriptionHandler implements ProtocolHandler {
         // Ensure there is a subscription ID present
         const { subscriptionId } = initialReport;
         if (subscriptionId === undefined) {
-            logger.debug("Ignoring unsolicited data report with no subscription ID");
+            logger.debug(exchange.via, "Ignoring unsolicited data report with no subscription ID");
             await sendInvalid(messenger, undefined);
             return;
         }
@@ -55,6 +55,7 @@ export class ClientSubscriptionHandler implements ProtocolHandler {
         const subscription = this.#subscriptions.getPeer(session.peerAddress, subscriptionId);
         if (subscription === undefined) {
             logger.info(
+                exchange.via,
                 "Ignoring data report for unknown subscription ID",
                 Diagnostic.strong(Subscription.idStrOf(subscriptionId)),
             );
@@ -72,6 +73,7 @@ export class ClientSubscriptionHandler implements ProtocolHandler {
                 const ending = await reports.next();
                 if (!ending.done) {
                     logger.warn(
+                        exchange.via,
                         "Unexpected data reports after empty report",
                         Diagnostic.strong(Subscription.idStrOf(subscriptionId)),
                     );
@@ -125,13 +127,14 @@ async function* processReports(
     for await (const report of otherReports) {
         const { subscriptionId: reportSubscriptionId } = report;
         if (reportSubscriptionId === undefined) {
-            logger.debug("Ignoring data report with missing subscription id");
+            logger.debug(messenger.exchange.via, "Ignoring data report with missing subscription id");
             await sendInvalid(messenger, reportSubscriptionId);
             continue;
         }
 
         if (reportSubscriptionId !== subscriptionId) {
             logger.debug(
+                messenger.exchange.via,
                 "Ignoring data report for incorrect subscription id",
                 Diagnostic.strong(Subscription.idStrOf(reportSubscriptionId)),
                 "expected",

package/src/action/server/AttributeWriteResponse.ts

@@ -40,7 +40,6 @@ export class AttributeWriteResponse<
     // a cache between producers that touch the same endpoint and/or cluster
     #currentEndpoint?: EndpointProtocol;
     #currentCluster?: ClusterProtocol;
-    #previousProcessedAttributePath?: WriteResult.ConcreteAttributePath;
 
     // Count how many attribute status (on error) and attribute values (on success) we have emitted
     #statusCount = 0;
@@ -52,7 +51,7 @@ export class AttributeWriteResponse<
         this.#fabricIndex = session.fabric ?? FabricIndex.NO_FABRIC;
     }
 
-    async process<T extends Write>({ writeRequests, suppressResponse }: T): WriteResult<T> {
+    async process({ writeRequests, suppressResponse }: Write): Promise<WriteResult.AttributeStatus[] | undefined> {
         using _writing = this.join("writing");
 
         const writeResponses = new Array<WriteResult.AttributeStatus>();
@@ -75,9 +74,9 @@ export class AttributeWriteResponse<
         }
 
         if (!suppressResponse) {
-            return writeResponses as Awaited<WriteResult<T>>;
+            return writeResponses;
         }
-        return undefined as Awaited<WriteResult<T>>;
+        return undefined;
     }
 
     /** Guarded accessor for this.#currentEndpoint.  This should never be undefined */
@@ -394,9 +393,6 @@ export class AttributeWriteResponse<
             );
         }
 
-        const previousPath = this.#previousProcessedAttributePath;
-        this.#previousProcessedAttributePath = path;
-
         try {
             const { tlv } = attribute;
             if (listIndex === undefined) {
@@ -408,15 +404,7 @@ export class AttributeWriteResponse<
                 writeState[attributeId] = decoded;
                 await this.session.transaction?.commit();
             } else if (listIndex === null) {
-                if (
-                    previousPath?.endpointId !== path.endpointId ||
-                    previousPath?.clusterId !== path.clusterId ||
-                    previousPath?.attributeId !== path.attributeId
-                ) {
-                    // Mimic chip sdk behavior
-                    throw new StatusResponseError("ADD list action without a former REPLACE_ALL action", Status.Busy);
-                }
-                // ADD
+                // ADD - caller (InteractionServer) has already validated that this ADD is allowed
                 if (!(tlv instanceof ArraySchema)) {
                     throw new StatusResponseError(
                         `Unsupported Write path provided: listIndex === ${listIndex} but attribute is not a list`,

package/src/action/server/DataResponse.ts

@@ -42,6 +42,14 @@ export abstract class DataResponse<SessionT extends InteractionSession = Interac
         return this.#session;
     }
 
+    /**
+     * Update the session for processing subsequent chunks.
+     * This allows reusing the same response instance while maintaining state across chunks.
+     */
+    protected updateSession(session: SessionT) {
+        this.#session = session;
+    }
+
     /**
      * The node ID used to filter paths with node ID specified.  Unsure if this is ever actually used.
      */

package/src/action/server/ServerInteraction.ts

@@ -69,11 +69,11 @@ export class ServerInteraction<
         // TODO - validate request
 
         const writer = new AttributeWriteResponse(this.#node, session);
-        return await writer.process(request);
+        return (await writer.process(request)) as Awaited<WriteResult<T>>;
     }
 
     async *invoke(request: Invoke, session: SessionT): InvokeResult {
-        // TODO -  validate request
+        // TODO - validate request
 
         const invoker = new CommandInvokeResponse(this.#node, session);
         yield* invoker.process(request);

package/src/dcl/DclCertificateService.ts

@@ -218,6 +218,9 @@ export class DclCertificateService {
     async close() {
         this.#closed = true;
         this.#updateTimer?.stop();
+        if (this.#fetchPromise !== undefined) {
+            await this.#fetchPromise;
+        }
         await this.#storageManager?.close();
     }
 

package/src/dcl/DclOtaUpdateService.ts

@@ -227,11 +227,17 @@ export class DclOtaUpdateService {
                         localUpdates[0].maxApplicableSoftwareVersion ?? localUpdates[0].softwareVersion - 1,
                     source: localUpdates[0].mode === "prod" ? "dcl-prod" : "local",
                 };
-                logger.debug(`Found local update`, Diagnostic.dict(localUpdate));
-                if (targetSoftwareVersion !== undefined && localUpdate.softwareVersion === targetSoftwareVersion) {
-                    return localUpdate;
+                if (
+                    localUpdate.softwareVersion > currentSoftwareVersion &&
+                    currentSoftwareVersion >= localUpdate.minApplicableSoftwareVersion &&
+                    currentSoftwareVersion <= localUpdate.maxApplicableSoftwareVersion
+                ) {
+                    logger.debug(`Found applicable local update`, Diagnostic.dict(localUpdate));
+                    if (targetSoftwareVersion !== undefined && localUpdate.softwareVersion === targetSoftwareVersion) {
+                        return localUpdate;
+                    }
+                    foundUpdates.push(localUpdate);
                 }
-                foundUpdates.push(localUpdate);
             }
         }
 
@@ -508,7 +514,7 @@ export class DclOtaUpdateService {
             return false;
         }
 
-        // Current version must be within the applicable range if specified
+        // The current version must be within the applicable range if specified
         if (
             versionInfo.minApplicableSoftwareVersion !== undefined &&
             currentVersion < versionInfo.minApplicableSoftwareVersion

package/src/interaction/InteractionMessenger.ts

@@ -30,6 +30,7 @@ import {
     TlvDataVersionFilter,
     TlvInvokeRequest,
     TlvInvokeResponse,
+    TlvInvokeResponseForSend,
     TlvReadRequest,
     TlvSchema,
     TlvStatusResponse,
@@ -76,6 +77,7 @@ export type SubscribeRequest = TypeFromSchema<typeof TlvSubscribeRequest>;
 export type SubscribeResponse = TypeFromSchema<typeof TlvSubscribeResponse>;
 export type InvokeRequest = TypeFromSchema<typeof TlvInvokeRequest>;
 export type InvokeResponse = TypeFromSchema<typeof TlvInvokeResponse>;
+export type InvokeResponseForSend = TypeFromSchema<typeof TlvInvokeResponseForSend>;
 export type TimedRequest = TypeFromSchema<typeof TlvTimedRequest>;
 export type WriteRequest = TypeFromSchema<typeof TlvWriteRequest>;
 export type WriteResponse = TypeFromSchema<typeof TlvWriteResponse>;
@@ -211,7 +213,12 @@ export interface InteractionRecipient {
         request: ReadRequest,
         message: Message,
     ): Promise<{ dataReport: DataReport; payload?: DataReportPayloadIterator }>;
-    handleWriteRequest(exchange: MessageExchange, request: WriteRequest, message: Message): Promise<WriteResponse>;
+    handleWriteRequest(
+        exchange: MessageExchange,
+        request: WriteRequest,
+        messenger: InteractionServerMessenger,
+        message: Message,
+    ): Promise<void>;
     handleSubscribeRequest(
         exchange: MessageExchange,
         request: SubscribeRequest,
@@ -262,11 +269,8 @@ export class InteractionServerMessenger extends InteractionMessenger {
                     }
                     case MessageType.WriteRequest: {
                         const writeRequest = TlvWriteRequest.decode(message.payload);
-                        const { suppressResponse } = writeRequest;
-                        const writeResponse = await recipient.handleWriteRequest(this.exchange, writeRequest, message);
-                        if (!suppressResponse && !isGroupSession) {
-                            await this.send(MessageType.WriteResponse, TlvWriteResponse.encode(writeResponse));
-                        }
+                        await recipient.handleWriteRequest(this.exchange, writeRequest, this, message);
+                        // response is sent by the handler
                         break;
                     }
                     case MessageType.SubscribeRequest: {
@@ -278,7 +282,7 @@ export class InteractionServerMessenger extends InteractionMessenger {
                         }
                         const subscribeRequest = TlvSubscribeRequest.decode(message.payload);
                         await recipient.handleSubscribeRequest(this.exchange, subscribeRequest, this, message);
-                        // response is sent by handler
+                        // response is sent by the handler
                         break;
                     }
                     case MessageType.InvokeRequest: {
@@ -797,6 +801,60 @@ export class InteractionServerMessenger extends InteractionMessenger {
             }
         }
     }
+
+    /**
+     * Send a WriteResponse message.
+     */
+    async sendWriteResponse(response: WriteResponse, options?: { logContext?: string }) {
+        await this.send(MessageType.WriteResponse, TlvWriteResponse.encode(response), {
+            logContext: options?.logContext ? { for: options.logContext } : undefined,
+        });
+    }
+
+    /**
+     * Wait for and decode the next WriteRequest message (for chunked writes).
+     */
+    async readNextWriteRequest(): Promise<{ writeRequest: WriteRequest; message: Message }> {
+        const message = await this.nextMessage(MessageType.WriteRequest, undefined, "WriteRequest-chunk");
+        return {
+            writeRequest: TlvWriteRequest.decode(message.payload),
+            message,
+        };
+    }
+
+    /**
+     * Send an intermediate InvokeResponse chunk with moreChunkedMessages=true and wait for Status.Success.
+     * Returns true if a client acknowledged, and we should continue, false if a client terminated the chunked series.
+     */
+    async sendInvokeResponseChunk(response: InvokeResponseForSend): Promise<boolean> {
+        await this.send(
+            MessageType.InvokeResponse,
+            TlvInvokeResponseForSend.encode({
+                ...response,
+                moreChunkedMessages: true,
+            }),
+            {
+                logContext: { for: "InvokeResponse-chunk" },
+            },
+        );
+
+        try {
+            await this.waitForSuccess("InvokeResponse-chunk");
+            return true; // Continue sending chunks
+        } catch (error) {
+            // Any non-success status or error terminate further transmission of InvokeResponseMessages,
+            // close the exchange, and consider the Invoke Interaction completed.
+            logger.debug("Chunked invoke response terminated by client", error);
+            return false;
+        }
+    }
+
+    /**
+     * Send the final InvokeResponse (without moreChunkedMessages flag).
+     */
+    async sendInvokeResponse(response: InvokeResponseForSend) {
+        await this.send(MessageType.InvokeResponse, TlvInvokeResponseForSend.encode(response));
+    }
 }
 
 export class IncomingInteractionClientMessenger extends InteractionMessenger {
@@ -972,7 +1030,14 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
         await this.send(MessageType.SubscribeRequest, request);
     }
 
-    async sendInvokeCommand(invokeRequest: InvokeRequest, expectedProcessingTime?: Duration) {
+    /**
+     * Send an invoke command and handle chunked responses.
+     * Returns a combined InvokeResponse with all responses from all chunks, or undefined if suppressResponse
+     */
+    async sendInvokeCommand(
+        invokeRequest: InvokeRequest,
+        expectedProcessingTime?: Duration,
+    ): Promise<InvokeResponse | undefined> {
         if (invokeRequest.suppressResponse) {
             await this.requestWithSuppressedResponse(
                 MessageType.InvokeRequest,
@@ -980,16 +1045,49 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
                 invokeRequest,
                 expectedProcessingTime,
             );
-        } else {
-            return await this.request(
-                MessageType.InvokeRequest,
-                TlvInvokeRequest,
+            return undefined;
+        }
+
+        // Send invoke request
+        await this.send(MessageType.InvokeRequest, TlvInvokeRequest.encode(invokeRequest), {
+            expectAckOnly: false,
+            expectedProcessingTime,
+        });
+
+        // Receive and accumulate responses from potentially multiple chunks
+        const allInvokeResponses: InvokeResponse["invokeResponses"] = [];
+        let finalResponse: InvokeResponse | undefined;
+
+        while (true) {
+            const responseMessage = await this.nextMessage(
                 MessageType.InvokeResponse,
-                TlvInvokeResponse,
-                invokeRequest,
-                expectedProcessingTime,
+                { expectedProcessingTime },
+                "InvokeResponse",
             );
+            const response = TlvInvokeResponse.decode(responseMessage.payload);
+
+            // Accumulate responses from this chunk
+            if (response.invokeResponses) {
+                allInvokeResponses.push(...response.invokeResponses);
+            }
+
+            // Check if more chunks are coming
+            if (response.moreChunkedMessages) {
+                await this.sendStatus(Status.Success, {
+                    multipleMessageInteraction: true,
+                    logContext: { for: "InvokeResponse-chunk" },
+                });
+            } else {
+                // This is the final chunk
+                finalResponse = {
+                    ...response,
+                    invokeResponses: allInvokeResponses,
+                };
+                break;
+            }
         }
+
+        return finalResponse;
     }
 
     async sendWriteCommand(writeRequest: WriteRequest) {