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

package/src/behavior/system/{subscription/SubscriptionBehavior.ts → subscriptions/SubscriptionsServer.ts}

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { deepCopy, isIpNetworkChannel, Logger, MatterError, MaybePromise, ServerAddressIp } from "#general";
+import { deepCopy, isIpNetworkChannel, Logger, MatterError, MaybePromise, Seconds, ServerAddressIp } from "#general";
 import { DatatypeModel, FieldElement } from "#model";
 import { InteractionServer, PeerSubscription } from "#node/server/InteractionServer.js";
 import { ServerSubscription } from "#node/server/ServerSubscription.js";
@@ -21,10 +21,10 @@ import {
 import { StatusCode, StatusResponseError } from "#types";
 import { Behavior } from "../../Behavior.js";
 import { SessionsBehavior } from "../sessions/SessionsBehavior.js";
-const logger = Logger.get("SubscriptionBehavior");
+const logger = Logger.get("SubscriptionsBehavior");
 
 /** Timeout in seconds to wait for responses or discovery of the peer node when trying to re-establish a subscription. */
-const REESTABLISH_SUBSCRIPTIONS_TIMEOUT_S = 2;
+const REESTABLISH_SUBSCRIPTIONS_TIMEOUT = Seconds(2);
 
 /**
  * Subscriptions Persistence handling.
@@ -33,11 +33,11 @@ const REESTABLISH_SUBSCRIPTIONS_TIMEOUT_S = 2;
  * speed up the controller reconnection process. This can mean a bit more memory usage on start of the device. To
  * disable this feature set `persistenceEnabled` as state of the `subscription` behavior to `false`.
  */
-export class SubscriptionBehavior extends Behavior {
-    static override readonly id = "subscription";
+export class SubscriptionsBehavior extends Behavior {
+    static override readonly id = "subscriptions";
 
-    declare state: SubscriptionBehavior.State;
-    declare internal: SubscriptionBehavior.Internal;
+    declare state: SubscriptionsBehavior.State;
+    declare internal: SubscriptionsBehavior.Internal;
 
     override initialize() {
         if (this.state.subscriptions !== undefined && this.state.persistenceEnabled !== false) {
@@ -115,10 +115,10 @@ export class SubscriptionBehavior extends Behavior {
                     ),
                 ),
                 FieldElement({ name: "isFabricFiltered", type: "bool" }),
-                FieldElement({ name: "maxIntervalCeilingSeconds", type: "uint16" }),
-                FieldElement({ name: "minIntervalFloorSeconds", type: "uint16" }),
-                FieldElement({ name: "maxInterval", type: "uint16" }),
-                FieldElement({ name: "sendInterval", type: "uint16" }),
+                FieldElement({ name: "maxIntervalCeiling", type: "duration" }),
+                FieldElement({ name: "minIntervalFloor", type: "duration" }),
+                FieldElement({ name: "maxInterval", type: "duration" }),
+                FieldElement({ name: "sendInterval", type: "duration" }),
                 FieldElement(
                     {
                         name: "operationalAddress",
@@ -142,8 +142,8 @@ export class SubscriptionBehavior extends Behavior {
             maxInterval,
             sendInterval,
             id,
-            maxIntervalCeilingSeconds,
-            minIntervalFloorSeconds,
+            maxIntervalCeiling,
+            minIntervalFloor,
         } = subscription;
         const { peerAddress } = session;
         const { fabricIndex, nodeId } = peerAddress;
@@ -160,8 +160,8 @@ export class SubscriptionBehavior extends Behavior {
         const peerSubscription: PeerSubscription = {
             subscriptionId: id,
             peerAddress: { fabricIndex, nodeId },
-            maxIntervalCeilingSeconds,
-            minIntervalFloorSeconds,
+            maxIntervalCeiling,
+            minIntervalFloor,
             attributeRequests,
             eventRequests,
             isFabricFiltered,
@@ -234,7 +234,7 @@ export class SubscriptionBehavior extends Behavior {
                     await peers.ensureConnection(peerAddress, {
                         discoveryOptions: {
                             discoveryType: NodeDiscoveryType.TimedDiscovery,
-                            timeoutSeconds: REESTABLISH_SUBSCRIPTIONS_TIMEOUT_S,
+                            timeout: REESTABLISH_SUBSCRIPTIONS_TIMEOUT,
                         },
                         allowUnknownPeer: true,
                         operationalAddress,
@@ -282,7 +282,7 @@ export class SubscriptionBehavior extends Behavior {
     }
 }
 
-export namespace SubscriptionBehavior {
+export namespace SubscriptionsBehavior {
     export class State {
         /** Set to false if persistence of subscriptions should be disabled */
         persistenceEnabled = true;

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

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from "./SubscriptionsServer.js";

package/src/behaviors/administrator-commissioning/AdministratorCommissioningServer.ts

@@ -5,14 +5,14 @@
  */
 
 import { AdministratorCommissioning } from "#clusters/administrator-commissioning";
-import { InternalError, Logger, Time, Timer } from "#general";
+import { Duration, InternalError, Logger, Seconds, Time, Timer } from "#general";
 import { AccessLevel } from "#model";
 import { DeviceCommissioner, FailsafeContext, PaseServer, SessionManager } from "#protocol";
 import {
     Command,
-    MINIMUM_COMMISSIONING_TIMEOUT_S,
+    MINIMUM_COMMISSIONING_TIMEOUT,
     PAKE_PASSCODE_VERIFIER_LENGTH,
-    STANDARD_COMMISSIONING_TIMEOUT_S,
+    STANDARD_COMMISSIONING_TIMEOUT,
     Status,
     StatusResponseError,
     TlvByteString,
@@ -86,10 +86,12 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
 
         const commissioner = this.env.get(DeviceCommissioner);
 
-        this.#assertCommissioningWindowRequirements(commissioningTimeout, commissioner);
+        const timeout = Seconds(commissioningTimeout);
+
+        this.#assertCommissioningWindowRequirements(timeout, commissioner);
 
         this.#initializeCommissioningWindow(
-            commissioningTimeout,
+            timeout,
             AdministratorCommissioning.CommissioningWindowStatus.EnhancedWindowOpen,
         );
 
@@ -109,10 +111,12 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
     }: AdministratorCommissioning.OpenBasicCommissioningWindowRequest) {
         const commissioner = this.env.get(DeviceCommissioner);
 
-        this.#assertCommissioningWindowRequirements(commissioningTimeout, commissioner);
+        const timeout = Seconds(commissioningTimeout);
+
+        this.#assertCommissioningWindowRequirements(timeout, commissioner);
 
         this.#initializeCommissioningWindow(
-            commissioningTimeout,
+            timeout,
             AdministratorCommissioning.CommissioningWindowStatus.BasicWindowOpen,
         );
 
@@ -144,7 +148,7 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
      * adjusts the needed attributes.
      */
     #initializeCommissioningWindow(
-        commissioningTimeout: number,
+        commissioningTimeout: Duration,
         windowStatus: AdministratorCommissioning.CommissioningWindowStatus,
     ) {
         if (this.internal.commissioningWindowTimeout !== undefined) {
@@ -156,7 +160,7 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
         );
         this.internal.commissioningWindowTimeout = Time.getTimer(
             "Commissioning timeout",
-            commissioningTimeout * 1000,
+            commissioningTimeout,
             this.callback(this.#commissioningTimeout),
         ).start();
 
@@ -178,21 +182,21 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
     /**
      * This method validates if a commissioning window can be opened and throws various exceptions in case of failures.
      */
-    #assertCommissioningWindowRequirements(commissioningTimeout: number, commissioner: DeviceCommissioner) {
+    #assertCommissioningWindowRequirements(commissioningTimeout: Duration, commissioner: DeviceCommissioner) {
         if (this.internal.commissioningWindowTimeout !== undefined) {
             throw new AdministratorCommissioning.BusyError("A commissioning window is already opened");
         }
 
-        if (commissioningTimeout > this.internal.maximumCommissioningTimeoutS) {
+        if (commissioningTimeout > this.internal.maximumCommissioningTimeout) {
             throw new StatusResponseError(
-                `Commissioning timeout must not exceed ${this.internal.maximumCommissioningTimeoutS} seconds.`,
+                `Commissioning timeout must not exceed ${this.internal.maximumCommissioningTimeout} seconds.`,
                 Status.InvalidCommand,
             );
         }
 
-        if (commissioningTimeout < this.internal.minimumCommissioningTimeoutS) {
+        if (commissioningTimeout < this.internal.minimumCommissioningTimeout) {
             throw new StatusResponseError(
-                `Commissioning timeout must not be lower then ${this.internal.minimumCommissioningTimeoutS} seconds.`,
+                `Commissioning timeout must not be lower then ${this.internal.minimumCommissioningTimeout} seconds.`,
                 Status.InvalidCommand,
             );
         }
@@ -261,13 +265,13 @@ export namespace AdministratorCommissioningServer {
         /**
          * Mandated by spec; should only be modified in testing.
          */
-        minimumCommissioningTimeoutS = MINIMUM_COMMISSIONING_TIMEOUT_S;
+        minimumCommissioningTimeout = MINIMUM_COMMISSIONING_TIMEOUT;
 
         /**
          * Commissioning beyond the standard 15-minute window is "extended commissioning" and has limitations on
          * advertisement.  We default to the standard window.
          */
-        maximumCommissioningTimeoutS = STANDARD_COMMISSIONING_TIMEOUT_S;
+        maximumCommissioningTimeout = STANDARD_COMMISSIONING_TIMEOUT;
     }
 
     export class State extends AdministratorCommissioningBehavior.State {

package/src/behaviors/color-control/ColorControlServer.ts

@@ -19,6 +19,7 @@ import {
     ImplementationError,
     Logger,
     MaybePromise,
+    Millis,
 } from "#general";
 import { ServerNode } from "#node/ServerNode.js";
 import { Val } from "#protocol";
@@ -1671,8 +1672,8 @@ export class ColorControlBaseServer extends ColorControlBase {
                 return readOnlyState.transitionEndTimeMs;
             },
 
-            get stepIntervalMs() {
-                return readOnlyState.transitionStepIntervalMs;
+            get stepInterval() {
+                return readOnlyState.transitionStepInterval;
             },
 
             properties: {
@@ -1803,12 +1804,12 @@ export namespace ColorControlBaseServer {
          * If transition management is disabled you may specify this as the "end time" for transitions.  The remaining
          * time attribute will then report correctly.
          */
-        transitionEndTimeMs = undefined;
+        transitionEndTimeMs?: number;
 
         /**
          * When managing transitions, this is the interval at which steps occur in ms.
          */
-        transitionStepIntervalMs = 100;
+        transitionStepInterval = Millis(100);
 
         [Val.properties](endpoint: Endpoint) {
             // Only return remaining time if the attribute is defined in the endpoint

package/src/behaviors/general-commissioning/GeneralCommissioningServer.ts

@@ -8,7 +8,7 @@ import { AdministratorCommissioningServer } from "#behaviors/administrator-commi
 import { BasicInformationServer } from "#behaviors/basic-information";
 import { AdministratorCommissioning } from "#clusters/administrator-commissioning";
 import { GeneralCommissioning } from "#clusters/general-commissioning";
-import { Bytes, Diagnostic, Logger, MatterFlowError, MaybePromise } from "#general";
+import { Bytes, Diagnostic, Logger, MatterFlowError, MaybePromise, Seconds } from "#general";
 import type { ServerNode } from "#node/ServerNode.js";
 import { DeviceCommissioner, FabricManager, GroupSession, NodeSession, SecureSession, SessionManager } from "#protocol";
 import { GeneralCommissioningBehavior } from "./GeneralCommissioningBehavior.js";
@@ -80,7 +80,7 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
             }
 
             if (commissioner.isFailsafeArmed) {
-                await commissioner.failsafeContext.extend(session.fabric, expiryLengthSeconds);
+                await commissioner.failsafeContext.extend(session.fabric, Seconds(expiryLengthSeconds));
             } else {
                 // If ExpiryLengthSeconds is 0 and the fail-safe timer was not armed, then this command invocation SHALL
                 // lead to a success response with no side effect against the fail-safe context.
@@ -89,8 +89,8 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
                 const failsafe = new ServerNodeFailsafeContext(this.endpoint as ServerNode, {
                     fabrics: this.env.get(FabricManager),
                     sessions: this.env.get(SessionManager),
-                    expiryLengthSeconds,
-                    maxCumulativeFailsafeSeconds: this.state.basicCommissioningInfo.maxCumulativeFailsafeSeconds,
+                    expiryLength: Seconds(expiryLengthSeconds),
+                    maxCumulativeFailsafe: Seconds(this.state.basicCommissioningInfo.maxCumulativeFailsafeSeconds),
                     associatedFabric: session.fabric,
                 });
 

package/src/behaviors/general-diagnostics/GeneralDiagnosticsServer.ts

@@ -11,7 +11,21 @@ import { NetworkCommissioningServer } from "#behaviors/network-commissioning";
 import { TimeSynchronizationBehavior } from "#behaviors/time-synchronization";
 import { GeneralDiagnostics } from "#clusters/general-diagnostics";
 import type { Endpoint } from "#endpoint/Endpoint.js";
-import { Bytes, ImplementationError, ipv4ToBytes, Logger, MaybePromise, Time, Timer } from "#general";
+import {
+    Bytes,
+    Duration,
+    Hours,
+    ImplementationError,
+    ipv4ToBytes,
+    Logger,
+    MaybePromise,
+    Millis,
+    Minutes,
+    Seconds,
+    Time,
+    Timer,
+    Timespan,
+} from "#general";
 import { FieldElement, Specification } from "#model";
 import type { NodeLifecycle } from "#node/NodeLifecycle.js";
 import { MdnsService, Val } from "#protocol";
@@ -105,7 +119,7 @@ export class GeneralDiagnosticsServer extends Base {
     }
 
     override timeSnapshot(): MaybePromise<GeneralDiagnostics.TimeSnapshotResponse> {
-        const time = Time.nowMs();
+        const time = Time.nowMs;
 
         // TC_DGGEN_2_4.py fails us if we set this without TimeSynchronizationCluster support.  Spec is worded poorly
         // but my read of "SHALL only if" is "may not unless" and not "SHALL if and only if".  But conforming to tests
@@ -294,11 +308,11 @@ export class GeneralDiagnosticsServer extends Base {
         );
 
         // Update the timestamps now that node is really online.
-        this.internal.lastTotalOperationalHoursCounterUpdateTime = Time.nowMs();
+        this.internal.lastTotalOperationalHoursCounterUpdateTime = Time.nowMs;
 
         this.internal.lastTotalOperationalHoursTimer = Time.getPeriodicTimer(
             "GeneralDiagnostics.operationalHours",
-            5 * 60_000,
+            Minutes(5),
             this.callback(this.#updateTotalOperationalHoursCounter),
         ).start();
 
@@ -311,9 +325,9 @@ export class GeneralDiagnosticsServer extends Base {
     }
 
     #updateTotalOperationalHoursCounter() {
-        const now = Time.nowMs();
-        const elapsedTime = now - this.internal.lastTotalOperationalHoursCounterUpdateTime;
-        this.state.totalOperationalHoursCounter = this.state.totalOperationalHoursCounter + elapsedTime;
+        const now = Time.nowMs;
+        const elapsedTime = Timespan(this.internal.lastTotalOperationalHoursCounterUpdateTime, now).duration;
+        this.state.totalOperationalHoursCounter = Millis(this.state.totalOperationalHoursCounter + elapsedTime);
         this.internal.lastTotalOperationalHoursCounterUpdateTime = now;
     }
 
@@ -382,15 +396,15 @@ export class GeneralDiagnosticsServer extends Base {
 export namespace GeneralDiagnosticsServer {
     export class Internal {
         /** Last time the total operational hours counter was updated. */
-        lastTotalOperationalHoursCounterUpdateTime: number = Time.nowMs();
+        lastTotalOperationalHoursCounterUpdateTime = Time.nowMs;
 
         /** Timer to update the total operational hours counter every 5 minutes. */
         lastTotalOperationalHoursTimer: Timer | undefined;
     }
 
     export class State extends Base.State {
-        /** Internal counter of the total operational hours, counted in seconds, updated every 5 minutes. */
-        totalOperationalHoursCounter: number = 0;
+        /** Internal counter of the total time, updated every 5 minutes. */
+        totalOperationalHoursCounter: Duration = 0;
 
         /** The TestEnableKey set for this device for the test commands. Default means "not enabled"." */
         deviceTestEnableKey: Bytes = new Uint8Array(16).fill(0);
@@ -415,7 +429,7 @@ export namespace GeneralDiagnosticsServer {
                         return 0;
                     }
 
-                    return Math.round((Time.nowMs() - onlineAt.getTime()) / 1000);
+                    return Seconds.of(Timespan(onlineAt, Time.nowMs).duration);
                 },
 
                 /**
@@ -423,16 +437,19 @@ export namespace GeneralDiagnosticsServer {
                  * is not send out via subscriptions anyway.
                  */
                 get totalOperationalHours() {
-                    const lastTotalOperationalHoursCounterUpdateTime =
-                        endpoint.behaviors.internalsOf(
-                            GeneralDiagnosticsServer,
-                        ).lastTotalOperationalHoursCounterUpdateTime;
-                    const totalOperationalHoursCounter =
-                        endpoint.stateOf(GeneralDiagnosticsServer).totalOperationalHoursCounter;
-                    return Math.floor(
-                        (Time.nowMs() - lastTotalOperationalHoursCounterUpdateTime + totalOperationalHoursCounter) /
-                            (60 * 60_000),
-                    );
+                    const { lastTotalOperationalHoursCounterUpdateTime } =
+                        endpoint.behaviors.internalsOf(GeneralDiagnosticsServer);
+
+                    const timeSinceLastUpdate = Timespan(
+                        lastTotalOperationalHoursCounterUpdateTime,
+                        Time.nowMs,
+                    ).duration;
+
+                    const timeAsOfLastUpdate = endpoint.stateOf(GeneralDiagnosticsServer).totalOperationalHoursCounter;
+
+                    const totalOperationalTime = Millis(timeAsOfLastUpdate + timeSinceLastUpdate);
+
+                    return Hours.of(totalOperationalTime);
                 },
             };
         }

package/src/behaviors/identify/IdentifyServer.ts

@@ -5,7 +5,7 @@
  */
 
 import { Identify } from "#clusters/identify";
-import { MaybePromise, Observable, Time, Timer } from "#general";
+import { MaybePromise, Observable, Seconds, Time, Timer } from "#general";
 import { IdentifyBehavior } from "./IdentifyBehavior.js";
 
 /**
@@ -37,7 +37,7 @@ export class IdentifyServer extends IdentifyBehavior {
         // Enable I/2.4 once this is done
         this.internal.identifyTimer = Time.getPeriodicTimer(
             "Identify time update",
-            1000,
+            Seconds.one,
             this.callback(this.#identifyTick, { lock: true }),
         );
 

package/src/behaviors/level-control/LevelControlServer.ts

@@ -13,7 +13,7 @@ import { OnOffServer } from "#behaviors/on-off";
 import { GeneralDiagnostics } from "#clusters/general-diagnostics";
 import { LevelControl } from "#clusters/level-control";
 import { Endpoint } from "#endpoint/Endpoint.js";
-import { AsyncObservable, Identity, Logger, MaybePromise } from "#general";
+import { AsyncObservable, Identity, Logger, MaybePromise, Millis } from "#general";
 import { ServerNode } from "#node/ServerNode.js";
 import { Val } from "#protocol";
 import { ClusterType, StatusCode, StatusResponseError, TypeFromPartialBitSchema } from "#types";
@@ -141,8 +141,8 @@ export class LevelControlBaseServer extends LevelControlBase {
                 return readOnlyState.transitionEndTimeMs;
             },
 
-            get stepIntervalMs() {
-                return readOnlyState.transitionStepIntervalMs;
+            get stepInterval() {
+                return readOnlyState.transitionStepInterval;
             },
 
             properties: {
@@ -614,7 +614,7 @@ export namespace LevelControlBaseServer {
         /**
          * When managing transitions, this is the interval at which steps occur in ms.
          */
-        transitionStepIntervalMs = 100;
+        transitionStepInterval = Millis(100);
 
         [Val.properties](endpoint: Endpoint) {
             // Only return remaining time if the attribute is defined in the endpoint

package/src/behaviors/on-off/OnOffServer.ts

@@ -7,7 +7,7 @@
 import { GeneralDiagnosticsBehavior } from "#behaviors/general-diagnostics";
 import { GeneralDiagnostics } from "#clusters/general-diagnostics";
 import { OnOff } from "#clusters/on-off";
-import { MaybePromise, Time, Timer } from "#general";
+import { MaybePromise, Millis, Time, Timer } from "#general";
 import { ServerNode } from "#node/ServerNode.js";
 import { OnOffBehavior } from "./OnOffBehavior.js";
 
@@ -147,7 +147,7 @@ export class OnOffBaseServer extends OnOffLogicBase {
         if (timer === undefined) {
             timer = this.internal.timedOnTimer = Time.getPeriodicTimer(
                 "Timed on",
-                100,
+                Millis(100),
                 this.callback(this.#timedOnTick, { lock: true }),
             );
         }
@@ -170,7 +170,7 @@ export class OnOffBaseServer extends OnOffLogicBase {
         if (timer === undefined) {
             timer = this.internal.delayedOffTimer = Time.getPeriodicTimer(
                 "Delayed off",
-                100,
+                Millis(100),
                 this.callback(this.#delayedOffTick, { lock: true }),
             );
         }

package/src/behaviors/power-source/PowerSourceServer.ts

@@ -6,6 +6,7 @@
 
 import { DescriptorServer } from "#behaviors/descriptor";
 import { PowerSource } from "#clusters/power-source";
+import { Seconds } from "#general";
 import { ClusterType } from "#types";
 import { PowerSourceBehavior } from "./PowerSourceBehavior.js";
 
@@ -25,7 +26,7 @@ export class PowerSourceBaseServer extends PowerSourceLevelBase {
             this.events.batTimeToFullCharge$Changed,
         ].forEach(event => {
             if (event !== undefined) {
-                event.quiet.minimumEmitIntervalMs = 10_000;
+                event.quiet.minimumEmitInterval = Seconds(10);
             }
         });
     }

package/src/behaviors/switch/SwitchServer.ts

@@ -6,11 +6,14 @@
 
 import { ActionContext } from "#behavior/context/ActionContext.js";
 import { Switch } from "#clusters/switch";
-import { Logger, MaybePromise, Observable, Time, Timer } from "#general";
+import { Duration, Logger, MaybePromise, Millis, Observable, Seconds, Time, Timer } from "#general";
 import { FieldElement } from "#model";
 import { ClusterType, StatusCode, StatusResponseError } from "#types";
 import { SwitchBehavior } from "./SwitchBehavior.js";
 
+const DEFAULT_MULTIPRESS_DELAY = Millis(300);
+const DEFAULT_LONG_PRESS_DELAY = Seconds(2);
+
 const logger = Logger.get("SwitchServer");
 
 const SwitchServerBase = SwitchBehavior.for(Switch.Complete).with(
@@ -99,7 +102,7 @@ export class SwitchBaseServer extends SwitchServerBase {
 
     #debounceRawPosition(newPosition: number) {
         // When a debounce delay is set then we debounce the raw position, else we set the current position immediately
-        if (this.state.debounceDelay !== 0) {
+        if (this.state.debounceDelay) {
             this.internal.debounceTimer?.stop();
 
             this.internal.currentUnstablePosition = newPosition;
@@ -170,7 +173,7 @@ export class SwitchBaseServer extends SwitchServerBase {
                 this.internal.currentLongPressPosition = newPosition;
                 this.internal.longPressTimer = Time.getTimer(
                     "longPress",
-                    this.state.longPressDelay,
+                    this.state.longPressDelay ?? DEFAULT_LONG_PRESS_DELAY,
                     this.callback(this.#handleLongPress, { lock: true }),
                 ).start();
             }
@@ -226,7 +229,7 @@ export class SwitchBaseServer extends SwitchServerBase {
             if (!pressSequenceFinished) {
                 this.internal.multiPressTimer = Time.getTimer(
                     "multiPress",
-                    this.state.multiPressDelay,
+                    this.state.multiPressDelay ?? DEFAULT_MULTIPRESS_DELAY,
                     this.callback(this.#handleMultiPressComplete, { lock: true }),
                 ).start();
             }
@@ -318,13 +321,13 @@ export namespace SwitchBaseServer {
          * Debounce Delay to wait until a newly reported raw position is considered stable and written to the
          * currentPosition attribue.
          */
-        debounceDelay: number = 0;
+        debounceDelay?: Duration;
 
         /** Time to wait until a value is considered "long" pressed */
-        longPressDelay: number = 0;
+        longPressDelay?: Duration;
 
         /** Timeframe starting with a stable release to detect multi-presses. */
-        multiPressDelay: number = 0;
+        multiPressDelay?: Duration;
 
         /** Number of the position considered as the neutral position for the momentary switch. */
         momentaryNeutralPosition: number = 0;

package/src/endpoint/Endpoint.ts

@@ -206,8 +206,15 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
                         `State values for ${behaviorId} must be an object, not ${typeof vals}`,
                     );
                 }
+
+                if (vals instanceof Date) {
+                    throw new ImplementationError(
+                        `State values for ${behaviorId} must be an object, not ${vals.constructor.name}`,
+                    );
+                }
+
                 if (Array.isArray(vals)) {
-                    throw new ImplementationError(`StateValue for ${behaviorId} must be an object, not an array`);
+                    throw new ImplementationError(`State value for ${behaviorId} must be an object, not an array`);
                 }
 
                 patch(vals, behavior.state, this.path);
@@ -236,6 +243,11 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
             if (typeof values !== "object") {
                 throw new ImplementationError(`State values for ${type.id} must be an object, not ${typeof values}`);
             }
+            if (values instanceof Date) {
+                throw new ImplementationError(
+                    `State values for ${type.id} must be an object, not ${values.constructor.name}`,
+                );
+            }
             if (Array.isArray(values)) {
                 throw new ImplementationError(`State values for ${type.id} must be an object, not an array`);
             }

package/src/endpoint/properties/SupportedBehaviors.ts

@@ -100,7 +100,7 @@ export namespace SupportedBehaviors {
      * Patch input version of {@link StateOf}.
      */
     export type StatePatchOf<SB extends SupportedBehaviors> = {
-        [K in keyof SB]?: Behavior.PatchStateOf<SB[K]>;
+        readonly [K in keyof SB]?: Behavior.PatchStateOf<SB[K]>;
     } & {
         descriptor?: Behavior.PatchStateOf<typeof DescriptorBehavior>;
     };

package/src/node/ServerNode.ts

@@ -12,7 +12,7 @@ import { NetworkServer } from "#behavior/system/network/NetworkServer.js";
 import { ServerNetworkRuntime } from "#behavior/system/network/ServerNetworkRuntime.js";
 import { ProductDescriptionServer } from "#behavior/system/product-description/ProductDescriptionServer.js";
 import { SessionsBehavior } from "#behavior/system/sessions/SessionsBehavior.js";
-import { SubscriptionBehavior } from "#behavior/system/subscription/SubscriptionBehavior.js";
+import { SubscriptionsBehavior } from "#behavior/system/subscriptions/SubscriptionsServer.js";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import type { Environment } from "#general";
 import { asyncNew, Construction, DiagnosticSource, errorOf, Identity, MatterError } from "#general";
@@ -207,7 +207,7 @@ export namespace ServerNode {
         CommissioningServer,
         NetworkServer,
         ProductDescriptionServer,
-        SubscriptionBehavior,
+        SubscriptionsBehavior,
         SessionsBehavior,
         EventsBehavior,
         ControllerBehavior,

package/src/node/client/ClientNodes.ts

@@ -10,7 +10,7 @@ import { ContinuousDiscovery } from "#behavior/system/controller/discovery/Conti
 import { Discovery } from "#behavior/system/controller/discovery/Discovery.js";
 import { InstanceDiscovery } from "#behavior/system/controller/discovery/InstanceDiscovery.js";
 import { EndpointContainer } from "#endpoint/properties/EndpointContainer.js";
-import { CancelablePromise, Lifespan, Logger, Time } from "#general";
+import { CancelablePromise, Duration, Logger, Minutes, Seconds, Time, Timestamp } from "#general";
 import { PeerAddress, PeerAddressStore } from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { ClientNode } from "../ClientNode.js";
@@ -20,8 +20,8 @@ import { NodePeerAddressStore } from "./NodePeerAddressStore.js";
 
 const logger = Logger.get("ClientNodes");
 
-const DEFAULT_TTL = 900 * 1000;
-const EXPIRATION_INTERVAL = 60 * 1000;
+const DEFAULT_TTL = Minutes(15);
+const EXPIRATION_INTERVAL = Minutes.one;
 
 /**
  * Manages the set of known remote nodes.
@@ -160,7 +160,7 @@ export class ClientNodes extends EndpointContainer<ClientNode> {
     }
 
     async #cullExpiredNodesAndAddresses() {
-        const now = Time.nowMs();
+        const now = Time.nowMs;
 
         for (const node of this) {
             const state = node.state.commissioning;
@@ -243,11 +243,11 @@ class Factory extends ClientNodeFactory {
     }
 }
 
-function expirationOf<T extends Partial<Lifespan>>(
+function expirationOf<T extends { discoveredAt?: Timestamp; ttl?: Duration | number }>(
     lifespan: T,
-): T extends { discoveredAt: number } ? number : number | undefined {
+): T extends { discoveredAt: Timestamp } ? Timestamp : Timestamp | undefined {
     if (lifespan.discoveredAt !== undefined) {
-        return lifespan.discoveredAt + (lifespan.ttl ?? DEFAULT_TTL);
+        return Timestamp(lifespan.discoveredAt + (Seconds(lifespan.ttl) ?? DEFAULT_TTL));
     }
-    return undefined as unknown as number;
+    return undefined as unknown as Timestamp;
 }