@matter/node 0.16.0-alpha.0-20251108-514b3f69e → 0.16.0-alpha.0-20251110-c4c70a41b

package/src/behavior/context/server/LocalActorContext.ts

@@ -15,7 +15,12 @@ export let nextInternalId = 1;
 
 let ReadOnly: LocalActorContext | undefined;
 
-export interface LocalActorContext extends ValueSupervisor.LocalActorSession {}
+export interface LocalActorContext extends ValueSupervisor.LocalActorSession {
+    /**
+     * @deprecated use `context.fabric === undefined` or `hasLocalActor(context)` to detect a local actor
+     */
+    offline: true;
+}
 
 /**
  * The context for operations triggered locally, either for in-process node implementations or remote nodes that are
@@ -80,9 +85,6 @@ export const LocalActorContext = {
             const context = Object.freeze({
                 ...options,
 
-                // Disable access level enforcement
-                offline: true,
-
                 transaction,
                 activity: frame,
 
@@ -101,6 +103,8 @@ export const LocalActorContext = {
 
                 resolve: transaction.resolve.bind(transaction),
                 reject: transaction.reject.bind(transaction),
+
+                offline: true,
             });
 
             return context;

package/src/behavior/context/server/RemoteActorContext.ts

@@ -45,6 +45,11 @@ export interface RemoteActorContext extends ValueSupervisor.RemoteActorSession {
      * The priority of actions in this context.
      */
     priority?: Priority;
+
+    /**
+     * @deprecated use `context.fabric !== undefined` or `hasRemoteActor(context)` to detect a remote actor
+     */
+    offline?: false;
 }
 
 /**
@@ -185,6 +190,7 @@ export function RemoteActorContext(options: RemoteActorContext.Options) {
             exchange,
             subject,
             largeMessage: exchange?.channel.supportsLargeMessages,
+            offline: false,
 
             fabric: fabric?.fabricIndex ?? FabricIndex.NO_FABRIC,
             transaction,

package/src/behavior/internal/BehaviorBacking.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ClientBehavior } from "#behavior/cluster/ClientBehavior.js";
+import { isClientBehavior } from "#behavior/cluster/cluster-behavior-utils.js";
 import { OnlineEvent } from "#behavior/Events.js";
 import { Migration } from "#behavior/state/migrations/Migration.js";
 import type { Agent } from "#endpoint/Agent.js";
@@ -185,7 +185,7 @@ export abstract class BehaviorBacking {
      */
     createBehavior(agent: Agent, type: Behavior.Type) {
         const behavior = new this.#type(agent, this);
-        if (behavior instanceof type || ClientBehavior.is(type)) {
+        if (behavior instanceof type || isClientBehavior(type)) {
             return behavior;
         }
 

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

@@ -18,6 +18,7 @@ import {
     Logger,
     MatterFlowError,
     Mutex,
+    MutexClosedError,
     Observable,
 } from "#general";
 import { DatatypeModel, FieldElement } from "#model";
@@ -159,14 +160,14 @@ export class CommissioningServer extends Behavior {
             const sessions = this.agent.get(SessionsBehavior);
             if (Object.keys(sessions.state.sessions).length > 0) {
                 // We have still open sessions, wait for them to close
-                this.reactTo(sessions.events.closed, this.#handleSessionClosed);
+                this.reactTo(sessions.events.closed, this.#resetAfterSessionsClear);
             } else {
                 this.#triggerFactoryReset();
             }
         }
     }
 
-    #handleSessionClosed() {
+    #resetAfterSessionsClear() {
         const sessions = this.agent.get(SessionsBehavior);
         if (Object.keys(sessions.state.sessions).length === 0) {
             this.#triggerFactoryReset();
@@ -174,7 +175,7 @@ export class CommissioningServer extends Behavior {
     }
 
     #triggerFactoryReset() {
-        this.env.runtime.add((this.endpoint as ServerNode).erase());
+        this.env.runtime.add((this.endpoint as ServerNode).erase().catch(e => MutexClosedError.accept(e)));
     }
 
     #monitorFailsafe(failsafe: FailsafeContext) {

package/src/behaviors/operational-credentials/OperationalCredentialsServer.ts

@@ -405,7 +405,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             };
         }
 
-        await fabric.remove(this.context.session.id);
+        await fabric.leave(this.context.session.id);
         // The state is updated on removal via commissionedFabricChanged event, see constructor
 
         return {

package/src/behaviors/operational-credentials/VendorIdVerification.ts

@@ -3,8 +3,8 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { OperationalCredentialsClient } from "#behaviors/operational-credentials";
-import { OperationalCredentials } from "#clusters/operational-credentials";
+
+import type { OperationalCredentials } from "#clusters/operational-credentials";
 import {
     Bytes,
     Crypto,
@@ -22,6 +22,7 @@ import { ClientNodeInteraction } from "#node/client/ClientNodeInteraction.js";
 import type { ClientNode } from "#node/ClientNode.js";
 import { Icac, Noc, NodeSession, Rcac, Vvsc } from "#protocol";
 import { FabricId, FabricIndex, ReceivedStatusResponseError, StatusResponse, VendorId } from "#types";
+import { OperationalCredentialsClient } from "../operational-credentials/OperationalCredentialsClient.js";
 
 const logger = Logger.get("VendorIdVerification");
 

package/src/endpoint/Endpoint.ts

@@ -191,13 +191,33 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
     stateOf<T extends Behavior.Type>(type: T): Immutable<Behavior.StateOf<T>>;
 
     stateOf(type: Behavior.Type | string) {
+        const state = this.maybeStateOf(type as any);
+        if (state) {
+            return state;
+        }
+
+        const id = typeof type === "string" ? type : type.id;
+        throw new ImplementationError(`Behavior ${id} is not supported by ${this}`);
+    }
+
+    /**
+     * Version of {@link stateOf} that returns undefined instead of throwing if the requested behavior unsupported.
+     */
+    maybeStateOf(type: string): Immutable<Val.Struct>;
+
+    /**
+     * Version of {@link stateOf} that returns undefined instead of throwing if the requested behavior unsupported.
+     */
+    maybeStateOf<T extends Behavior.Type>(type: T): Immutable<Behavior.StateOf<T>>;
+
+    maybeStateOf(type: Behavior.Type | string) {
         if (typeof type === "string") {
             if (!(type in this.#stateView)) {
-                throw new ImplementationError(`Behavior ${type} is not supported by ${this}`);
+                return undefined;
             }
         } else {
             if (!this.behaviors.has(type)) {
-                throw new ImplementationError(`Behavior ${type.id} is not supported by ${this}`);
+                return undefined;
             }
             type = type.id;
         }
@@ -371,7 +391,7 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
             }
         } else {
             if (!this.behaviors.has(type)) {
-                throw new ImplementationError(`Behavior ${type.id} is not supported by this endpoint`);
+                throw new ImplementationError(`Behavior ${type.id} is not supported by ${this}`);
             }
             type = type.id;
         }

package/src/endpoint/properties/Behaviors.ts

@@ -393,7 +393,11 @@ export class Behaviors {
     /**
      * Determine if a specified behavior is supported and active.
      */
-    isActive(type: Behavior.Type) {
+    isActive(type: Behavior.Type | string) {
+        if (typeof type === "string") {
+            return this.#backings[type] !== undefined;
+        }
+
         const backing = this.#backings[type.id];
         return !!backing && backing.type.supports(type);
     }
@@ -463,11 +467,6 @@ export class Behaviors {
             this.#supported = { ...this.#supported };
         }
 
-        // TODO how to better solve that?
-        if (this.#endpoint.env.has(EndpointInitializer)) {
-            type = this.#endpoint.env.get(EndpointInitializer).finalizeType(type);
-        }
-
         this.#supported[type.id] = type;
 
         this.#augmentEndpoint(type);
@@ -672,6 +671,13 @@ export class Behaviors {
 
         const backing = this.#endpoint.env.get(EndpointInitializer).createBacking(this.#endpoint, myType);
         this.#backings[backing.type.id] = backing;
+
+        // The EndpointInitializer may choose to replace the behavior implementation.  If so the replacement should be
+        // compatible, but update our support map to designate the specific implementation
+        if (backing.type !== myType) {
+            this.#supported[backing.type.id] = backing.type;
+        }
+
         if (!this.#protocol) {
             this.#protocol = this.#endpoint.env.get(ProtocolService);
         }

package/src/endpoint/properties/EndpointInitializer.ts

@@ -41,11 +41,4 @@ export abstract class EndpointInitializer {
      * Invoked after behaviors are initialized but before the initialization transaction commits.
      */
     behaviorsInitialized(_agent: Agent) {}
-
-    /**
-     * Allows Initializer to manipulate the type before it is used to create a backing or behavior.
-     */
-    finalizeType(type: Behavior.Type): Behavior.Type {
-        return type;
-    }
 }

package/src/node/Node.ts

@@ -177,7 +177,8 @@ export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEn
 
     override async close() {
         this.lifecycle.targetState = "offline";
-        await this.lifecycle.mutex.produce(this.closeWithMutex.bind(this));
+        await this.lifecycle.mutex.close();
+        await this.closeWithMutex();
     }
 
     protected async closeWithMutex() {

package/src/node/client/ClientCommandMethod.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ClusterBehavior } from "#behavior/cluster/ClusterBehavior.js";
+import type { ClientNode } from "#node/ClientNode.js";
+import { Node } from "#node/Node.js";
+import { ClientInteraction, Invoke } from "#protocol";
+import { Status, StatusResponseError } from "#types";
+
+/**
+ * Create the command method for a client behavior.
+ */
+export function ClientCommandMethod(name: string) {
+    // This is our usual hack to give a function a proper name in stack traces
+    const temp = {
+        // The actual implementation
+        [name](this: ClusterBehavior, fields?: {}) {
+            return invokeOnPeer(this, name, fields);
+        },
+    };
+
+    return temp[name];
+}
+
+/**
+ * Invokes a command remotely on behalf of client behaviors.
+ */
+async function invokeOnPeer(behavior: ClusterBehavior, command: string, fields?: {}) {
+    const node = behavior.env.get(Node) as ClientNode;
+
+    // TODO when implementing TCP add needed logic for Large messages
+    const chunks = (node.interaction as ClientInteraction).invoke(
+        Invoke({
+            commands: [
+                Invoke.ConcreteCommandRequest<any>({
+                    endpoint: behavior.endpoint,
+                    cluster: behavior.cluster,
+                    command,
+                    fields,
+                }),
+            ],
+        }),
+    );
+
+    for await (const chunk of chunks) {
+        for (const entry of chunk) {
+            // We send only one command, so we only get one response back
+            switch (entry.kind) {
+                case "cmd-status":
+                    if (entry.status !== Status.Success) {
+                        throw StatusResponseError.create(entry.status, undefined, entry.clusterStatus);
+                    }
+                    return;
+
+                case "cmd-response":
+                    return entry.data;
+            }
+        }
+    }
+}

package/src/node/client/ClientEndpointInitializer.ts

@@ -11,12 +11,10 @@ import { ClientBehaviorBacking } from "#behavior/internal/ClientBehaviorBacking.
 import { ServerBehaviorBacking } from "#behavior/internal/ServerBehaviorBacking.js";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
-import { FeatureBitmap } from "#model";
 import { PeerBehavior } from "#node/client/PeerBehavior.js";
 import type { ClientNode } from "#node/ClientNode.js";
 import { ClientNodeStore } from "#storage/client/ClientNodeStore.js";
 import { NodeStore } from "#storage/NodeStore.js";
-import { AttributeId, CommandId } from "#types";
 import { ClientStructure } from "./ClientStructure.js";
 
 export class ClientEndpointInitializer extends EndpointInitializer {
@@ -55,44 +53,13 @@ export class ClientEndpointInitializer extends EndpointInitializer {
             return new ServerBehaviorBacking(endpoint, type, store, endpoint.behaviors.optionsFor(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));
-    }
-
-    /** Convert the Cluster type to a ClientBehavior */
-    override finalizeType(type: Behavior.Type): Behavior.Type {
-        const cluster = (type as ClusterBehavior.Type).cluster;
-        if (cluster === undefined) {
-            return type;
-        }
-
-        const features: FeatureBitmap = {};
-        for (const f in cluster.features) {
-            features[f] = true;
-        }
-        const attributeNames = new Array<string>();
-        const attributes = new Array<AttributeId>();
-        for (const [name, attr] of Object.entries(cluster.attributes)) {
-            attributeNames.push(name);
-            attributes.push(attr.id);
-        }
-        const commandNames = new Array<string>();
-        const commands = new Array<CommandId>();
-        for (const [name, cmd] of Object.entries(cluster.commands)) {
-            commandNames.push(name);
-            commands.push(cmd.requestId);
-        }
+        // Cluster behaviors must be instrumented for access to a remote cluster.  If already instrumented this is a
+        // no-op, otherwise it creates a new type extension
+        const peerType = PeerBehavior({ kind: "known", behavior: type as ClusterBehavior.Type });
 
-        return PeerBehavior({
-            id: cluster.id,
-            revision: cluster.revision,
-            features,
-            attributes,
-            commands,
-            attributeNames,
-            commandNames,
-        });
+        // Activate remote behavior
+        const store = this.structure.storeForRemote(endpoint, peerType);
+        return new ClientBehaviorBacking(endpoint, type, store, endpoint.behaviors.optionsFor(peerType));
     }
 
     get structure() {

package/src/node/client/ClientStructure.ts

@@ -11,6 +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 { InternalError, Logger } from "#general";
 import {
     AcceptedCommandList,
     AttributeList,
@@ -22,13 +23,17 @@ import {
     type FeatureBitmap,
 } from "#model";
 import type { ClientNode } from "#node/ClientNode.js";
+import type { Node } from "#node/Node.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, ClusterType, CommandId, EndpointNumber } from "#types";
 import { ClientEventEmitter } from "./ClientEventEmitter.js";
+import { ClientStructureEvents } from "./ClientStructureEvents.js";
 import { PeerBehavior } from "./PeerBehavior.js";
 
+const logger = Logger.get("ClientStructure");
+
 const DEVICE_TYPE_LIST_ATTR_ID = Descriptor.Cluster.attributes.deviceTypeList.id;
 const SERVER_LIST_ATTR_ID = Descriptor.Cluster.attributes.serverList.id;
 const PARTS_LIST_ATTR_ID = Descriptor.Cluster.attributes.partsList.id;
@@ -42,6 +47,8 @@ export class ClientStructure {
     #emitEvent: ClientEventEmitter;
     #node: ClientNode;
     #subscribedFabricFiltered?: boolean;
+    #pending = new Map<EndpointStructure, "erase" | "reparent">();
+    #events: ClientStructureEvents;
 
     constructor(node: ClientNode) {
         this.#node = node;
@@ -51,6 +58,7 @@ export class ClientStructure {
             clusters: {},
         };
         this.#emitEvent = ClientEventEmitter(node, this);
+        this.#events = this.#node.env.get(ClientStructureEvents);
     }
 
     /**
@@ -76,7 +84,20 @@ export class ClientStructure {
                 }
 
                 const cluster = this.#clusterFor(endpoint, id);
-                this.#initializeCluster(endpoint, cluster);
+                this.#synchronizeCluster(endpoint, cluster);
+            }
+        }
+
+        for (const [endpoint, opcode] of this.#pending.entries()) {
+            this.#pending.delete(endpoint);
+
+            switch (opcode) {
+                case "reparent":
+                    this.#install(endpoint);
+                    break;
+
+                default:
+                    throw new InternalError(`Unexpected ${opcode} operation in initial hierarchy load`);
             }
         }
     }
@@ -142,10 +163,14 @@ export class ClientStructure {
      * Update the node structure by applying attribute changes.
      */
     async *mutate(request: Read, changes: ReadResult) {
-        const scope = ReadScope(request);
+        // Ensure mutations run serially and integrate properly with node lifecycle
+        using _lock = await this.#node.lifecycle.mutex.lock();
 
+        // We collect updates and only apply when we transition clusters
         let currentUpdates: AttributeUpdates | undefined;
 
+        // Apply changes
+        const scope = ReadScope(request);
         for await (const chunk of changes) {
             for (const change of chunk) {
                 switch (change.kind) {
@@ -164,9 +189,32 @@ export class ClientStructure {
             yield chunk;
         }
 
+        // The last cluster still needs its changes applied
         if (currentUpdates) {
             await this.#updateCluster(currentUpdates);
         }
+
+        // We don't apply structural changes until we've processed all attribute data if a.) listeners might otherwise
+        // see partially initialized endpoints, or b.) the change requires an async operation
+        for (const [endpoint, opcode] of this.#pending.entries()) {
+            this.#pending.delete(endpoint);
+
+            switch (opcode) {
+                case "reparent":
+                    this.#install(endpoint);
+                    break;
+
+                case "erase":
+                    logger.debug(`Removing endpoint ${endpoint.endpoint} because it is no longer present on the peer`);
+                    delete this.#endpoints[endpoint.endpoint.number];
+                    try {
+                        await endpoint.endpoint.delete();
+                    } catch (e) {
+                        logger.error(`Error erasing peer endpoint ${endpoint.endpoint}:`, e);
+                    }
+                    break;
+            }
+        }
     }
 
     /** Reference to the default subscription used when the node was started. */
@@ -246,10 +294,11 @@ export class ClientStructure {
      * This is invoked in a batch when we've collected all sequential values for the current endpoint/cluster.
      */
     async #updateCluster(attrs: AttributeUpdates) {
+        // TODO: Detect changes in revision/features/attributes/commands and update behavior if needed
         const endpoint = this.#endpointFor(attrs.endpointId);
         const cluster = this.#clusterFor(endpoint, attrs.clusterId);
         await cluster.store.externalSet(attrs.values);
-        this.#initializeCluster(endpoint, cluster);
+        this.#synchronizeCluster(endpoint, cluster);
     }
 
     /**
@@ -260,18 +309,15 @@ export class ClientStructure {
      *
      * Invoked once we've loaded all attributes in an interaction.
      */
-    #initializeCluster(endpoint: EndpointStructure, cluster: ClusterStructure) {
-        const attrs = cluster.store.initialValues ?? {};
-
+    #synchronizeCluster(endpoint: EndpointStructure, cluster: ClusterStructure) {
         // Generate a behavior if enough information is available
-        // TODO: Detect changes in revision/features/attributes/commands and update behavior if needed
-        if (cluster.behavior === undefined) {
+        if (cluster.behavior === undefined && cluster.store.initialValues) {
             const {
                 [ClusterRevision.id]: clusterRevision,
                 [FeatureMap.id]: features,
                 [AttributeList.id]: attributeList,
                 [AcceptedCommandList.id]: commandList,
-            } = attrs;
+            } = cluster.store.initialValues;
 
             if (typeof clusterRevision === "number") {
                 cluster.revision = clusterRevision;
@@ -297,11 +343,20 @@ export class ClientStructure {
             ) {
                 cluster.behavior = PeerBehavior(cluster as PeerBehavior.ClusterShape);
                 endpoint.endpoint.behaviors.require(cluster.behavior);
+                if (endpoint.endpoint.lifecycle.isInstalled) {
+                    this.#events.emitCluster(endpoint.endpoint, cluster.behavior);
+                }
             }
         }
 
         // Special handling for descriptor cluster
         if (cluster.id === Descriptor.Cluster.id) {
+            let attrs;
+            if (cluster.behavior && endpoint.endpoint.behaviors.isActive(cluster.behavior.id)) {
+                attrs = endpoint.endpoint.stateOf(cluster.behavior);
+            } else {
+                attrs = cluster.store.initialValues ?? {};
+            }
             this.#synchronizeDescriptor(endpoint, attrs);
         }
     }
@@ -356,31 +411,52 @@ export class ClientStructure {
             }
         }
 
+        // The remaining logic deals with the parts list
         const partsList = attrs[PARTS_LIST_ATTR_ID];
-        if (Array.isArray(partsList)) {
-            for (const partNo of partsList) {
-                if (typeof partNo !== "number") {
-                    continue;
-                }
+        if (!Array.isArray(partsList)) {
+            return;
+        }
 
-                const part = this.#endpointFor(partNo as EndpointNumber);
+        // Ensure an endpoint is present and installed for each part in the partsList
+        for (const partNo of partsList) {
+            if (typeof partNo !== "number") {
+                continue;
+            }
 
-                // TODO - remove endpoints/parts that are no longer present
-                //  Including events vis parts/endpoints on node (per endpoint and generic "changed")?
-                //  Including data cleanup
-                let isAlreadyDescendant = false;
-                for (let owner = part.endpoint.owner; owner; owner = owner.owner) {
-                    if (owner === endpoint.endpoint) {
-                        isAlreadyDescendant = true;
-                        break;
-                    }
+            const part = this.#endpointFor(partNo as EndpointNumber);
+
+            let isAlreadyDescendant = false;
+            for (let owner = this.#ownerOf(part); owner; owner = this.#ownerOf(owner)) {
+                if (owner === endpoint) {
+                    isAlreadyDescendant = true;
+                    break;
                 }
+            }
 
-                if (isAlreadyDescendant) {
+            if (isAlreadyDescendant) {
+                continue;
+            }
+
+            part.pendingOwner = endpoint;
+            this.#pending.set(part, "reparent");
+        }
+
+        // For the root partsList specifically, if an endpoint is no longer present then it has been removd from the
+        // node.  Schedule for erase
+        if (endpoint.endpoint.maybeNumber === 0) {
+            const numbersUsed = new Set(partsList);
+            for (const descendent of (endpoint.endpoint as Node).endpoints) {
+                // Skip root endpoint and uninitialized numbers (though latter shouldn't be possible)
+                if (!descendent.maybeNumber) {
                     continue;
                 }
 
-                part.endpoint.owner = endpoint.endpoint;
+                if (!numbersUsed.has(descendent.number)) {
+                    const endpoint = this.#endpoints[descendent.number];
+                    if (endpoint) {
+                        this.#pending.set(endpoint, "erase");
+                    }
+                }
             }
         }
     }
@@ -415,6 +491,7 @@ export class ClientStructure {
         }
 
         cluster = {
+            kind: "discovered",
             id,
             store: this.#nodeStore.storeForEndpoint(endpoint.endpoint).createStoreForBehavior(id.toString()),
         };
@@ -422,6 +499,33 @@ export class ClientStructure {
 
         return cluster;
     }
+
+    #ownerOf(endpoint: EndpointStructure) {
+        if (endpoint.pendingOwner) {
+            return endpoint.pendingOwner;
+        }
+
+        // Do not return the ServerNode if this is the ClientNode
+        if (endpoint.endpoint.number === 0) {
+            return;
+        }
+
+        const ownerNumber = endpoint.endpoint.owner?.maybeNumber;
+        if (ownerNumber !== undefined) {
+            return this.#endpointFor(ownerNumber);
+        }
+    }
+
+    #install(endpoint: EndpointStructure) {
+        const { pendingOwner } = endpoint;
+        if (!pendingOwner) {
+            return;
+        }
+
+        endpoint.endpoint.owner = pendingOwner.endpoint;
+        endpoint.pendingOwner = undefined;
+        this.#events.emitEndpoint(endpoint.endpoint);
+    }
 }
 
 interface AttributeUpdates {
@@ -433,11 +537,13 @@ interface AttributeUpdates {
 }
 
 interface EndpointStructure {
+    pendingOwner?: EndpointStructure;
     endpoint: Endpoint;
     clusters: Record<ClusterId, ClusterStructure>;
 }
 
-interface ClusterStructure extends Partial<PeerBehavior.ClusterShape> {
+interface ClusterStructure extends Partial<PeerBehavior.DiscoveredClusterShape> {
+    kind: "discovered";
     id: ClusterId;
     behavior?: ClusterBehavior.Type;
     store: Datasource.ExternallyMutableStore;