@matter/protocol 0.16.0-alpha.0-20250816-d22ad240d → 0.16.0-alpha.0-20250819-0a388db8b

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@matter/protocol",
-    "version": "0.16.0-alpha.0-20250816-d22ad240d",
+    "version": "0.16.0-alpha.0-20250819-0a388db8b",
     "description": "Low-level APIs for Matter interaction",
     "keywords": [
         "iot",
@@ -40,13 +40,13 @@
         "#*": "./src/*"
     },
     "dependencies": {
-        "@matter/general": "0.16.0-alpha.0-20250816-d22ad240d",
-        "@matter/model": "0.16.0-alpha.0-20250816-d22ad240d",
-        "@matter/types": "0.16.0-alpha.0-20250816-d22ad240d"
+        "@matter/general": "0.16.0-alpha.0-20250819-0a388db8b",
+        "@matter/model": "0.16.0-alpha.0-20250819-0a388db8b",
+        "@matter/types": "0.16.0-alpha.0-20250819-0a388db8b"
     },
     "devDependencies": {
-        "@matter/tools": "0.16.0-alpha.0-20250816-d22ad240d",
-        "@matter/testing": "0.16.0-alpha.0-20250816-d22ad240d"
+        "@matter/tools": "0.16.0-alpha.0-20250819-0a388db8b",
+        "@matter/testing": "0.16.0-alpha.0-20250819-0a388db8b"
     },
     "files": [
         "dist/**/*",

package/src/action/Val.ts

@@ -32,6 +32,11 @@ export namespace Val {
      */
     export type Collection = Struct | List;
 
+    /**
+     * A readonly version of {@link Collection}.
+     */
+    export type ReadonlyCollection = { readonly [K: string | number]: Val } | ReadonlyArray<unknown>;
+
     /**
      * A Reference offers a simple mechanism for referring to properties by reference.
      */

package/src/action/client/ClientInteraction.ts

@@ -13,7 +13,7 @@ import { InvokeResult } from "#action/response/InvokeResult.js";
 import { ReadResult } from "#action/response/ReadResult.js";
 import { SubscribeResult } from "#action/response/SubscribeResult.js";
 import { WriteResult } from "#action/response/WriteResult.js";
-import { BasicSet, Environment, Environmental, ImplementationError, PromiseQueue } from "#general";
+import { BasicSet, Environment, Environmental, ImplementationError, PromiseQueue, Seconds } from "#general";
 import { InteractionClientMessenger, MessageType } from "#interaction/InteractionMessenger.js";
 import { InteractionQueue } from "#peer/InteractionQueue.js";
 import { ExchangeProvider } from "#protocol/ExchangeProvider.js";
@@ -27,7 +27,7 @@ export interface ClientInteractionContext {
     queue: PromiseQueue;
 }
 
-export const DEFAULT_MIN_INTERVAL_FLOOR_SECONDS = 1;
+export const DEFAULT_MIN_INTERVAL_FLOOR = Seconds(1);
 
 /**
  * Client-side implementation of the Matter protocol.
@@ -195,8 +195,8 @@ export class ClientInteraction<SessionT extends InteractionSession = Interaction
 
             await messenger.sendSubscribeRequest({
                 ...request,
-                minIntervalFloorSeconds: DEFAULT_MIN_INTERVAL_FLOOR_SECONDS,
-                maxIntervalCeilingSeconds: DEFAULT_MIN_INTERVAL_FLOOR_SECONDS,
+                minIntervalFloorSeconds: Seconds.of(DEFAULT_MIN_INTERVAL_FLOOR),
+                maxIntervalCeilingSeconds: Seconds.of(DEFAULT_MIN_INTERVAL_FLOOR),
             });
 
             await this.#handleSubscriptionResponse(request, readChunks(messenger));

package/src/action/client/ClientSubscription.ts

@@ -6,13 +6,14 @@
 
 import { Subscribe } from "#action/request/Subscribe.js";
 import { ActiveSubscription } from "#action/response/SubscribeResult.js";
+import { Timestamp } from "#general";
 
 /**
  * The client view of an established Matter subscription.
  */
 export interface ClientSubscription extends ActiveSubscription {
     request: Subscribe;
-    timeoutAtMs?: number;
+    timeoutAt?: Timestamp;
     isClosed: boolean;
     isReading: boolean;
 }

package/src/action/client/ClientSubscriptionHandler.ts

@@ -59,7 +59,7 @@ export class ClientSubscriptionHandler implements ProtocolHandler {
 
         // If this is just a ping, only reset the timeout
         if (!initialReport.attributeReports?.length && !initialReport.eventReports?.length) {
-            subscription.timeoutAtMs = undefined;
+            subscription.timeoutAt = undefined;
             this.#subscriptions.resetTimer();
             await exchange.close();
             return;
@@ -79,7 +79,7 @@ export class ClientSubscriptionHandler implements ProtocolHandler {
             }
         } finally {
             subscription.isReading = false;
-            subscription.timeoutAtMs = undefined;
+            subscription.timeoutAt = undefined;
             this.#subscriptions.resetTimer();
             await exchange.close();
         }

package/src/action/client/ClientSubscriptions.ts

@@ -14,9 +14,11 @@ import {
     Environment,
     Environmental,
     Logger,
+    Millis,
     Time,
     TimeoutError,
     Timer,
+    Timestamp,
 } from "#general";
 import { SubscriptionId } from "#interaction/Subscription.js";
 import { SubscribeResponse } from "#types";
@@ -46,7 +48,7 @@ export class ClientSubscriptions {
             ...response,
             request,
             close: () => this.#closeOne(subscription, new CanceledError()),
-            timeoutAtMs: undefined,
+            timeoutAt: undefined,
             isClosed: false,
             isReading: true,
         };
@@ -88,8 +90,8 @@ export class ClientSubscriptions {
      * Restart the timeout timer for the current set of active subscriptions.
      */
     resetTimer() {
-        const now = Time.nowMs();
-        let nextTimeoutAt: number | undefined;
+        const now = Time.nowMs;
+        let nextTimeoutAt: Timestamp | undefined;
 
         // Process each subscription
         for (const subscription of this.#subscriptions) {
@@ -99,10 +101,10 @@ export class ClientSubscriptions {
             }
 
             // Update timeout or expire if timed out
-            let { timeoutAtMs } = subscription;
+            let { timeoutAt: timeoutAtMs } = subscription;
             if (timeoutAtMs === undefined) {
                 // Set timeout time
-                timeoutAtMs = subscription.timeoutAtMs = timeoutFor(subscription);
+                timeoutAtMs = subscription.timeoutAt = timeoutFor(subscription);
             } else if (timeoutAtMs < now) {
                 // Timeout
                 this.#timeOut(subscription);
@@ -127,9 +129,13 @@ export class ClientSubscriptions {
             this.#nextTimeoutAt = nextTimeoutAt;
             if (this.#timeout) {
                 this.#timeout?.stop();
-                this.#timeout.intervalMs = nextTimeoutAt - now;
+                this.#timeout.interval = Millis(nextTimeoutAt - now);
             } else {
-                this.#timeout = Time.getTimer("SubscriptionTimeout", nextTimeoutAt - now, this.resetTimer.bind(this));
+                this.#timeout = Time.getTimer(
+                    "SubscriptionTimeout",
+                    Millis(nextTimeoutAt - now),
+                    this.resetTimer.bind(this),
+                );
             }
         }
     }
@@ -162,7 +168,7 @@ export class ClientSubscriptions {
 }
 
 function timeoutFor(subscription: ClientSubscription) {
-    return subscription.maxInterval * 1000 + (subscription.request.maxPeerResponseTime ?? 0);
+    return Timestamp(subscription.maxInterval * 1000 + (subscription.request.maxPeerResponseTime ?? 0));
 }
 
 export namespace ClientSubscriptions {

package/src/action/request/Subscribe.ts

@@ -5,7 +5,7 @@
  */
 
 import type { ReadResult } from "#action/response/ReadResult.js";
-import { CanceledError, TimeoutError, UINT16_MAX } from "#general";
+import { CanceledError, Duration, Seconds, TimeoutError, UINT16_MAX } from "#general";
 import { MalformedRequestError } from "./MalformedRequestError.js";
 import { Read } from "./Read.js";
 
@@ -17,9 +17,9 @@ import { Read } from "./Read.js";
  */
 export interface Subscribe extends Read {
     keepSubscriptions: boolean;
-    minIntervalFloorSeconds?: number;
-    maxIntervalCeilingSeconds?: number;
-    maxPeerResponseTime?: number;
+    minIntervalFloor?: Duration;
+    maxIntervalCeiling?: Duration;
+    maxPeerResponseTime?: Duration;
 
     /**
      * Invoked when subscribed data changes.
@@ -35,21 +35,23 @@ export interface Subscribe extends Read {
 export function Subscribe(options: Subscribe.Options, ...selectors: Read.Selector[]): Subscribe {
     const subscribe = Read(options, ...selectors) as unknown as Subscribe;
 
-    const { keepSubscriptions, minIntervalFloorSeconds, maxIntervalCeilingSeconds } = options;
+    const { keepSubscriptions, minIntervalFloor, maxIntervalCeiling } = options;
     subscribe.keepSubscriptions = keepSubscriptions ?? true;
 
-    if (minIntervalFloorSeconds !== undefined) {
-        if (minIntervalFloorSeconds < 0 || minIntervalFloorSeconds > UINT16_MAX) {
-            throw new MalformedRequestError(`Minimum interval floor ${minIntervalFloorSeconds} is out of range`);
+    if (minIntervalFloor !== undefined) {
+        if (minIntervalFloor < 0 || Seconds.of(minIntervalFloor) > UINT16_MAX) {
+            throw new MalformedRequestError(`Minimum interval floor ${Seconds.of(minIntervalFloor)} is out of range`);
         }
-        subscribe.minIntervalFloorSeconds = minIntervalFloorSeconds;
+        subscribe.minIntervalFloor = minIntervalFloor;
     }
 
-    if (maxIntervalCeilingSeconds !== undefined) {
-        if (maxIntervalCeilingSeconds < 0 || maxIntervalCeilingSeconds > UINT16_MAX) {
-            throw new MalformedRequestError(`Maximum interval ceiling ${maxIntervalCeilingSeconds} is out of range`);
+    if (maxIntervalCeiling !== undefined) {
+        if (maxIntervalCeiling < 0 || Seconds.of(maxIntervalCeiling) > UINT16_MAX) {
+            throw new MalformedRequestError(
+                `Maximum interval ceiling ${Seconds.of(maxIntervalCeiling)} is out of range`,
+            );
         }
-        subscribe.maxIntervalCeilingSeconds = maxIntervalCeilingSeconds;
+        subscribe.maxIntervalCeiling = maxIntervalCeiling;
     }
 
     return subscribe;
@@ -58,8 +60,8 @@ export function Subscribe(options: Subscribe.Options, ...selectors: Read.Selecto
 export namespace Subscribe {
     export interface Options extends Read.Options {
         keepSubscriptions?: boolean;
-        minIntervalFloorSeconds?: number;
-        maxIntervalCeilingSeconds?: number;
+        minIntervalFloor?: Duration;
+        maxIntervalCeiling?: Duration;
         update?: Subscribe["updated"];
         closed?: Subscribe["closed"];
     }

package/src/advertisement/Advertisement.ts

@@ -4,8 +4,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { asError, CancelablePromise, CanceledError, Diagnostic, Logger, MatterAggregateError, Time } from "#general";
-import { STANDARD_COMMISSIONING_TIMEOUT_S } from "#types";
+import {
+    asError,
+    CancelablePromise,
+    CanceledError,
+    Diagnostic,
+    Duration,
+    Logger,
+    MatterAggregateError,
+    Time,
+    Timespan,
+} from "#general";
+import { STANDARD_COMMISSIONING_TIMEOUT } from "#types";
 import type { Advertiser } from "./Advertiser.js";
 import { ServiceDescription } from "./ServiceDescription.js";
 
@@ -39,7 +49,7 @@ export abstract class Advertisement<T extends ServiceDescription = ServiceDescri
 
     #isBroadcasting = false;
     #closed?: Promise<void>;
-    #startedAt = Time.nowMs();
+    #startedAt = Time.nowMs;
 
     /**
      * Current activity.  This is a promise with helpers for base implementations.
@@ -163,7 +173,7 @@ export abstract class Advertisement<T extends ServiceDescription = ServiceDescri
         }
 
         // Extended announcement
-        if (Time.nowMs() - this.#startedAt >= STANDARD_COMMISSIONING_TIMEOUT_S * 1000) {
+        if (this.duration >= STANDARD_COMMISSIONING_TIMEOUT) {
             return true;
         }
 
@@ -210,7 +220,7 @@ export abstract class Advertisement<T extends ServiceDescription = ServiceDescri
      * Total duration so far.
      */
     get duration() {
-        return Time.nowMs() - this.#startedAt;
+        return Timespan(this.#startedAt, Time.nowMs).duration;
     }
 
     /**
@@ -292,7 +302,7 @@ export namespace Advertisement {
          * Throws {@link CanceledError} if interrupted.  If thrown from {@link run} this will result in the promise
          * resolving.
          */
-        sleep(name: string, intervalMs: number): Promise<void>;
+        sleep(name: string, duration: Duration): Promise<void>;
     }
 }
 
@@ -316,10 +326,10 @@ class ActivityContext extends CancelablePromise implements Advertisement.Activit
         });
     }
 
-    sleep(name: string, intervalMs: number) {
+    sleep(name: string, duration: Duration) {
         this.abortIfCanceled();
 
-        const sleep = Time.sleep(name, intervalMs).finally(() => {
+        const sleep = Time.sleep(name, duration).finally(() => {
             if (this.#sleep === sleep) {
                 this.#sleep = undefined;
             }

package/src/advertisement/ble/BleAdvertisement.ts

@@ -5,18 +5,19 @@
  */
 
 import { BtpCodec } from "#codec/BtpCodec.js";
+import { Days, Duration, Millis, Minutes, Seconds } from "#general";
 import { Advertisement } from "../Advertisement.js";
 import { ServiceDescription } from "../ServiceDescription.js";
 import type { BleAdvertiser } from "./BleAdvertiser.js";
 
 // Period for "fast" broadcast.  See core spec 5.4.2.5.3
-const EARLY_INTERVAL_SLEEP = 30_000;
+const EARLY_INTERVAL_SLEEP = Seconds(30);
 
 // Period for "medium" broadcast.  See core spec 5.4.2.5.3
-const LATE_INTERVAL_SLEEP = 15 * 60_000 - EARLY_INTERVAL_SLEEP;
+const LATE_INTERVAL_SLEEP = Millis(Minutes(15) - EARLY_INTERVAL_SLEEP);
 
 // Period for "extended" broadcast.  See core spec 5.4.2.5.3
-const EXTENDED_INTERVAL_SLEEP = 48 * 60 * 60_000 - LATE_INTERVAL_SLEEP;
+const EXTENDED_INTERVAL_SLEEP = Millis(Days(2) - LATE_INTERVAL_SLEEP);
 
 export class BleAdvertisement extends Advertisement<ServiceDescription.Commissionable> {
     declare advertiser: BleAdvertiser;
@@ -58,10 +59,10 @@ export class BleAdvertisement extends Advertisement<ServiceDescription.Commissio
                 await peripheral.advertise(advertisementData, aad, broadcastInterval);
 
                 // Wait for timeout at this broadcast interval
-                await context.sleep("BLE advertisement interval", Math.min(timeout, sleepTime));
+                await context.sleep("BLE advertisement interval", Duration.min(timeout, sleepTime));
 
-                timeout -= sleepTime;
-                if ((timeout -= sleepTime) <= 0) {
+                timeout = Millis(timeout - sleepTime);
+                if (timeout <= 0) {
                     break;
                 }
             }

package/src/advertisement/ble/BleAdvertiser.ts

@@ -5,9 +5,9 @@
  */
 
 import { BlePeripheralInterface } from "#ble/Ble.js";
-import { ImplementationError } from "#general";
+import { Bytes, Duration, ImplementationError, Millis } from "#general";
 import { DatatypeModel, FieldElement } from "#model";
-import { MAXIMUM_COMMISSIONING_TIMEOUT_S } from "#types";
+import { MAXIMUM_COMMISSIONING_TIMEOUT } from "#types";
 import { Advertisement } from "../Advertisement.js";
 import { Advertiser } from "../Advertiser.js";
 import { CommissioningMode } from "../CommissioningMode.js";
@@ -61,43 +61,43 @@ export namespace BleAdvertiser {
         /**
          * Additional advertisement data.
          */
-        readonly aad?: BufferSource;
+        readonly aad?: Bytes;
 
         /**
          * Advertisement timeout.
          */
-        readonly timeout: number;
+        readonly timeout: Duration;
 
         /**
          * Transmission interval for first 30 seconds.
          *
          * Per core spec 5.4.2.5.3 should be 20-60ms.
          */
-        readonly earlyInterval: number;
+        readonly earlyInterval: Duration;
 
         /**
          * Transmission interval after first 30 seconds but before 15 minutes.
          *
          * Per core spec 5.4.2.5.3 should be 150-1285ms.
          */
-        readonly lateInterval: number;
+        readonly lateInterval: Duration;
 
         /**
          * Transmission interval after 15 minutes.
          *
          * Per core spec 5.4.2.5.3 should be ~1285ms.
          */
-        readonly extendedInterval: number;
+        readonly extendedInterval: Duration;
     }
 
     export interface Options extends Partial<Configuration> {}
 
     export function Configuration(options?: Options) {
         return {
-            timeout: MAXIMUM_COMMISSIONING_TIMEOUT_S,
-            earlyInterval: 20,
-            lateInterval: 150,
-            extendedInterval: 1285,
+            timeout: MAXIMUM_COMMISSIONING_TIMEOUT,
+            earlyInterval: Millis(20),
+            lateInterval: Millis(150),
+            extendedInterval: Millis(1285),
             ...options,
         };
     }

package/src/advertisement/mdns/MdnsAdvertisement.ts

@@ -8,7 +8,18 @@ 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 {
+    AAAARecord,
+    ARecord,
+    DnsRecord,
+    Duration,
+    Logger,
+    NetworkInterfaceDetails,
+    SrvRecord,
+    Time,
+    Timestamp,
+    TxtRecord,
+} from "#general";
 import type { MdnsServer } from "#mdns/MdnsServer.js";
 import { SessionIntervals } from "#session/SessionIntervals.js";
 import type { MdnsAdvertiser } from "./MdnsAdvertiser.js";
@@ -29,7 +40,7 @@ export abstract class MdnsAdvertisement<T extends ServiceDescription = ServiceDe
     qname: string;
 
     #isPrivacyMasked: boolean;
-    #stopAt?: number;
+    #stopAt?: Timestamp;
 
     constructor(advertiser: MdnsAdvertiser, qname: string, description: T) {
         description = {
@@ -51,12 +62,12 @@ export abstract class MdnsAdvertisement<T extends ServiceDescription = ServiceDe
         this.#stopAt = undefined;
         let number = 0;
         for (const retryInterval of this.advertiser.broadcastScheduleFor(this, event)) {
-            if (this.#stopAt !== undefined && this.#stopAt <= Time.nowMs()) {
+            if (this.#stopAt !== undefined && this.#stopAt <= Time.nowMs) {
                 break;
             }
 
             number++;
-            logger.debug("Broadcast", this.dict({ number, next: retryInterval }));
+            logger.debug("Broadcast", this.dict({ number, next: Duration.format(retryInterval) }));
             await this.broadcast();
             await context.sleep("MDNS repeat", retryInterval);
         }
@@ -78,7 +89,7 @@ export abstract class MdnsAdvertisement<T extends ServiceDescription = ServiceDe
      * Broadcast expiration announcement immediately.
      */
     async expire() {
-        logger.info("Unpublishing", this.dict({ time: this.duration }));
+        logger.info("Unpublishing", this.dict({ time: Duration.format(this.duration) }));
         await this.advertiser.server.expireAnnouncements(this.service);
     }
 
@@ -94,7 +105,7 @@ export abstract class MdnsAdvertisement<T extends ServiceDescription = ServiceDe
             return;
         }
 
-        this.#stopAt = Time.nowMs() + broadcastAfterConnection;
+        this.#stopAt = Timestamp(Time.nowMs + broadcastAfterConnection);
     }
 
     override serviceDisconnected() {
@@ -148,9 +159,9 @@ export abstract class MdnsAdvertisement<T extends ServiceDescription = ServiceDe
 
     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 */,
+            SII: this.description.idleInterval /* Session Idle Interval */,
+            SAI: this.description.activeInterval /* Session Active Interval */,
+            SAT: this.description.activeThreshold /* Session Active Threshold */,
             ...this.txtValues,
         };
 

package/src/advertisement/mdns/MdnsAdvertiser.ts

@@ -6,10 +6,20 @@
 
 import { Advertiser } from "#advertisement/Advertiser.js";
 import { ServiceDescription } from "#advertisement/ServiceDescription.js";
-import { Bytes, Crypto, ImplementationError, InternalError, RetrySchedule, STANDARD_MATTER_PORT } from "#general";
+import {
+    Bytes,
+    Crypto,
+    Duration,
+    ImplementationError,
+    Instant,
+    InternalError,
+    RetrySchedule,
+    Seconds,
+    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 { MAXIMUM_COMMISSIONING_TIMEOUT } from "#types";
 import { CommissionableMdnsAdvertisement } from "./CommissionableMdnsAdvertisement.js";
 import { CommissionerMdnsAdvertisement } from "./CommissionerMdnsAdvertisement.js";
 import type { MdnsAdvertisement } from "./MdnsAdvertisement.js";
@@ -188,7 +198,7 @@ export namespace MdnsAdvertiser {
          * 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;
+        readonly broadcastAfterConnection?: Duration;
     }
 
     /**
@@ -196,23 +206,23 @@ export namespace MdnsAdvertiser {
      */
     export const DefaultBroadcastSchedule: BroadcastSchedule = {
         // Mandated by MDNS specification
-        initialInterval: 1_000,
+        initialInterval: Seconds.one,
 
         // Maximum commissioning timeout per Matter specification 5.4.2.3.1, although
-        timeout: MAXIMUM_COMMISSIONING_TIMEOUT_S * 1000,
+        timeout: MAXIMUM_COMMISSIONING_TIMEOUT,
 
         // 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,
+        maximumInterval: Seconds(90),
 
         // 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,
+        broadcastAfterConnection: Instant,
     };
 
     /**

package/src/ble/Ble.ts

@@ -4,7 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Bytes, Channel, ChannelType, MatterError, NetInterface, NoProviderError, TransportInterface } from "#general";
+import {
+    Bytes,
+    Channel,
+    ChannelType,
+    Duration,
+    MatterError,
+    NetInterface,
+    NoProviderError,
+    TransportInterface,
+} from "#general";
 import { Scanner } from "../common/Scanner.js";
 import { BLE_MAX_MATTER_PAYLOAD_SIZE } from "./BleConsts.js";
 
@@ -28,7 +37,7 @@ export abstract class Ble {
 }
 
 export interface BlePeripheralInterface extends TransportInterface {
-    advertise(advertiseData: Bytes, additionalAdvertisementData?: Bytes, intervalMs?: number): Promise<void>;
+    advertise(advertiseData: Bytes, additionalAdvertisementData?: Bytes, interval?: Duration): Promise<void>;
     stopAdvertising(): Promise<void>;
 }
 

package/src/ble/BleConsts.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { MAX_UDP_MESSAGE_SIZE } from "#general";
+import { MAX_UDP_MESSAGE_SIZE, Millis, Seconds } from "#general";
 
 /** @see {@link MatterSpecification.v11.Core} § 4.17.3.2 */
 export const BLE_MATTER_SERVICE_UUID_SHORT = "fff6";
@@ -22,18 +22,18 @@ export const BTP_MAXIMUM_WINDOW_SIZE = 255; // Server maximum window size
  * The maximum amount of time after sending a BTP Session Handshake request to wait for a BTP Session Handshake response
  * before closing the connection.
  */
-export const BTP_CONN_RSP_TIMEOUT_MS = 5_000; // timer starts when receives handshake request & waits for a subscription request on c2
+export const BTP_CONN_RSP_TIMEOUT = Seconds(5); // timer starts when receives handshake request & waits for a subscription request on c2
 
 /** The maximum amount of time after receipt of a segment before a stand-alone ACK must be sent. */
-export const BTP_ACK_TIMEOUT_MS = 15_000; // timer in ms before ack should be sent for a segment
+export const BTP_ACK_TIMEOUT = Seconds(15); // timer in ms before ack should be sent for a segment
 
-export const BTP_SEND_ACK_TIMEOUT_MS = BTP_ACK_TIMEOUT_MS / 3; // timer starts when we receive a packet and stops when we sends its ack
+export const BTP_SEND_ACK_TIMEOUT = Millis(BTP_ACK_TIMEOUT / 3); // timer starts when we receive a packet and stops when we sends its ack
 
 /**
  * The maximum amount of time no unique data has been sent over a BTP session before the Central Device must close the
  * BTP session.
  */
-export const BTP_CONN_IDLE_TIMEOUT = 30_000;
+export const BTP_CONN_IDLE_TIMEOUT = Seconds(30);
 
 /**
  * The maximum message size that can be transported in a Matter message via BTP.

package/src/ble/BtpSessionHandler.ts

@@ -9,10 +9,10 @@ import { BtpCodec } from "../codec/BtpCodec.js";
 import {
     BLE_MAXIMUM_BTP_MTU,
     BLE_MINIMUM_ATT_MTU,
-    BTP_ACK_TIMEOUT_MS,
+    BTP_ACK_TIMEOUT,
     BTP_CONN_IDLE_TIMEOUT,
     BTP_MAXIMUM_WINDOW_SIZE,
-    BTP_SEND_ACK_TIMEOUT_MS,
+    BTP_SEND_ACK_TIMEOUT,
 } from "./BleConsts.js";
 
 export class BtpMatterError extends MatterError {}
@@ -29,7 +29,7 @@ export class BtpSessionHandler {
     private currentIncomingSegmentedPayload: Bytes | undefined;
     private prevIncomingSequenceNumber = 255; // Incoming Sequence Number received. Set to 255 to start at 0
     private prevIncomingAckNumber = -1; // Previous ackNumber received
-    private readonly ackReceiveTimer = Time.getTimer("BTP ack timeout", BTP_ACK_TIMEOUT_MS, () =>
+    private readonly ackReceiveTimer = Time.getTimer("BTP ack timeout", BTP_ACK_TIMEOUT, () =>
         this.btpAckTimeoutTriggered(),
     );
 
@@ -37,7 +37,7 @@ export class BtpSessionHandler {
     private prevAckedSequenceNumber = -1; // Previous (outgoing) Acked Sequence Number
     private readonly queuedOutgoingMatterMessages = new Array<DataReader<Endian.Little>>();
     private sendInProgress = false;
-    private readonly sendAckTimer = Time.getTimer("BTP send timeout", BTP_SEND_ACK_TIMEOUT_MS, () =>
+    private readonly sendAckTimer = Time.getTimer("BTP send timeout", BTP_SEND_ACK_TIMEOUT, () =>
         this.btpSendAckTimeoutTriggered(),
     );
     private isActive = true;