@matter/node 0.17.3 → 0.17.4-alpha.0-20260623-5647634fc

package/src/behavior/cluster/FabricScopedDataHandler.ts

@@ -5,6 +5,7 @@
  */
 
 import type { Behavior } from "#behavior/Behavior.js";
+import type { Agent } from "#endpoint/Agent.js";
 import type { Endpoint } from "#endpoint/Endpoint.js";
 import type { SupportedElements } from "#endpoint/properties/Behaviors.js";
 import type { ServerNode } from "#node/ServerNode.js";
@@ -34,18 +35,15 @@ async function forBehaviors(
 }
 
 /**
- * Sanitize fabric-scoped attributes for a given endpoint and cluster.
- * The changed state is returned in an array of promises and should be awaited to ensure the state is updated.
+ * Compute a state patch that strips fabric-scoped attribute entries no longer belonging to an allowed fabric.
+ * Returns `undefined` when nothing needs to change.
  */
-async function sanitizeAttributeData(
+function computeFabricScopedUpdate(
     endpoint: Endpoint,
     type: Behavior.Type,
-    cluster: ClusterType,
     supportedAttributes: Set<string>,
     allowedIndices: FabricIndex[],
-) {
-    const stateUpdatePromises = new Array<Promise<void>>();
-
+): Val.Struct | undefined {
     // Build a set of fabric-scoped attribute names from the schema
     const fabricScopedAttrs = new Set<string>();
     const schema = Schema(type) as ClusterModel;
@@ -58,11 +56,11 @@ async function sanitizeAttributeData(
     }
 
     const stateUpdate = {} as Val.Struct;
-    // Iterate over all attributes and check if they are fabric-scoped
+    const state = endpoint.stateOf(type) as Val.Struct;
     for (const attributeName of supportedAttributes) {
         if (fabricScopedAttrs.has(attributeName)) {
-            const value = (endpoint.stateOf(type) as Val.Struct)[attributeName];
-            // If the value contains data for the fabric being removed, remove the data
+            const value = state[attributeName];
+            // If the value contains data for a fabric no longer present, remove that data
             if (Array.isArray(value) && value.length > 0) {
                 const filtered = value.filter(entry => allowedIndices.includes(entry.fabricIndex));
                 if (filtered.length !== value.length) {
@@ -71,20 +69,38 @@ async function sanitizeAttributeData(
             }
         }
     }
-    // If we have any state updates for this behavior, we need to set the state.
-    // Errors are being logged and ignored
-    if (Object.keys(stateUpdate).length > 0) {
-        const { resolver, promise } = createPromise<void>();
-        (endpoint.eventsOf(type) as Behavior.EventsOf<any>).stateChanged?.on(resolver);
-        try {
-            await endpoint.setStateOf(type, stateUpdate);
-            stateUpdatePromises.push(withTimeout(Seconds(5), promise)); // 5s should be enough for state change
-        } catch (error) {
-            logger.warn(
-                `Could not sanitize fabric-scoped attributes for cluster ${cluster.name} on endpoint ${endpoint.id}`,
-                error,
-            );
-        }
+    return Object.keys(stateUpdate).length > 0 ? stateUpdate : undefined;
+}
+
+/**
+ * Sanitize fabric-scoped attributes for an already-active endpoint via {@link Endpoint.setStateOf}.
+ * The changed state is returned in an array of promises and should be awaited to ensure the state is updated.
+ */
+async function sanitizeAttributeData(
+    endpoint: Endpoint,
+    type: Behavior.Type,
+    cluster: ClusterType,
+    supportedAttributes: Set<string>,
+    allowedIndices: FabricIndex[],
+) {
+    const stateUpdate = computeFabricScopedUpdate(endpoint, type, supportedAttributes, allowedIndices);
+    if (stateUpdate === undefined) {
+        return [];
+    }
+
+    const stateUpdatePromises = new Array<Promise<void>>();
+    // Best-effort during online fabric removal: a per-cluster failure must not abort the removal already in progress.
+    // The startup path (limitEndpointAttributeDataToAllowedFabrics) instead lets failures throw.
+    const { resolver, promise } = createPromise<void>();
+    (endpoint.eventsOf(type) as Behavior.EventsOf<any>).stateChanged?.on(resolver);
+    try {
+        await endpoint.setStateOf(type, stateUpdate);
+        stateUpdatePromises.push(withTimeout(Seconds(5), promise)); // 5s should be enough for state change
+    } catch (error) {
+        logger.warn(
+            `Could not sanitize fabric-scoped attributes for cluster ${cluster.name} on endpoint ${endpoint.id}`,
+            error,
+        );
     }
 
     return stateUpdatePromises;
@@ -151,16 +167,24 @@ export async function limitNodeDataToAllowedFabrics(node: ServerNode, allowedInd
     }
 }
 
-export async function limitEndpointAttributeDataToAllowedFabrics(endpoint: Endpoint, allowedIndices: FabricIndex[]) {
-    const stateUpdatePromises = new Array<Promise<void>>();
-    await forBehaviors(endpoint, async (type, cluster, elements) => {
-        if (elements.attributes.size) {
-            stateUpdatePromises.push(
-                ...(await sanitizeAttributeData(endpoint, type, cluster, elements.attributes, allowedIndices)),
-            );
+/**
+ * Sanitize fabric-scoped attributes for a single endpoint while it is still initializing.
+ *
+ * Invoked from {@link EndpointInitializer.behaviorsInitialized}, which runs inside the endpoint's construction
+ * context. The endpoint is not yet active, so {@link Endpoint.setStateOf} (which opens a fresh action that asserts an
+ * active endpoint) would throw. Instead we patch state through the supplied {@link Agent}, whose context is the
+ * construction transaction that commits when initialization completes.
+ */
+export async function limitEndpointAttributeDataToAllowedFabrics(agent: Agent, allowedIndices: FabricIndex[]) {
+    await forBehaviors(agent.endpoint, async (type, _cluster, elements) => {
+        if (!elements.attributes.size) {
+            return;
+        }
+        const stateUpdate = computeFabricScopedUpdate(agent.endpoint, type, elements.attributes, allowedIndices);
+        if (stateUpdate === undefined) {
+            return;
         }
+        const behavior = agent.get(type);
+        behavior.type.supervisor.patch(stateUpdate, behavior.state, agent.endpoint.path);
     });
-
-    // Wait for all state changed to be executed before processing events
-    await Promise.allSettled(stateUpdatePromises);
 }

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

@@ -192,6 +192,12 @@ export namespace Datasource {
          */
         consumer?: ExternallyMutableStore.Consumer;
 
+        /**
+         * Current values, preferring the live consumer over {@link Store.initialValues}.  Reflects up-to-date
+         * data while a consumer is attached, where {@link Store.initialValues} may be absent.
+         */
+        currentValues?: Val.Struct;
+
         /**
          * The current version of the data.
          */
@@ -213,6 +219,11 @@ export namespace Datasource {
              */
             readValues(keys: Set<string>): Val.Struct;
 
+            /**
+             * Read a non-destructive copy of all current values.
+             */
+            snapshot(): Val.Struct;
+
             /**
              * Release all values from the datasource, transferring ownership back to the store.
              */
@@ -557,6 +568,10 @@ class DatasourceImpl implements Datasource, Datasource.ExternallyMutableStore.Co
         return result;
     }
 
+    snapshot() {
+        return { ...this.#values };
+    }
+
     releaseValues() {
         const { values } = this;
         this.values = {};

package/src/node/client/ClientStructure.ts

@@ -501,9 +501,8 @@ export class ClientStructure {
 
         // Generate a behavior if enough information is available
         if (cluster.behavior === undefined) {
-            if (cluster.store.initialValues) {
-                const values = cluster.store.initialValues;
-
+            const values = cluster.store.currentValues;
+            if (values) {
                 const clusterRevision = getStoreValue(values, ClusterRevision.id, "clusterRevision");
                 const features = getStoreValue(values, FeatureMap.id, "featureMap");
                 const attributeList = getStoreValue(values, AttributeList.id, "attributeList");
@@ -579,7 +578,7 @@ export class ClientStructure {
             if (cluster.behavior && endpoint.behaviors.isActive(cluster.behavior.id)) {
                 attrs = endpoint.stateOf(cluster.behavior);
             } else {
-                attrs = cluster.store.initialValues ?? {};
+                attrs = cluster.store.currentValues ?? {};
             }
             this.#synchronizeDescriptor(structure, attrs);
         }

package/src/node/server/ServerEndpointInitializer.ts

@@ -116,7 +116,7 @@ export class ServerEndpointInitializer extends EndpointInitializer {
         if (agent.env.has(FabricManager)) {
             const fabricIndices = agent.env.get(FabricManager).fabrics.map(fabric => fabric.fabricIndex);
             if (fabricIndices.length > 0) {
-                return limitEndpointAttributeDataToAllowedFabrics(agent.endpoint, fabricIndices);
+                return limitEndpointAttributeDataToAllowedFabrics(agent, fabricIndices);
             }
         }
     }

package/src/storage/client/DatasourceCache.ts

@@ -52,9 +52,20 @@ export class DatasourceCache implements Datasource.ExternallyMutableStore, Remot
         this.#consumer = consumer;
         if (consumer !== undefined) {
             this.#reclaimed = false;
+
+            // Consumer owns the values while attached; drop our seed copy so we don't shadow it.
+            this.initialValues = undefined;
         }
     }
 
+    /**
+     * Current values, preferring the live consumer over the seed snapshot, so cluster structure can rebuild from
+     * up-to-date data while a behavior is active.
+     */
+    get currentValues(): Val.Struct | undefined {
+        return this.#consumer && !this.#reclaimed ? this.#consumer.snapshot() : this.initialValues;
+    }
+
     async set(transaction: Transaction, values: Val.Struct) {
         let participant = transaction.getParticipant(this.#writer);
         if (participant === undefined) {
@@ -126,8 +137,7 @@ export class DatasourceCache implements Datasource.ExternallyMutableStore, Remot
             if (!this.initialValues) {
                 this.initialValues = {};
             }
-            const valuesStruct = Object.fromEntries(values) as Val.Struct;
-            Object.assign(this.initialValues, valuesStruct);
+            Object.assign(this.initialValues, Object.fromEntries(values));
         }
     }
 

package/src/storage/server/ServerNodeStore.ts

@@ -105,6 +105,8 @@ export class ServerNodeStore extends NodeStore implements Destructable {
             Diagnostic.dict({
                 location: root?.path ?? "(unknown location)",
                 driver: this.#storageManager?.driverId ?? "unknown",
+                // Only meaningful on close, where a non-zero count means a holder did not release
+                ...(what === "Closed" && root ? { locks: root.lockCount } : {}),
             }),
         );
     }