@matter/node 0.15.2-alpha.0-20250717-3607eeac6 → 0.15.2-alpha.0-20250718-7e661c331

package/src/behavior/internal/ServerBehaviorBacking.ts

@@ -11,11 +11,8 @@ import type { SupportedElements } from "#endpoint/properties/Behaviors.js";
 import { camelize } from "#general";
 import { FieldValue } from "#model";
 import { Val } from "#protocol";
-import { NodeStore } from "#storage/NodeStore.js";
-import { DatasourceStore } from "#storage/server/DatasourceStore.js";
 import { ClusterType, TlvNoResponse } from "#types";
 import { Behavior } from "../Behavior.js";
-import { Datasource } from "../state/managed/Datasource.js";
 import { BehaviorBacking } from "./BehaviorBacking.js";
 
 const NoElements = new Set<string>();
@@ -24,20 +21,8 @@ const NoElements = new Set<string>();
  * This class backs the server implementation of a behavior.
  */
 export class ServerBehaviorBacking extends BehaviorBacking {
-    #store?: Datasource.Store;
     #elements?: SupportedElements;
 
-    override get store() {
-        if (!this.#store) {
-            this.#store = this.createStore();
-        }
-        return this.#store;
-    }
-
-    protected createStore() {
-        return this.#nodeStore.storeForEndpoint(this.endpoint).createStoreForBehavior(this.type.id, DatasourceStore);
-    }
-
     get elements() {
         return this.#elements;
     }
@@ -70,10 +55,6 @@ export class ServerBehaviorBacking extends BehaviorBacking {
         finalizeState();
     }
 
-    get #nodeStore() {
-        return this.endpoint.env.get(NodeStore);
-    }
-
     /**
      * Schema may specify that state fields default to the value of another field.  We apply these defaults after
      * initialization when the other field should be defined.

package/src/behavior/state/managed/Datasource.ts

@@ -284,6 +284,7 @@ interface Internals extends Datasource.Options {
     interactionObserver(session?: AccessControl.Session): MaybePromise<void>;
     events: Datasource.InternalEvents;
     changedEventFor(key: string): undefined | Datasource.Events[any];
+    persistentFields: Set<string>;
 }
 
 /**
@@ -339,6 +340,8 @@ function configure(options: Datasource.Options): Internals {
 
     let changedEventIndex: undefined | Map<string, undefined | Datasource.InternalEvents[`${string}$Changed`]>;
 
+    const persistentFields = options.supervisor.persistentKeys(options.primaryKey);
+
     return {
         ...options,
         primaryKey: options.primaryKey === "id" ? "id" : "name",
@@ -347,6 +350,7 @@ function configure(options: Datasource.Options): Internals {
         values,
         featuresKey,
         manageVersion: true,
+        persistentFields,
 
         interactionObserver(session?: ValueSupervisor.Session) {
             function handleObserverError(error: any) {
@@ -390,6 +394,10 @@ function configure(options: Datasource.Options): Internals {
     };
 }
 
+function isExternal(store?: Datasource.Store): store is Datasource.ExternallyMutableStore {
+    return !!store && "externalSet" in store;
+}
+
 /**
  * If the store supports external mutation, add a listener to update internal state and notify observers.
  *
@@ -398,7 +406,7 @@ function configure(options: Datasource.Options): Internals {
  */
 function configureExternalChanges(internals: Internals) {
     const { store } = internals;
-    if (!store || !("externalSet" in store)) {
+    if (!isExternal(store)) {
         return;
     }
 
@@ -507,7 +515,6 @@ function createReference(resource: Transaction.Resource, internals: Internals, s
     });
 
     const fields = internals.supervisor.memberNames;
-    const persistentFields = internals.supervisor.persistentNames;
 
     // This is the actual reference
     const reference: Val.Reference<Val.Struct> = {
@@ -762,7 +769,7 @@ function createReference(resource: Transaction.Resource, internals: Internals, s
                 }
                 changes.changeList.add(name);
 
-                if (persistentFields.has(name)) {
+                if (internals.persistentFields.has(name)) {
                     if (changes.persistent === undefined) {
                         changes.persistent = {};
                     }

package/src/behavior/supervision/RootSupervisor.ts

@@ -59,7 +59,6 @@ export class RootSupervisor implements ValueSupervisor {
     #rootSchema: Schema;
     #root: ValueSupervisor;
     #memberNames?: Set<string>;
-    #persistentNames?: Set<string>;
     #attributeNamesToIds?: Map<string, AttributeId>; // Whenever we need more than Attributes and Fields, we need to generalize
 
     /**
@@ -144,23 +143,27 @@ export class RootSupervisor implements ValueSupervisor {
     }
 
     /**
-     * Names of fields configured as non-volatile.
+     * Retrieve names or IDs of fields configured as non-volatile.
      */
-    get persistentNames() {
-        let persistent = this.#persistentNames;
-        if (!persistent) {
-            persistent = new Set();
-            for (const member of this.#members) {
-                // TODO: We should handle writable/fabric scoped being non-volatile already in the conformance interpreter
-                if (
-                    member.effectiveQuality.nonvolatile ||
-                    member.effectiveAccess.writable ||
-                    member.effectiveAccess.fabricScoped
-                ) {
-                    persistent.add(camelize(member.name));
+    persistentKeys(key: "id" | "name" = "name") {
+        const persistent = new Set<string>();
+
+        for (const member of this.#members) {
+            // TODO: We should handle writable/fabric scoped being non-volatile already in the conformance interpreter
+            if (
+                member.effectiveQuality.nonvolatile ||
+                member.effectiveAccess.writable ||
+                member.effectiveAccess.fabricScoped
+            ) {
+                if (key === "id") {
+                    const id = member.effectiveId;
+                    if (id !== undefined) {
+                        persistent.add(id.toString());
+                        continue;
+                    }
                 }
+                persistent.add(camelize(member.name));
             }
-            this.#persistentNames = persistent;
         }
         return persistent;
     }

package/src/node/ClientNode.ts

@@ -14,7 +14,7 @@ import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js
 import { Identity, Lifecycle, MaybePromise } from "#general";
 import { Interactable } from "#protocol";
 import { ClientNodeStore } from "#storage/client/ClientNodeStore.js";
-import { NodeStore } from "#storage/NodeStore.js";
+import { RemoteWriter } from "#storage/client/RemoteWriter.js";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { Matter, MatterModel } from "@matter/model";
 import { ClientEndpointInitializer } from "./client/ClientEndpointInitializer.js";
@@ -58,12 +58,14 @@ export class ClientNode extends Node<ClientNode.RootEndpoint> {
 
     override initialize() {
         const store = this.env.get(ServerNodeStore).clientStores.storeForNode(this);
-        this.env.set(NodeStore, store);
+
         this.env.set(ClientNodeStore, store);
 
         const initializer = new ClientEndpointInitializer(this);
         this.env.set(EndpointInitializer, initializer);
 
+        store.write = RemoteWriter(this, initializer.structure);
+
         initializer.structure.loadCache();
 
         return super.initialize();

package/src/node/ServerNode.ts

@@ -17,7 +17,7 @@ import { Endpoint } from "#endpoint/Endpoint.js";
 import type { Environment } from "#general";
 import { asyncNew, Construction, DiagnosticSource, errorOf, Identity, MatterError } from "#general";
 import { FabricManager, Interactable, OccurrenceManager, ServerInteraction, SessionManager } from "#protocol";
-import { NodeStore } from "#storage/NodeStore.js";
+import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { RootEndpoint as BaseRootEndpoint } from "../endpoints/root.js";
 import { Node } from "./Node.js";
 import { ClientNodes } from "./client/ClientNodes.js";
@@ -192,7 +192,7 @@ export class ServerNode<T extends ServerNode.RootEndpoint = ServerNode.RootEndpo
         await this.env.get(SessionManager).clear();
         await this.env.get(FabricManager).clear();
         await this.env.get(OccurrenceManager).clear();
-        await this.env.get(NodeStore).erase();
+        await this.env.get(ServerNodeStore).erase();
     }
 
     /**

package/src/node/client/ClientEndpointInitializer.ts

@@ -12,6 +12,7 @@ import { ServerBehaviorBacking } from "#behavior/internal/ServerBehaviorBacking.
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
 import type { ClientNode } from "#node/ClientNode.js";
+import { ClientNodeStore } from "#storage/client/ClientNodeStore.js";
 import { NodeStore } from "#storage/NodeStore.js";
 import { ClientStructure } from "./ClientStructure.js";
 
@@ -23,7 +24,7 @@ export class ClientEndpointInitializer extends EndpointInitializer {
     constructor(node: ClientNode) {
         super();
         this.#node = node;
-        this.#store = node.env.get(NodeStore);
+        this.#store = node.env.get(ClientNodeStore);
     }
 
     async eraseDescendant(endpoint: Endpoint) {
@@ -45,11 +46,14 @@ export class ClientEndpointInitializer extends EndpointInitializer {
     }
 
     override createBacking(endpoint: Endpoint, type: Behavior.Type): BehaviorBacking {
+        // Non-cluster behaviors are local operation the same server behaviors
         if ((type as ClusterBehavior.Type).cluster === undefined) {
-            return new ServerBehaviorBacking(endpoint, type, endpoint.behaviors.optionsFor(type));
+            const store = this.structure.storeForLocal(endpoint, type);
+            return new ServerBehaviorBacking(endpoint, type, store, endpoint.behaviors.optionsFor(type));
         }
 
-        const store = this.structure.storeFor(endpoint, type as ClusterBehavior.Type);
+        // Cluster behaviors are clients to a remote cluster
+        const store = this.structure.storeForRemote(endpoint, type as ClusterBehavior.Type);
         return new ClientBehaviorBacking(endpoint, type, store, endpoint.behaviors.optionsFor(type));
     }
 

package/src/node/client/ClientStructure.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Behavior } from "#behavior/Behavior.js";
 import { ClusterBehavior } from "#behavior/cluster/ClusterBehavior.js";
 import { Datasource } from "#behavior/state/managed/Datasource.js";
 import { DescriptorCluster } from "#clusters/descriptor";
@@ -14,7 +15,7 @@ import type { ClientNode } from "#node/ClientNode.js";
 import { ReadScope, type Read, type ReadResult } from "#protocol";
 import { DatasourceCache } from "#storage/client/DatasourceCache.js";
 import { ClientNodeStore } from "#storage/index.js";
-import type { AttributeId, ClusterId, CommandId, DeviceTypeId, EndpointNumber } from "#types";
+import type { AttributeId, ClusterId, ClusterType, CommandId, DeviceTypeId, EndpointNumber } from "#types";
 import { ClientBehavior } from "./ClientBehavior.js";
 
 const DEVICE_TYPE_LIST_ATTR_ID = DescriptorCluster.attributes.deviceTypeList.id;
@@ -65,15 +66,24 @@ export class ClientStructure {
     }
 
     /**
-     * Obtain the store for a behavior.
+     * Obtain the store for a remote cluster.
      */
-    storeFor(endpoint: Endpoint, type: ClusterBehavior.Type) {
+    storeForRemote(endpoint: Endpoint, type: ClusterBehavior.Type) {
         const endpointStructure = this.#endpointFor(endpoint.number);
         const clusterStructure = this.#clusterFor(endpointStructure, type.cluster.id);
 
         return clusterStructure.store;
     }
 
+    /**
+     *
+     * @param request
+     * @returns
+     */
+    storeForLocal(endpoint: Endpoint, type: Behavior.Type) {
+        return this.#nodeStore.storeForEndpoint(endpoint).createStoreForLocalBehavior(type.id);
+    }
+
     /**
      * Inject version filters into a Read or Subscribe request.
      */
@@ -166,6 +176,18 @@ export class ClientStructure {
         }
     }
 
+    /**
+     * Obtain the {@link ClusterType} for an endpoint number and cluster ID.
+     */
+    clusterFor(endpoint: EndpointNumber, cluster: ClusterId) {
+        const ep = this.#endpointFor(endpoint);
+        if (!ep) {
+            return;
+        }
+
+        return this.#clusterFor(ep, cluster)?.behavior?.cluster;
+    }
+
     /**
      * Apply new attribute values for specific endpoint/cluster.
      *
@@ -309,9 +331,7 @@ export class ClientStructure {
 
         cluster = {
             id,
-            store: this.#nodeStore
-                .storeForEndpoint(endpoint.endpoint)
-                .createStoreForBehavior(id.toString(), DatasourceCache),
+            store: this.#nodeStore.storeForEndpoint(endpoint.endpoint).createStoreForBehavior(id.toString()),
         };
         endpoint.clusters[id] = cluster;
 

package/src/node/server/ServerEndpointInitializer.ts

@@ -59,7 +59,9 @@ export class ServerEndpointInitializer extends EndpointInitializer {
      * initializes.
      */
     createBacking(endpoint: Endpoint, type: Behavior.Type): BehaviorBacking {
-        return new ServerBehaviorBacking(endpoint, type, endpoint.behaviors.optionsFor(type));
+        const store = this.#store.storeForEndpoint(endpoint).createStoreForBehavior(type.id);
+
+        return new ServerBehaviorBacking(endpoint, type, store, endpoint.behaviors.optionsFor(type));
     }
 
     /**

package/src/node/server/ServerEnvironment.ts

@@ -10,7 +10,6 @@ import { Crypto, Observable } from "#general";
 import { ServerEndpointInitializer } from "#node/server/ServerEndpointInitializer.js";
 import type { ServerNode } from "#node/ServerNode.js";
 import { FabricManager, SessionManager } from "#protocol";
-import { NodeStore } from "#storage/NodeStore.js";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { IdentityService } from "./IdentityService.js";
 
@@ -26,7 +25,6 @@ export namespace ServerEnvironment {
 
         // Install support services
         const store = await ServerNodeStore.create(env, node.id);
-        env.set(NodeStore, store);
         env.set(ServerNodeStore, store);
         env.set(EndpointInitializer, new ServerEndpointInitializer(env));
         env.set(IdentityService, new IdentityService(node));

package/src/storage/EndpointStore.ts

@@ -7,13 +7,12 @@
 import type { Datasource } from "#behavior/state/managed/Datasource.js";
 import { StorageContext, SupportedStorageTypes } from "#general";
 import { Val } from "#protocol";
-import { DatasourceStore } from "./server/DatasourceStore.js";
 
 /**
  * Persistence for state values associated with a specific endpoint.
  */
 export class EndpointStore {
-    protected initialValues = {} as Record<string, Val.Struct>;
+    protected initialValues = new Map<string, Val.Struct>();
 
     #storage: StorageContext;
 
@@ -31,15 +30,15 @@ export class EndpointStore {
     }
 
     /**
-     * Create a {@link Datasource.Store} for a behavior.
+     * Extract initial values for a behavior.  Derivatives invoke this when instantiating a store.  The values are then
+     * owned by the store.
      */
-    createStoreForBehavior<T extends DatasourceStore.Type>(behaviorId: string, factory: T): ReturnType<T> {
-        const initialValues = this.initialValues[behaviorId];
+    protected consumeInitialValues(behaviorId: string) {
+        const initialValues = this.initialValues.get(behaviorId);
         if (initialValues !== undefined) {
-            delete this.initialValues[behaviorId];
+            this.initialValues.delete(behaviorId);
         }
-
-        return factory(this, behaviorId, initialValues) as ReturnType<T>;
+        return initialValues;
     }
 
     /**
@@ -102,7 +101,8 @@ export class EndpointStore {
         this.#knownBehaviors = new Set(await this.storage.contexts());
 
         for (const behaviorId of this.#knownBehaviors) {
-            const behaviorValues = (this.initialValues[behaviorId] = {} as Val.Struct);
+            const behaviorValues = {} as Val.Struct;
+            this.initialValues.set(behaviorId, behaviorValues);
             const behaviorStorage = this.storage.createContext(behaviorId);
 
             const storedValues = await behaviorStorage.values();

package/src/storage/client/ClientEndpointStore.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { StorageContext, Transaction } from "#general";
+import { EndpointStore } from "#storage/EndpointStore.js";
+import { DatasourceStore } from "#storage/server/DatasourceStore.js";
+import type { EndpointNumber } from "#types";
+import type { ClientNodeStore } from "./ClientNodeStore.js";
+import { DatasourceCache } from "./DatasourceCache.js";
+import { RemoteWriteParticipant } from "./RemoteWriteParticipant.js";
+
+export class ClientEndpointStore extends EndpointStore {
+    #owner: ClientNodeStore;
+    #number: EndpointNumber;
+
+    constructor(owner: ClientNodeStore, number: EndpointNumber, storage: StorageContext) {
+        super(storage);
+        this.#owner = owner;
+        this.#number = number;
+    }
+
+    get number() {
+        return this.#number;
+    }
+
+    participantFor(transaction: Transaction) {
+        let participant = transaction.getParticipant(this.#owner);
+        if (participant === undefined) {
+            participant = new RemoteWriteParticipant(this.#owner);
+            transaction.addParticipants(participant);
+        }
+        return participant;
+    }
+
+    /**
+     * Create a {@link Datasource.ExternallyMutableStore} for a behavior.
+     */
+    createStoreForBehavior(behaviorId: string) {
+        const initialValues = this.consumeInitialValues(behaviorId);
+        return DatasourceCache(this, behaviorId, initialValues);
+    }
+
+    /**
+     * Create a {@link Datasource.Store} for a behavior that does not track a remote cluster.
+     */
+    createStoreForLocalBehavior(behaviorId: string) {
+        const initialValues = this.consumeInitialValues(behaviorId);
+        return DatasourceStore(this, behaviorId, initialValues);
+    }
+}

package/src/storage/client/ClientNodeStore.ts

@@ -5,14 +5,46 @@
  */
 
 import { Endpoint } from "#endpoint/Endpoint.js";
-import { InternalError, StorageContext } from "#general";
-import { EndpointStore } from "#storage/EndpointStore.js";
+import { InternalError, StorageContext, StorageContextFactory } from "#general";
+import type { ClientNode } from "#node/ClientNode.js";
 import { EndpointNumber } from "#types";
 import { NodeStore } from "../NodeStore.js";
+import { ClientEndpointStore } from "./ClientEndpointStore.js";
+import type { RemoteWriter } from "./RemoteWriter.js";
 
+/**
+ * {@link ClientNode} persistence.
+ */
 export class ClientNodeStore extends NodeStore {
+    #id: string;
     #storage?: StorageContext;
-    #stores = new Map<EndpointNumber, EndpointStore>();
+    #stores = new Map<EndpointNumber, ClientEndpointStore>();
+    #write?: RemoteWriter;
+
+    constructor(id: string, storage: StorageContextFactory) {
+        super(storage);
+        this.#id = id;
+    }
+
+    override toString() {
+        return `client-node-store#${this.#id}`;
+    }
+
+    get id() {
+        return this.#id;
+    }
+
+    get write() {
+        if (this.#write === undefined) {
+            throw new InternalError("Write attempt on ClientNodeStore without writer installed");
+        }
+
+        return this.#write;
+    }
+
+    set write(write: RemoteWriter) {
+        this.#write = write;
+    }
 
     get endpointStores() {
         return this.#stores.values();
@@ -23,7 +55,7 @@ export class ClientNodeStore extends NodeStore {
         return this.#storage?.clearAll();
     }
 
-    override storeForEndpoint(endpoint: Endpoint): EndpointStore {
+    override storeForEndpoint(endpoint: Endpoint) {
         const { number } = endpoint;
 
         if (this.#storage === undefined) {
@@ -32,7 +64,7 @@ export class ClientNodeStore extends NodeStore {
 
         let store = this.#stores.get(number);
         if (store === undefined) {
-            store = new EndpointStore(this.#storage.createContext(number.toString()));
+            store = new ClientEndpointStore(this, number, this.#storage.createContext(number.toString()));
             this.#stores.set(number, store);
         }
 
@@ -47,7 +79,7 @@ export class ClientNodeStore extends NodeStore {
                 continue;
             }
 
-            const store = new EndpointStore(this.#storage.createContext(id));
+            const store = new ClientEndpointStore(this, number, this.#storage.createContext(id));
             await store.load();
             this.#stores.set(number, store);
         }

package/src/storage/client/ClientNodeStores.ts

@@ -7,7 +7,6 @@
 import { Construction, MatterAggregateError, StorageContext } from "#general";
 import type { ClientNode } from "#node/ClientNode.js";
 import type { Node } from "#node/Node.js";
-import { NodeStore } from "../NodeStore.js";
 import { ClientNodeStore } from "./ClientNodeStore.js";
 
 const CLIENT_ID_PREFIX = "peer";
@@ -17,7 +16,7 @@ const CLIENT_ID_PREFIX = "peer";
  */
 export class ClientNodeStores {
     #storage: StorageContext;
-    #stores = {} as Record<string, NodeStore>;
+    #stores = {} as Record<string, ClientNodeStore>;
     #construction: Construction<ClientNodeStores>;
     #nextAutomaticId = 1;
 
@@ -72,7 +71,7 @@ export class ClientNodeStores {
      *
      * These stores are cached internally by ID.
      */
-    storeForNode(node: ClientNode): NodeStore {
+    storeForNode(node: ClientNode): ClientNodeStore {
         this.#construction.assert();
 
         const store = this.#stores[node.id];
@@ -97,7 +96,7 @@ export class ClientNodeStores {
     }
 
     #createNodeStore(id: string) {
-        const store = new ClientNodeStore(this.#storage.createContext(id));
+        const store = new ClientNodeStore(id, this.#storage.createContext(id));
         store.construction.start();
         this.#stores[id] = store;
         return store;

package/src/storage/client/DatasourceCache.ts

@@ -5,10 +5,10 @@
  */
 
 import { Datasource } from "#behavior/state/managed/Datasource.js";
-import { InternalError } from "#general";
+import { InternalError, Transaction } from "#general";
 import { Val } from "#protocol";
-import { EndpointStore } from "#storage/EndpointStore.js";
-import { DatasourceStore } from "../server/DatasourceStore.js";
+import type { ClientEndpointStore } from "./ClientEndpointStore.js";
+import type { RemoteWriteParticipant } from "./RemoteWriteParticipant.js";
 
 /**
  * Factory function for the default implementation of {@link Datasource.ExternallyMutableStore}.
@@ -16,7 +16,7 @@ import { DatasourceStore } from "../server/DatasourceStore.js";
  * This implements storage for attribute values for a single cluster loaded from remote nodes.
  */
 export function DatasourceCache(
-    store: EndpointStore,
+    store: ClientEndpointStore,
     behaviorId: string,
     initialValues: Val.Struct | undefined,
 ): Datasource.ExternallyMutableStore {
@@ -26,7 +26,12 @@ export function DatasourceCache(
     }
 
     return {
-        ...DatasourceStore(store, behaviorId, initialValues),
+        initialValues,
+
+        async set(transaction: Transaction, values: Val.Struct) {
+            const participant = store.participantFor(transaction) as RemoteWriteParticipant;
+            participant.set(store.number, behaviorId, values);
+        },
 
         async externalSet(values: Val.Struct) {
             if (typeof values[DatasourceCache.VERSION_KEY] === "number") {
@@ -57,8 +62,6 @@ export function DatasourceCache(
     };
 }
 
-DatasourceCache satisfies DatasourceStore.Type;
-
 export namespace DatasourceCache {
     /**
      * Standard key for storing the version.

package/src/storage/client/RemoteWriteParticipant.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Transaction } from "#general";
+import { Val } from "#protocol";
+import { EndpointNumber } from "#types";
+import type { ClientNodeStore } from "./ClientNodeStore.js";
+import type { RemoteWriter } from "./RemoteWriter.js";
+
+/**
+ * A transaction participant that persists changes to a remote node.
+ *
+ * There is one of these for node/transaction pair.  All attributes in a transaction commit with a single interaction.
+ */
+export class RemoteWriteParticipant implements Transaction.Participant {
+    #request: RemoteWriter.Request = [];
+    #store: ClientNodeStore;
+
+    /**
+     * There is one participant for each transaction/client node pair.  We therefore use the store as the role.
+     */
+    get role() {
+        return this.#store;
+    }
+
+    /**
+     * Add an attribute update to the write request.
+     */
+    set(endpointNumber: EndpointNumber, behaviorId: string, values: Val.Struct) {
+        this.#request.push({
+            number: endpointNumber,
+            behaviorId: behaviorId,
+            values,
+        });
+    }
+
+    async commit2() {
+        if (!this.#request.length) {
+            return;
+        }
+
+        const request = this.#request;
+        this.#request = [];
+
+        await this.#store.write(request);
+    }
+
+    rollback() {
+        this.#request = [];
+    }
+
+    toString() {
+        return `writer#${this.#store.id}`;
+    }
+
+    constructor(store: ClientNodeStore) {
+        this.#store = store;
+    }
+}