@matter/node 0.17.9 → 0.18.0-alpha.0-20260812-4d7f2790e

package/src/behavior/system/network/NetworkClient.ts

@@ -5,9 +5,11 @@
  */
 
 import { RemoteDescriptor } from "#behavior/system/commissioning/RemoteDescriptor.js";
+import { IcdClient } from "#behavior/system/icd/IcdClient.js";
 import { ClientNodeInteraction } from "#node/client/ClientNodeInteraction.js";
 import { ClientNodePhysicalProperties } from "#node/client/ClientNodePhysicalProperties.js";
 import type { ClientNode } from "#node/ClientNode.js";
+import { NodeConnectionState } from "#node/ClientNodeLifecycle.js";
 import { Node } from "#node/Node.js";
 import { ClientCacheBuffer } from "#storage/client/ClientCacheBuffer.js";
 import { ChannelType, Observable, ServerAddress } from "@matter/general";
@@ -41,6 +43,10 @@ export class NetworkClient extends NetworkBehavior {
                 offline: true,
             });
             this.reactTo(this.events.subscriptionStatusChanged, this.#flushCacheOnSubscribed);
+
+            this.reactTo(this.events.subscriptionStatusChanged, this.#recomputeConnectionState);
+            this.reactTo(this.events.isDisabled$Changed, this.#recomputeConnectionState);
+            this.reactTo(this.#node.lifecycle.decommissioned, this.#recomputeConnectionState);
         }
     }
 
@@ -79,11 +85,29 @@ export class NetworkClient extends NetworkBehavior {
                     this.state.transportPreference ??
                     (this.#node.owner?.state as Record<string, Val.Struct> | undefined)?.network?.transportPreference;
                 peer.transportPreference = pref === "tcp" ? ChannelType.TCP : undefined;
+
+                if (this.#node.nodeType !== "group") {
+                    // These emit synchronously from the peer's retransmission/session paths with no context, so the
+                    // handlers run in an isolated transaction (offline) and a fault cannot escape into those paths.
+                    this.reactTo(peer.establishmentUnresponsive, this.#markLikelyOffline, { offline: true });
+                    this.reactTo(peer.sessions.added, this.#onSessionEstablished, { offline: true });
+                }
             }
         }
 
         await this.#syncAutoSubscribe();
 
+        if (this.#node.nodeType !== "group") {
+            if (this.endpoint.behaviors.has(IcdClient)) {
+                // Gated on startup-time presence only; ICD support installed later falls back to the slower
+                // establishment-unresponsive path for offline detection rather than this check-in fast path.
+                this.reactTo(this.endpoint.eventsOf(IcdClient).checkInMissed, this.#markLikelyOffline, {
+                    offline: true,
+                });
+            }
+            this.#recomputeConnectionState();
+        }
+
         this.internal.runtime!.isReady = true;
     }
 
@@ -194,6 +218,50 @@ export class NetworkClient extends NetworkBehavior {
         return activeSubscription instanceof SustainedSubscription ? activeSubscription.active.value : true;
     }
 
+    /**
+     * Recompute the node's {@link NodeConnectionState} from the current liveness signals and push it into the
+     * lifecycle.  A live subscription is authoritative and clears the likely-offline latch.
+     */
+    #recomputeConnectionState() {
+        const { lifecycle } = this.#node;
+
+        let state: NodeConnectionState;
+        if (this.subscriptionActive) {
+            this.internal.likelyOffline = false;
+            state = NodeConnectionState.Connected;
+        } else if (this.state.isDisabled || lifecycle.shouldBeOffline) {
+            // Disabled, stopped or not yet started.  Reset the offline latch so a later re-enable/restart does not
+            // resume in WaitingForDeviceDiscovery before any fresh session.
+            this.internal.likelyOffline = false;
+            state = NodeConnectionState.Disconnected;
+        } else if (this.internal.likelyOffline) {
+            state = NodeConnectionState.WaitingForDeviceDiscovery;
+        } else {
+            state = NodeConnectionState.Reconnecting;
+        }
+
+        lifecycle.setConnectionState(state);
+    }
+
+    /**
+     * Latch the peer as likely offline (idempotent) and re-evaluate.  Driven by an establishment-unresponsive signal
+     * or a registered ICD missing its check-in.
+     */
+    #markLikelyOffline() {
+        this.internal.likelyOffline = true;
+        this.#recomputeConnectionState();
+    }
+
+    /**
+     * A fresh session is proof the peer responded, so drop the likely-offline latch and re-evaluate.  This relaxes
+     * {@link NodeConnectionState.WaitingForDeviceDiscovery} back to {@link NodeConnectionState.Reconnecting} until the
+     * subscription re-establishes.
+     */
+    #onSessionEstablished() {
+        this.internal.likelyOffline = false;
+        this.#recomputeConnectionState();
+    }
+
     override async [Symbol.asyncDispose]() {
         // Clean up any active subscription
         this.internal.activeSubscription?.close();
@@ -277,6 +345,13 @@ export namespace NetworkClient {
          * ensures we have a complete snapshot of the node's state when commissioning logic is complete.
          */
         isNewlyCommissioned = false;
+
+        /**
+         * Latch indicating the peer is likely offline (unresponsive establishment, hard send failure or a missed ICD
+         * check-in).  Set by liveness signals, cleared on a fresh session, an active subscription or when the node is
+         * disabled/stopped.  Drives {@link NodeConnectionState.WaitingForDeviceDiscovery}.
+         */
+        likelyOffline = false;
     }
 
     export class State extends NetworkBehavior.State {
@@ -331,6 +406,7 @@ export namespace NetworkClient {
     export class Events extends NetworkBehavior.Events {
         autoSubscribe$Changed = new Observable<[value: boolean, oldValue: boolean]>();
         defaultSubscription$Changed = new Observable<[value: Subscribe | undefined, oldValue: Subscribe | undefined]>();
+        isDisabled$Changed = new Observable<[value: boolean, oldValue: boolean]>();
         subscriptionStatusChanged = new Observable<[isActive: boolean]>();
         subscriptionAlive = new Observable<[]>();
     }

package/src/behavior/system/network/NetworkServer.ts

@@ -149,6 +149,9 @@ export namespace NetworkServer {
     }
 
     export class LimitsConfig extends ConcreteLimitsConfig {
+        @field(duration)
+        bdxAdditionalMrpDelay?: Duration;
+
         @field(ConcreteLimitsConfig)
         connect?: ConcreteLimitsConfig;
 
@@ -218,6 +221,20 @@ export namespace NetworkServer {
          */
         transportPreference?: "tcp" | "udp";
 
+        /**
+         * Controller-level connection policy for commissioned peers.
+         *
+         * When true (default), the node auto-connects every commissioned, non-disabled peer as it goes online — the
+         * right choice for a headless controller or bridge that wants all peers live.
+         *
+         * When false, no peer is connected on online and the consumer starts peers on demand (`ClientNode.start()` /
+         * `ClientNode.enable()`).  Use this for interactive or debug controllers that manage connections themselves
+         * (e.g. the nodejs shell).  This is orthogonal to per-node `ClientNode.disable()`: this flag is a controller
+         * policy that leaves peers enabled, whereas disabling a peer is a persisted per-node "this node is off" state
+         * (a seasonal device, say) that the bulk connect skips regardless of this flag.
+         */
+        autoStartCommissionedPeers = true;
+
         /**
          * Network profile describing our own (local) network — the sender-side MRP additive-delay
          * axis.  Defaults to "fast"; set to "thread" on a Thread device.

package/src/behavior/system/network/ServerNetworkRuntime.ts

@@ -18,6 +18,7 @@ import {
     NetworkInterfaceDetailed,
     NoAddressAvailableError,
     ObserverGroup,
+    STANDARD_MATTER_PORT,
     Transport,
     TransportSet,
     UdpTransport,
@@ -316,6 +317,13 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         const { owner } = this;
         const { env } = owner;
 
+        // A commissionable node binds the well-known Matter port so commissioners find it at a known location.  A node
+        // with commissioning disabled (e.g. a controller) uses an ephemeral port rather than squatting 5540.  An
+        // explicit port is always honored.
+        if (owner.state.network.port === undefined && owner.state.commissioning.enabled !== false) {
+            await owner.set({ network: { port: STANDARD_MATTER_PORT } });
+        }
+
         // Configure network
         const interfaces = env.get(TransportSet);
         await this.addTransports(interfaces);

package/src/behavior/system/software-update/SoftwareUpdateManager.ts

@@ -55,10 +55,19 @@ import { OtaSoftwareUpdateRequestor } from "@matter/types/clusters/ota-software-
 
 const logger = Logger.get("SoftwareUpdateManager");
 
-interface UpdateConsent {
-    vendorId: VendorId;
-    productId: number;
-    targetSoftwareVersion: number;
+/** Rejects transfer options a BDX session could not honour, before any state changes on their behalf. */
+function assertTransferOptions({ maxBdxBlockSize, bdxAdditionalMrpDelay }: SoftwareUpdateManager.UpdateTarget) {
+    if (maxBdxBlockSize !== undefined && (!Number.isInteger(maxBdxBlockSize) || maxBdxBlockSize <= 0)) {
+        throw new ImplementationError(`maxBdxBlockSize must be a positive integer, got ${maxBdxBlockSize}`);
+    }
+    if (bdxAdditionalMrpDelay !== undefined && (!Number.isFinite(bdxAdditionalMrpDelay) || bdxAdditionalMrpDelay < 0)) {
+        throw new ImplementationError(
+            `bdxAdditionalMrpDelay must be a finite, non-negative duration, got ${bdxAdditionalMrpDelay}`,
+        );
+    }
+}
+
+interface UpdateConsent extends SoftwareUpdateManager.UpdateTarget {
     peerAddress: PeerAddress;
 }
 
@@ -646,7 +655,7 @@ export class SoftwareUpdateManager extends Behavior {
             };
             this.internal.knownUpdates.set(peerAddress, details);
 
-            const hasConsent = this.internal.consents.some(
+            const consent = this.internal.consents.find(
                 consent =>
                     consent.vendorId === vendorId &&
                     consent.productId === productId &&
@@ -657,13 +666,15 @@ export class SoftwareUpdateManager extends Behavior {
             if (this.internal.suppressUpdates) {
                 break;
             }
-            if (hasConsent) {
+            if (consent !== undefined) {
                 // We already have a consent for this update, so just announce the provider
                 this.#queueUpdate({
                     endpoint,
                     vendorId,
                     productId,
                     targetSoftwareVersion: updateDetails.softwareVersion,
+                    maxBdxBlockSize: consent.maxBdxBlockSize,
+                    bdxAdditionalMrpDelay: consent.bdxAdditionalMrpDelay,
                     peerAddress,
                 });
             } else {
@@ -837,6 +848,8 @@ export class SoftwareUpdateManager extends Behavior {
             existing.productId = entry.productId;
             existing.targetSoftwareVersion = entry.targetSoftwareVersion;
             existing.endpoint = entry.endpoint;
+            existing.maxBdxBlockSize = entry.maxBdxBlockSize;
+            existing.bdxAdditionalMrpDelay = entry.bdxAdditionalMrpDelay;
             logger.info(`Updated existing queued update for node ${entry.peerAddress.toString()}`);
         } else {
             logger.info(`Queuing update consent for node ${entry.peerAddress.toString()}`);
@@ -954,7 +967,9 @@ export class SoftwareUpdateManager extends Behavior {
      * This can be used when an exact timing of the update is needed. When the update can be executed in a delayed/queued
      * manner, please use `addUpdateConsent()`.
      */
-    async forceUpdate(peerAddress: PeerAddress, vendorId: VendorId, productId: number, targetSoftwareVersion: number) {
+    async forceUpdate(peerAddress: PeerAddress, target: SoftwareUpdateManager.UpdateTarget) {
+        const { vendorId, productId, targetSoftwareVersion } = target;
+        assertTransferOptions(target);
         peerAddress = PeerAddress(peerAddress);
         const existingEntry = this.internal.updateQueue.find(
             e =>
@@ -988,7 +1003,7 @@ export class SoftwareUpdateManager extends Behavior {
             }
         }
 
-        const added = await this.addUpdateConsent(peerAddress, vendorId, productId, targetSoftwareVersion);
+        const added = await this.addUpdateConsent(peerAddress, target);
         if (!added) {
             throw new OtaUpdateError(`Node at ${peerAddress.toString()} is not currently applicable for OTA updates`);
         }
@@ -1048,6 +1063,25 @@ export class SoftwareUpdateManager extends Behavior {
         this.#triggerQueuedUpdate();
     }
 
+    /**
+     * How BDX should carry this peer's pending update: the options given with its consent, else the general defaults
+     * in {@link State}.  An absent value leaves the decision to the peer and its medium.
+     *
+     * A consent may exist before the update is queued, so both are consulted.
+     */
+    bdxTransferOptionsFor(peerAddress: PeerAddress) {
+        peerAddress = PeerAddress(peerAddress);
+        const matches = (candidate: PeerAddress) =>
+            candidate.fabricIndex === peerAddress.fabricIndex && candidate.nodeId === peerAddress.nodeId;
+        const pending =
+            this.internal.updateQueue.find(entry => matches(entry.peerAddress)) ??
+            this.internal.consents.find(consent => matches(consent.peerAddress));
+        return {
+            maxBlockSize: pending?.maxBdxBlockSize ?? this.state.maxBdxBlockSize,
+            additionalMrpDelay: pending?.bdxAdditionalMrpDelay ?? this.state.bdxAdditionalMrpDelay,
+        };
+    }
+
     /**
      * Adds or updates a consent for a given peer address, vendor ID, product ID, and target software version.
      * Filters out existing consents for the given peer address and replaces them with the new one.
@@ -1055,12 +1089,9 @@ export class SoftwareUpdateManager extends Behavior {
      * the next queue slot, so potentially delayed.
      * This can be used when the update can be executed in a delayed/queued manner and it does not matter exactly when.
      */
-    async addUpdateConsent(
-        peerAddress: PeerAddress,
-        vendorId: VendorId,
-        productId: number,
-        targetSoftwareVersion: number,
-    ) {
+    async addUpdateConsent(peerAddress: PeerAddress, target: SoftwareUpdateManager.UpdateTarget) {
+        const { vendorId, productId, targetSoftwareVersion, maxBdxBlockSize, bdxAdditionalMrpDelay } = target;
+        assertTransferOptions(target);
         peerAddress = PeerAddress(peerAddress);
         // Filter out all existing consents for this peer, they are replaced by the new one
         const consents = this.internal.consents.filter(
@@ -1083,6 +1114,8 @@ export class SoftwareUpdateManager extends Behavior {
             vendorId,
             productId,
             targetSoftwareVersion,
+            maxBdxBlockSize,
+            bdxAdditionalMrpDelay,
             peerAddress,
         });
         this.internal.consents = consents;
@@ -1092,7 +1125,15 @@ export class SoftwareUpdateManager extends Behavior {
             return false;
         }
 
-        this.#queueUpdate({ vendorId, productId, targetSoftwareVersion, peerAddress, endpoint: otaEndpoint });
+        this.#queueUpdate({
+            vendorId,
+            productId,
+            targetSoftwareVersion,
+            maxBdxBlockSize,
+            bdxAdditionalMrpDelay,
+            peerAddress,
+            endpoint: otaEndpoint,
+        });
         return true;
     }
 
@@ -1231,6 +1272,42 @@ export namespace SoftwareUpdateManager {
 
         /** Interval to Announces this controller as Update provider. Must not be lower than 24h! */
         announcementInterval = Hours(24);
+
+        /**
+         * Caps the BDX block size offered for OTA transfers.  Unset accepts whatever the peer requests, which is the
+         * transport maximum.
+         *
+         * A smaller block multiplies round trips, and each of those is bounded by the peer's BDX response budget, so
+         * lower this only for a peer that cannot handle full-size blocks.
+         */
+        maxBdxBlockSize?: number = undefined;
+
+        /**
+         * Additive MRP retransmission margin for OTA transfers, overriding the margin the peer's medium implies.
+         *
+         * A BDX retransmission interval is capped so the whole schedule fits the peer's response budget, so values
+         * above roughly 7s are inert.
+         */
+        bdxAdditionalMrpDelay?: Duration = undefined;
+    }
+
+    /** Identifies the update a consent applies to, and how to transfer it. */
+    export interface UpdateTarget {
+        vendorId: VendorId;
+        productId: number;
+        targetSoftwareVersion: number;
+
+        /**
+         * Caps the BDX block size for this transfer, overriding {@link State.maxBdxBlockSize}.  Unset falls back to
+         * that default.
+         */
+        maxBdxBlockSize?: number;
+
+        /**
+         * Additive MRP retransmission margin for this transfer, overriding {@link State.bdxAdditionalMrpDelay} and the
+         * margin the peer's medium implies.  Unset falls back to that default.
+         */
+        bdxAdditionalMrpDelay?: Duration;
     }
 
     export class Internal {

package/src/behaviors/color-control/ColorControlServer.ts

@@ -2016,6 +2016,5 @@ export namespace ColorControlBaseServer {
     };
 }
 
-// We had turned on some more features to provide a default implementation, but export the cluster with default
-// Features again.
-export class ColorControlServer extends ColorControlBaseServer.for(ColorControl) {}
+// Drop the features the base implementation enables internally so consumers select their own
+export class ColorControlServer extends ColorControlBaseServer.with() {}

package/src/behaviors/door-lock/DoorLockServer.ts

@@ -1160,4 +1160,4 @@ export namespace DoorLockBaseServer {
 /**
  * Default DoorLock server with no features enabled. Use `.with()` to enable features.
  */
-export class DoorLockServer extends DoorLockBaseServer.for(DoorLock) {}
+export class DoorLockServer extends DoorLockBaseServer.with() {}

package/src/behaviors/electrical-energy-measurement/ElectricalEnergyMeasurementServer.ts

@@ -89,7 +89,5 @@ export namespace ElectricalEnergyMeasurementBaseServer {
     };
 }
 
-// Reset all Features
-export class ElectricalEnergyMeasurementServer extends ElectricalEnergyMeasurementBaseServer.for(
-    ElectricalEnergyMeasurement,
-) {}
+// Drop the features the base implementation enables internally so consumers select their own
+export class ElectricalEnergyMeasurementServer extends ElectricalEnergyMeasurementBaseServer.with() {}

package/src/behaviors/general-diagnostics/GeneralDiagnosticsServer.ts

@@ -7,6 +7,7 @@
 import type { ValueSupervisor } from "#behavior/supervision/ValueSupervisor.js";
 import { NetworkRuntime } from "#behavior/system/network/NetworkRuntime.js";
 import type { ServerNetworkRuntime } from "#behavior/system/network/ServerNetworkRuntime.js";
+import { BasicInformationBehavior } from "#behaviors/basic-information";
 import { NetworkCommissioningServer } from "#behaviors/network-commissioning";
 import { TimeSynchronizationBehavior } from "#behaviors/time-synchronization";
 import type { Endpoint } from "#endpoint/Endpoint.js";
@@ -32,7 +33,15 @@ import {
 } from "@matter/general";
 import { FieldElement, Specification } from "@matter/model";
 import { assertRemoteActor, MdnsService, SessionManager, Val } from "@matter/protocol";
-import { CommandId, FabricIndex, Status, StatusResponseError, TlvInvokeResponse, TlvOfModel } from "@matter/types";
+import {
+    CommandId,
+    DEFAULT_MAX_PATHS_PER_INVOKE,
+    FabricIndex,
+    Status,
+    StatusResponseError,
+    TlvInvokeResponse,
+    TlvOfModel,
+} from "@matter/types";
 import { GeneralDiagnostics } from "@matter/types/clusters/general-diagnostics";
 import { GeneralDiagnosticsBehavior } from "./GeneralDiagnosticsBehavior.js";
 
@@ -96,6 +105,32 @@ export class GeneralDiagnosticsServer extends Base {
         this.maybeReactTo(this.events.activeNetworkFaults$Changed, this.#triggerActiveNetworkFaultsChangedEvent);
     }
 
+    /**
+     * DataModelTest is mandatory above a maxPathsPerInvoke of one.
+     *
+     * @see {@link MatterSpecification.v16.Core} § 11.12.4.1
+     * @throws {@link ImplementationError} if the feature is absent above a maxPathsPerInvoke of one
+     */
+    #assertDataModelTest() {
+        const maxPathsPerInvoke =
+            this.endpoint.maybeStateOf(BasicInformationBehavior)?.maxPathsPerInvoke ?? DEFAULT_MAX_PATHS_PER_INVOKE;
+
+        if (!this.features.dataModelTest) {
+            if (maxPathsPerInvoke > 1) {
+                throw new ImplementationError(
+                    `The DataModelTest feature is mandatory with a maxPathsPerInvoke of ${maxPathsPerInvoke}; select it with GeneralDiagnosticsServer.with("DataModelTest") or set maxPathsPerInvoke to 1`,
+                );
+            }
+            return;
+        }
+
+        if (maxPathsPerInvoke === 1) {
+            logger.info(
+                "The DataModelTest feature is enabled but is only required when maxPathsPerInvoke is greater than 1; disable it with GeneralDiagnosticsServer.with() if you do not want to advertise it",
+            );
+        }
+    }
+
     #validateTestEnabledKey(enableKey: Bytes) {
         const keyData = Bytes.of(enableKey);
         if (keyData.every(byte => byte === 0)) {
@@ -303,6 +338,8 @@ export class GeneralDiagnosticsServer extends Base {
     }
 
     async #online() {
+        this.#assertDataModelTest();
+
         this.events.bootReason.emit(
             { bootReason: this.state.bootReason ?? GeneralDiagnostics.BootReason.Unspecified },
             this.context,
@@ -412,6 +449,10 @@ export namespace GeneralDiagnosticsServer {
         deviceTestEnableKey: Bytes = new Uint8Array(16).fill(0);
 
         [Val.properties](endpoint: Endpoint, session: ValueSupervisor.Session) {
+            // Invoked on the underlying state, so read our own values from here.  Reading them via the endpoint would
+            // require naming this behavior's type, and a type naming features the application did not select is absent
+            const state = this;
+
             return {
                 /**
                  * Report uptime
@@ -447,7 +488,7 @@ export namespace GeneralDiagnosticsServer {
                         Time.nowMs,
                     ).duration;
 
-                    const timeAsOfLastUpdate = endpoint.stateOf(GeneralDiagnosticsServer).totalOperationalHoursCounter;
+                    const timeAsOfLastUpdate = state.totalOperationalHoursCounter;
 
                     const totalOperationalTime = Millis(timeAsOfLastUpdate + timeSinceLastUpdate);
 

package/src/behaviors/groupcast/GroupcastServer.ts

@@ -30,6 +30,23 @@ const UNMAPPED_KEYSET_ID = 0xffff;
 /** TODO: remove once the Groupcast cluster leaves provisional state in the Matter specification. */
 const GROUPCAST_IS_PROVISIONAL = true;
 
+/**
+ * Every element of this provisional cluster is optional, so declare the ones this server implements.
+ *
+ * TODO: remove once the Groupcast cluster leaves provisional state in the Matter specification.  Its elements become
+ * mandatory again at that point and matter.js implements them without this declaration.
+ */
+const Base = GroupcastBehavior.enable({
+    attributes: {
+        membership: true,
+        maxMembershipCount: true,
+        maxMcastAddrCount: true,
+        usedMcastAddrCount: true,
+        fabricUnderTest: true,
+    },
+    events: { groupcastTesting: true },
+});
+
 /**
  * This is the default server implementation of {@link GroupcastBehavior}.
  *
@@ -44,7 +61,7 @@ const GROUPCAST_IS_PROVISIONAL = true;
  * - On first use by a fabric, marks the fabric as "GroupcastAdopted" in GKM, making GroupKeyMap read-only.
  * - Migrates legacy group data from the Groups cluster on startup.
  */
-export class GroupcastServer extends GroupcastBehavior {
+export class GroupcastServer extends Base {
     declare internal: GroupcastServer.Internal;
 
     /** Timer for GroupcastTesting auto-disable. */
@@ -652,7 +669,7 @@ export namespace GroupcastServer {
     }
 
     /** Default state overrides for GroupcastServer. */
-    export class State extends GroupcastBehavior.State {
+    export class State extends Base.State {
         /**
          * Implementation-defined maximum membership count (min 10 per spec).
          * Set to 2 * GKM.maxGroupsPerFabric (44) so per-fabric quota floor(44/2)=22 aligns exactly

package/src/behaviors/icd-management/IcdManagementServer.ts

@@ -154,9 +154,10 @@ const INSTRUCTION_REQUIRED_TRIGGER_HINTS = [
  * ## Long Idle Time (LITS)
  *
  * Enable LITS with `IcdManagementServer.with(IcdManagement.Feature.CheckInProtocolSupport,
- * IcdManagement.Feature.LongIdleTimeSupport)` — CIP is mandatory under LITS and `.with` replaces (does not augment)
- * the feature set, so both must be listed. The mandatory `operatingMode` attribute has no spec-defined default and
- * must be configured by the application (initialization throws otherwise); set it to
+ * IcdManagement.Feature.LongIdleTimeSupport, IcdManagement.Feature.UserActiveModeTrigger)` — CIP and UAT are mandatory
+ * under LITS and `.with` replaces (does not augment) the feature set, so all three must be listed. The mandatory
+ * `operatingMode` attribute has no spec-defined default and must be configured by the application (initialization
+ * throws otherwise); set it to
  * {@link IcdManagement.OperatingMode.Sit} unless the device starts in LIT. DSLS devices may additionally call
  * {@link setOperatingMode} to switch SIT↔LIT at runtime.
  *

package/src/behaviors/identify/IdentifyServer.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Behavior } from "#behavior/Behavior.js";
 import { MaybePromise, Observable, Seconds, Time, Timer } from "@matter/general";
 import { hasRemoteActor } from "@matter/protocol";
 import { Identify } from "@matter/types/clusters/identify";
@@ -23,6 +24,9 @@ import { IdentifyBehavior } from "./IdentifyBehavior.js";
  * * `startIdentifying` - Emitted when the device starts identifying. Use it to start your own identifying logic. This is mandatory.
  * * `stopIdentifying` - Emitted when the device stops identifying. This is mandatory.
  * * `effectTriggered` - Emitted when an effect should be triggered. Use it to trigger the effect. Depending on the device type this is mandatory!
+ *
+ * The following protected methods are available for override:
+ * * `suppressTriggerEffect` - Decides whether the TriggerEffect command is supported by this endpoint.
  */
 export class IdentifyServer extends IdentifyBehavior {
     declare protected internal: IdentifyServer.Internal;
@@ -52,6 +56,37 @@ export class IdentifyServer extends IdentifyBehavior {
 
         // So whenever the attribute OR the identify command was invoked we react to it.
         this.reactTo(this.events.identifyTime$Changed, this.#identifyTimeChangedHandler);
+
+        this.suppressTriggerEffect();
+    }
+
+    /**
+     * Withdraw support for the optional TriggerEffect command.
+     *
+     * Support is retained when {@link triggerEffect} is implemented rather than inherited, or when the schema
+     * declares the command supported.  The latter covers device types that require the command, such as lights and
+     * plug-in units, as well as `IdentifyServer.alter({ commands: { triggerEffect: { optional: false } } })` and
+     * `IdentifyServer.enable({ commands: { triggerEffect: true } })`.
+     *
+     * Override with an empty implementation to offer the command in any other case.  Note that an override on a
+     * type derived via `alter()`, `enable()` or `with()` must be public, as {@link IdentifyServer.ExtensionInterface}
+     * exposes this method publicly to such types.
+     *
+     * Withdrawal applies to the Matter view of the endpoint.  Local invocation via the agent still runs
+     * {@link triggerEffect}.
+     */
+    protected suppressTriggerEffect() {
+        if (this.triggerEffect !== IdentifyServer.prototype.triggerEffect) {
+            return;
+        }
+
+        const schema = this.type.schema;
+        const command = schema.commands("triggerEffect");
+        if (command === undefined || schema.scope.hasOperationalSupport(command)) {
+            return;
+        }
+
+        this.triggerEffect = Behavior.unimplemented;
     }
 
     #startIdentifying() {
@@ -114,4 +149,8 @@ export namespace IdentifyServer {
         stopIdentifying = Observable();
         effectTriggered = Observable<[effect: Identify.TriggerEffectRequest]>();
     }
+
+    export declare const ExtensionInterface: {
+        suppressTriggerEffect(): void;
+    };
 }

package/src/behaviors/level-control/LevelControlServer.ts

@@ -730,9 +730,8 @@ export namespace LevelControlBaseServer {
     };
 }
 
-// We had turned on some more features to provide the default implementation, but export the cluster with no
-// Features again.
-export class LevelControlServer extends LevelControlBaseServer.for(LevelControl) {}
+// Drop the features the base implementation enables internally so consumers select their own
+export class LevelControlServer extends LevelControlBaseServer.with() {}
 
 function asIntOrNull(value: number | null) {
     if (value === null) {

package/src/behaviors/mode-select/ModeSelectServer.ts

@@ -108,4 +108,5 @@ export class ModeSelectBaseServer extends ModeSelectBase {
     }
 }
 
-export class ModeSelectServer extends ModeSelectBaseServer.for(ModeSelect) {}
+// Drop the features the base implementation enables internally so consumers select their own
+export class ModeSelectServer extends ModeSelectBaseServer.with() {}

package/src/behaviors/on-off/OnOffServer.ts

@@ -341,6 +341,5 @@ export namespace OnOffBaseServer {
     }
 }
 
-// We had turned on some more features to provide a default implementation, but export the cluster with default
-// Features again.
+// Drop the features the base implementation enables internally so consumers select their own
 export class OnOffServer extends OnOffBaseServer.with() {}

package/src/behaviors/ota-software-update-provider/OtaSoftwareUpdateProviderServer.ts

@@ -284,9 +284,9 @@ export class OtaSoftwareUpdateProviderServer extends OtaSoftwareUpdateProviderBe
             if (
                 !bdxProtocol.enablePeerForScope(peerAddress, this.updateStorage, {
                     preferredDriverModes: [Flow.DriverMode.ReceiverDrive],
-                    // That's also the default but especially states for OTA, but let's set it explicitly
+                    // That's also the default but especially stated for OTA, but let's set it explicitly
                     messageTimeout: Minutes(5),
-                    // maxBlockSize 1024 (non-TCP), 8192 (TCP) - We support whatever the peer wants, so do not set that
+                    ...this.agent.get(SoftwareUpdateManager).bdxTransferOptionsFor(peerAddress),
                 })
             ) {
                 // We could not enable BDX for this scope because another process is registered with different details
@@ -337,7 +337,7 @@ export class OtaSoftwareUpdateProviderServer extends OtaSoftwareUpdateProviderBe
                         newSoftwareVersion,
                     ),
                 );
-                bdxSession.closed.on(() => {
+                bdxSession.closed.once(() => {
                     const details = this.#inProgressDetailsForPeer(peerAddress, updateToken);
                     if (
                         details !== undefined &&