@matter/node 0.16.0-alpha.0-20251018-dd1ea6a8a → 0.16.0-alpha.0-20251021-cca02fb0e

package/src/behavior/system/commissioning/CommissioningServer.ts

@@ -296,35 +296,6 @@ export class CommissioningServer extends Behavior {
         );
     }
 
-    /**
-     * Obtain pairing codes for a node.
-     */
-    static pairingCodesFor(node: Endpoint) {
-        const bi = node.stateOf(BasicInformationBehavior);
-        const comm = node.stateOf(CommissioningServer);
-        const net = node.stateOf(NetworkServer);
-
-        const qrPairingCode = QrPairingCodeCodec.encode([
-            {
-                version: 0,
-                vendorId: bi.vendorId,
-                productId: bi.productId,
-                flowType: comm.flowType,
-                discriminator: comm.discriminator,
-                passcode: comm.passcode,
-                discoveryCapabilities: DiscoveryCapabilitiesSchema.encode(net.discoveryCapabilities),
-            },
-        ]);
-
-        return {
-            manualPairingCode: ManualPairingCodeCodec.encode({
-                discriminator: comm.discriminator,
-                passcode: comm.passcode,
-            }),
-            qrPairingCode,
-        };
-    }
-
     /**
      * Define logical schema to make passcode and discriminator persistent.
      */
@@ -384,9 +355,33 @@ export namespace CommissioningServer {
         ble?: BleAdvertiser.Options;
 
         [Val.properties](endpoint: Endpoint) {
+            const comm = this;
             return {
                 get pairingCodes() {
-                    return CommissioningServer.pairingCodesFor(endpoint);
+                    const bi = endpoint.stateOf(BasicInformationBehavior);
+                    const net = endpoint.stateOf(NetworkServer);
+
+                    const qrPairingCode = QrPairingCodeCodec.encode([
+                        {
+                            version: 0,
+                            vendorId: bi.vendorId,
+                            productId: bi.productId,
+                            flowType: comm.flowType,
+                            discriminator: comm.discriminator,
+                            passcode: comm.passcode,
+                            discoveryCapabilities: DiscoveryCapabilitiesSchema.encode(net.discoveryCapabilities),
+                        },
+                    ]);
+
+                    return {
+                        manualPairingCode: ManualPairingCodeCodec.encode({
+                            // We use -1 to flag "need generated value" but this will crash the pairing code generator.  So use 0
+                            // so we don't throw an error during initialization
+                            discriminator: comm.discriminator < 0 ? 0 : comm.discriminator,
+                            passcode: comm.passcode < 0 ? 0 : comm.passcode,
+                        }),
+                        qrPairingCode,
+                    };
                 },
 
                 get fabrics() {

package/src/behavior/system/commissioning/RemoteDescriptor.ts

@@ -57,7 +57,7 @@ export namespace RemoteDescriptor {
             rotatingIdentifier,
             pairingHint,
             pairingInstructions,
-            sessionParameters,
+            sessionIntervals,
             tcpSupport,
             longIdleTimeOperatingMode,
         } = long;
@@ -102,8 +102,8 @@ export namespace RemoteDescriptor {
             result.PI = pairingInstructions;
         }
 
-        if (sessionParameters !== undefined) {
-            const { idleInterval, activeInterval, activeThreshold } = sessionParameters;
+        if (sessionIntervals !== undefined) {
+            const { idleInterval, activeInterval, activeThreshold } = sessionIntervals;
 
             if (idleInterval !== undefined) {
                 result.SII = idleInterval;
@@ -189,7 +189,7 @@ export namespace RemoteDescriptor {
         if (SAT !== undefined) {
             (sessionParameters ??= {}).activeThreshold = SAT;
         }
-        long.sessionParameters = sessionParameters;
+        long.sessionIntervals = sessionParameters;
 
         long.deviceType = DT === undefined ? undefined : DeviceTypeId(DT);
         long.deviceName = DN;

package/src/behavior/system/controller/ControllerBehavior.ts

@@ -6,14 +6,14 @@
 
 import { Behavior } from "#behavior/Behavior.js";
 import { BasicInformationBehavior } from "#behaviors/basic-information";
-import { ConnectionlessTransportSet, ImplementationError } from "#general";
+import { ConnectionlessTransportSet, ImplementationError, Logger } from "#general";
 import { Node } from "#node/Node.js";
 import {
     Ble,
     ClientSubscriptions,
     Fabric,
     FabricAuthority,
-    FabricAuthorityConfigurationProvider,
+    FabricAuthorityConfiguration,
     FabricManager,
     MdnsClient,
     MdnsScannerTargetCriteria,
@@ -21,13 +21,15 @@ import {
     Scanner,
     ScannerSet,
 } from "#protocol";
-import { FabricId } from "@matter/types";
+import { CaseAuthenticatedTag, FabricId, NodeId } from "#types";
 import type { CommissioningClient } from "../commissioning/CommissioningClient.js";
 import { CommissioningServer } from "../commissioning/CommissioningServer.js";
 import { NetworkServer } from "../network/NetworkServer.js";
 import { ActiveDiscoveries } from "./discovery/ActiveDiscoveries.js";
 import type { Discovery } from "./discovery/Discovery.js";
 
+const logger = Logger.get("ControllerBehavior");
+
 /**
  * Node controller functionality.
  *
@@ -44,10 +46,8 @@ export class ControllerBehavior extends Behavior {
 
     override async initialize() {
         if (this.state.adminFabricLabel === undefined || this.state.adminFabricLabel === "") {
-            throw new ImplementationError("adminFabricLabel must be set for ControllerBehavior.");
+            throw new ImplementationError("adminFabricLabel must be set for ControllerBehavior");
         }
-        const adminFabricLabel = this.state.adminFabricLabel;
-        const adminFabricId = this.state.adminFabricId;
 
         // Configure discovery transports
         if (this.state.ip === undefined) {
@@ -61,28 +61,12 @@ export class ControllerBehavior extends Behavior {
             this.state.ble = (await this.agent.load(NetworkServer)).state.ble;
         }
         if (this.state.ble !== false) {
-            this.env.get(ScannerSet).add(this.env.get(Ble).scanner);
-        }
-
-        // Configure management of controlled fabrics
-        if (!this.env.has(FabricAuthorityConfigurationProvider)) {
-            const biState = this.endpoint.stateOf(BasicInformationBehavior);
-            this.env.set(
-                FabricAuthorityConfigurationProvider,
-                new (class extends FabricAuthorityConfigurationProvider {
-                    get vendorId() {
-                        return biState.vendorId;
-                    }
-
-                    override get adminFabricLabel() {
-                        return adminFabricLabel;
-                    }
-
-                    get fabricId() {
-                        return adminFabricId;
-                    }
-                })(),
-            );
+            try {
+                this.env.get(ScannerSet).add(this.env.get(Ble).scanner);
+            } catch (error) {
+                logger.error("Disabling BLE due to initialization error:", error);
+                this.state.ble = false;
+            }
         }
 
         // Ensure the fabric authority is fully initialized
@@ -104,6 +88,7 @@ export class ControllerBehavior extends Behavior {
         if (node.lifecycle.isOnline) {
             this.#nodeOnline();
         }
+        this.reactTo(node.lifecycle.goingOffline, this.#nodeGoingOffline);
     }
 
     override async [Symbol.asyncDispose]() {
@@ -112,17 +97,22 @@ export class ControllerBehavior extends Behavior {
         this.env.delete(ScannerSet);
     }
 
+    get fabricAuthorityConfig(): FabricAuthorityConfiguration {
+        const biState = this.endpoint.stateOf(BasicInformationBehavior);
+        return {
+            adminVendorId: biState.vendorId,
+            ...this.state,
+        };
+    }
+
     #nodeOnline() {
         // Configure network connections
         const netTransports = this.env.get(ConnectionlessTransportSet);
         if (this.state.ble) {
+            // no try-catch needed because we already added the scanner in initialize()
             netTransports.add(this.env.get(Ble).centralInterface);
         }
 
-        // Clean up as the node goes offline
-        const node = Node.forEndpoint(this.endpoint);
-        this.reactTo(node.lifecycle.goingOffline, this.#nodeGoingOffline);
-
         // Add each pre-existing fabric to discovery criteria
         const authority = this.env.get(FabricAuthority);
         for (const fabric of authority.fabrics) {
@@ -140,6 +130,21 @@ export class ControllerBehavior extends Behavior {
 
     async #nodeGoingOffline() {
         await this.env.close(ClientSubscriptions);
+
+        // Configure each MDNS scanner with criteria
+        const scanners = this.env.get(ScannerSet);
+        for (const scanner of scanners) {
+            if (scanner instanceof MdnsClient) {
+                scanner.targetCriteriaProviders.delete(this.internal.mdnsTargetCriteria);
+            }
+        }
+        // Clear operational targets
+        this.internal.mdnsTargetCriteria.operationalTargets.length = 0;
+
+        const netTransports = this.env.get(ConnectionlessTransportSet);
+        if (this.state.ble) {
+            netTransports.delete(this.env.get(Ble).centralInterface);
+        }
     }
 
     #enableScanningForFabric(fabric: Fabric) {
@@ -191,5 +196,17 @@ export namespace ControllerBehavior {
          * If not provided, a random FabricId will be generated.
          */
         adminFabricId?: FabricId = undefined;
+
+        /**
+         * Contains the NodeId of the admin node when a defined number needs to be used because special Certificates
+         * are used.
+         * If not provided, a random NodeId will be generated.
+         */
+        adminNodeId?: NodeId = undefined;
+
+        /**
+         * Case Authenticated Tags to be used to commission and connect to devices.
+         */
+        caseAuthenticatedTags?: CaseAuthenticatedTag[] = undefined;
     }
 }

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

@@ -20,8 +20,14 @@ export class NetworkClient extends NetworkBehavior {
     declare events: NetworkClient.Events;
 
     override initialize() {
-        this.reactTo(this.events.autoSubscribe$Changed, this.#handleSubscription);
-        this.reactTo(this.events.defaultSubscription$Changed, this.#handleChangedDefaultSubscription);
+        if (this.#node.isGroup) {
+            // Groups can never subscribe
+            this.state.autoSubscribe = false;
+            this.state.defaultSubscription = undefined;
+        } else {
+            this.reactTo(this.events.autoSubscribe$Changed, this.#handleSubscription, { offline: true });
+            this.reactTo(this.events.defaultSubscription$Changed, this.#handleChangedDefaultSubscription);
+        }
     }
 
     override async startup() {

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

@@ -49,7 +49,7 @@ export class NetworkServer extends NetworkBehavior {
             discoveryCaps.onIpNetwork = true;
         }
 
-        this.reactTo(this.agent.get(CommissioningServer).events.commissioned, this.#endUncommissionedMode);
+        this.reactTo(this.endpoint.eventsOf(CommissioningServer).commissioned, this.#endUncommissionedMode);
 
         return super.initialize();
     }

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

@@ -18,7 +18,6 @@ import {
     UdpInterface,
 } from "#general";
 import type { ServerNode } from "#node/ServerNode.js";
-import { NodePeerAddressStore } from "#node/client/NodePeerAddressStore.js";
 import { InteractionServer } from "#node/server/InteractionServer.js";
 import {
     Advertiser,
@@ -30,7 +29,6 @@ import {
     ExchangeManager,
     MdnsAdvertiser,
     MdnsService,
-    PeerAddressStore,
     PeerSet,
     ScannerSet,
     SecureChannelProtocol,
@@ -294,7 +292,6 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         // Initialize ScannerSet
         this.owner.env.get(ScannerSet).add(mdns.client);
 
-        env.set(PeerAddressStore, new NodePeerAddressStore(owner));
         await env.load(PeerSet);
 
         await this.owner.act(agent => this.owner.lifecycle.online.emit(agent.context));
@@ -327,6 +324,7 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         await env.close(SecureChannelProtocol);
         await env.close(ConnectionlessTransportSet);
         await env.close(InteractionServer);
+        await env.close(PeerSet);
     }
 
     protected override blockNewActivity() {

package/src/behavior/system/subscriptions/SubscriptionsServer.ts

@@ -227,10 +227,10 @@ export class SubscriptionsBehavior extends Behavior {
             const { peerAddress: peerAddressDetails, operationalAddress, subscriptionId } = subscription;
             const peerAddress = PeerAddress(peerAddressDetails);
             if (peerStopList.has(peerAddress)) {
-                logger.debug(`Skip re-establishing former subscription to ${peerAddress}`);
+                logger.debug(`Skip reestablishing former subscription to ${peerAddress}`);
                 continue;
             }
-            logger.debug(`Try to re-establish former subscription ${subscriptionId} to ${peerAddress}`);
+            logger.debug(`Try to reestablish former subscription ${subscriptionId} to ${peerAddress}`);
             if (sessions.getSessionForNode(peerAddress) !== undefined) {
                 logger.debug(`We already have and existing session for peer ${peerAddress}`);
             } else {
@@ -280,7 +280,7 @@ export class SubscriptionsBehavior extends Behavior {
         interactionServer.subscriptionEstablishmentStarted.off(blockHandler);
 
         logger.info(
-            `Re-established ${successfullReEstablishments.length}${successfullReEstablishments.length ? ` (${successfullReEstablishments.join(",")})` : ""} of ${formerSubscriptions.length} former subscriptions successfully`,
+            `Reestablished ${successfullReEstablishments.length}${successfullReEstablishments.length ? ` (${successfullReEstablishments.join(",")})` : ""} of ${formerSubscriptions.length} former subscriptions successfully`,
         );
     }
 }

package/src/behaviors/access-control/AccessControlServer.ts

@@ -77,21 +77,14 @@ export class AccessControlServer extends AccessControlBehavior.with("Extension")
                 // Handle Backward compatibility to Matter.js before 0.9.1 and add the missing ACL entry if no entry was set
                 // so far by the controller
                 const fallbackAcl: AccessControlTypes.AccessControlEntry = {
-                    fabricIndex: fabric.fabricIndex,
                     privilege: AccessControlTypes.AccessControlEntryPrivilege.Administer,
                     authMode: AccessControlTypes.AccessControlEntryAuthMode.Case,
                     subjects: [fabric.rootNodeId],
                     targets: null, // entire node
+                    fabricIndex: fabric.fabricIndex,
                 };
                 this.state.acl.push(fallbackAcl);
                 fabricAcls.push(fallbackAcl);
-                logger.warn(
-                    "Added missing ACL entry for fabric",
-                    fabric.fabricIndex,
-                    "for Node ID",
-                    fabric.rootNodeId,
-                    ". This should only happen once after upgrading to matter.js 0.9.1",
-                );
             }
             fabric.accessControl.aclList = fabricAcls;
             fabric.accessControl.extensionEntryAccessCheck = this.extensionEntryAccessCheck.bind(this);

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

@@ -99,7 +99,7 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
                     sessions: this.env.get(SessionManager),
                     expiryLength: Seconds(expiryLengthSeconds),
                     maxCumulativeFailsafe: Seconds(this.state.basicCommissioningInfo.maxCumulativeFailsafeSeconds),
-                    associatedFabric: session.fabric,
+                    session,
                 });
 
                 // Note - this used to be async and wait for construction internally.  However that leads to race

package/src/endpoint/properties/Endpoints.ts

@@ -8,7 +8,7 @@ import { IndexBehavior } from "#behavior/system/index/IndexBehavior.js";
 import type { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
 import type { ImmutableSet } from "#general";
-import { Node } from "#node/Node.js";
+import type { Node } from "#node/Node.js";
 import { StatusResponse } from "#types";
 
 /**

package/src/node/ClientGroup.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ActionContext } from "#behavior/context/ActionContext.js";
+import { Interactable } from "#protocol";
+import { ServerNodeStore } from "#storage/index.js";
+import { ClientNode } from "./ClientNode.js";
+import { ClientGroupInteraction } from "./client/ClientGroupInteraction.js";
+
+export class ClientGroup extends ClientNode {
+    #interaction?: ClientGroupInteraction;
+
+    override get isGroup() {
+        return true;
+    }
+
+    override get interaction(): Interactable<ActionContext> {
+        if (this.#interaction === undefined) {
+            this.#interaction = new ClientGroupInteraction(this);
+        }
+
+        return this.#interaction;
+    }
+
+    protected override get store() {
+        return this.env.get(ServerNodeStore).clientStores.storeForGroup(this);
+    }
+}
+
+export namespace ClientGroup {
+    export function is(value: unknown): value is ClientGroup {
+        return value instanceof ClientGroup;
+    }
+}

package/src/node/ClientNode.ts

@@ -53,6 +53,10 @@ export class ClientNode extends Node<ClientNode.RootEndpoint> {
         this.#matter = options.matter ?? Matter;
     }
 
+    get isGroup() {
+        return false;
+    }
+
     /**
      * Model of Matter semantics understood by this node.
      *
@@ -66,8 +70,12 @@ export class ClientNode extends Node<ClientNode.RootEndpoint> {
         return new ClientNodeEndpoints(this);
     }
 
+    protected get store() {
+        return this.env.get(ServerNodeStore).clientStores.storeForNode(this);
+    }
+
     override initialize() {
-        const store = this.env.get(ServerNodeStore).clientStores.storeForNode(this);
+        const store = this.store;
 
         this.env.set(ClientNodeStore, store);
 
@@ -202,7 +210,7 @@ export class ClientNode extends Node<ClientNode.RootEndpoint> {
 
         // During early initialization commissioning state may not be loaded, so check directly in storage too
         if (!address) {
-            address = this.env.get(ClientNodeStore).storeForEndpoint(this).peerAddress as PeerAddress | undefined;
+            address = this.store.storeForEndpoint(this).peerAddress as PeerAddress | undefined;
         }
 
         // Use the peer address as a log identifier if present

package/src/node/client/ClientEndpointInitializer.ts

@@ -49,7 +49,7 @@ export class ClientEndpointInitializer extends EndpointInitializer {
     }
 
     override createBacking(endpoint: Endpoint, type: Behavior.Type): BehaviorBacking {
-        // Non-cluster behaviors are local operation the same server behaviors
+        // Non-cluster behaviors are local, operating the same server behaviors
         if ((type as ClusterBehavior.Type).cluster === undefined) {
             const store = this.structure.storeForLocal(endpoint, type);
             return new ServerBehaviorBacking(endpoint, type, store, endpoint.behaviors.optionsFor(type));

package/src/node/client/ClientGroupInteraction.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { ActionContext } from "#behavior/index.js";
+import { ImplementationError } from "#general";
+import {
+    ClientInvoke,
+    DecodedInvokeResult,
+    Read,
+    ReadResult,
+    Subscribe,
+    SubscribeResult,
+    Write,
+    WriteResult,
+} from "#protocol";
+import { ClientNodeInteraction } from "./ClientNodeInteraction.js";
+
+export class InvalidGroupOperationError extends ImplementationError {}
+
+export class ClientGroupInteraction extends ClientNodeInteraction {
+    /** Groups do not support reading or subscribing to attributes */
+    override read(_request: Read, _context?: ActionContext): ReadResult {
+        throw new InvalidGroupOperationError("Groups do not support reading attributes");
+    }
+
+    /** Groups do not support reading or subscribing to attributes */
+    override async subscribe(_request: Subscribe, _context?: ActionContext): SubscribeResult {
+        throw new InvalidGroupOperationError("Groups do not support subscribing to attributes");
+    }
+
+    override async write<T extends Write>(
+        request: T,
+        context?: ActionContext,
+    ): WriteResult<T & { suppressResponse: true }> {
+        if (request.timedRequest) {
+            throw new InvalidGroupOperationError("Timed requests are not supported for group address writes.");
+        }
+
+        if (request.suppressResponse === false) {
+            // If flag was explicitly set to false, we cannot comply
+            throw new InvalidGroupOperationError("Writing attributes on a group address can not return a response.");
+        }
+
+        if (
+            request.writeRequests.some(
+                ({ path: { endpointId, clusterId, attributeId } }) =>
+                    endpointId !== undefined || clusterId === undefined || attributeId === undefined,
+            )
+        ) {
+            throw new InvalidGroupOperationError("Not all attribute write paths are valid for group address writes.");
+        }
+
+        // Writing to a group does not yield a response
+        return super.write({ ...request, suppressResponse: true }, context);
+    }
+
+    override invoke(request: ClientInvoke, context?: ActionContext): DecodedInvokeResult {
+        if (request.invokeRequests.some(({ commandPath: { endpointId } }) => endpointId !== undefined)) {
+            throw new InvalidGroupOperationError("Invoking a concrete command on a group address is not supported.");
+        }
+        if (request.timedRequest) {
+            throw new InvalidGroupOperationError("Timed requests are not supported for group address invokes.");
+        }
+
+        return super.invoke(request, context);
+    }
+}

package/src/node/client/ClientNodeFactory.ts

@@ -7,6 +7,7 @@
 import type { RemoteDescriptor } from "#behavior/system/commissioning/RemoteDescriptor.js";
 import type { ImmutableSet } from "#general";
 import type { ClientNode } from "#node/ClientNode.js";
+import type { PeerAddress } from "#protocol";
 
 /**
  * Create a new client node.
@@ -16,6 +17,6 @@ import type { ClientNode } from "#node/ClientNode.js";
  */
 export abstract class ClientNodeFactory {
     abstract find(descriptor: RemoteDescriptor): ClientNode | undefined;
-    abstract create(options: ClientNode.Options): ClientNode;
+    abstract create(options: ClientNode.Options, peerAddress?: PeerAddress): ClientNode;
     abstract nodes: ImmutableSet<ClientNode>;
 }

package/src/node/client/Peers.ts

@@ -11,14 +11,13 @@ import { Discovery } from "#behavior/system/controller/discovery/Discovery.js";
 import { InstanceDiscovery } from "#behavior/system/controller/discovery/InstanceDiscovery.js";
 import { EndpointContainer } from "#endpoint/properties/EndpointContainer.js";
 import { CancelablePromise, Duration, ImplementationError, Logger, Minutes, Seconds, Time, Timestamp } from "#general";
-import { InteractionServer } from "#node/index.js";
-import { FabricManager, PeerAddress, PeerAddressStore } from "#protocol";
+import { ClientGroup } from "#node/ClientGroup.js";
+import { InteractionServer } from "#node/server/InteractionServer.js";
+import { ClientSubscriptionHandler, ClientSubscriptions, FabricManager, PeerAddress } from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
-import { ClientSubscriptionHandler, ClientSubscriptions } from "@matter/protocol";
 import { ClientNode } from "../ClientNode.js";
 import type { ServerNode } from "../ServerNode.js";
 import { ClientNodeFactory } from "./ClientNodeFactory.js";
-import { NodePeerAddressStore } from "./NodePeerAddressStore.js";
 
 const logger = Logger.get("ClientNodes");
 
@@ -43,8 +42,6 @@ export class Peers extends EndpointContainer<ClientNode> {
             owner.env.set(ClientNodeFactory, new Factory(this));
         }
 
-        this.owner.env.set(PeerAddressStore, new NodePeerAddressStore(owner));
-
         owner.env.applyTo(InteractionServer, this.#configureInteractionServer.bind(this));
 
         this.added.on(this.#handlePeerAdded.bind(this));
@@ -58,6 +55,7 @@ export class Peers extends EndpointContainer<ClientNode> {
         const factory = this.owner.env.get(ClientNodeFactory);
 
         const clientStores = this.owner.env.get(ServerNodeStore).clientStores;
+        // Group nodes have an in-memory only store, so all nodes restored here are ClientNode
         for (const id of clientStores.knownIds) {
             this.add(
                 factory.create({
@@ -131,7 +129,7 @@ export class Peers extends EndpointContainer<ClientNode> {
         if (!node) {
             // We do not have that node till now, also not persisted, so create it
             const factory = this.owner.env.get(ClientNodeFactory);
-            node = factory.create(options);
+            node = factory.create(options, peerAddress);
             await node.construction;
             this.add(node);
 
@@ -278,20 +276,33 @@ export class Peers extends EndpointContainer<ClientNode> {
 
 class Factory extends ClientNodeFactory {
     #owner: Peers;
+    #groupIdCounter = 0;
 
     constructor(owner: Peers) {
         super();
         this.#owner = owner;
     }
 
-    create(options: ClientNode.Options) {
-        if (options.id === undefined) {
-            options.id = this.#owner.owner.env.get(ServerNodeStore).clientStores.allocateId();
+    create(options: ClientNode.Options, peerAddress?: PeerAddress) {
+        let node: ClientNode;
+        if (peerAddress !== undefined && PeerAddress.isGroup(peerAddress)) {
+            if (options.id === undefined) {
+                options.id = `group${++this.#groupIdCounter}`;
+            }
+            node = new ClientGroup({
+                ...options,
+                owner: this.#owner.owner,
+            });
+        } else {
+            if (options.id === undefined) {
+                options.id = this.#owner.owner.env.get(ServerNodeStore).clientStores.allocateId();
+            }
+            node = new ClientNode({
+                ...options,
+                owner: this.#owner.owner,
+            });
         }
-        const node = new ClientNode({
-            ...options,
-            owner: this.#owner.owner,
-        });
+
         node.construction.start();
         return node;
     }

package/src/node/server/ServerEnvironment.ts

@@ -7,10 +7,11 @@
 import { limitNodeDataToAllowedFabrics } from "#behavior/cluster/FabricScopedDataHandler.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
 import { Crypto, Observable } from "#general";
+import { NodePeerAddressStore } from "#node/client/NodePeerAddressStore.js";
 import { ChangeNotificationService } from "#node/integration/ChangeNotificationService.js";
 import { ServerEndpointInitializer } from "#node/server/ServerEndpointInitializer.js";
 import type { ServerNode } from "#node/ServerNode.js";
-import { FabricManager, MdnsService, OccurrenceManager, SessionManager } from "#protocol";
+import { FabricManager, MdnsService, OccurrenceManager, PeerAddressStore, SessionManager } from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { IdentityService } from "./IdentityService.js";
 
@@ -25,10 +26,17 @@ export namespace ServerEnvironment {
         const { env } = node;
 
         // Install support services
-        const store = await ServerNodeStore.create(env, node.id);
-        env.set(ServerNodeStore, store);
+        if (!env.has(ServerNodeStore)) {
+            // TODO Remove the "if" once the legacy controller is removed
+            const store = await ServerNodeStore.create(env, node.id);
+            env.set(ServerNodeStore, store);
+        }
         env.set(EndpointInitializer, new ServerEndpointInitializer(env));
         env.set(IdentityService, new IdentityService(node));
+        if (!env.has(PeerAddressStore)) {
+            // TODO Remove the "if" once the legacy controller is removed
+            env.set(PeerAddressStore, new NodePeerAddressStore(node));
+        }
         env.set(ChangeNotificationService, new ChangeNotificationService(node));
 
         // Ensure these are fully initialized