@matter/protocol 0.16.0-alpha.0-20250809-ee8375bcb → 0.16.0-alpha.0-20250812-285b75d83

package/src/advertisement/mdns/CommissionerMdnsAdvertisement.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Advertisement } from "#advertisement/Advertisement.js";
+import { ServiceDescription } from "#advertisement/ServiceDescription.js";
+import { PtrRecord } from "#general";
+import {
+    getCommissionerDeviceQname,
+    MATTER_COMMISSIONER_SERVICE_QNAME,
+    SERVICE_DISCOVERY_QNAME,
+} from "#mdns/MdnsConsts.js";
+import { MdnsAdvertisement } from "./MdnsAdvertisement.js";
+import type { MdnsAdvertiser } from "./MdnsAdvertiser.js";
+
+/**
+ * Advertise a node as a commissioner service.
+ */
+export class CommissionerMdnsAdvertisement extends MdnsAdvertisement<ServiceDescription.Commissioner> {
+    instanceId: string;
+
+    constructor(advertiser: MdnsAdvertiser, description: ServiceDescription.Commissioner) {
+        const instanceId = advertiser.createInstanceId();
+        const qname = getCommissionerDeviceQname(instanceId);
+
+        super(advertiser, qname, description);
+
+        this.instanceId = instanceId;
+    }
+
+    override get ptrRecords() {
+        const { deviceType, vendorId } = this.description;
+
+        const vendorQname = `_V${vendorId}._sub.${MATTER_COMMISSIONER_SERVICE_QNAME}`;
+
+        const records = [
+            PtrRecord(SERVICE_DISCOVERY_QNAME, MATTER_COMMISSIONER_SERVICE_QNAME),
+            PtrRecord(MATTER_COMMISSIONER_SERVICE_QNAME, vendorQname),
+            PtrRecord(vendorQname, this.qname),
+        ];
+
+        if (deviceType !== undefined) {
+            const deviceTypeQname = `_T${deviceType}._sub.${MATTER_COMMISSIONER_SERVICE_QNAME}`;
+
+            records.push(PtrRecord(SERVICE_DISCOVERY_QNAME, deviceTypeQname));
+            records.push(PtrRecord(deviceTypeQname, this.qname));
+        }
+
+        return records;
+    }
+
+    override get txtValues() {
+        const { vendorId, productId, deviceType, name: deviceName } = this.description;
+
+        const values: Record<string, unknown> = {
+            DN: deviceName /* Device Name */,
+            DT: deviceType /* Device Type */,
+        };
+
+        if (!this.isPrivacyMasked) {
+            values.VP = `${vendorId}+${productId}`; /* Vendor / Product */
+        }
+
+        return values;
+    }
+
+    override isDuplicate(other: Advertisement) {
+        // Only one commissioning advertisement allowed per advertiser
+        return other.isCommissioning();
+    }
+}

package/src/advertisement/mdns/MdnsAdvertisement.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Advertisement } from "#advertisement/Advertisement.js";
+import type { Advertiser } from "#advertisement/Advertiser.js";
+import type { ServiceDescription } from "#advertisement/ServiceDescription.js";
+import { SupportedTransportsSchema } from "#common/SupportedTransportsBitmap.js";
+import { AAAARecord, ARecord, DnsRecord, Logger, NetworkInterfaceDetails, SrvRecord, Time, TxtRecord } from "#general";
+import type { MdnsServer } from "#mdns/MdnsServer.js";
+import { SessionIntervals } from "#session/SessionIntervals.js";
+import type { MdnsAdvertiser } from "./MdnsAdvertiser.js";
+
+const logger = Logger.get("MdnsAdvertisement");
+
+/**
+ * Base class for MDNS advertisements.
+ *
+ * Individual classes specialize for each type of service.
+ */
+export abstract class MdnsAdvertisement<T extends ServiceDescription = ServiceDescription> extends Advertisement<T> {
+    declare advertiser: MdnsAdvertiser;
+
+    /**
+     * The device qname.
+     */
+    qname: string;
+
+    #isPrivacyMasked: boolean;
+    #stopAt?: number;
+
+    constructor(advertiser: MdnsAdvertiser, qname: string, description: T) {
+        description = {
+            ...description,
+            ...SessionIntervals(description),
+        };
+        super(advertiser, `mdns:${qname}`, description, { omitPrivateDetails: advertiser.omitPrivateDetails });
+        this.qname = qname;
+        this.#isPrivacyMasked = this.isPrivacyMasked;
+    }
+
+    protected abstract ptrRecords: DnsRecord[];
+
+    protected get txtValues(): Record<string, unknown> {
+        return {};
+    }
+
+    override async run(context: Advertisement.ActivityContext, event: Advertiser.BroadcastEvent = "startup") {
+        this.#stopAt = undefined;
+        let number = 0;
+        for (const retryInterval of this.advertiser.broadcastScheduleFor(this, event)) {
+            if (this.#stopAt !== undefined && this.#stopAt <= Time.nowMs()) {
+                break;
+            }
+
+            number++;
+            logger.debug("Broadcast", this.dict({ number, next: retryInterval }));
+            await this.broadcast();
+            await context.sleep("MDNS repeat", retryInterval);
+        }
+    }
+
+    /**
+     * Broadcast a single announcement immediately.
+     */
+    async broadcast() {
+        if (!this.#isPrivacyMasked && this.isPrivacyMasked) {
+            this.#isPrivacyMasked = true;
+            await this.advertiser.server.setRecordsGenerator(this.service, this.#recordsGenerator);
+        }
+
+        await this.advertiser.server.broadcast(this.service);
+    }
+
+    /**
+     * Broadcast expiration announcement immediately.
+     */
+    async expire() {
+        logger.info("Unpublishing", this.dict({ time: this.duration }));
+        await this.advertiser.server.expireAnnouncements(this.service);
+    }
+
+    override serviceConnected() {
+        const { broadcastAfterConnection } = this.advertiser.broadcastConfigFor(this);
+
+        if (broadcastAfterConnection === undefined) {
+            return;
+        }
+
+        if (broadcastAfterConnection <= 0) {
+            this.stop();
+            return;
+        }
+
+        this.#stopAt = Time.nowMs() + broadcastAfterConnection;
+    }
+
+    override serviceDisconnected() {
+        this.start("reconnect");
+    }
+
+    protected override async onCreate() {
+        // Use Promise.resolve() to initialize on next microtick so the constructor completes before invocation
+        await Promise.resolve().then(() => {
+            // Install the records generator.  This will be used for broadcast and to respond to queries
+            logger.info("Publishing", this.dict());
+            return this.advertiser.server.setRecordsGenerator(this.service, this.#recordsGenerator);
+        });
+    }
+
+    protected override async onClose() {
+        // The MDNS server doesn't currently track which answers have been sent so just expire unconditionally
+        await this.expire();
+    }
+
+    get #recordsGenerator(): MdnsServer.RecordGenerator {
+        return (_intf, addrs) => this.#recordsFor(addrs);
+    }
+
+    #recordsFor(addrs: NetworkInterfaceDetails) {
+        const hostname = addrs.mac.replace(/:/g, "").toUpperCase() + "0000.local";
+
+        const records: DnsRecord[] = [
+            ...this.ptrRecords,
+            SrvRecord(this.qname, { priority: 0, weight: 0, port: this.advertiser.port, target: hostname }),
+            TxtRecord(
+                this.qname,
+                Object.entries(this.#txtValues)
+                    .filter(([, v]) => v !== undefined)
+                    .map(([k, v]) => `${k}=${v}`),
+            ),
+        ];
+
+        for (const addr of addrs.ipV6) {
+            records.push(AAAARecord(hostname, addr));
+        }
+
+        if (this.advertiser.server.supportsIpv4) {
+            for (const addr of addrs.ipV4) {
+                records.push(ARecord(hostname, addr));
+            }
+        }
+
+        return records;
+    }
+
+    get #txtValues() {
+        const values: Record<string, unknown> = {
+            SII: this.description.idleIntervalMs /* Session Idle Interval */,
+            SAI: this.description.activeIntervalMs /* Session Active Interval */,
+            SAT: this.description.activeThresholdMs /* Session Active Threshold */,
+            ...this.txtValues,
+        };
+
+        if (this.description.tcp !== undefined) {
+            values.T = SupportedTransportsSchema.encode(this.description.tcp); /* TCP support */
+        }
+
+        if (this.description.icd !== undefined) {
+            values.ICD = this.description.icd; /* ICD support */
+        }
+
+        return values;
+    }
+}

package/src/advertisement/mdns/MdnsAdvertiser.ts

@@ -0,0 +1,248 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Advertiser } from "#advertisement/Advertiser.js";
+import { ServiceDescription } from "#advertisement/ServiceDescription.js";
+import { Bytes, Crypto, ImplementationError, InternalError, RetrySchedule, STANDARD_MATTER_PORT } from "#general";
+import type { MdnsServer } from "#mdns/MdnsServer.js";
+import { DatatypeModel, FieldElement } from "#model";
+import { MAXIMUM_COMMISSIONING_TIMEOUT_S } from "#types";
+import { CommissionableMdnsAdvertisement } from "./CommissionableMdnsAdvertisement.js";
+import { CommissionerMdnsAdvertisement } from "./CommissionerMdnsAdvertisement.js";
+import type { MdnsAdvertisement } from "./MdnsAdvertisement.js";
+import { OperationalMdnsAdvertisement } from "./OperationalMdnsAdvertisement.js";
+
+/**
+ * An {@link Advertiser} that advertises using an in-process MDNS implementation.
+ */
+export class MdnsAdvertiser extends Advertiser {
+    readonly port: number;
+    readonly omitPrivateDetails: boolean;
+
+    #schedules = new Array<{ config: MdnsAdvertiser.BroadcastSchedule; schedule?: RetrySchedule }>();
+
+    constructor(
+        readonly crypto: Crypto,
+        readonly server: MdnsServer,
+        options?: MdnsAdvertiser.Options,
+    ) {
+        super();
+
+        this.port = options?.port ?? STANDARD_MATTER_PORT;
+        this.omitPrivateDetails = options?.omitPrivateDetails ?? false;
+
+        let hasDefaultSchedule = false;
+        let hasRetransmitSchedule = false;
+        if (options?.schedules) {
+            for (const schedule of options.schedules) {
+                if (schedule.serviceKind === undefined) {
+                    if (schedule.event === undefined) {
+                        hasDefaultSchedule = true;
+                    }
+
+                    if (schedule.event === "retransmit") {
+                        hasRetransmitSchedule = true;
+                    }
+                }
+
+                this.#schedules.push({ config: schedule });
+            }
+        }
+
+        if (!hasRetransmitSchedule) {
+            this.#schedules.push({ config: MdnsAdvertiser.RetransmissionBroadcastSchedule });
+        }
+
+        if (!hasDefaultSchedule) {
+            this.#schedules.push({ config: MdnsAdvertiser.DefaultBroadcastSchedule });
+        }
+    }
+
+    /**
+     * Create an advertisement for the specific service.
+     */
+    override getAdvertisement(description: ServiceDescription): MdnsAdvertisement | undefined {
+        switch (description.kind) {
+            case "operational":
+                return (
+                    (this.advertisementForFabric(description.fabric) as MdnsAdvertisement | undefined) ??
+                    new OperationalMdnsAdvertisement(this, description)
+                );
+
+            case "commissionable":
+                return new CommissionableMdnsAdvertisement(this, description);
+
+            case "commissioner":
+                return new CommissionerMdnsAdvertisement(this, description);
+
+            default:
+                throw new ImplementationError(
+                    `Unsupported service description kind "${(description as ServiceDescription).kind}`,
+                );
+        }
+    }
+
+    /**
+     * Generate a random 8-byte Matter instance identifier.
+     */
+    createInstanceId() {
+        return Bytes.toHex(this.crypto.randomBytes(8)).toUpperCase();
+    }
+
+    /**
+     * Retrieve the broadcast schedule for a specific advertisement.
+     */
+    broadcastScheduleFor(advertisement: MdnsAdvertisement, event?: Advertiser.BroadcastEvent) {
+        const entry = this.#scheduleFor(advertisement, event);
+
+        if (entry.schedule === undefined) {
+            entry.schedule = new RetrySchedule(
+                this.crypto,
+                RetrySchedule.Configuration(MdnsAdvertiser.DefaultBroadcastSchedule, entry.config),
+            );
+        }
+
+        return entry.schedule;
+    }
+
+    /**
+     * Retrieve broadcast configuration for a specific advertisement.
+     */
+    broadcastConfigFor(advertisement: MdnsAdvertisement, event?: Advertiser.BroadcastEvent) {
+        return this.#scheduleFor(advertisement, event).config;
+    }
+
+    #scheduleFor(advertisement: MdnsAdvertisement, event?: Advertiser.BroadcastEvent) {
+        if (!event) {
+            event = "startup";
+        }
+
+        for (const entry of this.#schedules) {
+            const { serviceKind, event: event2 } = entry.config;
+
+            if (serviceKind !== undefined && serviceKind !== advertisement.description.kind) {
+                continue;
+            }
+
+            if (event2 !== undefined && event2 !== event) {
+                continue;
+            }
+
+            return entry;
+        }
+
+        throw new InternalError("Default retry schedule not present");
+    }
+}
+
+export namespace MdnsAdvertiser {
+    /**
+     * MDNS advertisement configuration options.
+     */
+    export interface Options {
+        /**
+         * The port of the Matter service to advertise.
+         *
+         * Defaults to 5540.
+         */
+        readonly port?: number;
+
+        /**
+         * Omit the vendor and product ID from announcements for privacy reasons.
+         */
+        readonly omitPrivateDetails?: boolean;
+
+        /**
+         * Broadcast schedule.
+         *
+         * These control the intervals at which the server broadcasts the advertisement.  Note that order is important;
+         * more specific schedules should appear first.
+         *
+         * By default all broadcasts are configured using {@link DefaultBroadcastSchedule}.
+         */
+        readonly schedules?: readonly BroadcastSchedule[];
+    }
+
+    /**
+     * Schedule for automatic broadcasts.
+     *
+     * Schedules apply conditionally with {@link DefaultBroadcastSchedule} as the fallback.
+     */
+    export interface BroadcastSchedule extends RetrySchedule.Configuration {
+        /**
+         * Limit this schedule to a particular service kind.
+         */
+        readonly serviceKind?: ServiceDescription["kind"];
+
+        /**
+         * Limit this schedule to initial broadcast or broadcast when reconnecting.
+         */
+        readonly event?: Advertiser.BroadcastEvent;
+
+        /**
+         * Extra time to broadcast after establishing an operational connection.
+         *
+         * Set to zero to terminate broadcast immediately after connection.  If undefined broadcasts will continue until
+         * terminated by {@link timeout} or {@link maximumCount}.
+         */
+        readonly broadcastAfterConnection?: number;
+    }
+
+    /**
+     * Default schedule for automatic broadcast.
+     */
+    export const DefaultBroadcastSchedule: BroadcastSchedule = {
+        // Mandated by MDNS specification
+        initialInterval: 1_000,
+
+        // Maximum commissioning timeout per Matter specification 5.4.2.3.1, although
+        timeout: MAXIMUM_COMMISSIONING_TIMEOUT_S * 1000,
+
+        // Minimum per MDNS specification
+        backoffFactor: 2,
+
+        // Technically this may result in us emitting more than 8 packets which is the maximum per the MDNS
+        // specification but extra packets will only come every 90 seconds
+        maximumInterval: 90_000,
+
+        // Not in any specification AFAIK but common sense to reduce thundering herd
+        jitterFactor: 0.25,
+
+        // Generally operational broadcast is unnecessary once an operational connection is established
+        broadcastAfterConnection: 0,
+    };
+
+    /**
+     * Default schedule for retransmission broadcast.
+     */
+    export const RetransmissionBroadcastSchedule: BroadcastSchedule = {
+        event: "retransmit",
+
+        // Retransmission events occur for every packet retry so limit count to 1
+        maximumCount: 1,
+    };
+
+    /**
+     * Data model for MDNS advertiser configuration.
+     */
+    export const OptionsSchema = new DatatypeModel(
+        { name: "MdnsAdvertiserOptions", type: "struct" },
+        FieldElement({ name: "omitPrivateDetails", type: "bool" }),
+        FieldElement(
+            { name: "schedules", type: "list" },
+            FieldElement(
+                { name: "entry", type: "struct" },
+                FieldElement({ name: "initialInterval", type: "uint32" }),
+                FieldElement({ name: "timeout", type: "uint32" }),
+                FieldElement({ name: "backoffFactor", type: "uint8" }),
+                FieldElement({ name: "maximumInterval", type: "uint32" }),
+                FieldElement({ name: "jitterFactor", type: "single" }),
+                FieldElement({ name: "serviceKind", type: "string" }),
+                FieldElement({ name: "event", type: "string" }),
+            ),
+        ),
+    );
+}

package/src/advertisement/mdns/OperationalMdnsAdvertisement.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Advertisement } from "#advertisement/Advertisement.js";
+import { ServiceDescription } from "#advertisement/ServiceDescription.js";
+import { Bytes, PtrRecord } from "#general";
+import {
+    getFabricQname,
+    getOperationalDeviceQname,
+    MATTER_SERVICE_QNAME,
+    SERVICE_DISCOVERY_QNAME,
+} from "#mdns/MdnsConsts.js";
+import { NodeId } from "#types";
+import { MdnsAdvertisement } from "./MdnsAdvertisement.js";
+import type { MdnsAdvertiser } from "./MdnsAdvertiser.js";
+
+/**
+ * Advertise a node as a fabric member.
+ */
+export class OperationalMdnsAdvertisement extends MdnsAdvertisement<ServiceDescription.Operational> {
+    constructor(advertiser: MdnsAdvertiser, description: ServiceDescription.Operational) {
+        const {
+            fabric: { operationalId, nodeId },
+        } = description;
+
+        const qname = getOperationalDeviceQname(Bytes.toHex(operationalId).toUpperCase(), NodeId.toHexString(nodeId));
+
+        super(advertiser, qname, description);
+    }
+
+    override get ptrRecords() {
+        const operationalIdString = Bytes.toHex(this.description.fabric.operationalId).toUpperCase();
+        const fabricQname = getFabricQname(operationalIdString);
+
+        return [
+            PtrRecord(SERVICE_DISCOVERY_QNAME, MATTER_SERVICE_QNAME),
+            PtrRecord(SERVICE_DISCOVERY_QNAME, fabricQname),
+            PtrRecord(MATTER_SERVICE_QNAME, this.qname),
+            PtrRecord(fabricQname, this.qname),
+        ];
+    }
+
+    override isDuplicate(other: Advertisement) {
+        // There may only be one operational advertisement per service per advertiser
+        return other.isOperational() && other.service === this.service;
+    }
+}

package/src/advertisement/mdns/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from "./CommissionableMdnsAdvertisement.js";
+export * from "./CommissionerMdnsAdvertisement.js";
+export * from "./MdnsAdvertisement.js";
+export * from "./MdnsAdvertiser.js";
+export * from "./OperationalMdnsAdvertisement.js";

package/src/ble/Ble.ts

@@ -5,7 +5,6 @@
  */
 
 import { Channel, ChannelType, MatterError, NetInterface, NoProviderError, TransportInterface } from "#general";
-import { InstanceBroadcaster } from "../common/InstanceBroadcaster.js";
 import { Scanner } from "../common/Scanner.js";
 import { BLE_MAX_MATTER_PAYLOAD_SIZE } from "./BleConsts.js";
 
@@ -23,10 +22,14 @@ export abstract class Ble {
         return this.get !== BleDisabled;
     }
 
-    abstract getBlePeripheralInterface(): TransportInterface;
-    abstract getBleCentralInterface(): NetInterface;
-    abstract getBleBroadcaster(additionalAdvertisementData?: Uint8Array): InstanceBroadcaster;
-    abstract getBleScanner(): Scanner;
+    abstract get peripheralInterface(): BlePeripheralInterface;
+    abstract get centralInterface(): NetInterface;
+    abstract get scanner(): Scanner;
+}
+
+export interface BlePeripheralInterface extends TransportInterface {
+    advertise(advertiseData: Uint8Array, additionalAdvertisementData?: Uint8Array, intervalMs?: number): Promise<void>;
+    stopAdvertising(): Promise<void>;
 }
 
 export abstract class BleChannel<T> implements Channel<T> {

package/src/ble/BleConsts.ts

@@ -7,7 +7,8 @@
 import { MAX_UDP_MESSAGE_SIZE } from "#general";
 
 /** @see {@link MatterSpecification.v11.Core} § 4.17.3.2 */
-export const BLE_MATTER_SERVICE_UUID = "fff6";
+export const BLE_MATTER_SERVICE_UUID_SHORT = "fff6";
+export const BLE_MATTER_SERVICE_UUID = "0000FFF6-0000-1000-8000-00805F9B34FB";
 export const BLE_MATTER_C1_CHARACTERISTIC_UUID = "18EE2EF5-263D-4559-959F-4F9C429F9D11";
 export const BLE_MATTER_C2_CHARACTERISTIC_UUID = "18EE2EF5-263D-4559-959F-4F9C429F9D12";
 export const BLE_MATTER_C3_CHARACTERISTIC_UUID = "64630238-8772-45F2-B87D-748A83218F04";

package/src/codec/BtpCodec.ts

@@ -283,6 +283,7 @@ export class BtpCodec {
         vendorId: number,
         productId: number,
         hasAdditionalAdvertisementData = false,
+        isExtendedAnnouncement = false,
     ) {
         const writer = new DataWriter(Endian.Little);
         writer.writeUInt8(0x02);
@@ -293,9 +294,9 @@ export class BtpCodec {
         writer.writeUInt16(0xfff6);
         writer.writeUInt8(0x00);
         writer.writeUInt16(discriminator);
-        writer.writeUInt16(vendorId);
-        writer.writeUInt16(productId);
-        writer.writeUInt8(hasAdditionalAdvertisementData ? 0x01 : 0x00);
+        writer.writeUInt16(isExtendedAnnouncement ? 0 : vendorId);
+        writer.writeUInt16(isExtendedAnnouncement ? 0 : productId);
+        writer.writeUInt8((hasAdditionalAdvertisementData ? 1 : 0) | (isExtendedAnnouncement ? 2 : 0));
         return writer.toByteArray();
     }
 

package/src/common/Scanner.ts

@@ -5,25 +5,9 @@
  */
 
 import { BasicSet, ChannelType, Environment, Environmental, Lifespan, ServerAddress, ServerAddressIp } from "#general";
-import { BitFlag, BitmapSchema, DiscoveryCapabilitiesBitmap, NodeId, TypeFromPartialBitSchema, VendorId } from "#types";
+import { DiscoveryCapabilitiesBitmap, NodeId, TypeFromPartialBitSchema, VendorId } from "#types";
 import { Fabric } from "../fabric/Fabric.js";
 
-export const SupportedTransportsBitmap = {
-    // Bit 0 is reserved
-    /**
-     * TCP Client
-     * The advertising Node implements the TCP Client mode and MAY connect to a peer Node that is a TCP Server.
-     */
-    tcpClient: BitFlag(1),
-
-    /**
-     * TCP Server
-     * The advertising Node implements the TCP Server mode and SHALL listen for incoming TCP connections.
-     */
-    tcpServer: BitFlag(2),
-};
-export const SupportedTransportsSchema = BitmapSchema(SupportedTransportsBitmap);
-
 /**
  * All information exposed by a commissionable device via announcements.
  * The properties are named identical as in the Matter specification.

package/src/common/SupportedTransportsBitmap.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BitFlag, BitmapSchema, TypeFromBitSchema } from "@matter/types";
+
+export const SupportedTransportsBitmap = {
+    // Bit 0 is reserved
+    /**
+     * TCP Client
+     * The advertising Node implements the TCP Client mode and MAY connect to a peer Node that is a TCP Server.
+     */
+    tcpClient: BitFlag(1),
+
+    /**
+     * TCP Server
+     * The advertising Node implements the TCP Server mode and SHALL listen for incoming TCP connections.
+     */
+    tcpServer: BitFlag(2),
+};
+export const SupportedTransportsSchema = BitmapSchema(SupportedTransportsBitmap);
+
+export interface SupportedTransportsBitmap extends TypeFromBitSchema<typeof SupportedTransportsBitmap> {}

package/src/common/index.ts

@@ -8,6 +8,6 @@ export * from "../peer/PeerAddress.js";
 export * from "./ExpandedPath.js";
 export * from "./FailsafeContext.js";
 export * from "./FailsafeTimer.js";
-export * from "./InstanceBroadcaster.js";
 export * from "./OperationalCredentialsTypes.js";
 export * from "./Scanner.js";
+export * from "./SupportedTransportsBitmap.js";

package/src/fabric/Fabric.ts

@@ -214,6 +214,14 @@ export class Fabric {
         this.#sessions.delete(session);
     }
 
+    hasSessionForPeer(peerNodeId: NodeId) {
+        for (const session of this.#sessions) {
+            if (session.peerNodeId === peerNodeId) {
+                return true;
+            }
+        }
+    }
+
     addRemoveCallback(callback: () => MaybePromise<void>) {
         this.#removeCallbacks.push(callback);
     }