@matter/protocol 0.12.4-alpha.0-20250217-b0bba5179 → 0.12.4-alpha.0-20250224-e0964a795

package/src/interaction/InteractionServer.ts

@@ -227,9 +227,11 @@ export interface InteractionContext {
  * Translates interactions from the Matter protocol to matter.js APIs.
  */
 export class InteractionServer implements ProtocolHandler, InteractionRecipient {
+    readonly id = INTERACTION_PROTOCOL_ID;
     #context: InteractionContext;
     #nextSubscriptionId = Crypto.getRandomUInt32();
     #isClosing = false;
+    #clientHandler?: ProtocolHandler;
     readonly #subscriptionConfig: ServerSubscriptionConfig;
     readonly #maxPathsPerInvoke;
 
@@ -244,10 +246,6 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         });
     }
 
-    getId() {
-        return INTERACTION_PROTOCOL_ID;
-    }
-
     protected get isClosing() {
         return this.#isClosing;
     }
@@ -256,13 +254,28 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         return this.#maxPathsPerInvoke;
     }
 
-    async onNewExchange(exchange: MessageExchange) {
+    async onNewExchange(exchange: MessageExchange, message: Message) {
         // Note - changes here must be copied to TransactionalInteractionServer as it does not call super() to avoid
         // the stack frame
         if (this.#isClosing) return; // We are closing, ignore anything newly incoming
+
+        // An incoming data report as the first message is not a valid server operation.  We instead delegate to a
+        // client implementation if available
+        if (message.payloadHeader.messageType === MessageType.SubscribeRequest && this.#clientHandler) {
+            return this.#clientHandler.onNewExchange(exchange, message);
+        }
+
         await new InteractionServerMessenger(exchange).handleRequest(this);
     }
 
+    get clientHandler(): ProtocolHandler | undefined {
+        return this.#clientHandler;
+    }
+
+    set clientHandler(clientHandler: ProtocolHandler) {
+        this.#clientHandler = clientHandler;
+    }
+
     async #collectEventDataForRead(
         { eventRequests, eventFilters, isFabricFiltered }: ReadRequest,
         exchange: MessageExchange,

package/src/interaction/SubscriptionClient.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MessageExchange } from "#protocol/MessageExchange.js";
+import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
+import { Environment, Environmental, Logger, MaybePromise, Time, Timer } from "@matter/general";
+import { INTERACTION_PROTOCOL_ID } from "@matter/types";
+import { DataReport, IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
+
+const logger = Logger.get("SubscriptionClient");
+
+export interface RegisteredSubscription {
+    id: number;
+    maximumPeerResponseTime: number;
+    maxIntervalS: number;
+    onData: (dataReport: DataReport) => MaybePromise<void>;
+    onTimeout?: () => void;
+}
+
+/**
+ * A simple protocol handler that handles exchanges starting with data reports.
+ *
+ * Incoming data reports must match to a subscription registered with {@link add} or the exchange is invalid.
+ */
+export class SubscriptionClient implements ProtocolHandler {
+    readonly #listeners = new Map<number, (dataReport: DataReport) => MaybePromise<void>>();
+    readonly #timeouts = new Map<number, Timer>();
+
+    constructor() {}
+
+    static [Environmental.create](env: Environment) {
+        const client = new SubscriptionClient();
+        env.set(SubscriptionClient, client);
+        return client;
+    }
+
+    readonly id = INTERACTION_PROTOCOL_ID;
+
+    /**
+     * Register a subscription.
+     */
+    add(subscription: RegisteredSubscription) {
+        const { id, onData, onTimeout } = subscription;
+
+        this.#listeners.set(id, onData);
+        if (onTimeout) {
+            let timer = this.#timeouts.get(id);
+            if (timer !== undefined) {
+                timer.stop();
+                this.#timeouts.delete(id);
+            }
+
+            const maxIntervalMs = subscription.maxIntervalS * 1000 + subscription.maximumPeerResponseTime;
+
+            timer = Time.getTimer("Subscription timeout", maxIntervalMs, () => {
+                logger.info(`Subscription ${id} timed out after ${maxIntervalMs}ms`);
+                this.delete(id);
+                onTimeout();
+            }).start();
+
+            this.#timeouts.set(id, timer);
+        }
+    }
+
+    /**
+     * Unregister a subscription.
+     */
+    delete(id: number) {
+        this.#listeners.delete(id);
+        const timer = this.#timeouts.get(id);
+        if (timer !== undefined) {
+            timer.stop();
+            this.#timeouts.delete(id);
+        }
+    }
+
+    async onNewExchange(exchange: MessageExchange) {
+        const messenger = new IncomingInteractionClientMessenger(exchange);
+
+        let dataReport: DataReport;
+        try {
+            // TODO Adjust this to getting packages as callback when received to handle error cases and checks outside
+            dataReport = await messenger.readAggregateDataReport([...this.#listeners.keys()]);
+        } finally {
+            messenger.close().catch(error => logger.info("Error closing client messenger", error));
+        }
+        const subscriptionId = dataReport.subscriptionId as number; // this is checked in the messenger already because we hand over allowed list
+
+        const listener = this.#listeners.get(subscriptionId);
+        const timer = this.#timeouts.get(subscriptionId);
+
+        if (timer !== undefined) {
+            timer.stop().start(); // Restart timer because we received data
+        }
+
+        await listener?.(dataReport);
+    }
+
+    async close() {
+        this.#listeners.clear();
+        this.#timeouts.forEach(timer => timer.stop());
+        this.#timeouts.clear();
+    }
+}

package/src/interaction/index.ts

@@ -14,3 +14,4 @@ export * from "./InteractionMessenger.js";
 export * from "./InteractionServer.js";
 export * from "./ServerSubscription.js";
 export * from "./Subscription.js";
+export * from "./SubscriptionClient.js";

package/src/peer/ControllerCommissioner.ts

@@ -27,11 +27,11 @@ import { ChannelStatusResponseError } from "#securechannel/index.js";
 import { PaseClient } from "#session/index.js";
 import { SessionManager } from "#session/SessionManager.js";
 import { DiscoveryCapabilitiesBitmap, NodeId, SECURE_CHANNEL_PROTOCOL_ID, TypeFromPartialBitSchema } from "#types";
-import { InteractionClient } from "../interaction/InteractionClient.js";
+import { InteractionClient, InteractionClientProvider } from "../interaction/InteractionClient.js";
 import { ExchangeManager, MessageChannel } from "../protocol/ExchangeManager.js";
 import { DedicatedChannelExchangeProvider } from "../protocol/ExchangeProvider.js";
 import { PeerAddress } from "./PeerAddress.js";
-import { NodeDiscoveryType, PeerSet } from "./PeerSet.js";
+import { NodeDiscoveryType } from "./PeerSet.js";
 
 const logger = Logger.get("PeerCommissioner");
 
@@ -108,7 +108,7 @@ export interface DiscoveryAndCommissioningOptions extends CommissioningOptions {
  * Interfaces {@link ControllerCommissioner} with other components.
  */
 export interface ControllerCommissionerContext {
-    peers: PeerSet;
+    clients: InteractionClientProvider;
     scanners: ScannerSet;
     netInterfaces: NetInterfaceSet;
     sessions: SessionManager;
@@ -130,7 +130,7 @@ export class ControllerCommissioner {
 
     static [Environmental.create](env: Environment) {
         const instance = new ControllerCommissioner({
-            peers: env.get(PeerSet),
+            clients: env.get(InteractionClientProvider),
             scanners: env.get(ScannerSet),
             netInterfaces: env.get(NetInterfaceSet),
             sessions: env.get(SessionManager),
@@ -385,6 +385,7 @@ export class ControllerCommissioner {
             // Use the created secure session to do the commissioning
             new InteractionClient(
                 new DedicatedChannelExchangeProvider(this.#context.exchanges, paseSecureMessageChannel),
+                this.#context.clients.peers.subscriptionClient,
                 address,
             ),
             this.#context.ca,
@@ -406,7 +407,7 @@ export class ControllerCommissioner {
                 }
 
                 // Look for the device broadcast over MDNS and do CASE pairing
-                return await this.#context.peers.connect(
+                return await this.#context.clients.connect(
                     address,
                     {
                         discoveryType: NodeDiscoveryType.TimedDiscovery,
@@ -422,7 +423,7 @@ export class ControllerCommissioner {
             await commissioningManager.executeCommissioning();
         } catch (error) {
             // We might have added data for an operational address that we need to cleanup
-            await this.#context.peers.delete(address);
+            await this.#context.clients.peers.delete(address);
             throw error;
         } finally {
             if (!paseSecureMessageChannel.closed) {

package/src/peer/InteractionQueue.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Environment, Environmental, PromiseQueue } from "@matter/general";
+
+const CONCURRENT_QUEUED_INTERACTIONS = 4;
+const INTERACTION_QUEUE_DELAY_MS = 100;
+
+export class InteractionQueue extends PromiseQueue {
+    constructor() {
+        super(CONCURRENT_QUEUED_INTERACTIONS, INTERACTION_QUEUE_DELAY_MS);
+    }
+
+    static [Environmental.create](env: Environment) {
+        const instance = new InteractionQueue();
+        env.set(InteractionQueue, instance);
+        return instance;
+    }
+}

package/src/peer/PeerAddressStore.ts

@@ -18,7 +18,7 @@ export abstract class PeerAddressStore {
     abstract loadPeers(): MaybePromise<Iterable<OperationalPeer>>;
     abstract updatePeer(peer: OperationalPeer): MaybePromise<void>;
     abstract deletePeer(address: PeerAddress): MaybePromise<void>;
-    abstract createNodeStore(address: PeerAddress): Promise<PeerDataStore>;
+    abstract createNodeStore(address: PeerAddress): MaybePromise<PeerDataStore | undefined>;
 }
 
 export abstract class PeerDataStore {

package/src/peer/PeerSet.ts

@@ -7,6 +7,7 @@
 import { DiscoveryData, ScannerSet } from "#common/Scanner.js";
 import {
     anyPromise,
+    AsyncObservable,
     BasicSet,
     ChannelType,
     Construction,
@@ -22,13 +23,12 @@ import {
     NetInterfaceSet,
     NoResponseTimeoutError,
     ObservableSet,
-    PromiseQueue,
     ServerAddressIp,
     serverAddressToString,
     Time,
     Timer,
 } from "#general";
-import { InteractionClient } from "#interaction/InteractionClient.js";
+import { SubscriptionClient } from "#interaction/SubscriptionClient.js";
 import { MdnsScanner } from "#mdns/MdnsScanner.js";
 import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
 import { CaseClient, SecureSession, Session } from "#session/index.js";
@@ -39,6 +39,7 @@ import { ChannelNotConnectedError, ExchangeManager, MessageChannel } from "../pr
 import { ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
 import { RetransmissionLimitReachedError } from "../protocol/MessageExchange.js";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
+import { InteractionQueue } from "./InteractionQueue.js";
 import { OperationalPeer } from "./OperationalPeer.js";
 import { PeerAddressStore, PeerDataStore } from "./PeerAddressStore.js";
 
@@ -47,9 +48,6 @@ const logger = Logger.get("PeerSet");
 const RECONNECTION_POLLING_INTERVAL_MS = 600_000; // 10 minutes
 const RETRANSMISSION_DISCOVERY_TIMEOUT_S = 5;
 
-const CONCURRENT_QUEUED_INTERACTIONS = 4;
-const INTERACTION_QUEUE_DELAY_MS = 100;
-
 /**
  * Types of discovery that may be performed when connecting operationally.
  */
@@ -93,6 +91,7 @@ export interface PeerSetContext {
     sessions: SessionManager;
     channels: ChannelManager;
     exchanges: ExchangeManager;
+    subscriptionClient: SubscriptionClient;
     scanners: ScannerSet;
     netInterfaces: NetInterfaceSet;
     store: PeerAddressStore;
@@ -105,6 +104,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     readonly #sessions: SessionManager;
     readonly #channels: ChannelManager;
     readonly #exchanges: ExchangeManager;
+    readonly #subscriptionClient: SubscriptionClient;
     readonly #scanners: ScannerSet;
     readonly #netInterfaces: NetInterfaceSet;
     readonly #caseClient: CaseClient;
@@ -117,16 +117,17 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     }>();
     readonly #construction: Construction<PeerSet>;
     readonly #store: PeerAddressStore;
-    readonly #interactionQueue = new PromiseQueue(CONCURRENT_QUEUED_INTERACTIONS, INTERACTION_QUEUE_DELAY_MS);
+    readonly #interactionQueue = new InteractionQueue();
     readonly #nodeCachedData = new PeerAddressMap<PeerDataStore>(); // Temporarily until we store it in new API
-    readonly #clients = new PeerAddressMap<InteractionClient>();
+    readonly #disconnected = AsyncObservable<[address: PeerAddress]>();
 
     constructor(context: PeerSetContext) {
-        const { sessions, channels, exchanges, scanners, netInterfaces, store } = context;
+        const { sessions, channels, exchanges, subscriptionClient, scanners, netInterfaces, store } = context;
 
         this.#sessions = sessions;
         this.#channels = channels;
         this.#exchanges = exchanges;
+        this.#subscriptionClient = subscriptionClient;
         this.#scanners = scanners;
         this.#netInterfaces = netInterfaces;
         this.#store = store;
@@ -165,6 +166,10 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         return this.#peers.deleted;
     }
 
+    get disconnected() {
+        return this.#disconnected;
+    }
+
     has(item: PeerAddress | OperationalPeer) {
         if ("address" in item) {
             return this.#peers.has(item);
@@ -201,6 +206,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             sessions: env.get(SessionManager),
             channels: env.get(ChannelManager),
             exchanges: env.get(ExchangeManager),
+            subscriptionClient: env.get(SubscriptionClient),
             scanners: env.get(ScannerSet),
             netInterfaces: env.get(NetInterfaceSet),
             store: env.get(PeerAddressStore),
@@ -213,20 +219,18 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         return this.#peers;
     }
 
-    /**
-     * Connect to a node on a fabric.
-     */
-    async connect(
-        address: PeerAddress,
-        discoveryOptions: DiscoveryOptions,
-        allowUnknownPeer = false,
-    ): Promise<InteractionClient> {
-        await this.#ensureConnection(address, discoveryOptions, allowUnknownPeer);
+    get subscriptionClient() {
+        return this.#subscriptionClient;
+    }
 
-        return this.initializeInteractionClient(address, discoveryOptions);
+    get interactionQueue() {
+        return this.#interactionQueue;
     }
 
-    async #ensureConnection(address: PeerAddress, discoveryOptions: DiscoveryOptions, allowUnknownPeer = false) {
+    /**
+     * Ensure there is a channel to the designated peer.
+     */
+    async ensureConnection(address: PeerAddress, discoveryOptions: DiscoveryOptions, allowUnknownPeer = false) {
         if (!this.#peersByAddress.has(address) && !allowUnknownPeer) {
             throw new UnknownNodeError(`Cannot connect to unknown device ${PeerAddress(address)}`);
         }
@@ -256,62 +260,44 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         }
     }
 
-    async initializeInteractionClient(address: PeerAddress, discoveryOptions?: DiscoveryOptions) {
-        const existingClient = this.#clients.get(address);
-        if (existingClient !== undefined) {
-            return existingClient;
-        }
-
-        const nodeStore = this.get(address)?.dataStore;
-        await nodeStore?.construction; // Lazy initialize the data if not already done
-
+    /**
+     * Obtain an exchange provider for the designated peer.
+     */
+    async exchangeProviderFor(address: PeerAddress, discoveryOptions?: DiscoveryOptions) {
         let initiallyConnected = this.#channels.hasChannel(address);
-        const client = new InteractionClient(
-            new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
-                if (!initiallyConnected && !this.#channels.hasChannel(address)) {
-                    // We got an uninitialized node, so do the first connection as usual
-                    await this.#ensureConnection(address, { discoveryType: NodeDiscoveryType.None });
-                    initiallyConnected = true; // We only do this connection once, rest is handled in following code
-                    if (this.#channels.hasChannel(address)) {
-                        return;
-                    }
+        return new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
+            if (!initiallyConnected && !this.#channels.hasChannel(address)) {
+                // We got an uninitialized node, so do the first connection as usual
+                await this.ensureConnection(address, { discoveryType: NodeDiscoveryType.None });
+                initiallyConnected = true; // We only do this connection once, rest is handled in following code
+                if (this.#channels.hasChannel(address)) {
+                    return;
                 }
+            }
 
-                if (!this.#channels.hasChannel(address)) {
-                    throw new RetransmissionLimitReachedError(
-                        `Device ${PeerAddress(address)} is currently not reachable.`,
-                    );
-                }
-                await this.#channels.removeAllNodeChannels(address);
+            if (!this.#channels.hasChannel(address)) {
+                throw new RetransmissionLimitReachedError(`Device ${PeerAddress(address)} is currently not reachable.`);
+            }
+            await this.#channels.removeAllNodeChannels(address);
 
-                // Enrich discoveryData with data from the node store when not provided
-                const { discoveryData } = discoveryOptions ?? {
-                    discoveryData: this.#peersByAddress.get(address)?.discoveryData,
-                };
-                // Try to use first result for one last try before we need to reconnect
-                const operationalAddress = this.#knownOperationalAddressFor(address, true);
-                if (operationalAddress === undefined) {
-                    logger.info(
-                        `Re-discovering device failed (no address found), remove all sessions for ${PeerAddress(address)}`,
-                    );
-                    // We remove all sessions, this also informs the PairedNode class
-                    await this.#sessions.removeAllSessionsForNode(address);
-                    throw new RetransmissionLimitReachedError(
-                        `No operational address found for ${PeerAddress(address)}`,
-                    );
-                }
-                if (
-                    (await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, 2_000)) === undefined
-                ) {
-                    throw new RetransmissionLimitReachedError(`${PeerAddress(address)} is not reachable.`);
-                }
-            }),
-            address,
-            this.#interactionQueue,
-            nodeStore,
-        );
-        this.#clients.set(address, client);
-        return client;
+            // Enrich discoveryData with data from the node store when not provided
+            const { discoveryData } = discoveryOptions ?? {
+                discoveryData: this.#peersByAddress.get(address)?.discoveryData,
+            };
+            // Try to use first result for one last try before we need to reconnect
+            const operationalAddress = this.#knownOperationalAddressFor(address, true);
+            if (operationalAddress === undefined) {
+                logger.info(
+                    `Re-discovering device failed (no address found), remove all sessions for ${PeerAddress(address)}`,
+                );
+                // We remove all sessions, this also informs the PairedNode class
+                await this.#sessions.removeAllSessionsForNode(address);
+                throw new RetransmissionLimitReachedError(`No operational address found for ${PeerAddress(address)}`);
+            }
+            if ((await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, 2_000)) === undefined) {
+                throw new RetransmissionLimitReachedError(`${PeerAddress(address)} is not reachable.`);
+            }
+        });
     }
 
     /**
@@ -327,10 +313,15 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     /**
      * Terminate any active peer connection.
      */
-    async disconnect(address: PeerAddress, sendSessionClose = true) {
-        this.#clients.get(address)?.removeAllSubscriptions();
+    async disconnect(peer: PeerAddress | OperationalPeer, sendSessionClose = true) {
+        const address = this.get(peer)?.address;
+        if (address === undefined) {
+            return;
+        }
+
         await this.#sessions.removeAllSessionsForNode(address, sendSessionClose);
         await this.#channels.removeAllNodeChannels(address);
+        await this.#disconnected.emit(address);
     }
 
     /**
@@ -348,7 +339,6 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         await this.#store.deletePeer(address);
         await this.disconnect(address, false);
         await this.#sessions.deleteResumptionRecord(address);
-        this.#clients.delete(address);
     }
 
     async close() {
@@ -358,8 +348,11 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             // This ends discovery without triggering promises
             mdnsScanner?.cancelOperationalDeviceDiscovery(this.#sessions.fabricFor(address), address.nodeId, false);
         }
-        this.#clients.forEach(client => client.close());
-        this.#clients.clear();
+
+        for (const { address } of this.#peers) {
+            await this.disconnect(address, false);
+        }
+
         this.#interactionQueue.close();
         this.#runningPeerReconnections.forEach(({ rejecter }) =>
             rejecter(new ChannelNotConnectedError("PeerSet closed")),

package/src/peer/PhysicalDeviceProperties.ts

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Logger } from "#general";
+
+const logger = Logger.get("PhysicalDeviceProperties");
+
+const DEFAULT_SUBSCRIPTION_FLOOR_DEFAULT_S = 1;
+const DEFAULT_SUBSCRIPTION_FLOOR_ICD_S = 0;
+const DEFAULT_SUBSCRIPTION_CEILING_WIFI_S = 60;
+const DEFAULT_SUBSCRIPTION_CEILING_THREAD_S = 60;
+const DEFAULT_SUBSCRIPTION_CEILING_THREAD_SLEEPY_S = 180;
+const DEFAULT_SUBSCRIPTION_CEILING_BATTERY_POWERED_S = 600;
+
+export interface PhysicalDeviceProperties {
+    threadConnected: boolean;
+    wifiConnected: boolean;
+    ethernetConnected: boolean;
+    rootEndpointServerList: number[];
+    isBatteryPowered: boolean;
+    isIntermittentlyConnected: boolean;
+    isThreadSleepyEndDevice: boolean;
+}
+
+export namespace PhysicalDeviceProperties {
+    export function determineSubscriptionParameters(options?: {
+        properties?: PhysicalDeviceProperties;
+        description?: string;
+        subscribeMinIntervalFloorSeconds?: number;
+        subscribeMaxIntervalCeilingSeconds?: number;
+    }) {
+        const { properties } = options ?? {};
+
+        let {
+            description,
+            subscribeMinIntervalFloorSeconds: minIntervalFloorSeconds,
+            subscribeMaxIntervalCeilingSeconds: maxIntervalCeilingSeconds,
+        } = options ?? {};
+
+        if (description === undefined) {
+            description = "Node";
+        }
+
+        const { isBatteryPowered, isIntermittentlyConnected, threadConnected, isThreadSleepyEndDevice } =
+            properties ?? {};
+
+        if (isIntermittentlyConnected) {
+            if (minIntervalFloorSeconds !== undefined && minIntervalFloorSeconds !== DEFAULT_SUBSCRIPTION_FLOOR_ICD_S) {
+                logger.info(
+                    `${description}: Overwriting minIntervalFloorSeconds for intermittently connected device to ${DEFAULT_SUBSCRIPTION_FLOOR_ICD_S}`,
+                );
+                minIntervalFloorSeconds = DEFAULT_SUBSCRIPTION_FLOOR_ICD_S;
+            }
+        }
+
+        const defaultCeiling = isBatteryPowered
+            ? DEFAULT_SUBSCRIPTION_CEILING_BATTERY_POWERED_S
+            : isThreadSleepyEndDevice
+              ? DEFAULT_SUBSCRIPTION_CEILING_THREAD_SLEEPY_S
+              : threadConnected
+                ? DEFAULT_SUBSCRIPTION_CEILING_THREAD_S
+                : DEFAULT_SUBSCRIPTION_CEILING_WIFI_S;
+        if (maxIntervalCeilingSeconds === undefined) {
+            maxIntervalCeilingSeconds = defaultCeiling;
+        }
+        if (maxIntervalCeilingSeconds < defaultCeiling) {
+            logger.debug(
+                `${description}: maxIntervalCeilingSeconds ideally is ${defaultCeiling}s instead of ${maxIntervalCeilingSeconds}s due to device type`,
+            );
+        }
+
+        return {
+            minIntervalFloorSeconds: minIntervalFloorSeconds ?? DEFAULT_SUBSCRIPTION_FLOOR_DEFAULT_S,
+            maxIntervalCeilingSeconds,
+        };
+    }
+}

package/src/peer/index.ts

@@ -11,3 +11,4 @@ export * from "./OperationalPeer.js";
 export * from "./PeerAddress.js";
 export * from "./PeerAddressStore.js";
 export * from "./PeerSet.js";
+export * from "./PhysicalDeviceProperties.js";