@matter/node 0.17.0-alpha.0-20260507-059f7763b → 0.17.0-alpha.0-20260508-96d5c3a88

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

@@ -10,9 +10,16 @@ import { ClientNodePhysicalProperties } from "#node/client/ClientNodePhysicalPro
 import type { ClientNode } from "#node/ClientNode.js";
 import { Node } from "#node/Node.js";
 import { ClientCacheBuffer } from "#storage/client/ClientCacheBuffer.js";
-import { ChannelType, Observable, ServerAddress, ServerAddressIp } from "@matter/general";
+import { ChannelType, Observable, ServerAddress } from "@matter/general";
 import { DatatypeModel, FieldElement } from "@matter/model";
-import { ClientSubscription, PeerSet, Subscribe, SustainedSubscription } from "@matter/protocol";
+import {
+    ClientSubscription,
+    OperationalAddress,
+    PeerSet,
+    Subscribe,
+    SustainedSubscription,
+    Val,
+} from "@matter/protocol";
 import { EventNumber } from "@matter/types";
 import { ClientNetworkRuntime } from "./ClientNetworkRuntime.js";
 import { NetworkBehavior } from "./NetworkBehavior.js";
@@ -41,13 +48,15 @@ export class NetworkClient extends NetworkBehavior {
             if (!peerSet.has(peerAddress)) {
                 const ipAddresses = this.#node.state.commissioning.addresses?.filter(a => ServerAddress.isIp(a)) ?? [];
                 if (ipAddresses.length) {
-                    const operationalAddress = ServerAddress(ipAddresses[0]) as ServerAddressIp;
-                    // Make sure the PeerSet knows about this peer now too
-                    peerSet.addKnownPeer({
-                        address: peerAddress,
-                        operationalAddress,
-                        discoveryData: RemoteDescriptor.fromLongForm(this.#node.state.commissioning),
-                    });
+                    const operationalAddress = OperationalAddress.from(ServerAddress(ipAddresses[0]));
+                    if (operationalAddress !== undefined) {
+                        // Make sure the PeerSet knows about this peer now too
+                        peerSet.addKnownPeer({
+                            address: peerAddress,
+                            operationalAddress,
+                            discoveryData: RemoteDescriptor.fromLongForm(this.#node.state.commissioning),
+                        });
+                    }
                 }
             }
 
@@ -57,12 +66,12 @@ export class NetworkClient extends NetworkBehavior {
                 peer.physicalProperties = ClientNodePhysicalProperties(this.#node);
 
                 // Set transport preference: per-peer override from NetworkClient, or inherit
-                // from the controller (owner) NetworkServer default. Maps "tcp"/"udp" string to ChannelType.
+                // from the controller (owner) NetworkServer default. Explicit "udp" clears any
+                // controller-wide TCP default already applied by PeerSet.#applyDefaultPreference.
                 const pref =
-                    this.state.transportPreference ?? (this.#node.owner?.state as any)?.network?.transportPreference;
-                if (pref === "tcp") {
-                    peer.transportPreference = ChannelType.TCP;
-                }
+                    this.state.transportPreference ??
+                    (this.#node.owner?.state as Record<string, Val.Struct> | undefined)?.network?.transportPreference;
+                peer.transportPreference = pref === "tcp" ? ChannelType.TCP : undefined;
             }
         }
 

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

@@ -9,6 +9,7 @@ import type { ServerNode } from "#node/ServerNode.js";
 import { InteractionServer } from "#node/server/InteractionServer.js";
 import {
     AddressInUseError,
+    ChannelType,
     Crypto,
     InterfaceType,
     Logger,
@@ -327,6 +328,17 @@ export class ServerNetworkRuntime extends NetworkRuntime {
             advertiser.supportedTransports = { tcpClient: tcpConfig.outgoing, tcpServer: tcpConfig.incoming };
         }
 
+        // Apply default outgoing transport preference to peers created by this controller, so
+        // peers used during commissioning (before their per-peer NetworkClient hook runs) inherit
+        // the TCP preference and use it for the post-commissioning Reconnect step.
+        if (owner.state.network.transportPreference === "tcp") {
+            if (tcpConfig.outgoing) {
+                env.get(PeerSet).transportPreference = ChannelType.TCP;
+            } else {
+                logger.warn("transportPreference is 'tcp' but outgoing TCP is disabled; preference ignored");
+            }
+        }
+
         await this.addBroadcasters(advertiser);
 
         await owner.act("start-network", agent => agent.load(ProductDescriptionServer));

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

@@ -228,13 +228,13 @@ export class SubscriptionsServer extends Behavior {
                         const { operationalAddress } = peer.descriptor;
 
                         // If the peer's last known address was TCP, prefer TCP for re-establishment
-                        const transport =
+                        const preferredTransport =
                             operationalAddress && "type" in operationalAddress && operationalAddress.type === "tcp"
                                 ? ChannelType.TCP
                                 : undefined;
                         session = await peer.connect({
                             connectionTimeout: REESTABLISH_SUBSCRIPTIONS_TIMEOUT,
-                            transport,
+                            preferredTransport,
                         });
                         if (GroupSession.is(session)) {
                             // Should never happen but add for easier typing

package/src/endpoint/Endpoint.ts

@@ -459,7 +459,7 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
      * This is the recommended way to access events for a specific behavior because it provides proper type checking
      * and enforces the correctness of the used Behavior type including all enabled features.
      */
-    eventsOf<T extends Behavior.Type>(type: T | string): Behavior.EventsOf<T>;
+    eventsOf<T extends Behavior.Type>(type: T): Behavior.EventsOf<T>;
 
     eventsOf(type: Behavior.Type | string): unknown {
         if (typeof type === "string") {