@matter/node 0.16.0-alpha.0-20251022-5a69ce65a → 0.16.0-alpha.0-20251027-17770fb28

package/src/behavior/cluster/ClusterBehaviorUtil.ts

@@ -9,6 +9,8 @@ import { camelize, EventEmitter, GeneratedClass, ImplementationError, Observable
 import {
     ClassSemantics,
     ClusterModel,
+    Conformance,
+    DecodedBitmap,
     DefaultValue,
     ElementTag,
     FeatureMap,
@@ -20,7 +22,7 @@ import {
     ValueModel,
 } from "#model";
 import { Val } from "#protocol";
-import { Attribute, ClusterType } from "#types";
+import { ClusterType } from "#types";
 import { Behavior } from "../Behavior.js";
 import { DerivedState } from "../state/StateType.js";
 import type { ClusterBehavior } from "./ClusterBehavior.js";
@@ -82,8 +84,7 @@ export function createType<const C extends ClusterType>(
         }
     }
 
-    const newProps = {} as Record<string, ValueModel>;
-    const scope = Scope(schema);
+    const context = DerivationContext(schema, cluster, base);
 
     const type = GeneratedClass({
         name,
@@ -93,9 +94,9 @@ export function createType<const C extends ClusterType>(
         // namespace overrides.  If we instead override as static properties then we lose the automatic interface type.
         // So just publish as static properties.
         staticProperties: {
-            State: createDerivedState(cluster, scope, base, newProps),
+            State: createDerivedState(context),
 
-            Events: createDerivedEvents(cluster, scope, base, newProps),
+            Events: createDerivedEvents(context),
         },
 
         staticDescriptors: {
@@ -140,18 +141,52 @@ export type ExtensionInterfaceOf<B extends Behavior.Type> = B extends { Extensio
     ? I
     : {};
 
+interface DerivationContext {
+    cluster: ClusterType;
+    scope: Scope;
+    featuresAvailable: FeatureSet;
+    featuresSupported: FeatureSet;
+    base: Behavior.Type;
+    newProps: Record<string, ValueModel>;
+}
+
+function DerivationContext(schema: Schema, cluster: ClusterType, base: Behavior.Type): DerivationContext {
+    const scope = Scope(schema);
+    // Determine the set of features so we can test element applicability
+    let featuresAvailable, featuresSupported;
+    if (scope.owner instanceof ClusterModel) {
+        const normalized = FeatureSet.normalize(scope.owner.featureMap, scope.owner.supportedFeatures);
+        featuresAvailable = normalized.featuresAvailable;
+        featuresSupported = normalized.featuresSupported;
+    } else {
+        featuresAvailable = new FeatureSet();
+        featuresSupported = new FeatureSet();
+    }
+
+    return {
+        cluster,
+        scope: Scope(schema),
+        featuresAvailable,
+        featuresSupported,
+        base,
+        newProps: {},
+    };
+}
+
 /**
  * Create a new state subclass that inherits relevant default values from a base Behavior.Type and adds new default
  * values from cluster attributes.
  *
  * Note - we only use the cluster here for default values
  */
-function createDerivedState(
-    cluster: ClusterType,
-    scope: Scope,
-    base: Behavior.Type,
-    newProps: Record<string, ValueModel>,
-) {
+function createDerivedState({
+    cluster,
+    scope,
+    base,
+    newProps,
+    featuresAvailable,
+    featuresSupported,
+}: DerivationContext) {
     const BaseState = base["State"];
     if (BaseState === undefined) {
         throw new ImplementationError(`No state class defined for behavior class ${base.name}`);
@@ -160,17 +195,6 @@ function createDerivedState(
     const oldDefaults = new BaseState() as Record<string, any>;
     let knownDefaults = (BaseState as HasKnownDefaults)[KNOWN_DEFAULTS];
 
-    // Determine the set of features so we can test attribute applicability
-    let featuresAvailable, featuresSupported;
-    if (scope.owner instanceof ClusterModel) {
-        const normalized = FeatureSet.normalize(scope.owner.featureMap, scope.owner.supportedFeatures);
-        featuresAvailable = normalized.featuresAvailable;
-        featuresSupported = normalized.featuresSupported;
-    } else {
-        featuresAvailable = new FeatureSet();
-        featuresSupported = new FeatureSet();
-    }
-
     // Index schema members by name
     const props = {} as Record<string, ValueModel[]>;
     for (const member of scope.membersOf(scope.owner, { conformance: "deconflicted" })) {
@@ -191,21 +215,22 @@ function createDerivedState(
         let propSchema: ValueModel | undefined;
 
         // Determine whether the attribute applies
+        let applicability;
         for (const attr of attrs) {
-            const applicability = attr.effectiveConformance.applicabilityOf(featuresAvailable, featuresSupported);
+            applicability = attr.effectiveConformance.applicabilityOf(featuresAvailable, featuresSupported);
 
             // Inapplicable; ignore
             if (!applicability) {
                 continue;
             }
 
-            // Applicable; add new default.  If conditional then cluster logic must modify
+            // Use this model for the property
             propSchema = attr;
             break;
         }
 
         // If the attribute doesn't apply, erase any previous default unless conditionally applicable
-        if (propSchema === undefined) {
+        if (!propSchema) {
             // Inapplicable; ensure no default is present
             if (oldDefaults[name] !== undefined) {
                 // Save the default value so we can recreate it if a future derivative re-enables this element
@@ -234,12 +259,13 @@ function createDerivedState(
             continue;
         }
 
-        // Make sure a default value is present
+        // Make sure a default value is present if mandatory or marked as supported (note that the default value may
+        // be "undefined" to indicate that an attribute is available optionally)
         defaults[name] = selectDefaultValue(
             scope,
             oldDefaults[name] === undefined ? knownDefaults?.[name] : oldDefaults[name],
-            attribute,
             propSchema,
+            applicability,
         );
     }
 
@@ -259,19 +285,14 @@ function createDerivedState(
 /**
  * Extend events with additional implementations.
  */
-function createDerivedEvents(
-    cluster: ClusterType,
-    scope: Scope,
-    base: Behavior.Type,
-    newProps: Record<string, ValueModel>,
-) {
+function createDerivedEvents({ scope, base, newProps, featuresAvailable, featuresSupported }: DerivationContext) {
     const instanceDescriptors = {} as PropertyDescriptorMap;
 
     const baseInstance = new base.Events() as unknown as Record<string, unknown>;
 
     const eventNames = new Set<string>();
 
-    // Add mandatory events that are not present in the base class
+    // Add events that are mandatory or marked as supported and not present in the base class
     const applicableClusterEvents = new Set();
     for (const event of scope.membersOf(scope.owner as Schema, {
         conformance: "conformant",
@@ -279,7 +300,12 @@ function createDerivedEvents(
     })) {
         const name = camelize(event.name);
         applicableClusterEvents.add(name);
-        if (!cluster.events[name]?.optional && baseInstance[name] === undefined) {
+        if (
+            (event.conformance.applicabilityOf(featuresAvailable, featuresSupported) ===
+                Conformance.Applicability.Mandatory ||
+                event.isSupported) &&
+            baseInstance[name] === undefined
+        ) {
             eventNames.add(name);
             instanceDescriptors[name] = createEventDescriptor(
                 name,
@@ -312,7 +338,7 @@ function createDerivedEvents(
     // TODO - if necessary, mask out (set to undefined) events present in base cluster but not derived cluster
 
     return GeneratedClass({
-        name: `${cluster.name}$Events`,
+        name: `${base.name}$Events`,
         base: base.Events,
 
         instanceDescriptors,
@@ -413,43 +439,43 @@ function createDefaultCommandDescriptors(cluster: ClusterType, base: Behavior.Ty
     return result;
 }
 
-function selectDefaultValue(scope: Scope, oldDefault: Val, clusterAttr?: Attribute<any, any>, schemaProp?: ValueModel) {
+function selectDefaultValue(
+    scope: Scope,
+    oldDefault: Val,
+    member: ValueModel,
+    applicability?: Conformance.Applicability,
+) {
     if (oldDefault !== undefined) {
         return oldDefault;
     }
 
-    // Use cluster attribute rather than model attribute because currently "enable" modifies the cluster, not the schema
-    if (clusterAttr?.optional) {
+    // No default unless mandatory or explicitly marked as implemented
+    if (applicability !== Conformance.Applicability.Mandatory && !member.isSupported) {
         return;
     }
 
-    // Use cluster attribute rather than model attribute because currently "set" modifies the cluster, not the schema
-    if (clusterAttr?.default !== undefined) {
-        return clusterAttr.default;
-    }
-
-    // Following checks use the schema
-    if (!schemaProp) {
-        return;
+    // If there's an explicit default, use that
+    const effectiveDefault = DefaultValue(scope, member);
+    if (effectiveDefault !== undefined) {
+        if (member.effectiveMetatype === "bitmap") {
+            return DecodedBitmap(member, effectiveDefault);
+        }
+        return effectiveDefault;
     }
 
-    if (schemaProp.nullable) {
+    // Default for nullable is null
+    if (member.nullable) {
         return null;
     }
 
-    const effectiveDefault = DefaultValue(scope, schemaProp);
-    if (effectiveDefault) {
-        return effectiveDefault;
-    }
+    switch (member.effectiveMetatype) {
+        case Metatype.integer:
+        case Metatype.float:
+            return 0;
 
-    // TODO - skip the following defaults if conformance is not absolutely mandatory.  This is pretty limited, may need
-    // to use more sophisticated evaluation if insufficient
-    const conformance = schemaProp.effectiveConformance;
-    if (!conformance.isMandatory) {
-        return;
-    }
+        case Metatype.boolean:
+            return false;
 
-    switch (schemaProp.effectiveMetatype) {
         case Metatype.bitmap:
         case Metatype.object:
             // This is not a very good default but it is better than undefined

package/src/behavior/state/validation/conformance-compiler.ts

@@ -187,7 +187,7 @@ export function astToFunction(schema: ValueModel, supervisor: RootSupervisor): V
             case Conformance.Special.Choice:
                 return createChoice(ast.param);
 
-            case Conformance.Special.Group:
+            case Conformance.Special.Otherwise:
                 return createGroup(ast.param);
 
             case Conformance.Special.Name:
@@ -281,7 +281,7 @@ export function astToFunction(schema: ValueModel, supervisor: RootSupervisor): V
      * A "group" node is a list or the entries in an optional ([ ... ]) clause. The resulting node is the value of the
      * first list member that does not report as Code.Nonconformant.
      */
-    function createGroup(param: Conformance.Ast.Group): DynamicNode {
+    function createGroup(param: Conformance.Ast.Otherwise): DynamicNode {
         if (!Array.isArray(param)) {
             throw new SchemaImplementationError(
                 DataModelPath(schema.path),
@@ -627,7 +627,12 @@ export function astToFunction(schema: ValueModel, supervisor: RootSupervisor): V
                 continue;
             }
 
-            const compiledNode = compile(member.conformance.ast);
+            // Enum choice indicates support for the value; it should not affect validation
+            let ast = member.conformance.ast;
+            if (ast.type === Conformance.Special.Choice) {
+                ast = ast.param.expr;
+            }
+            const compiledNode = compile(ast);
 
             let memberValidator: undefined | EnumMemberValidator;
             switch (compiledNode.code) {

package/src/behaviors/account-login/AccountLoginInterface.ts

@@ -13,13 +13,13 @@ export namespace AccountLoginInterface {
     export interface Base {
         /**
          * The purpose of this command is to determine if the active user account of the given Content App matches the
-         * active user account of a given Commissionee, and when it does, return a Setup PIN code which can be used for
+         * active user account of a given Commissionee, and when it does, return a Setup PIN which can be used for
          * password-authenticated session establishment (PASE) with the Commissionee.
          *
          * For example, a Video Player with a Content App Platform may invoke this command on one of its Content App
          * endpoints to facilitate commissioning of a Phone App made by the same vendor as the Content App. If the
-         * accounts match, then the Content App may return a setup code that can be used by the Video Player to
-         * commission the Phone App without requiring the user to physically input a setup code.
+         * accounts match, then the Content App may return a Setup PIN that can be used by the Video Player to
+         * commission the Phone App without requiring the user to physically input a Setup PIN.
          *
          * The account match is determined by the Content App using a method which is outside the scope of this
          * specification and will typically involve a central service which is in communication with both the Content
@@ -45,7 +45,7 @@ export namespace AccountLoginInterface {
          * The Setup PIN is a character string so that it can accommodate different future formats, including
          * alpha-numeric encodings. For a Commissionee it shall be populated with the Manual Pairing Code (see Manual
          * Pairing Code section in [MatterCore]) encoded as a string (11 characters) or the Passcode portion of the
-         * Manual Pairing Code (when less than 11 characters) .
+         * Manual Pairing Code (when less than 11 characters).
          *
          * The server shall implement rate limiting to prevent brute force attacks. No more than 10 unique requests in a
          * 10 minute period shall be allowed; a command response status of FAILURE should sent for additional commands
@@ -60,7 +60,7 @@ export namespace AccountLoginInterface {
 
         /**
          * The purpose of this command is to allow the Content App to assume the user account of a given Commissionee by
-         * leveraging the Setup PIN code input by the user during the commissioning process.
+         * leveraging the Setup PIN input by the user during the commissioning process.
          *
          * For example, a Video Player with a Content App Platform may invoke this command on one of its Content App
          * endpoints after the commissioning has completed of a Phone App made by the same vendor as the Content App.
@@ -87,12 +87,12 @@ export namespace AccountLoginInterface {
          *
          * The Setup PIN for a Commissionee may be populated with the Manual Pairing Code encoded as a string of decimal
          * numbers (11 characters) or the Passcode portion of the Manual Pairing Code encoded as a string of decimal
-         * numbers (8 characters) .
+         * numbers (8 characters).
          *
          * The server shall implement rate limiting to prevent brute force attacks. No more than 10 unique requests in a
          * 10 minute period shall be allowed; a command response status of FAILURE should sent for additional commands
          * received within the 10 minute period. Because access to this command is limited to nodes with Admin-level
-         * access, and the user is involved when obtaining the SetupPIN, there are in place multiple obstacles to
+         * access, and the user is involved when obtaining the Setup PIN, there are in place multiple obstacles to
          * successfully mounting a brute force attack. A Content App that supports this command shall ensure that the
          * Temporary Account Identifier used by its clients is not valid for more than 10 minutes.
          *

package/src/behaviors/actions/ActionsInterface.ts

@@ -12,6 +12,8 @@ import { Actions } from "#clusters/actions";
 export namespace ActionsInterface {
     export interface Base {
         /**
+         * This command is used to trigger an instantaneous action.
+         *
          * This command triggers an action (state change) on the involved endpoints, in a "fire and forget" manner.
          * Afterwards, the action’s state shall be Inactive.
          *
@@ -22,6 +24,8 @@ export namespace ActionsInterface {
         instantAction(request: Actions.InstantActionRequest): MaybePromise;
 
         /**
+         * This command is used to trigger an instantaneous action with a transition over a given time.
+         *
          * It is recommended that, where possible (e.g., it is not possible for attributes with Boolean data type), a
          * gradual transition SHOULD take place from the old to the new state over this time period. However, the exact
          * transition is manufacturer dependent.
@@ -37,6 +41,8 @@ export namespace ActionsInterface {
         instantActionWithTransition(request: Actions.InstantActionWithTransitionRequest): MaybePromise;
 
         /**
+         * This command is used to trigger the commencement of an action.
+         *
          * This command triggers the commencement of an action on the involved endpoints. Afterwards, the action’s state
          * shall be Active.
          *
@@ -51,6 +57,8 @@ export namespace ActionsInterface {
         startAction(request: Actions.StartActionRequest): MaybePromise;
 
         /**
+         * This command is used to trigger the commencement of an action with a duration.
+         *
          * This command triggers the commencement of an action on the involved endpoints, and shall change the action’s
          * state to Active. After the specified Duration, the action will stop, and the action’s state shall change to
          * Inactive.
@@ -63,6 +71,8 @@ export namespace ActionsInterface {
         startActionWithDuration(request: Actions.StartActionWithDurationRequest): MaybePromise;
 
         /**
+         * This command is used to stop an action.
+         *
          * This command stops the ongoing action on the involved endpoints. Afterwards, the action’s state shall be
          * Inactive.
          *
@@ -73,6 +83,8 @@ export namespace ActionsInterface {
         stopAction(request: Actions.StopActionRequest): MaybePromise;
 
         /**
+         * This command is used to pause an action.
+         *
          * This command pauses an ongoing action, and shall change the action’s state to Paused.
          *
          * Example: pause a dynamic lighting effect (the lights stay at their current color) which was previously
@@ -83,6 +95,8 @@ export namespace ActionsInterface {
         pauseAction(request: Actions.PauseActionRequest): MaybePromise;
 
         /**
+         * This command is used to pause an action with a duration.
+         *
          * This command pauses an ongoing action, and shall change the action’s state to Paused. After the specified
          * Duration, the ongoing action will be automatically resumed. which shall change the action’s state to Active.
          *
@@ -100,6 +114,8 @@ export namespace ActionsInterface {
         pauseActionWithDuration(request: Actions.PauseActionWithDurationRequest): MaybePromise;
 
         /**
+         * This command is used to resume an action.
+         *
          * This command resumes a previously paused action, and shall change the action’s state to Active.
          *
          * The difference between ResumeAction and StartAction is that ResumeAction will continue the action from the
@@ -113,6 +129,8 @@ export namespace ActionsInterface {
         resumeAction(request: Actions.ResumeActionRequest): MaybePromise;
 
         /**
+         * This command is used to enable an action.
+         *
          * This command enables a certain action or automation. Afterwards, the action’s state shall be Active.
          *
          * Example: enable a motion sensor to control the lights in an area.
@@ -122,6 +140,8 @@ export namespace ActionsInterface {
         enableAction(request: Actions.EnableActionRequest): MaybePromise;
 
         /**
+         * This command is used to enable an action with a duration.
+         *
          * This command enables a certain action or automation, and shall change the action’s state to be Active. After
          * the specified Duration, the action or automation will stop, and the action’s state shall change to Disabled.
          *
@@ -134,6 +154,8 @@ export namespace ActionsInterface {
         enableActionWithDuration(request: Actions.EnableActionWithDurationRequest): MaybePromise;
 
         /**
+         * This command is used to disable an action.
+         *
          * This command disables a certain action or automation, and shall change the action’s state to Inactive.
          *
          * Example: disable a motion sensor to no longer control the lights in an area.
@@ -143,9 +165,12 @@ export namespace ActionsInterface {
         disableAction(request: Actions.DisableActionRequest): MaybePromise;
 
         /**
+         * This command is used to disable an action with a duration.
+         *
          * This command disables a certain action or automation, and shall change the action’s state to Disabled. After
          * the specified Duration, the action or automation will re-start, and the action’s state shall change to either
-         * Inactive or Active, depending on the actions (see examples 4 and 6).
+         * Inactive or Active, depending on the actions (see Section 9.14.8.4, “Example 4: Wake-up routine” and Section
+         * 9.14.8.6, “Example 6: Alarm system”).
          *
          * Example: disable a "wakeup" experience for a period of 1 week when going on holiday (to prevent them from
          * turning on in the morning while you’re not at home). After this period, the wakeup experience will control

package/src/behaviors/application-launcher/ApplicationLauncherInterface.ts

@@ -60,7 +60,9 @@ export namespace ApplicationLauncherInterface {
          * constraints if any. The Status attribute shall be updated to ActiveHidden or Stopped, depending on the action
          * taken, on the Application Basic cluster of the Endpoint corresponding to the application on which the action
          * was taken. The Status attribute shall be updated on any other application whose Status may have changed as a
-         * result of this command. This command returns a Launcher Response.
+         * result of this command.
+         *
+         * This command returns a Launcher Response.
          *
          * @see {@link MatterSpecification.v141.Cluster} § 6.4.7.3
          */

package/src/behaviors/channel/ChannelInterface.ts

@@ -22,6 +22,10 @@ export namespace ChannelInterface {
          * This command provides channel up and channel down functionality, but allows channel index jumps of size
          * Count.
          *
+         * Jumps are relative to the available list of channels. For example, when the current channel is 100.0 and the
+         * list of available channels is [100.0, 200.0, 201.0, 305.1], a SkipChannel command with jump value of 2 shall
+         * change the channel to 201.0.
+         *
          * When the value of the increase or decrease is larger than the number of channels remaining in the given
          * direction, then the behavior shall be to return to the beginning (or end) of the channel list and continue.
          * For example, if the current channel is at index 0 and count value of -1 is given, then the current channel

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

@@ -131,6 +131,10 @@ export namespace ColorControlInterface {
         /**
          * This command is provided to allow MoveTo and Step commands to be stopped.
          *
+         * NOTE This automatically provides symmetry to the Level Control cluster.
+         *
+         * NOTE The StopMoveStep command has no effect on an active color loop.
+         *
          * @see {@link MatterSpecification.v141.Cluster} § 3.2.8.20
          */
         stopMoveStep(request: ColorControl.StopMoveStepRequest): MaybePromise;

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

@@ -216,11 +216,7 @@ export class ColorControlBaseServer extends ColorControlBase {
      * Sets the current color temperature value in Mireds (0..0xFFFF) and converts into Matter number range.
      */
     set mireds(value: number) {
-        this.state.colorTemperatureMireds = cropValueRange(
-            value,
-            this.minimumColorTemperatureMireds,
-            this.maximumColorTemperatureMireds,
-        );
+        this.state.colorTemperatureMireds = this.#cropColorTemperature(value);
     }
 
     /** Returns the current color temperature value in Kelvin (from internal Mireds). */
@@ -380,7 +376,7 @@ export class ColorControlBaseServer extends ColorControlBase {
             let targetMiredsValue: number | null;
             switch (startUpMiredsValue) {
                 case null:
-                    targetMiredsValue = currentMiredsValue;
+                    targetMiredsValue = this.#cropColorTemperature(currentMiredsValue);
                     break;
                 default:
                     targetMiredsValue = startUpMiredsValue;
@@ -1270,16 +1266,8 @@ export class ColorControlBaseServer extends ColorControlBase {
             if (colorTemperatureMaximumMireds === 0) {
                 colorTemperatureMaximumMireds = this.maximumColorTemperatureMireds;
             }
-            colorTemperatureMinimumMireds = cropValueRange(
-                colorTemperatureMinimumMireds,
-                this.minimumColorTemperatureMireds,
-                this.maximumColorTemperatureMireds,
-            );
-            colorTemperatureMaximumMireds = cropValueRange(
-                colorTemperatureMaximumMireds,
-                this.minimumColorTemperatureMireds,
-                this.maximumColorTemperatureMireds,
-            );
+            colorTemperatureMinimumMireds = this.#cropColorTemperature(colorTemperatureMinimumMireds);
+            colorTemperatureMaximumMireds = this.#cropColorTemperature(colorTemperatureMaximumMireds);
 
             return this.moveColorTemperatureLogic(
                 moveMode,
@@ -1350,16 +1338,8 @@ export class ColorControlBaseServer extends ColorControlBase {
             if (colorTemperatureMaximumMireds === 0) {
                 colorTemperatureMaximumMireds = this.maximumColorTemperatureMireds;
             }
-            colorTemperatureMinimumMireds = cropValueRange(
-                colorTemperatureMinimumMireds,
-                this.minimumColorTemperatureMireds,
-                this.maximumColorTemperatureMireds,
-            );
-            colorTemperatureMaximumMireds = cropValueRange(
-                colorTemperatureMaximumMireds,
-                this.minimumColorTemperatureMireds,
-                this.maximumColorTemperatureMireds,
-            );
+            colorTemperatureMinimumMireds = this.#cropColorTemperature(colorTemperatureMinimumMireds);
+            colorTemperatureMaximumMireds = this.#cropColorTemperature(colorTemperatureMaximumMireds);
 
             return this.stepColorTemperatureLogic(
                 stepMode,
@@ -1773,6 +1753,14 @@ export class ColorControlBaseServer extends ColorControlBase {
         (this.state as any)[fieldName] = cropValueRange(Math.round(value * 65536), MIN_CIE_XY_VALUE, MAX_CIE_XY_VALUE);
     }
 
+    #cropColorTemperature(temperatureMireds: number) {
+        return cropValueRange(
+            temperatureMireds,
+            this.minimumColorTemperatureMireds,
+            this.maximumColorTemperatureMireds,
+        );
+    }
+
     override async [Symbol.asyncDispose]() {
         if (this.internal.transitions) {
             await this.internal.transitions.close();
@@ -1811,6 +1799,17 @@ export namespace ColorControlBaseServer {
          */
         transitionStepInterval = Millis(100);
 
+        // These were the default values specified prior to Matter 1.4.2.  We still need default values so using the
+        // previously specified values which are presumably educated logical defaults
+        override currentX = 24939;
+        override currentY = 24701;
+        override colorTemperatureMireds = 250;
+        override enhancedColorMode = ColorControl.EnhancedColorMode.CurrentXAndCurrentY;
+        override colorLoopTime = 25;
+        override colorLoopStartEnhancedHue = 8960;
+        override colorLoopActive = ColorControl.ColorLoopActive.Inactive;
+        override colorLoopDirection = ColorControl.ColorLoopDirection.Increment;
+
         [Val.properties](endpoint: Endpoint) {
             // Only return remaining time if the attribute is defined in the endpoint
             if (

package/src/behaviors/content-control/ContentControlInterface.ts

@@ -108,7 +108,7 @@ export namespace ContentControlInterface {
          * The purpose of this command is to specify whether programs with no Content rating must be blocked by this
          * media device.
          *
-         * Upon receipt of the UnblockUnratedContent command, the media device shall set the BlockUnrated attribute to
+         * Upon receipt of the UnblockUnratedContent command, the media device shall set the BlockUn rated attribute to
          * FALSE.
          *
          * @see {@link MatterSpecification.v141.Cluster} § 6.13.8.9

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

@@ -69,7 +69,7 @@ export namespace DoorLockInterface {
         /**
          * Retrieve user.
          *
-         * An InvokeResponse command shall be sent with an appropriate error (e.g. FAILURE, INVALID_COMMAND, etc.) as
+         * An InvokeResponse command shall be sent with an appropriate error (e.g. FAILURE, INVALID_ COMMAND, etc.) as
          * needed otherwise the GetUserResponse Command shall be sent implying a status of SUCCESS.
          *
          * @see {@link MatterSpecification.v141.Cluster} § 5.2.10.33

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

@@ -14,10 +14,17 @@ import LockState = DoorLock.LockState;
  */
 export class DoorLockServer extends DoorLockBehavior {
     override initialize(): MaybePromise {
-        if (this.state.supportedOperatingModes.alwaysSet !== 2047) {
-            throw new ImplementationError(
-                `DoorLockServer: The "alwaysSet" bit-range in supportedOperatingModes must be set. Please check the specification about the meaning of this field because bits are inverted here!`,
-            );
+        if (!Object.values(this.state.supportedOperatingModes).some(v => v)) {
+            // Empty operating modes; default to mandatory ones (note that values are inverted so true indicates not
+            // supported)
+            this.state.supportedOperatingModes = { vacation: true, privacy: true, passage: true, alwaysSet: 2047 };
+        } else {
+            // Warn if it looks like the confusing Matter semantics have confused someone
+            if (this.state.supportedOperatingModes.alwaysSet !== 2047) {
+                throw new ImplementationError(
+                    `DoorLockServer: The "alwaysSet" bit-range in supportedOperatingModes must be set. Please check the specification about the meaning of this field because bits are inverted here!`,
+                );
+            }
         }
     }
 

package/src/behaviors/ethernet-network-diagnostics/EthernetNetworkDiagnosticsInterface.ts

@@ -11,6 +11,8 @@ import { MaybePromise } from "#general";
 export namespace EthernetNetworkDiagnosticsInterface {
     export interface PacketCountsOrErrorCounts {
         /**
+         * This command is used to reset the count attributes.
+         *
          * Reception of this command shall reset the following attributes to 0:
          *
          *   • PacketRxCount
@@ -23,8 +25,6 @@ export namespace EthernetNetworkDiagnosticsInterface {
          *
          *   • OverrunCount
          *
-         * This command has no associated data.
-         *
          * @see {@link MatterSpecification.v141.Core} § 11.16.7.1
          */
         resetCounts(): MaybePromise;