@matter/protocol 0.16.0-alpha.0-20251213-e83db3732 → 0.16.0-alpha.0-20251217-038f88085

package/src/action/client/ClientInteraction.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ClientRead } from "#action/client/ClientRead.js";
 import { Interactable, InteractionSession } from "#action/Interactable.js";
 import { ClientInvoke, Invoke } from "#action/request/Invoke.js";
 import { Read } from "#action/request/Read.js";
@@ -28,6 +29,8 @@ import {
     Minutes,
     RetrySchedule,
     Seconds,
+    Time,
+    TimeoutError,
 } from "#general";
 import { InteractionClientMessenger, MessageType } from "#interaction/InteractionMessenger.js";
 import { Subscription } from "#interaction/Subscription.js";
@@ -35,6 +38,7 @@ import { PeerAddress } from "#peer/index.js";
 import { ExchangeProvider } from "#protocol/ExchangeProvider.js";
 import { SecureSession } from "#session/SecureSession.js";
 import { Status, TlvAttributeReport, TlvNoResponse, TlvSubscribeResponse, TypeFromSchema } from "#types";
+import { ClientWrite } from "./ClientWrite.js";
 import { InputChunk } from "./InputChunk.js";
 import { ClientSubscribe } from "./subscription/ClientSubscribe.js";
 import { ClientSubscription } from "./subscription/ClientSubscription.js";
@@ -53,6 +57,7 @@ export interface ClientInteractionContext {
     abort?: Abort.Signal;
     sustainRetries?: RetrySchedule.Configuration;
     exchangeProvider?: ExchangeProvider;
+    address?: PeerAddress;
 }
 
 export const DEFAULT_MIN_INTERVAL_FLOOR = Seconds(1);
@@ -74,16 +79,17 @@ const DEFAULT_MINIMUM_RESPONSE_TIMEOUT_WITH_FAILSAFE = Seconds(30);
 export class ClientInteraction<
     SessionT extends InteractionSession = InteractionSession,
 > implements Interactable<SessionT> {
-    readonly #environment: Environment;
+    protected readonly environment: Environment;
     readonly #lifetime: Lifetime;
     readonly #exchanges: ExchangeProvider;
     readonly #interactions = new BasicSet<Read | Write | Invoke | Subscribe>();
     #subscriptions?: ClientSubscriptions;
     readonly #abort: Abort;
     readonly #sustainRetries: RetrySchedule;
+    readonly #address?: PeerAddress;
 
-    constructor({ environment, abort, sustainRetries, exchangeProvider }: ClientInteractionContext) {
-        this.#environment = environment;
+    constructor({ environment, abort, sustainRetries, exchangeProvider, address }: ClientInteractionContext) {
+        this.environment = environment;
         this.#exchanges = exchangeProvider ?? environment.get(ExchangeProvider);
         if (environment.has(ClientSubscriptions)) {
             this.#subscriptions = environment.get(ClientSubscriptions);
@@ -93,6 +99,7 @@ export class ClientInteraction<
             environment.get(Entropy),
             RetrySchedule.Configuration(SustainedSubscription.DefaultRetrySchedule, sustainRetries),
         );
+        this.#address = address;
 
         this.#lifetime = environment.join("interactions");
         Object.defineProperties(this.#lifetime.details, {
@@ -126,7 +133,7 @@ export class ClientInteraction<
 
     get subscriptions() {
         if (this.#subscriptions === undefined) {
-            this.#subscriptions = this.#environment.get(ClientSubscriptions);
+            this.#subscriptions = this.environment.get(ClientSubscriptions);
         }
         return this.#subscriptions;
     }
@@ -134,7 +141,7 @@ export class ClientInteraction<
     /**
      * Read attributes and events.
      */
-    async *read(request: Read, session?: SessionT): ReadResult {
+    async *read(request: ClientRead, session?: SessionT): ReadResult {
         const readPathsCount = (request.attributeRequests?.length ?? 0) + (request.eventRequests?.length ?? 0);
         if (readPathsCount === 0) {
             throw new ImplementationError("When reading attributes and events, at least one must be specified.");
@@ -182,7 +189,7 @@ export class ClientInteraction<
      * 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.
      */
-    async write<T extends Write>(request: T, session?: SessionT): WriteResult<T> {
+    async write<T extends ClientWrite>(request: T, session?: SessionT): WriteResult<T> {
         await using context = await this.#begin("writing", request, session);
         const { checkAbort, messenger } = context;
 
@@ -419,16 +426,6 @@ export class ClientInteraction<
             const responseMessage = await messenger.nextMessage(MessageType.SubscribeResponse);
             const response = TlvSubscribeResponse.decode(responseMessage.payload);
 
-            logger.info(
-                "Subscription successful",
-                Mark.INBOUND,
-                messenger.exchange.via,
-                Diagnostic.dict({
-                    id: response.subscriptionId,
-                    interval: Duration.format(Seconds(response.maxInterval)),
-                }),
-            );
-
             const subscription = new PeerSubscription({
                 lifetime: this.subscriptions,
                 request,
@@ -440,6 +437,17 @@ export class ClientInteraction<
             });
             this.subscriptions.addPeer(subscription);
 
+            logger.info(
+                "Subscription successful",
+                Mark.INBOUND,
+                messenger.exchange.via,
+                Diagnostic.dict({
+                    id: Subscription.idStrOf(response.subscriptionId),
+                    interval: Duration.format(Seconds(response.maxInterval)),
+                    timeout: Duration.format(subscription.timeout),
+                }),
+            );
+
             return subscription;
         };
 
@@ -482,13 +490,28 @@ export class ClientInteraction<
         if (this.#abort.aborted) {
             throw new ImplementationError("Client interaction unavailable after close");
         }
-        this.#interactions.add(request);
 
         const checkAbort = Abort.checkerFor(session);
 
-        const messenger = await InteractionClientMessenger.create(this.#exchanges);
+        const now = Time.nowMs;
+        let messenger: InteractionClientMessenger;
+        try {
+            messenger = await InteractionClientMessenger.create(this.#exchanges);
+        } catch (error) {
+            TimeoutError.accept(error);
+
+            // This logic implements a very basic automatic reconnection mechanism which is a bit like PairedNode
+            // The exchange creation fails only when the node is considered to be unavailable, so in this case we
+            // either try the last addresses again (if existing), or do a short-timed re-discovery. This would block
+            // the execution max 10s. What's missing is that one layer (like Sustained Subscription) would trigger a
+            // FullDiscovery instead of just a timed one, but for the tests and currently this should be enough.
+            await this.exchanges.reconnectChannel({ asOf: now, resetInitialState: true });
+            messenger = await InteractionClientMessenger.create(this.#exchanges);
+        }
+
+        this.#interactions.add(request);
 
-        // Provide via dynamically so is up-to-date if exchange changes due to retry
+        // Provide via dynamically so is up to date if exchange changes due to retry
         Object.defineProperty(lifetime.details, "via", {
             get() {
                 return messenger.exchange.via;
@@ -513,6 +536,22 @@ export class ClientInteraction<
 
         return context;
     }
+
+    get channelType() {
+        return this.#exchanges.channelType;
+    }
+
+    /** Calculates the current maximum response time for a message use in additional logic like timers. */
+    maximumPeerResponseTime(expectedProcessingTime?: Duration) {
+        return this.#exchanges.maximumPeerResponseTime(expectedProcessingTime);
+    }
+
+    get address() {
+        if (this.#address === undefined) {
+            throw new ImplementationError("This InteractionClient is not bound to a specific peer.");
+        }
+        return this.#address;
+    }
 }
 
 interface RequestContext {

package/src/action/client/ClientRead.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Read } from "#action/request/Read.js";
+import { ClientRequest } from "./ClientRequest.js";
+
+export interface ClientRead extends Read, ClientRequest {}

package/src/action/client/ClientRequest.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Represents a client request with customizable transmission behavior.
+ */
+export interface ClientRequest {
+    /**
+     * If true, the request will be queued over all peers of the node.
+     * If false, the request will be sent directly.
+     * If undefined, the request will be queued if the physical device is thread connected.
+     * TODO Adjust this to be owned by some internal network layer that maintains automatic limits per connection type
+     *  or such
+     * @deprecated
+     */
+    queued?: boolean;
+}

package/src/action/client/ClientWrite.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Write } from "#action/request/Write.js";
+import { ClientRequest } from "./ClientRequest.js";
+
+export interface ClientWrite extends Write, ClientRequest {}

package/src/action/client/QueuedClientInteraction.ts

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+    ClientInvoke,
+    ClientSubscribe,
+    ClientWrite,
+    DecodedInvokeResult,
+    InteractionSession,
+    ReadResult,
+    SubscriptionResult,
+    WriteResult,
+} from "#action/index.js";
+import { InteractionQueue } from "#peer/index.js";
+import { ClientInteraction, ClientInteractionContext } from "./ClientInteraction.js";
+import { ClientRead } from "./ClientRead.js";
+
+export interface QueuedClientInteractionContext extends ClientInteractionContext {
+    queue: InteractionQueue;
+}
+
+export class QueuedClientInteraction<
+    SessionT extends InteractionSession = InteractionSession,
+> extends ClientInteraction<SessionT> {
+    #queue?: InteractionQueue;
+
+    constructor(options: QueuedClientInteractionContext) {
+        super(options);
+        this.#queue = options.queue;
+    }
+
+    protected get queue() {
+        if (this.#queue === undefined) {
+            this.#queue = this.environment.get(InteractionQueue);
+        }
+        return this.#queue;
+    }
+
+    /**
+     * Read chosen attributes remotely from the node. Known data versions are automatically injected into the request to
+     * optimize the read.
+     * Therefore, the returned data only contains attributes that have changed since the last read or subscription.
+     * TODO: Allow control of data version injection and enrich response with attribute data missing in response due to data versioning?
+     */
+    override async *read(request: ClientRead, session?: SessionT): ReadResult {
+        using _slot = await this.queue.obtainSlot();
+
+        yield* super.read(request, session);
+    }
+
+    /**
+     * Subscribe to remote events and attributes as defined by {@link request}.
+     *
+     * matter.js updates local state
+     *
+     * By default, matter.js subscribes to all attributes and events of the peer and updates {@link ClientNode} state
+     * automatically.  So you normally do not need to subscribe manually.
+     *
+     * When providing the "sustain" flag, a SustainedSubscription is returned immediately. You need to use the events to
+     * know when/if a subscription could be established.  This class handles reconnections automatically.
+     * When not providing the "sustain" flag, a PeerSubscription is returned after a subscription have been successfully
+     * established; or an error is returned if this was not possible.
+     */
+    override async subscribe<T extends ClientSubscribe>(request: T, session?: SessionT): SubscriptionResult<T> {
+        using _slot = await this.queue.obtainSlot();
+
+        return super.subscribe(request, session);
+    }
+
+    /**
+     * 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();
+
+        return super.write(request, session);
+    }
+
+    /**
+     * Invoke a command remotely on the node.
+     * The returned command response is returned as response chunks
+     */
+    override async *invoke(request: ClientInvoke, session?: SessionT): DecodedInvokeResult {
+        using _slot = await this.queue.obtainSlot();
+
+        yield* super.invoke(request, session);
+    }
+}

package/src/action/client/index.ts

@@ -5,6 +5,10 @@
  */
 
 export * from "./ClientInteraction.js";
+export * from "./ClientRead.js";
+export * from "./ClientRequest.js";
+export * from "./ClientWrite.js";
 export * from "./InputChunk.js";
+export * from "./QueuedClientInteraction.js";
 export * from "./ReadScope.js";
 export * from "./subscription/index.js";

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

@@ -1,6 +1,7 @@
 import { Subscribe } from "#action/request/Subscribe.js";
+import { ClientRequest } from "../ClientRequest.js";
 
-export interface ClientSubscribe extends Subscribe {
+export interface ClientSubscribe extends Subscribe, ClientRequest {
     /**
      * If true the subscription is virtualized and the underlying subscription is reestablished when lost.
      */

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

@@ -54,7 +54,10 @@ export class ClientSubscriptionHandler implements ProtocolHandler {
         SecureSession.assert(session);
         const subscription = this.#subscriptions.getPeer(session.peerAddress, subscriptionId);
         if (subscription === undefined) {
-            logger.info("Ignoring data report for unknown subscription ID", Diagnostic.strong(subscriptionId));
+            logger.info(
+                "Ignoring data report for unknown subscription ID",
+                Diagnostic.strong(Subscription.idStrOf(subscriptionId)),
+            );
             await sendInvalid(messenger, subscriptionId);
             return;
         }
@@ -68,7 +71,10 @@ export class ClientSubscriptionHandler implements ProtocolHandler {
                 // Read the next report to trigger success message sent out
                 const ending = await reports.next();
                 if (!ending.done) {
-                    logger.warn("Unexpected data reports after empty report", Diagnostic.strong(subscriptionId));
+                    logger.warn(
+                        "Unexpected data reports after empty report",
+                        Diagnostic.strong(Subscription.idStrOf(subscriptionId)),
+                    );
                     for await (const _chunk of reports); // Read over these extraneous reports
                 }
             } else {
@@ -125,7 +131,12 @@ async function* processReports(
         }
 
         if (reportSubscriptionId !== subscriptionId) {
-            logger.debug("Ignoring data report for incorrect subscription id", Diagnostic.strong(reportSubscriptionId));
+            logger.debug(
+                "Ignoring data report for incorrect subscription id",
+                Diagnostic.strong(Subscription.idStrOf(reportSubscriptionId)),
+                "expected",
+                Subscription.idStrOf(subscriptionId),
+            );
             await sendInvalid(messenger, reportSubscriptionId);
             continue;
         }

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

@@ -56,7 +56,7 @@ export class SustainedSubscription extends ClientSubscription {
     }
 
     /**
-     * Emits when active state changes.
+     * Emits when the active state changes.
      */
     get active() {
         return this.#active;
@@ -73,7 +73,7 @@ export class SustainedSubscription extends ClientSubscription {
         const updated = this.#request.updated?.bind(this.#request);
 
         while (true) {
-            // Create request and promise that will inform us when the underlying subscription closes
+            // Create a request and promise that will inform us when the underlying subscription closes
             const request = { ...this.#request, updated };
             if (this.#request.updated) {
                 request.updated = this.#request.updated.bind(request);
@@ -111,7 +111,7 @@ export class SustainedSubscription extends ClientSubscription {
                 }
             }
 
-            // Notify listeners of active subscription
+            // Notify listeners of an active subscription
             await this.#inactive.emit(false);
             await this.#active.emit(true);
             if (this.abort.aborted) {
@@ -121,19 +121,16 @@ export class SustainedSubscription extends ClientSubscription {
             // Wait for the subscription to close
             await closed;
 
-            // Notify listeners of inactive subscription
+            // Notify listeners of an inactive subscription
             await this.#active.emit(false);
             await this.#inactive.emit(true);
-            if (this.abort.aborted) {
-                break;
-            }
 
-            // If aborted then we're done
+            // If aborted, then we're done
             if (this.abort.aborted) {
                 break;
             }
 
-            // If we aren't aborted then we are here due to timeout
+            // If we aren't aborted, then we are here due to timeout
             logger.error(`Replacing subscription to ${this.peer} due to timeout`);
         }
 

package/src/action/request/Invoke.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ClientRequest } from "#action/client/ClientRequest.js";
 import { Diagnostic, Duration, isObject } from "#general";
 import { SessionParameters } from "#session/SessionParameters.js";
 import { ClusterType, CommandData, FabricIndex, InvokeRequest, ObjectSchema, TlvSchema, TypeFromSchema } from "#types";
@@ -17,11 +18,20 @@ export interface InvokeCommandData extends CommandData {
 export interface Invoke extends InvokeRequest {
     /** Timeout only relevant for Client Interactions */
     timeout?: Duration;
+
+    /** Expected processing time of the command on the server side to calculated response timeout */
     expectedProcessingTime?: Duration;
+
+    /** Whether to use extended timeout for fail-safe messages.  Overwrites the expectedProcessingTime if both are set */
     useExtendedFailSafeMessageResponseTimeout?: boolean;
 }
 
-export interface ClientInvoke extends Invoke {
+export interface CommandDecodeDetails {
+    responseSchema: TlvSchema<any>;
+    [Diagnostic.value]: () => unknown;
+}
+
+export interface ClientInvoke extends Invoke, ClientRequest {
     commands: Map<number | undefined, Invoke.CommandRequest<any>>;
 }
 
@@ -234,9 +244,6 @@ export namespace Invoke {
     export function commandOf<const R extends CommandRequest>(request: R): ClusterType.Command {
         if (typeof request.command === "string") {
             const cluster = Specifier.clusterFor(request.cluster);
-            if (cluster === undefined) {
-                throw new MalformedRequestError(`Cannot designate command "${request.command}" without cluster`);
-            }
             const command = cluster.commands[request.command];
             if (command === undefined) {
                 throw new MalformedRequestError(`Cluster ${cluster.name} does not define command ${request.command}`);

package/src/action/request/Read.ts

@@ -45,11 +45,12 @@ export function Read(optionsOrSelector: Read.Options | Read.Selector, ...selecto
     } else {
         options = optionsOrSelector;
     }
+    const { fabricFilter = true, interactionModelRevision = Specification.INTERACTION_MODEL_REVISION } = options;
     let { attributes: attributeRequests, versionFilters, events: eventRequests, eventFilters } = options;
 
     const result = {
-        isFabricFiltered: options.fabricFilter ?? true,
-        interactionModelRevision: options.interactionModelRevision ?? Specification.INTERACTION_MODEL_REVISION,
+        isFabricFiltered: fabricFilter,
+        interactionModelRevision,
         [Diagnostic.value]: () =>
             Diagnostic.dict({
                 attributes: attributeRequests?.length

package/src/action/request/Specifier.ts

@@ -57,7 +57,10 @@ export namespace Specifier {
     /**
      * Extract a cluster type from a cluster specifier.
      */
-    export function clusterFor<const T extends Cluster>(specifier: T) {
+    export function clusterFor<const T extends Cluster>(specifier?: T) {
+        if (specifier === undefined) {
+            throw new MalformedRequestError(`Cannot designate command "${specifier}" without a cluster`);
+        }
         if ("cluster" in specifier) {
             return specifier["cluster"] as ClusterFor<T>;
         }

package/src/action/request/Write.ts

@@ -52,14 +52,22 @@ export function Write(optionsOrData: Write.Options | Write.Attribute, ...data: W
     } else {
         options = optionsOrData;
     }
-    const { writes: writeRequests = [], timed, timeout, chunkLists } = options;
+    const {
+        writes: writeRequests = [],
+        timed,
+        timeout,
+        chunkLists,
+        suppressResponse,
+        interactionModelRevision = Specification.INTERACTION_MODEL_REVISION,
+    } = options;
 
     const result = {
         timedRequest: !!timed || !!timeout,
         timeout,
         writeRequests,
         moreChunkedMessages: false,
-        interactionModelRevision: options.interactionModelRevision ?? Specification.INTERACTION_MODEL_REVISION,
+        suppressResponse,
+        interactionModelRevision,
 
         [Diagnostic.value]: () =>
             Diagnostic.list(
@@ -158,6 +166,7 @@ export namespace Write {
         timeout?: Duration;
         interactionModelRevision?: number;
         chunkLists?: boolean;
+        suppressResponse?: boolean;
     }
 
     /**

package/src/action/response/ReadResult.ts

@@ -28,7 +28,7 @@ import type {
  * Iteration occurs in chunks for performance reasons.  A chunk is an iterable of reports, one per output attribute or
  * event.
  */
-export interface ReadResult<Chunk = ReadResult.Chunk> extends AsyncIterableIterator<Chunk> {}
+export interface ReadResult<Chunk = ReadResult.Chunk> extends AsyncIterable<Chunk> {}
 
 export namespace ReadResult {
     export type Chunk = Iterable<Report>;

package/src/cluster/client/ClusterClientTypes.ts

@@ -16,7 +16,9 @@ import {
     CommandId,
     Commands,
     EndpointNumber,
+    Event,
     EventId,
+    EventNumber,
     EventType,
     Events,
     GlobalAttributeNames,
@@ -35,15 +37,53 @@ import {
     WritableAttribute,
 } from "#types";
 import { DecodedEventData } from "../../interaction/EventDataDecoder.js";
-import { AttributeClient } from "./AttributeClient.js";
-import { EventClient } from "./EventClient.js";
+
+export interface AttributeClientObj<T = any> {
+    readonly id: AttributeId;
+    readonly attribute: Attribute<T, any>;
+    readonly name: string;
+    readonly endpointId: EndpointNumber | undefined;
+    readonly clusterId: ClusterId;
+    readonly fabricScoped: boolean;
+    set(value: T, dataVersion?: number): Promise<void>;
+    getLocal(): T | undefined;
+    get(requestFromRemote?: boolean, isFabricFiltered?: boolean): Promise<T | undefined>;
+    subscribe(
+        minIntervalFloorSeconds: number,
+        maxIntervalCeilingSeconds: number,
+        knownDataVersion?: number,
+        isFabricFiltered?: boolean,
+    ): Promise<{ maxInterval: number }>;
+    update(value: T): void;
+    addListener(listener: (newValue: T) => void): void;
+    removeListener(listener: (newValue: T) => void): void;
+}
+
+export interface EventClientObj<T> {
+    readonly id: EventId;
+    readonly event: Event<T, any>;
+    readonly name: string;
+    readonly endpointId: EndpointNumber | undefined;
+    readonly clusterId: ClusterId;
+    get(minimumEventNumber?: EventNumber, isFabricFiltered?: boolean): Promise<DecodedEventData<T>[] | undefined>;
+    subscribe(
+        minIntervalFloorSeconds: Duration,
+        maxIntervalCeilingSeconds: Duration,
+        isUrgent?: boolean,
+        minimumEventNumber?: EventNumber,
+        isFabricFiltered?: boolean,
+    ): Promise<{ maxInterval: number }>;
+    update(newEvent: DecodedEventData<T>): void;
+    addListener(listener: (newValue: DecodedEventData<T>) => void): void;
+    removeListener(listener: (newValue: DecodedEventData<T>) => void): void;
+}
 
 export type AttributeClients<F extends BitSchema, A extends Attributes> = Merge<
     Merge<
-        { [P in MandatoryAttributeNames<A>]: AttributeClient<AttributeJsType<A[P]>> },
-        { [P in OptionalAttributeNames<A>]: AttributeClient<AttributeJsType<A[P]> | undefined> }
+        { [P in MandatoryAttributeNames<A>]: AttributeClientObj<AttributeJsType<A[P]>> },
+        { [P in OptionalAttributeNames<A>]: AttributeClientObj<AttributeJsType<A[P]> | undefined> }
     >,
-    { [P in GlobalAttributeNames<F>]: AttributeClient<AttributeJsType<GlobalAttributes<F>[P]>> }
+    { [P in GlobalAttributeNames<F>]: AttributeClientObj<AttributeJsType<GlobalAttributes<F>[P]>> }
 >;
 
 export type AttributeClientValues<A extends Attributes> = Merge<
@@ -52,8 +92,8 @@ export type AttributeClientValues<A extends Attributes> = Merge<
 >;
 
 export type EventClients<E extends Events> = Merge<
-    { [P in MandatoryEventNames<E>]: EventClient<EventType<E[P]>> },
-    { [P in OptionalEventNames<E>]: EventClient<EventType<E[P]> | undefined> }
+    { [P in MandatoryEventNames<E>]: EventClientObj<EventType<E[P]>> },
+    { [P in OptionalEventNames<E>]: EventClientObj<EventType<E[P]> | undefined> }
 >;
 
 export type SignatureFromCommandSpec<C extends Command<any, any, any>> = (

package/src/cluster/client/index.ts

@@ -4,7 +4,4 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-export * from "./AttributeClient.js";
-export * from "./ClusterClient.js";
 export * from "./ClusterClientTypes.js";
-export * from "./EventClient.js";

package/src/interaction/InteractionMessenger.ts

@@ -10,12 +10,12 @@ import {
     Bytes,
     Diagnostic,
     Duration,
-    hex,
     InternalError,
     Logger,
     MatterFlowError,
     Millis,
     NoResponseTimeoutError,
+    Time,
     UnexpectedDataError,
 } from "#general";
 import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
@@ -1014,7 +1014,7 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
 
     #logContextOf(report: DataReport) {
         return {
-            subId: report.subscriptionId === undefined ? undefined : hex.fixed(report.subscriptionId, 8),
+            subId: report.subscriptionId === undefined ? undefined : Subscription.idStrOf(report.subscriptionId),
             dataReportFlags: Diagnostic.asFlags({
                 empty: !report.attributeReports?.length && !report.eventReports?.length,
                 suppressResponse: report.suppressResponse,
@@ -1041,6 +1041,7 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
 
     /** Implements a send method with an automatic reconnection mechanism */
     override async send(messageType: number, payload: Bytes, options?: ExchangeSendOptions) {
+        const now = Time.nowMs;
         try {
             if (this.exchange.channel.closed) {
                 throw new SessionClosedError("The exchange channel is closed. Please connect the device first.");
@@ -1054,12 +1055,12 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
                 !options?.multipleMessageInteraction
             ) {
                 // When retransmission failed (most likely due to a lost connection or invalid session),
-                // try to reconnect if possible and resend the message once
+                // try to reconnect if possible and resend the message one more time
                 logger.debug(
                     `${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()) {
+                if (await this.#exchangeProvider.reconnectChannel({ asOf: now })) {
                     this.exchange = await this.#exchangeProvider.initiateExchange();
                     return await this.exchange.send(messageType, payload, options);
                 }