@matter/node 0.16.0-alpha.0-20250817-1b000357c → 0.16.0-alpha.0-20250819-0a388db8b

package/src/behavior/Transitions.ts

@@ -10,12 +10,16 @@ import {
     addValueWithOverflow,
     cropValueRange,
     Diagnostic,
+    Duration,
     ImplementationError,
     Logger,
     MaybePromise,
+    Millis,
     ObserverGroup,
     Time,
     Timer,
+    Timespan,
+    Timestamp,
 } from "#general";
 import { Behavior } from "./Behavior.js";
 import { ClusterEvents } from "./cluster/ClusterEvents.js";
@@ -170,7 +174,7 @@ export class Transitions<B extends Behavior> {
             configuration: transition,
             currentValue,
             changePerMs: changePerS / 1000,
-            prevStepAt: Time.nowMs() - (this.#config.stepIntervalMs ?? Transitions.DEFAULT_STEP_INTERVAL_MS),
+            prevStepAt: Timestamp(Time.nowMs - (this.#config.stepInterval ?? Transitions.DEFAULT_STEP_INTERVAL)),
             distanceLeft,
         };
 
@@ -244,7 +248,7 @@ export class Transitions<B extends Behavior> {
         if (this.#timer === undefined) {
             this.#timer = Time.getPeriodicTimer(
                 `transition-${this.#endpoint}-${this.#config.type.name}`,
-                this.#config.stepIntervalMs ?? Transitions.DEFAULT_STEP_INTERVAL_MS,
+                this.#config.stepInterval ?? Transitions.DEFAULT_STEP_INTERVAL,
                 this.#step.bind(this),
             );
 
@@ -357,7 +361,7 @@ export class Transitions<B extends Behavior> {
     get remainingTime() {
         if (this.#config.manageTransitions === false) {
             if (this.#config.transitionEndTimeMs !== undefined) {
-                const remaining = this.#config.transitionEndTimeMs - Time.nowMs();
+                const remaining = Timespan(Time.nowMs, this.#config.transitionEndTimeMs).duration;
                 if (remaining < 0) {
                     return 0;
                 }
@@ -403,7 +407,7 @@ export class Transitions<B extends Behavior> {
      * You may override this method if you want matter.js to run a timer, but you want to handle value updates yourself.
      */
     protected async step(behavior: B) {
-        const now = Time.nowMs();
+        const now = Time.nowMs;
 
         // Compute updated values for all transitioning attributes
         for (const prop of this) {
@@ -593,11 +597,11 @@ export class Transitions<B extends Behavior> {
     }
 
     #externalTimeOf(ms: number) {
-        return Math.round(ms / (this.#config.externalTimeUnitMs ?? Transitions.DEFAULT_EXTERNAL_TIME_UNIT_MS));
+        return Math.round(ms / (this.#config.externalTimeUnit ?? Transitions.DEFAULT_EXTERNAL_TIME_UNIT));
     }
 
     #internalTimeOf(externalUnits: number) {
-        return externalUnits * (this.#config.externalTimeUnitMs ?? Transitions.DEFAULT_EXTERNAL_TIME_UNIT_MS);
+        return Millis(externalUnits * (this.#config.externalTimeUnit ?? Transitions.DEFAULT_EXTERNAL_TIME_UNIT));
     }
 
     /**
@@ -644,8 +648,8 @@ export class Transitions<B extends Behavior> {
 }
 
 export namespace Transitions {
-    export const DEFAULT_STEP_INTERVAL_MS = 100;
-    export const DEFAULT_EXTERNAL_TIME_UNIT_MS = 100;
+    export const DEFAULT_STEP_INTERVAL = Millis(100);
+    export const DEFAULT_EXTERNAL_TIME_UNIT = Millis(100);
 
     /**
      * A valid transitionable attribute name for the specified type.
@@ -674,19 +678,19 @@ export namespace Transitions {
         readonly manageTransitions?: boolean;
 
         /**
-         * Milliseconds-per external time unit.  Defaults to 100 which is appropriate for CC & LVL "remaining time"
+         * Interval per external time unit.  Defaults to 100ms which is appropriate for CC & LVL "remaining time"
          * attribute that is defined as 10ths of a second.
          */
-        readonly externalTimeUnitMs?: number;
+        readonly externalTimeUnit?: Duration;
 
         /**
          * The internal tick rate for transitions.
          *
          * This is the smallest time increment between value adjustments.
          *
-         * Defaults to {@link DEFAULT_STEP_INTERVAL_MS}.
+         * Defaults to {@link DEFAULT_STEP_INTERVAL}.
          */
-        readonly stepIntervalMs?: number;
+        readonly stepInterval?: Duration;
 
         /**
          * The end time for a transition if transition management is disabled.
@@ -821,7 +825,7 @@ export namespace Transitions {
         /**
          * The time of the last step.
          */
-        prevStepAt: number;
+        prevStepAt: Timestamp;
 
         /**
          * Set to true when the reporting of remaining time should be suppressed when finishing the transition.

package/src/behavior/cluster/FabricScopedDataHandler.ts

@@ -7,7 +7,7 @@
 import type { Behavior } from "#behavior/Behavior.js";
 import type { Endpoint } from "#endpoint/Endpoint.js";
 import type { SupportedElements } from "#endpoint/properties/Behaviors.js";
-import { createPromise, deepCopy, isObject, Logger, MaybePromise, withTimeout } from "#general";
+import { createPromise, deepCopy, isObject, Logger, MaybePromise, Seconds, withTimeout } from "#general";
 import type { ServerNode } from "#node/ServerNode.js";
 import { OccurrenceManager, Val } from "#protocol";
 import type { ClusterType, FabricIndex, ObjectSchema } from "#types";
@@ -67,7 +67,7 @@ async function sanitizeAttributeData(
         (endpoint.eventsOf(type) as Behavior.EventsOf<any>).stateChanged?.on(resolver);
         try {
             await endpoint.setStateOf(type, stateUpdate);
-            stateUpdatePromises.push(withTimeout(5_000, promise)); // 5s should be enough for state change
+            stateUpdatePromises.push(withTimeout(Seconds(5), promise)); // 5s should be enough for state change
         } catch (error) {
             logger.warn(
                 `Could not sanitize fabric-scoped attributes for cluster ${cluster.name} on endpoint ${endpoint.id}`,

package/src/behavior/internal/BehaviorBacking.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Migration } from "#behavior/state/migrations/Migration.js";
 import type { Agent } from "#endpoint/Agent.js";
 import type { Endpoint } from "#endpoint/Endpoint.js";
 import { BehaviorInitializationError } from "#endpoint/errors.js";
@@ -102,9 +103,15 @@ export abstract class BehaviorBacking {
     }
 
     initializeDataSource() {
-        if (!this.#datasource) {
-            this.#datasource = Datasource(this.datasourceOptions);
+        if (this.#datasource) {
+            return;
         }
+
+        if (this.store.initialValues !== undefined) {
+            Migration.migrate(this.type, this.store.initialValues);
+        }
+
+        this.#datasource = Datasource(this.datasourceOptions);
     }
 
     /**

package/src/behavior/state/managed/values/PrimitiveManager.ts

@@ -7,10 +7,9 @@
 import type { ValueSupervisor } from "../../../supervision/ValueSupervisor.js";
 
 /**
- * If you invoke {@link ValueSupervisor.manage} on a non-collection value, this is
- * the manage implementation you will receive.
+ * If you invoke {@link ValueSupervisor.manage} on a non-collection value, this is the manage implementation you will
+ * receive.
  *
- * Struct and list manager implementations optimize by bypassing
- * PrimitiveManager.
+ * Struct and list manager implementations optimize by bypassing PrimitiveManager.
  */
 export const PrimitiveManager: ValueSupervisor.Manage = reference => reference;

package/src/behavior/state/managed/values/ValuePatcher.ts

@@ -105,13 +105,13 @@ function StructPatcher(schema: ValueModel, supervisor: RootSupervisor): ValueSup
             throw new WriteError(path, `cannot patch ${target} because it is not an object`);
         }
 
-        for (const key in changes) {
+        for (const key in changes as Val.Struct) {
             // Validate the key
             if (!(key in memberPatchers)) {
                 throw new WriteError(path, `${key} is not a property of ${schema.name}`);
             }
 
-            let newValue = changes[key];
+            let newValue = (changes as Val.Struct)[key];
 
             // If this is not a subcollection or the new value is not an object, just do direct set
             const subpatch = memberPatchers[key];

package/src/behavior/state/migrations/Migration.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Behavior } from "#behavior/Behavior.js";
+import { InternalError } from "#general";
+import { Val } from "#protocol";
+
+const migrations = new Map<string, Migration.Migrator>();
+
+/**
+ * Add a data migration.
+ *
+ * Migrations allow the server to adjust persisted data when the stored format is incompatible with current code.
+ */
+export function Migration(id: string, migrator: Migration.Migrator) {
+    if (migrations.has(id)) {
+        throw new InternalError(`Duplicate migration ${id}`);
+    }
+
+    migrations.set(id, migrator);
+}
+
+export namespace Migration {
+    export function migrate(type: Behavior.Type, values: Val.Struct) {
+        migrations.get(type.id)?.(values, type);
+    }
+
+    export interface Migrator {
+        (values: Val.Struct, type: Behavior.Type): void;
+    }
+}

package/src/behavior/{system/subscription → state/migrations}/index.ts

@@ -4,4 +4,4 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-export * from "./SubscriptionBehavior.js";
+// Currently there are no migrations

package/src/behavior/state/validation/ValueValidator.ts

@@ -73,6 +73,7 @@ export function ValueValidator(schema: Schema, supervisor: RootSupervisor): Valu
             break;
 
         case Metatype.date:
+        case Metatype.duration:
         case Metatype.any:
             break;
 

package/src/behavior/supervision/ValueSupervisor.ts

@@ -102,7 +102,7 @@ export namespace ValueSupervisor {
 
     export type Manage = (reference: Val.Reference, session: Session) => Val;
 
-    export type Patch = (changes: Val.Collection, target: Val.Collection, path: DataModelPath) => Val;
+    export type Patch = (changes: Val.ReadonlyCollection, target: Val.Collection, path: DataModelPath) => Val;
 
     export type Cast = (value: Val) => Val;
 }

package/src/behavior/system/commissioning/CommissioningClient.ts

@@ -7,7 +7,15 @@
 import { Behavior } from "#behavior/Behavior.js";
 import { Events as BaseEvents } from "#behavior/Events.js";
 import { OperationalCredentialsClient } from "#behaviors/operational-credentials";
-import { ImplementationError, NotImplementedError, Observable, ServerAddress, Time } from "#general";
+import {
+    Duration,
+    ImplementationError,
+    NotImplementedError,
+    Observable,
+    ServerAddress,
+    Time,
+    Timestamp,
+} from "#general";
 import { DatatypeModel, FieldElement } from "#model";
 import type { ClientNode } from "#node/ClientNode.js";
 import type { Node } from "#node/Node.js";
@@ -55,7 +63,7 @@ export class CommissioningClient extends Behavior {
         }
 
         if (this.state.discoveredAt === undefined) {
-            this.state.discoveredAt = Time.nowMs();
+            this.state.discoveredAt = Time.nowMs;
         }
 
         this.reactTo((this.endpoint as Node).lifecycle.partsReady, this.#initializeNode);
@@ -120,7 +128,7 @@ export class CommissioningClient extends Behavior {
         const address = identityService.assignNodeAddress(node, fabric.fabricIndex, opts.nodeId);
 
         const commissioningOptions: LocatedNodeCommissioningOptions = {
-            addresses,
+            addresses: addresses.map(ServerAddress),
             fabric,
             nodeId: address.nodeId,
             passcode,
@@ -259,9 +267,9 @@ export class CommissioningClient extends Behavior {
                 type: "struct",
                 quality: "N",
                 children: [
-                    FieldElement({ name: "idleIntervalMs", type: "uint32", constraint: "max 3600000" }),
-                    FieldElement({ name: "activeIntervalMs", type: "uint32", constraint: "max 3600000" }),
-                    FieldElement({ name: "activeThresholdMs", type: "uint16" }),
+                    FieldElement({ name: "idleInterval", type: "duration", constraint: "max 3600000" }),
+                    FieldElement({ name: "activeInterval", type: "duration", constraint: "max 3600000" }),
+                    FieldElement({ name: "activeThreshold", type: "duration", constraint: "max 65535" }),
                 ],
             }),
             FieldElement({ name: "tcpSupport", type: "uint8", quality: "N" }),
@@ -281,27 +289,27 @@ export namespace CommissioningClient {
          * Known network addresses for the device.  If this is undefined the node has not been located on any network
          * interface.
          */
-        addresses?: ServerAddress[];
+        addresses?: ServerAddress.Definition[];
 
         /**
          * Time at which the device was discovered.
          */
-        discoveredAt?: number;
+        discoveredAt?: Timestamp;
 
         /**
          * Time at which we discovered the device's current operational addresses.
          */
-        onlineAt?: number;
+        onlineAt?: Timestamp;
 
         /**
          * Time at which we concluded the device's current operational address is unreachable.
          */
-        offlineAt?: number;
+        offlineAt?: Timestamp;
 
         /**
-         * The TTL of the discovery record if applicable.
+         * The TTL of the discovery record if applicable (in seconds).
          */
-        ttl?: number;
+        ttl?: Duration;
 
         /**
          * The canonical global ID of the device.

package/src/behavior/system/commissioning/RemoteDescriptor.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Immutable } from "#general";
+import { Immutable, Seconds, ServerAddress } from "#general";
 import { CommissionableDevice, OperationalDevice, PeerAddress, SessionParameters } from "#protocol";
 import { DeviceTypeId, VendorId } from "#types";
 import type { CommissioningClient } from "./CommissioningClient.js";
@@ -67,7 +67,7 @@ export namespace RemoteDescriptor {
         }
 
         if (ttl !== undefined) {
-            result.ttl = ttl;
+            result.ttl = Seconds(ttl);
         }
 
         if (deviceIdentifier !== undefined) {
@@ -103,18 +103,18 @@ export namespace RemoteDescriptor {
         }
 
         if (sessionParameters !== undefined) {
-            const { idleIntervalMs, activeIntervalMs, activeThresholdMs } = sessionParameters;
+            const { idleInterval, activeInterval, activeThreshold } = sessionParameters;
 
-            if (idleIntervalMs !== undefined) {
-                result.SII = idleIntervalMs;
+            if (idleInterval !== undefined) {
+                result.SII = idleInterval;
             }
 
-            if (activeIntervalMs !== undefined) {
-                result.SAI = activeIntervalMs;
+            if (activeInterval !== undefined) {
+                result.SAI = activeInterval;
             }
 
-            if (activeThresholdMs !== undefined) {
-                result.SAT = activeThresholdMs;
+            if (activeThreshold !== undefined) {
+                result.SAT = activeThreshold;
             }
         }
 
@@ -129,11 +129,11 @@ export namespace RemoteDescriptor {
         const isOperational = long.peerAddress !== undefined;
         if (isOperational) {
             if (addresses !== undefined) {
-                result.addresses = addresses?.filter(address => address.type === "udp");
+                result.addresses = addresses?.filter(address => address.type === "udp").map(ServerAddress);
             }
         } else {
             if (addresses !== undefined) {
-                result.addresses = addresses.map(address => ({ ...address }));
+                result.addresses = addresses.map(address => ({ ...address })).map(ServerAddress);
             }
 
             if (discriminator !== undefined) {
@@ -165,7 +165,7 @@ export namespace RemoteDescriptor {
         }
 
         if (addresses?.length) {
-            long.addresses = addresses;
+            long.addresses = addresses.map(ServerAddress.definitionOf);
         }
 
         if (deviceIdentifier !== undefined) {
@@ -181,13 +181,13 @@ export namespace RemoteDescriptor {
 
         let sessionParameters: Partial<SessionParameters> | undefined;
         if (SII !== undefined) {
-            (sessionParameters ??= {}).idleIntervalMs = SII;
+            (sessionParameters ??= {}).idleInterval = SII;
         }
         if (SAI !== undefined) {
-            (sessionParameters ??= {}).activeIntervalMs = SAI;
+            (sessionParameters ??= {}).activeInterval = SAI;
         }
         if (SAT !== undefined) {
-            (sessionParameters ??= {}).activeThresholdMs = SAT;
+            (sessionParameters ??= {}).activeThreshold = SAT;
         }
         long.sessionParameters = sessionParameters;
 

package/src/behavior/system/controller/discovery/ContinuousDiscovery.ts

@@ -22,7 +22,7 @@ export class ContinuousDiscovery extends Discovery<ClientNode[]> {
 
     constructor(owner: ServerNode, options?: Discovery.Options) {
         super(owner, options);
-        this.#bounded = options?.timeoutSeconds !== undefined;
+        this.#bounded = options?.timeout !== undefined;
     }
 
     /**

package/src/behavior/system/controller/discovery/Discovery.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { CancelablePromise, Diagnostic, Logger, MaybePromise, withTimeout } from "#general";
+import { CancelablePromise, Diagnostic, Duration, Logger, MaybePromise, withTimeout } from "#general";
 import { ClientNodeFactory } from "#node/client/ClientNodeFactory.js";
 import type { ClientNode } from "#node/ClientNode.js";
 import type { ServerNode } from "#node/ServerNode.js";
@@ -224,8 +224,8 @@ export abstract class Discovery<T = unknown> extends CancelablePromise<T> {
 
         let promise = DiscoveryAggregateError.allSettled(promises, `${this} failed`);
 
-        if (this.#options.timeoutSeconds !== undefined) {
-            promise = withTimeout(this.#options.timeoutSeconds * 1_000, promise, this.stop.bind(this));
+        if (this.#options.timeout !== undefined) {
+            promise = withTimeout(this.#options.timeout, promise, this.stop.bind(this));
         }
 
         promise.then(this.#afterDiscovery.bind(this)).catch(this.#reject);
@@ -260,7 +260,7 @@ export abstract class Discovery<T = unknown> extends CancelablePromise<T> {
 
 export namespace Discovery {
     export type Options = CommissionableDeviceIdentifiers & {
-        timeoutSeconds?: number;
+        timeout?: Duration;
     };
 
     export type InstanceOptions = Options & {

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

@@ -6,7 +6,7 @@
 
 import { DatatypeModel, FieldElement } from "#model";
 import { Node } from "#node/Node.js";
-import { DEFAULT_MIN_INTERVAL_FLOOR_SECONDS, Subscribe } from "#protocol";
+import { DEFAULT_MIN_INTERVAL_FLOOR, Subscribe } from "#protocol";
 import { ClientNetworkRuntime } from "./ClientNetworkRuntime.js";
 import { NetworkBehavior } from "./NetworkBehavior.js";
 
@@ -28,8 +28,8 @@ export class NetworkClient extends NetworkBehavior {
         // TODO - configure subscription based on physical device properties
         const subscribe = Subscribe({
             fabricFilter: true,
-            minIntervalFloorSeconds: DEFAULT_MIN_INTERVAL_FLOOR_SECONDS,
-            maxIntervalCeilingSeconds: 0,
+            minIntervalFloor: DEFAULT_MIN_INTERVAL_FLOOR,
+            maxIntervalCeiling: 0,
             attributes: [{}],
             ...startupSubscription,
         });

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { SubscriptionBehavior } from "#behavior/system/subscription/SubscriptionBehavior.js";
+import { SubscriptionsBehavior } from "#behavior/system/subscriptions/SubscriptionsServer.js";
 import {
     Construction,
     Crypto,
@@ -355,7 +355,7 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         this.#formerSubscriptionsHandled = true;
 
         await this.owner.act(agent =>
-            agent.get(SubscriptionBehavior).reestablishFormerSubscriptions(env.get(InteractionServer)),
+            agent.get(SubscriptionsBehavior).reestablishFormerSubscriptions(env.get(InteractionServer)),
         );
     }
 

package/src/behavior/system/sessions/SessionsBehavior.ts

@@ -72,7 +72,7 @@ export class SessionsBehavior extends Behavior {
             return;
         }
 
-        // When subscription was added then inform SubscriptionBehavior
+        // When subscription was added then inform SubscriptionsBehavior
         if (session.subscriptions.has(subscription)) {
             this.events.subscriptionAdded.emit(subscription);
         }

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";