@matter/node 0.16.0-alpha.0-20251209-d6072d23e → 0.16.0-alpha.0-20251211-0f80042cf

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

@@ -64,7 +64,7 @@ export class GeneralDiagnosticsServer extends Base {
     declare state: GeneralDiagnosticsServer.State;
     static override readonly schema = schema;
 
-    override initialize(): MaybePromise {
+    override initialize() {
         if (this.state.testEventTriggersEnabled === undefined) {
             this.state.testEventTriggersEnabled = false;
         } else if (this.state.testEventTriggersEnabled) {

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

@@ -6,7 +6,7 @@
 
 import { ActionContext } from "#behavior/context/ActionContext.js";
 import { GroupKeyManagement } from "#clusters/group-key-management";
-import { deepCopy, ImplementationError, Logger, MaybePromise } from "#general";
+import { deepCopy, ImplementationError, Logger } from "#general";
 import { DatatypeModel, FieldElement } from "#model";
 import { NodeLifecycle } from "#node/NodeLifecycle.js";
 import { assertRemoteActor, Fabric, FabricManager, hasRemoteActor, IPK_DEFAULT_EPOCH_START_TIME } from "#protocol";
@@ -47,7 +47,7 @@ export class GroupKeyManagementServer extends GroupKeyManagementBehavior {
     declare state: GroupKeyManagementServer.State;
     static override readonly schema = schema;
 
-    override initialize(): MaybePromise {
+    override initialize() {
         if (this.features.cacheAndSync) {
             throw new ImplementationError("The CacheAndSync feature is provisional. Do not use it.");
         }

package/src/endpoint/properties/Behaviors.ts

@@ -6,7 +6,6 @@
 
 import { Behavior } from "#behavior/Behavior.js";
 import type { ClusterBehavior } from "#behavior/cluster/ClusterBehavior.js";
-import { limitEndpointAttributeDataToAllowedFabrics } from "#behavior/cluster/FabricScopedDataHandler.js";
 import { ActionContext } from "#behavior/context/ActionContext.js";
 import { NodeActivity } from "#behavior/context/NodeActivity.js";
 import { LocalActorContext } from "#behavior/context/server/LocalActorContext.js";
@@ -28,7 +27,7 @@ import {
 } from "#general";
 import { FeatureSet } from "#model";
 import { ProtocolService } from "#node/integration/ProtocolService.js";
-import { ClusterTypeProtocol, FabricManager, Val } from "#protocol";
+import { ClusterTypeProtocol, Val } from "#protocol";
 import { ClusterType, VoidSchema } from "#types";
 import type { Agent } from "../Agent.js";
 import type { Endpoint } from "../Endpoint.js";
@@ -243,16 +242,6 @@ export class Behaviors {
                 promise = endpointInitializer.behaviorsInitialized(agent);
             }
 
-            if (this.#endpoint.env.has(FabricManager)) {
-                const fabricIndices = this.#endpoint.env.get(FabricManager).fabrics.map(fabric => fabric.fabricIndex);
-                if (fabricIndices.length > 0) {
-                    // Make sure the state on startup only includes allowed Fabric scoped data
-                    return MaybePromise.then(promise, () =>
-                        limitEndpointAttributeDataToAllowedFabrics(this.#endpoint, fabricIndices),
-                    );
-                }
-            }
-
             return promise;
         };
 
@@ -281,7 +270,17 @@ export class Behaviors {
     /**
      * Does the {@link Endpoint} support a specified behavior?
      */
-    has<T extends Behavior.Type>(type: T) {
+    has<T extends Behavior.Type>(type: T): boolean;
+
+    /**
+     * Does the {@link Endpoint} support a specified behavior by its behavior Id?
+     */
+    has(typeId: string): boolean;
+
+    has(type: Behavior.Type | string): boolean {
+        if (typeof type === "string") {
+            return !!this.#supported[type];
+        }
         const myType = this.#supported[type.id];
         return myType === type || myType?.supports(type);
     }
@@ -609,7 +608,18 @@ export class Behaviors {
     /**
      * Obtain current data version of behavior.
      */
-    versionOf(type: Behavior.Type) {
+    versionOf(type: Behavior.Type): number;
+
+    /**
+     * Obtain current data version of behavior by its behavior Id, if existing
+     */
+    versionOf(typeId: string): number | undefined;
+
+    versionOf(type: Behavior.Type | string) {
+        if (typeof type === "string") {
+            const backing = this.#backings[type];
+            return backing?.maybeDatasource?.version;
+        }
         const backing = this.#backingFor(type);
         return backing.datasource.version;
     }
@@ -751,9 +761,9 @@ export class Behaviors {
         const { id, Events } = type;
 
         const get = () => this.#backingFor(type).stateView;
-        Object.defineProperty(this.#endpoint.state, id, { get, enumerable: true });
+        Object.defineProperty(this.#endpoint.state, id, { get, enumerable: true, configurable: true });
         if (type.schema.id !== undefined) {
-            Object.defineProperty(this.#endpoint.state, type.schema.id, { get });
+            Object.defineProperty(this.#endpoint.state, type.schema.id, { get, configurable: true });
         }
 
         Object.defineProperty(this.#endpoint.events, id, {
@@ -770,6 +780,7 @@ export class Behaviors {
             },
 
             enumerable: true,
+            configurable: true,
         });
     }
 }

package/src/endpoint/properties/EndpointInitializer.ts

@@ -7,6 +7,7 @@
 import type { Behavior } from "#behavior/Behavior.js";
 import type { BehaviorBacking } from "#behavior/internal/BehaviorBacking.js";
 import type { Agent } from "#endpoint/Agent.js";
+import { MaybePromise } from "#general";
 import type { Endpoint } from "../Endpoint.js";
 
 /**
@@ -40,5 +41,5 @@ export abstract class EndpointInitializer {
     /**
      * Invoked after behaviors are initialized but before the initialization transaction commits.
      */
-    behaviorsInitialized(_agent: Agent) {}
+    behaviorsInitialized(_agent: Agent): MaybePromise {}
 }

package/src/endpoint/properties/Endpoints.ts

@@ -61,14 +61,14 @@ export class Endpoints implements ImmutableSet<Endpoint> {
         return this.#list[Symbol.iterator]();
     }
 
-    for(number: number | string): Endpoint {
-        if (number === 0) {
+    for(id: number | string): Endpoint {
+        if (id === 0) {
             return this.#node;
         }
 
-        const endpoint = typeof number === "string" ? this.#idIndex[number] : this.#index[number];
+        const endpoint = typeof id === "string" ? this.#idIndex[id] : this.#index[id];
         if (endpoint === undefined) {
-            throw new StatusResponse.NotFoundError(`Endpoint ${number} does not exist`);
+            throw new StatusResponse.NotFoundError(`Endpoint ${id} does not exist`);
         }
         return endpoint;
     }

package/src/node/Node.ts

@@ -41,6 +41,7 @@ export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEn
     #environment: Environment;
     #runtime?: NetworkRuntime;
     #startInProgress = false;
+    #closeInProgress = false;
 
     constructor(config: Node.Configuration<T>) {
         const parentEnvironment = config.environment ?? config.owner?.env ?? Environment.default;
@@ -183,9 +184,17 @@ export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEn
     }
 
     override async close() {
-        this.lifecycle.targetState = "offline";
-        await this.lifecycle.mutex.close();
-        await this.closeWithMutex();
+        if (this.#closeInProgress) {
+            return;
+        }
+        this.#closeInProgress = true;
+        try {
+            this.lifecycle.targetState = "offline";
+            await this.lifecycle.mutex.close();
+            await this.closeWithMutex();
+        } finally {
+            this.#closeInProgress = false;
+        }
     }
 
     protected async closeWithMutex() {

package/src/node/NodePhysicalProperties.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { DescriptorClient } from "#behaviors/descriptor";
 import { NetworkCommissioningClient } from "#behaviors/network-commissioning";
 import { PowerSourceClient } from "#behaviors/power-source";
 import { ThreadNetworkDiagnosticsClient } from "#behaviors/thread-network-diagnostics";
@@ -20,7 +21,7 @@ import { ClusterId } from "#types";
  * Inspects a node to generate {@link PhysicalDeviceProperties}.
  */
 export function NodePhysicalProperties(node: Node) {
-    const rootEndpointServerList = [...node.state.descriptor.serverList];
+    const rootEndpointServerList = [...(node.maybeStateOf(DescriptorClient)?.serverList ?? [])];
 
     const properties: PhysicalDeviceProperties = {
         threadConnected: false,
@@ -58,8 +59,9 @@ function inspectEndpoint(endpoint: Endpoint, properties: PhysicalDevicePropertie
     const powerSource = endpoint.behaviors.typeFor(PowerSourceClient);
     if (powerSource) {
         const features = powerSource.schema.supportedFeatures;
+        const status = endpoint.stateOf(PowerSourceClient).status;
         if (features.has("WIRED")) {
-            if (endpoint.stateOf(PowerSourceClient).status === PowerSource.PowerSourceStatus.Active) {
+            if (status === PowerSource.PowerSourceStatus.Active) {
                 // Should we only consider A/C "mains" powered?  What is a DC adapter?  What is an external battery?
                 // For now assuming "wired" means "don't worry about power consumption"
                 properties.isMainsPowered = true;
@@ -71,9 +73,9 @@ function inspectEndpoint(endpoint: Endpoint, properties: PhysicalDevicePropertie
             endpoint.behaviors.elementsOf(powerSource).attributes.has("batChargeLevel")
         ) {
             if (
-                endpoint.stateOf(PowerSourceClient).status === PowerSource.PowerSourceStatus.Active ||
+                status === PowerSource.PowerSourceStatus.Active ||
                 // Some devices do not properly specify state as active
-                endpoint.stateOf(PowerSourceClient).status === PowerSource.PowerSourceStatus.Unspecified
+                status === PowerSource.PowerSourceStatus.Unspecified
             ) {
                 properties.isBatteryPowered = true;
             }

package/src/node/client/ClientEventEmitter.ts

@@ -5,6 +5,7 @@
  */
 
 import type { ElementEvent, Events } from "#behavior/Events.js";
+import { NetworkClient } from "#behavior/system/network/NetworkClient.js";
 import { camelize, Diagnostic, isObject, Logger } from "#general";
 import { ClusterModel, EventModel, MatterModel } from "#model";
 import type { ClientNode } from "#node/ClientNode.js";
@@ -18,10 +19,9 @@ const logger = Logger.get("ClientEventEmitter");
  * Event handler for Matter events transmitted by a peer.
  *
  * TODO - set priority on context when split for server vs. client
- * TODO - record latest event number for each subscription shape (or just wildcard?)
  */
 export interface ClientEventEmitter {
-    (event: ReadResult.EventValue): void;
+    (event: ReadResult.EventValue): Promise<void>;
 }
 
 /**
@@ -40,7 +40,7 @@ const warnedForUnknown = new Set<ClusterId | `${ClusterId}-${EventId}`>();
 export function ClientEventEmitter(node: ClientNode, structure: ClientStructure) {
     return emitClientEvent;
 
-    function emitClientEvent(occurrence: ReadResult.EventValue) {
+    async function emitClientEvent(occurrence: ReadResult.EventValue) {
         const names = getNames(node.matter, occurrence);
         if (!names) {
             return;
@@ -48,10 +48,18 @@ export function ClientEventEmitter(node: ClientNode, structure: ClientStructure)
 
         const event = getEvent(node, occurrence, names.cluster, names.event);
         if (event) {
-            node.act(agent => {
+            await node.act(async agent => {
                 // Current ActionContext is not writable, could skip act() but meh, see TODO above
                 //agent.context.priority = occurrence.priority;
                 event.emit(occurrence.value, agent.context);
+
+                const network = agent.get(NetworkClient);
+                if (occurrence.number > network.state.maxEventNumber) {
+                    await agent.context.transaction.addResources(network);
+                    await agent.context.transaction.begin();
+                    network.state.maxEventNumber = occurrence.number;
+                    await agent.context.transaction.commit();
+                }
             });
         }
     }

package/src/node/client/ClientGroupInteraction.ts

@@ -8,11 +8,11 @@ import type { ActionContext } from "#behavior/index.js";
 import { ImplementationError } from "#general";
 import {
     ClientInvoke,
+    ClientSubscription,
     DecodedInvokeResult,
     Read,
     ReadResult,
     Subscribe,
-    SubscribeResult,
     Write,
     WriteResult,
 } from "#protocol";
@@ -27,7 +27,7 @@ export class ClientGroupInteraction extends ClientNodeInteraction {
     }
 
     /** Groups do not support reading or subscribing to attributes */
-    override async subscribe(_request: Subscribe, _context?: ActionContext): SubscribeResult {
+    override async subscribe(_request: Subscribe, _context?: ActionContext): Promise<ClientSubscription> {
         throw new InvalidGroupOperationError("Groups do not support subscribing to attributes");
     }
 
@@ -65,6 +65,8 @@ export class ClientGroupInteraction extends ClientNodeInteraction {
             throw new InvalidGroupOperationError("Timed requests are not supported for group address invokes.");
         }
 
+        request.suppressResponse = true; // Invoking on a group does not yield a response by definition
+
         return super.invoke(request, context);
     }
 }

package/src/node/client/ClientNodeInteraction.ts

@@ -74,7 +74,7 @@ export class ClientNodeInteraction implements Interactable<ActionContext> {
                 request,
             }),
 
-            sustain: request.sustain === undefined ? true : request.sustain,
+            sustain: request.sustain !== false,
 
             updated: async data => {
                 const result = this.structure.mutate(request, data);

package/src/node/client/ClientStructure.ts

@@ -11,7 +11,7 @@ import { Descriptor } from "#clusters/descriptor";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
 import { RootEndpoint } from "#endpoints/root";
-import { Diagnostic, InternalError, isDeepEqual, Logger } from "#general";
+import { Diagnostic, InternalError, isDeepEqual, Logger, Observable } from "#general";
 import {
     AcceptedCommandList,
     AttributeList,
@@ -25,8 +25,8 @@ import {
 import type { ClientNode } from "#node/ClientNode.js";
 import type { Node } from "#node/Node.js";
 import { ReadScope, type Read, type ReadResult } from "#protocol";
+import { ClientNodeStore } from "#storage/client/ClientNodeStore.js";
 import { DatasourceCache } from "#storage/client/DatasourceCache.js";
-import { ClientNodeStore } from "#storage/index.js";
 import type { AttributeId, ClusterId, ClusterType, CommandId, EndpointNumber } from "#types";
 import { Status } from "#types";
 import { ClientEventEmitter } from "./ClientEventEmitter.js";
@@ -52,6 +52,7 @@ export class ClientStructure {
     #pendingStructureEvents = Array<PendingEvent>();
     #delayedClusterEvents = new Array<ReadResult.EventValue>();
     #events: ClientStructureEvents;
+    #changed = Observable<[void]>();
 
     constructor(node: ClientNode) {
         this.#node = node;
@@ -64,6 +65,10 @@ export class ClientStructure {
         this.#events = this.#node.env.get(ClientStructureEvents);
     }
 
+    get changed() {
+        return this.#changed;
+    }
+
     /**
      * Load initial structure from cache.
      */
@@ -175,14 +180,16 @@ export class ClientStructure {
         // Apply changes
         const scope = ReadScope(request);
         for await (const chunk of changes) {
+            const chunkData = new Array<ReadResult.Report>();
             for (const change of chunk) {
+                chunkData.push(change);
                 switch (change.kind) {
                     case "attr-value":
                         currentUpdates = await this.#mutateAttribute(change, scope, currentUpdates);
                         break;
 
                     case "event-value":
-                        this.#emitEvent(change, currentUpdates);
+                        await this.#emitEvent(change, currentUpdates);
                         break;
 
                     case "attr-status":
@@ -197,7 +204,7 @@ export class ClientStructure {
                 }
             }
 
-            yield chunk;
+            yield chunkData;
         }
 
         // The last cluster still needs its changes applied
@@ -226,6 +233,7 @@ export class ClientStructure {
 
         // Likewise, we don't emit events until we've applied all structural changes
         this.#emitPendingStructureEvents();
+        await this.#emitPendingEvents();
     }
 
     /** Reference to the default subscription used when the node was started. */
@@ -280,7 +288,7 @@ export class ClientStructure {
         return currentUpdates;
     }
 
-    #emitEvent(occurrence: ReadResult.EventValue, currentUpdates?: AttributeUpdates) {
+    async #emitEvent(occurrence: ReadResult.EventValue, currentUpdates?: AttributeUpdates) {
         const { endpointId, clusterId } = occurrence.path;
 
         const endpoint = this.#endpoints.get(endpointId);
@@ -291,7 +299,7 @@ export class ClientStructure {
         ) {
             this.#delayedClusterEvents.push(occurrence);
         } else {
-            this.#eventEmitter(occurrence);
+            await this.#eventEmitter(occurrence);
         }
     }
 
@@ -628,7 +636,7 @@ export class ClientStructure {
     /**
      * Replace clusters after activation because fixed global attributes have changed.
      *
-     * Currently we apply granular updates to clusters.  This will possibly result in subtle errors if peers change in
+     * Currently, we apply granular updates to clusters.  This will possibly result in subtle errors if peers change in
      * incompatible ways, but the backings are designed to be fairly resilient to this.  This is simpler for API users
      * to deal with in the common case where they can just ignore. If it becomes problematic we can revert to replacing
      * entire endpoints or behaviors when there are structural changes.
@@ -742,8 +750,6 @@ export class ClientStructure {
      */
     #emitPendingStructureEvents() {
         const structureEvents = this.#pendingStructureEvents;
-        const clusterEvents = this.#delayedClusterEvents;
-        this.#delayedClusterEvents = [];
         this.#pendingStructureEvents = [];
         for (const event of structureEvents) {
             switch (event.kind) {
@@ -789,8 +795,14 @@ export class ClientStructure {
                 }
             }
         }
+        this.#changed.emit();
+    }
+
+    async #emitPendingEvents() {
+        const clusterEvents = this.#delayedClusterEvents;
+        this.#delayedClusterEvents = [];
         for (const occurrence of clusterEvents) {
-            this.#eventEmitter(occurrence);
+            await this.#eventEmitter(occurrence);
         }
     }
 }

package/src/node/client/NodePeerAddressStore.ts

@@ -5,12 +5,12 @@
  */
 
 import { RemoteDescriptor } from "#behavior/system/commissioning/RemoteDescriptor.js";
+import { Crypto, ServerAddress, ServerAddressUdp } from "#general";
 import type { ClientNode } from "#node/ClientNode.js";
 import { IdentityService } from "#node/server/IdentityService.js";
 import type { ServerNode } from "#node/ServerNode.js";
 import { PeerAddress, PeerAddressMap, PeerAddressStore, PeerDescriptor } from "#protocol";
 import { FabricIndex, NodeId } from "#types";
-import { Crypto, ServerAddress, ServerAddressUdp } from "@matter/general";
 
 /**
  * This is an adapter for lower-level components in the protocol package.
@@ -74,17 +74,20 @@ export class NodePeerAddressStore extends PeerAddressStore {
 
     async updatePeer(peer: PeerDescriptor) {
         const node = this.#owner.peers.get(peer.address);
-        if (!node) {
+        if (!node || !node.lifecycle.isInstalled) {
             return;
         }
 
-        await node.act(agent => {
+        await node.act(async agent => {
+            await agent.context.transaction.addResources(agent.commissioning);
+            await agent.context.transaction.begin();
             const state = agent.commissioning.state;
             RemoteDescriptor.toLongForm(peer.discoveryData, state);
             if (peer.operationalAddress) {
                 // TODO - modify lower tiers to pass along full set of operational addresses
                 state.addresses = [peer.operationalAddress];
             }
+            await agent.context.transaction.commit();
         });
     }
 

package/src/node/client/PeerBehavior.ts

@@ -25,6 +25,7 @@ import {
     ClusterComposer,
     ClusterId,
     ClusterRegistry,
+    ClusterType,
     Command,
     CommandId,
     MutableCluster,
@@ -103,12 +104,10 @@ function instrumentDiscoveredShape(shape: PeerBehavior.DiscoveredClusterShape) {
         return type;
     }
 
-    let baseType: Behavior.Type;
+    let baseType: Behavior.Type | undefined;
     const standardCluster = ClusterRegistry.get(shape.id);
-    if (standardCluster) {
+    if (standardCluster && !standardCluster.name.startsWith("Unknown cluster 0x")) {
         baseType = ClusterBehavior.for(standardCluster);
-    } else {
-        baseType = ClusterBehavior;
     }
 
     type = discoveredCache[fingerprint] = generateDiscoveredType(analysis, baseType);
@@ -138,22 +137,31 @@ function instrumentKnownShape(shape: PeerBehavior.KnownClusterShape) {
     return type;
 }
 
-function generateDiscoveredType(analysis: DiscoveredShapeAnalysis, baseType: Behavior.Type): ClusterBehavior.Type {
-    // Ensure the input type is a ClusterBehavior
-    if (!ClusterBehavior.is(baseType)) {
-        throw new InternalError(`Base for cluster ${analysis.schema.name} is not a ClusterBehavior`);
-    }
-
+function generateDiscoveredType(analysis: DiscoveredShapeAnalysis, baseType?: Behavior.Type): ClusterBehavior.Type {
     let { schema } = analysis;
-    let isExtended = false;
-    const { attrSupportOverrides, extraAttrs, commandSupportOverrides, extraCommands } = analysis;
 
-    // Obtain a ClusterType.  This provides TLV for known elements
-    let { cluster } = baseType;
-    if (!cluster) {
+    let isExtended: boolean;
+    let cluster: ClusterType;
+
+    if (baseType) {
+        isExtended = false;
+
+        // Ensure the input type is a ClusterBehavior
+        if (!ClusterBehavior.is(baseType)) {
+            throw new InternalError(`Base for cluster ${analysis.schema.name} is not a ClusterBehavior`);
+        }
+
+        cluster = baseType.cluster;
+    } else {
+        isExtended = true;
+
         cluster = MutableCluster({ id: schema.id, name: schema.name, revision: schema.revision });
+
+        baseType = ClusterBehavior;
     }
 
+    const { attrSupportOverrides, extraAttrs, commandSupportOverrides, extraCommands } = analysis;
+
     // Identify known features the device supports
     let supportedFeatures = analysis.shape.features;
     if (typeof supportedFeatures === "number") {

package/src/node/client/index.ts

@@ -5,5 +5,6 @@
  */
 
 export * from "./ClientEndpointInitializer.js";
+export * from "./ClientNodeInteraction.js";
 export * from "./NodePeerAddressStore.js";
 export * from "./Peers.js";

package/src/node/index.ts

@@ -5,6 +5,7 @@
  */
 
 export * from "./client/index.js";
+export * from "./ClientNode.js";
 export * from "./integration/index.js";
 export * from "./Node.js";
 export * from "./NodeLifecycle.js";

package/src/node/server/InteractionServer.ts

@@ -448,11 +448,16 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
 
         if (fabric !== undefined && !keepSubscriptions) {
             let clearedCount = 0;
-            for (const session of this.#context.sessions.sessions) {
-                for (const subscription of session.subscriptions) {
+            for (const sess of this.#context.sessions.sessions) {
+                // TODO Adjust this filtering when subscriptions move to Peer
+                if (!PeerAddress.is(sess.peerAddress, session.peerAddress)) {
+                    // Ignore subscriptions from other peers
+                    continue;
+                }
+                for (const subscription of sess.subscriptions) {
                     await subscription.handlePeerCancel();
+                    clearedCount++;
                 }
-                clearedCount++;
             }
             if (clearedCount > 0) {
                 logger.debug(

package/src/node/server/ServerEndpointInitializer.ts

@@ -5,11 +5,14 @@
  */
 
 import { Behavior } from "#behavior/Behavior.js";
+import { limitEndpointAttributeDataToAllowedFabrics } from "#behavior/cluster/FabricScopedDataHandler.js";
 import { BehaviorBacking } from "#behavior/internal/BehaviorBacking.js";
 import { ServerBehaviorBacking } from "#behavior/internal/ServerBehaviorBacking.js";
 import { Endpoint } from "#endpoint/Endpoint.js";
+import type { Agent } from "#endpoint/index.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
-import { Environment, InternalError, Logger } from "#general";
+import { Environment, InternalError, Logger, MaybePromise } from "#general";
+import { FabricManager } from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { DescriptorServer } from "../../behaviors/descriptor/DescriptorServer.js";
 
@@ -105,4 +108,14 @@ export class ServerEndpointInitializer extends EndpointInitializer {
 
         return id;
     }
+
+    override behaviorsInitialized(agent: Agent): MaybePromise {
+        // Make sure the state only includes allowed Fabric scoped data when an endpoint is added after node is online
+        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);
+            }
+        }
+    }
 }

package/src/node/server/ServerSubscription.ts

@@ -443,7 +443,7 @@ export class ServerSubscription implements Subscription {
                 break;
             }
 
-            this.#lastUpdateTime = Time.nowMs;
+            this.#lastUpdateTime = Time.nowMs; // TODO Count time from here or from "receive of the ack"?
 
             try {
                 using sending = updating?.join("sending");