@matter/node 0.17.4 → 0.17.5-alpha.0-20260702-a2cd6f764

package/src/behaviors/basic-information/BasicInformationServer.ts

@@ -7,7 +7,7 @@
 import { ActionContext } from "#behavior/context/ActionContext.js";
 import { OnlineEvent } from "#behavior/Events.js";
 import { NodeLifecycle } from "#node/NodeLifecycle.js";
-import { Diagnostic, ImplementationError, Logger } from "@matter/general";
+import { Diagnostic, ImplementationError, Logger, MaybePromise } from "@matter/general";
 import { AttributeModel, EventModel, Schema, Specification } from "@matter/model";
 import { Fabric, FabricManager } from "@matter/protocol";
 import { DEFAULT_MAX_PATHS_PER_INVOKE, VendorId } from "@matter/types";
@@ -22,8 +22,20 @@ const Base = BasicInformationBehavior.enable({
     events: { startUp: true, shutDown: true, leave: true },
 }).set({ maxPathsPerInvoke: 0 });
 
+// Advertised CapabilityMinima: the guaranteed minimums we promise clients (core §11.1).  These are a floor, not a cap;
+// the server accepts up to a higher hard ceiling and only blocks beyond it (see InteractionServer).
+const DEFAULT_SIMULTANEOUS_INVOCATIONS_SUPPORTED = 20;
+const DEFAULT_SIMULTANEOUS_WRITES_SUPPORTED = 20;
+const DEFAULT_READ_PATHS_SUPPORTED = 20;
+const DEFAULT_SUBSCRIBE_PATHS_SUPPORTED = 20;
+
 /**
  * This is the default server implementation of BasicInformationBehavior.
+ *
+ * `ConfigurationVersion` (mandatory since Matter 1.6) is seeded to 1 and constrained to only ever increase.  When the
+ * node's configuration changes in a way clients should detect, bump it with {@link increaseConfigurationVersion},
+ * which runs your change and increments the version exactly once afterwards — do not set `configurationVersion`
+ * directly.  Bridged nodes have their own version; see {@link BridgedDeviceBasicInformationServer}.
  */
 export class BasicInformationServer extends Base {
     override initialize() {
@@ -59,6 +71,21 @@ export class BasicInformationServer extends Base {
         setDefault("softwareVersionString", state.softwareVersion.toString());
         setDefault("specificationVersion", Specification.SPECIFICATION_VERSION);
         setDefault("maxPathsPerInvoke", DEFAULT_MAX_PATHS_PER_INVOKE);
+
+        setDefault("configurationVersion", 1);
+        this.reactTo(this.events.configurationVersion$Changing, this.#preventConfigurationVersionRegression);
+
+        const capabilityMinima = this.state.capabilityMinima;
+        this.state.capabilityMinima = {
+            ...capabilityMinima,
+            simultaneousInvocationsSupported:
+                capabilityMinima.simultaneousInvocationsSupported ?? DEFAULT_SIMULTANEOUS_INVOCATIONS_SUPPORTED,
+            simultaneousWritesSupported:
+                capabilityMinima.simultaneousWritesSupported ?? DEFAULT_SIMULTANEOUS_WRITES_SUPPORTED,
+            readPathsSupported: capabilityMinima.readPathsSupported ?? DEFAULT_READ_PATHS_SUPPORTED,
+            subscribePathsSupported: capabilityMinima.subscribePathsSupported ?? DEFAULT_SUBSCRIBE_PATHS_SUPPORTED,
+        };
+
         if (this.state.uniqueId === undefined) {
             this.state.uniqueId = BasicInformationServer.createUniqueId();
         }
@@ -91,6 +118,40 @@ export class BasicInformationServer extends Base {
         validateBasicInfoAttributes(this.state, logger);
     }
 
+    /**
+     * Run a configuration change and increase {@link BasicInformation.State.configurationVersion} afterwards.
+     *
+     * Use via the agent, e.g. `agent.get(BasicInformationServer).increaseConfigurationVersion(() => { ...changes... })`.
+     * The callback runs first and receives the acting {@link ActionContext}; the version is increased once it completes
+     * so a single logical change yields a single increment.
+     *
+     * To group changes across multiple bridged nodes into one transaction with a single bridge increment, perform the
+     * bridged-node changes inside this callback via the provided context and pass that context to
+     * {@link BridgedDeviceBasicInformationServer.increaseConfigurationVersion}.
+     */
+    async increaseConfigurationVersion<T = void>(change?: (context: ActionContext) => MaybePromise<T>): Promise<T> {
+        const result = await change?.(this.context);
+        this.state.configurationVersion = BasicInformationServer.nextConfigurationVersion(
+            this.state.configurationVersion,
+        );
+        return result as T;
+    }
+
+    /**
+     * Compute the next configuration version, wrapping at the uint32 maximum back to the minimum value of 1.  The
+     * overflow behavior is not defined by the specification; see the spec-clarification follow-up.
+     */
+    static nextConfigurationVersion(current = 0) {
+        return current >= 0xffffffff ? 1 : current + 1;
+    }
+
+    #preventConfigurationVersionRegression(value: number, oldValue: number) {
+        // ConfigurationVersion must only ever increase; the sole exception is the wrap from the uint32 maximum
+        if (value < oldValue && oldValue !== 0xffffffff) {
+            throw new ImplementationError(`ConfigurationVersion must not decrease (${oldValue} -> ${value})`);
+        }
+    }
+
     static override readonly schema = this.enableUniqueIdPersistence(Base.schema);
 
     static enableUniqueIdPersistence(schema: Schema.Cluster): Schema.Cluster {

package/src/behaviors/boolean-state/BooleanStateBehavior.ts

@@ -12,6 +12,9 @@ import { Identity } from "@matter/general";
 
 /**
  * BooleanStateBehavior is the base class for objects that support interaction with {@link BooleanState.Cluster}.
+ *
+ * This class does not have optional features of BooleanState.Cluster enabled. You can enable additional features using
+ * BooleanStateBehavior.with.
  */
 export const BooleanStateBehaviorConstructor = ClusterBehavior.for(BooleanState);
 

package/src/behaviors/boolean-state/BooleanStateServer.ts

@@ -5,15 +5,22 @@
  */
 
 import { MaybePromise } from "@matter/general";
+import { BooleanState } from "@matter/types/clusters/boolean-state";
 import { BooleanStateBehavior } from "./BooleanStateBehavior.js";
 
+// Enable the ChangeEvent feature by default so the StateChange event is available and emitted as it was prior to 1.6,
+// where the event became gated behind this feature.
+const Base = BooleanStateBehavior.with(BooleanState.Feature.ChangeEvent);
+
 /**
  * This is the default server implementation of {@link BooleanStateBehavior}.
- * If the `StateChanged` event is enabled it is emitted automatically on state change.
+ * If the `StateChange` event is enabled it is emitted automatically on state change.
  */
-export class BooleanStateServer extends BooleanStateBehavior {
+export class BooleanStateServer extends Base {
     override initialize(): MaybePromise {
-        this.reactTo(this.events.stateValue$Changed, this.#emitStateChange);
+        if (this.features.changeEvent) {
+            this.reactTo(this.events.stateValue$Changed, this.#emitStateChange);
+        }
     }
 
     #emitStateChange(stateValue: boolean) {

package/src/behaviors/bridged-device-basic-information/BridgedDeviceBasicInformationServer.ts

@@ -4,10 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ActionContext } from "#behavior/context/ActionContext.js";
 import { BasicInformationServer, validateBasicInfoAttributes } from "#behaviors/basic-information";
 import { DescriptorServer } from "#behaviors/descriptor";
 import { AggregatorEndpoint } from "#endpoints/aggregator";
-import { ImplementationError, Logger } from "@matter/general";
+import { RootEndpoint } from "#endpoints/root";
+import { ImplementationError, Logger, MaybePromise } from "@matter/general";
 import { BridgedDeviceBasicInformationBehavior } from "./BridgedDeviceBasicInformationBehavior.js";
 
 const logger = Logger.get("BridgedDeviceBasicInformationServer");
@@ -16,6 +18,13 @@ const logger = Logger.get("BridgedDeviceBasicInformationServer");
  * This is the default server implementation of BridgedDeviceBasicInformationBehavior.
  *
  * All attributes are optional except for the "reachable" attribute.
+ *
+ * `ConfigurationVersion` is optional on bridged devices; enable it by providing an initial value when configuring the
+ * device.  On a configuration change of the bridged node, bump it with {@link increaseConfigurationVersion} (which
+ * throws if not enabled); called standalone it also increments the bridge's {@link BasicInformationServer} version,
+ * since a bridged-node change is also a change of the bridge.  To coalesce several bridged-node changes into a single
+ * bridge increment, drive them from {@link BasicInformationServer.increaseConfigurationVersion} and pass its `context`
+ * here.
  */
 export class BridgedDeviceBasicInformationServer extends BridgedDeviceBasicInformationBehavior {
     override async initialize() {
@@ -36,6 +45,51 @@ export class BridgedDeviceBasicInformationServer extends BridgedDeviceBasicInfor
         validateBasicInfoAttributes(this.state, logger);
     }
 
+    /**
+     * Run a configuration change for this bridged node and increase its ConfigurationVersion afterwards.
+     *
+     * A bridged-node configuration change is also a configuration change of the bridge itself.  When called standalone
+     * the bridge's {@link BasicInformationServer} ConfigurationVersion is increased as well.
+     *
+     * To group changes across multiple bridged nodes into a single bridge increment, drive them from
+     * {@link BasicInformationServer.increaseConfigurationVersion} and pass its callback's `context` here: the change is
+     * applied in that shared transaction and the bridge increment is left to the enclosing call.
+     *
+     * `ConfigurationVersion` is optional on bridged devices.  Throws if it is not enabled on this node — provide an
+     * initial `configurationVersion` value when configuring the device before calling this.
+     */
+    async increaseConfigurationVersion<T = void>(
+        change?: (context: ActionContext) => MaybePromise<T>,
+        context?: ActionContext,
+    ): Promise<T> {
+        if (this.state.configurationVersion === undefined) {
+            throw new ImplementationError(
+                "ConfigurationVersion is not enabled on this bridged device; set an initial configurationVersion " +
+                    "value when configuring BridgedDeviceBasicInformation before calling increaseConfigurationVersion.",
+            );
+        }
+
+        const result = await change?.(context ?? this.context);
+
+        this.state.configurationVersion = BasicInformationServer.nextConfigurationVersion(
+            this.state.configurationVersion,
+        );
+
+        // A shared context means the bridge increment is owned by the enclosing change; only bump it standalone.
+        if (context === undefined) {
+            const root = this.endpoint.ownerOfType(RootEndpoint);
+            if (root !== undefined) {
+                const agent = root.agentFor(this.context);
+                const basicInformation = agent.get(BasicInformationServer);
+                await agent.context.transaction.addResources(basicInformation);
+                await agent.context.transaction.begin();
+                await basicInformation.increaseConfigurationVersion();
+            }
+        }
+
+        return result as T;
+    }
+
     static override readonly schema = BasicInformationServer.enableUniqueIdPersistence(
         BridgedDeviceBasicInformationBehavior.schema,
     );

package/src/behaviors/general-commissioning/ServerNodeFailsafeContext.ts

@@ -45,7 +45,7 @@ export class ServerNodeFailsafeContext extends FailsafeContext {
      * Persist endpoint credentials and network configurations for restoration if commissioning does not complete.
      *
      * The Matter 1.2 specification makes it pretty clear that Matter supports configuration of multiple network
-     * interfaces (e.g. @see {@link MatterSpecification.v11.Core} § 11.8.8 and § 2.3.2).
+     * interfaces (e.g. @see {@link MatterSpecification.v16.Core} § 11.9.8 and § 2.3.2).
      * {@link NetworkCommissioningCluster} of the primary interface is on the root endpoint.  However it's not clear
      * where {@link NetworkCommissioningCluster} instances for secondary interfaces reside.  To be on the safe side
      * we just assume any endpoint may support {@link NetworkCommissioningCluster}.

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

@@ -11,6 +11,7 @@ import { NetworkCommissioningServer } from "#behaviors/network-commissioning";
 import { TimeSynchronizationBehavior } from "#behaviors/time-synchronization";
 import type { Endpoint } from "#endpoint/Endpoint.js";
 import type { NodeLifecycle } from "#node/NodeLifecycle.js";
+import { InteractionServer } from "#node/server/InteractionServer.js";
 import {
     Bytes,
     Duration,
@@ -26,10 +27,12 @@ import {
     Time,
     Timer,
     Timespan,
+    UINT16_MAX,
+    UINT32_MAX,
 } from "@matter/general";
 import { FieldElement, Specification } from "@matter/model";
-import { assertRemoteActor, MdnsService, Val } from "@matter/protocol";
-import { CommandId, Status, StatusResponseError, TlvInvokeResponse, TlvOfModel } from "@matter/types";
+import { assertRemoteActor, MdnsService, SessionManager, Val } from "@matter/protocol";
+import { CommandId, FabricIndex, Status, StatusResponseError, TlvInvokeResponse, TlvOfModel } from "@matter/types";
 import { GeneralDiagnostics } from "@matter/types/clusters/general-diagnostics";
 import { GeneralDiagnosticsBehavior } from "./GeneralDiagnosticsBehavior.js";
 
@@ -408,7 +411,7 @@ export namespace GeneralDiagnosticsServer {
         /** The TestEnableKey set for this device for the test commands. Default means "not enabled"." */
         deviceTestEnableKey: Bytes = new Uint8Array(16).fill(0);
 
-        [Val.properties](endpoint: Endpoint, _session: ValueSupervisor.Session) {
+        [Val.properties](endpoint: Endpoint, session: ValueSupervisor.Session) {
             return {
                 /**
                  * Report uptime
@@ -450,6 +453,61 @@ export namespace GeneralDiagnosticsServer {
 
                     return Hours.of(totalOperationalTime);
                 },
+
+                /**
+                 * Dynamically compute device load metrics (Matter 1.6, cluster rev 3) from InteractionServer counters
+                 * and SessionManager.  Quality "C" means changes are not pushed to subscribers; clients re-read.
+                 *
+                 * Returns a zeroed struct before the interaction server is online (so the attribute appears in the
+                 * attributeList).  Throws if the node is online but the required services are unexpectedly absent.
+                 */
+                get deviceLoadStatus() {
+                    const isOnline = (endpoint.lifecycle as NodeLifecycle).isOnline;
+
+                    if (!endpoint.env.has(InteractionServer) || !endpoint.env.has(SessionManager)) {
+                        if (isOnline) {
+                            throw new StatusResponseError(
+                                "DeviceLoadStatus unavailable: InteractionServer or SessionManager missing",
+                                Status.Failure,
+                            );
+                        }
+                        return {
+                            currentSubscriptions: 0,
+                            currentSubscriptionsForFabric: 0,
+                            totalSubscriptionsEstablished: 0,
+                            totalInteractionModelMessagesSent: 0,
+                            totalInteractionModelMessagesReceived: 0,
+                        };
+                    }
+
+                    const sessionManager = endpoint.env.get(SessionManager);
+                    const { counters } = endpoint.env.get(InteractionServer);
+                    const accessingFabric = session.fabric ?? FabricIndex.NO_FABRIC;
+
+                    let currentSubscriptions = 0;
+                    let currentSubscriptionsForFabric = 0;
+                    for (const sess of sessionManager.sessions) {
+                        const count = sess.subscriptions.size;
+                        currentSubscriptions += count;
+                        if (sess.fabric?.fabricIndex === accessingFabric) {
+                            currentSubscriptionsForFabric += count;
+                        }
+                    }
+
+                    return {
+                        currentSubscriptions: Math.min(currentSubscriptions, UINT16_MAX),
+                        currentSubscriptionsForFabric: Math.min(currentSubscriptionsForFabric, UINT16_MAX),
+                        totalSubscriptionsEstablished: Math.min(counters.totalSubscriptionsEstablished, UINT32_MAX),
+                        totalInteractionModelMessagesSent: Math.min(
+                            counters.totalInteractionModelMessagesSent,
+                            UINT32_MAX,
+                        ),
+                        totalInteractionModelMessagesReceived: Math.min(
+                            counters.totalInteractionModelMessagesReceived,
+                            UINT32_MAX,
+                        ),
+                    };
+                },
             };
         }
     }

package/src/behaviors/group-key-management/GroupKeyManagementBehavior.ts

@@ -13,6 +13,9 @@ import { Identity } from "@matter/general";
 /**
  * GroupKeyManagementBehavior is the base class for objects that support interaction with
  * {@link GroupKeyManagement.Cluster}.
+ *
+ * This class does not have optional features of GroupKeyManagement.Cluster enabled. You can enable additional features
+ * using GroupKeyManagementBehavior.with.
  */
 export const GroupKeyManagementBehaviorConstructor = ClusterBehavior.for(GroupKeyManagement);
 

package/src/behaviors/group-key-management/GroupKeyManagementServer.ts

@@ -23,15 +23,17 @@ const logger = Logger.get("GroupKeyManagementServer");
 
 const MAX_64BIT_TIME = BigInt("0xffffffffffffffff");
 
+const GroupKeyManagementBase = GroupKeyManagementBehavior;
+
 // Enhance the schema by a fabric scoped structure for the GroupKeySetStruct to enable persistence
-const groupKeySetStruct = GroupKeyManagementBehavior.schema.datatypes.require("GroupKeySetStruct");
+const groupKeySetStruct = GroupKeyManagementBase.schema.datatypes.require("GroupKeySetStruct");
 const groupKeySetStructFS = groupKeySetStruct.extend(
     {
         name: "GroupKeySetStructFS",
     },
     FieldElement({ name: "FabricIndex", id: 0xfe, type: "FabricIndex", conformance: "M" }),
 );
-const schema = GroupKeyManagementBehavior.schema.extend(
+const schema = GroupKeyManagementBase.schema.extend(
     {},
     groupKeySetStructFS,
     FieldElement(
@@ -49,7 +51,7 @@ const schema = GroupKeyManagementBehavior.schema.extend(
 /**
  * This is the default server implementation of {@link GroupKeyManagementBehavior}.
  */
-export class GroupKeyManagementServer extends GroupKeyManagementBehavior {
+export class GroupKeyManagementServer extends GroupKeyManagementBase {
     declare readonly state: GroupKeyManagementServer.State;
     static override readonly schema = schema;
 
@@ -58,6 +60,13 @@ export class GroupKeyManagementServer extends GroupKeyManagementBehavior {
             throw new ImplementationError("The CacheAndSync feature is provisional. Do not use it.");
         }
 
+        // TODO: remove this guard once the Groupcast feature leaves provisional state in the Matter specification
+        if (this.features.groupcast) {
+            throw new ImplementationError(
+                "The Groupcast feature of GroupKeyManagement is provisional in Matter 1.6. Do not enable it.",
+            );
+        }
+
         // Validate the state
         this.reactTo(this.events.groupKeyMap$Changing, this.#validateGroupKeyMap);
         this.reactTo(this.events.groupTable$Changing, this.#validateGroupTable);
@@ -163,6 +172,17 @@ export class GroupKeyManagementServer extends GroupKeyManagementBehavior {
     }
 
     #validateGroupKeyMap(groupKeyMap: GroupKeyManagement.GroupKeyMap[]) {
+        // When GCAST is active and the fabric has adopted Groupcast, GroupKeyMap is read-only
+        if (this.features.groupcast && hasRemoteActor(this.context)) {
+            const fabricIndex = this.context.session?.fabric?.fabricIndex;
+            if (fabricIndex !== undefined && this.#isGroupcastAdoptedForFabric(fabricIndex)) {
+                throw new StatusResponseError(
+                    "GroupKeyMap is read-only when GroupcastAdoption.GroupcastAdopted is true",
+                    Status.InvalidInState,
+                );
+            }
+        }
+
         const knownGroupKeys = new Set<string>();
         for (const keySetId of this.state.groupKeySets) {
             const { groupKeySetId, fabricIndex } = keySetId;
@@ -422,10 +442,10 @@ export class GroupKeyManagementServer extends GroupKeyManagementBehavior {
         }
         this.state.groupKeySets.splice(existingIndex, 1);
 
-        // If there exist any entries for the accessing fabric within the GroupKeyMap attribute that refer to the
-        // GroupKeySetID just removed, then these entries SHALL be removed from that list.
+        // Per core§11.2.7.4.1: GroupKeyMap entries for the accessing fabric that refer to the removed key set SHALL be
+        // removed from the list.
         this.state.groupKeyMap = this.state.groupKeyMap.filter(
-            ({ groupKeySetId: entryId }) => groupKeySetId !== entryId,
+            entry => entry.fabricIndex !== fabricIndex || entry.groupKeySetId !== groupKeySetId,
         );
 
         // Sync to Fabric group manager to remove too
@@ -517,10 +537,74 @@ export class GroupKeyManagementServer extends GroupKeyManagementBehavior {
         }
         return existing;
     }
+
+    #isGroupcastAdoptedForFabric(fabricIndex: FabricIndex): boolean {
+        if (!this.features.groupcast) return false;
+        if (!this.state.groupcastAdoption) return false;
+        return this.state.groupcastAdoption.some(entry => entry.fabricIndex === fabricIndex && entry.groupcastAdopted);
+    }
+
+    /**
+     * Returns whether a GroupKeySetId exists for a given fabric. Called by GroupcastServer to validate KeySetIDs.
+     */
+    validateKeySetId(fabricIndex: FabricIndex, keySetId: number): boolean {
+        if (keySetId === 0) {
+            // IPK key set always exists
+            return true;
+        }
+        return this.state.groupKeySets.some(
+            entry => entry.fabricIndex === fabricIndex && entry.groupKeySetId === keySetId,
+        );
+    }
+
+    /**
+     * Creates a new GroupKeySet for a Groupcast group key, bypassing normal KeySetWrite validation.
+     * Used by GroupcastServer when JoinGroup or UpdateGroupKey is called with a `key` parameter.
+     * The key set uses TrustFirst policy and epochStartTime0=IPK_DEFAULT_EPOCH_START_TIME (Matter epoch zero = Jan 1, 2000).
+     *
+     * @returns true on success, throws if the key set already exists or resources are exhausted
+     */
+    createKeySetForGroupcast(fabric: Fabric, keySetId: number, epochKey0: Uint8Array): Promise<void> {
+        const fabricIndex = fabric.fabricIndex;
+        const keySetsOfFabric = this.state.groupKeySets.filter(({ fabricIndex: fi }) => fi === fabricIndex).length + 1;
+        if (keySetsOfFabric >= this.state.maxGroupKeysPerFabric) {
+            throw new StatusResponseError(
+                `Too many group key sets for fabric ${fabricIndex}`,
+                Status.ResourceExhausted,
+            );
+        }
+        const groupKeySet: GroupKeyManagement.GroupKeySet & { fabricIndex: FabricIndex } = {
+            groupKeySetId: keySetId,
+            groupKeySecurityPolicy: GroupKeyManagement.GroupKeySecurityPolicy.TrustFirst,
+            epochKey0,
+            epochStartTime0: IPK_DEFAULT_EPOCH_START_TIME, // Matter epoch zero
+            epochKey1: null,
+            epochStartTime1: null,
+            epochKey2: null,
+            epochStartTime2: null,
+            fabricIndex,
+        };
+        this.state.groupKeySets.push(groupKeySet);
+        // Update the fabric group manager so the key is immediately usable
+        return fabric.groups.setFromGroupKeySet(groupKeySet);
+    }
+
+    setGroupcastAdopted(fabricIndex: FabricIndex, adopted: boolean) {
+        if (!this.state.groupcastAdoption) return;
+        const existing = this.state.groupcastAdoption.findIndex(e => e.fabricIndex === fabricIndex);
+        if (existing !== -1) {
+            this.state.groupcastAdoption[existing] = {
+                ...this.state.groupcastAdoption[existing],
+                groupcastAdopted: adopted,
+            };
+        } else {
+            this.state.groupcastAdoption.push({ fabricIndex, groupcastAdopted: adopted });
+        }
+    }
 }
 
 export namespace GroupKeyManagementServer {
-    export class State extends GroupKeyManagementBehavior.State {
+    export class State extends GroupKeyManagementBase.State {
         /**
          * Extended state to hold and persist the group key sets for this server. This structure contains all
          * GroupKeySet entries for all fabrics beside the fabric specific entries of the groupKeyset 0
@@ -529,6 +613,12 @@ export namespace GroupKeyManagementServer {
 
         // Overwrite defaults to allow more than 3 group keys and 4 groups per fabric, because we can
         override maxGroupKeysPerFabric = 20; // The Minimum would be 3;
-        override maxGroupsPerFabric = 21; // The Minimum would be 4;
+        override maxGroupsPerFabric = 22; // The Minimum would be 4. Aligned with Groupcast quota=floor(44/2).
+
+        /**
+         * Per-fabric Groupcast adoption state (provisional Matter 1.6 GCAST feature).  Only present when the Groupcast
+         * feature is enabled; the default server rejects it while provisional.
+         */
+        declare groupcastAdoption?: GroupKeyManagement.GroupcastAdoption[];
     }
 }

package/src/behaviors/groupcast/GroupcastBehavior.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { Groupcast } from "@matter/types/clusters/groupcast";
+import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { Identity } from "@matter/general";
+
+/**
+ * GroupcastBehavior is the base class for objects that support interaction with {@link Groupcast.Cluster}.
+ *
+ * Groupcast.Cluster requires you to enable one or more optional features. You can do so using
+ * {@link GroupcastBehavior.with}.
+ */
+export const GroupcastBehaviorConstructor = ClusterBehavior.for(Groupcast);
+
+export interface GroupcastBehaviorConstructor extends Identity<typeof GroupcastBehaviorConstructor> {}
+export const GroupcastBehavior: GroupcastBehaviorConstructor = GroupcastBehaviorConstructor;
+export interface GroupcastBehavior extends InstanceType<GroupcastBehaviorConstructor> {}
+export namespace GroupcastBehavior { export interface State extends InstanceType<typeof GroupcastBehavior.State> {} }

package/src/behaviors/groupcast/GroupcastClient.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { Groupcast } from "@matter/types/clusters/groupcast";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
+import { Identity } from "@matter/general";
+
+export const GroupcastClientConstructor = ClientBehavior(Groupcast);
+export interface GroupcastClient extends InstanceType<typeof GroupcastClientConstructor> {}
+export interface GroupcastClientConstructor extends Identity<typeof GroupcastClientConstructor> {}
+export const GroupcastClient: GroupcastClientConstructor = GroupcastClientConstructor;

package/src/behaviors/groupcast/GroupcastInterface.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MaybePromise } from "@matter/general";
+import { Groupcast } from "@matter/types/clusters/groupcast";
+
+export namespace GroupcastInterface {
+    export interface Base {
+        joinGroup(request: Groupcast.JoinGroupRequest): MaybePromise;
+        leaveGroup(request: Groupcast.LeaveGroupRequest): MaybePromise<Groupcast.LeaveGroupResponse>;
+        updateGroupKey(request: Groupcast.UpdateGroupKeyRequest): MaybePromise;
+        groupcastTesting(request: Groupcast.GroupcastTestingRequest): MaybePromise;
+    }
+
+    export interface Listener {
+        configureAuxiliaryAcl(request: Groupcast.ConfigureAuxiliaryAclRequest): MaybePromise;
+    }
+}
+
+export type GroupcastInterface = {
+    components: [
+        { flags: {}, methods: GroupcastInterface.Base },
+        { flags: { listener: true }, methods: GroupcastInterface.Listener }
+    ]
+};