@matterbridge/core 3.10.6-dev-20260818-c2c6349 → 3.10.6-dev-20260820-36b52be

package/dist/behaviors/fanControlServer.d.ts

@@ -1,3 +1,4 @@
+import type { MaybePromise } from '@matter/general';
 import { FanControlServer } from '@matter/node/behaviors/fan-control';
 import { FanControl } from '@matter/types/clusters/fan-control';
 declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof FanControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<FanControl, {
@@ -9,6 +10,8 @@ declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterB
     wind: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "fanControl">;
 export declare class MatterbridgeFanControlServer extends MatterbridgeFanControlServer_base {
+    #private;
+    initialize(): MaybePromise;
     step(request: FanControl.StepRequest): Promise<void>;
 }
 export {};

package/dist/behaviors/fanControlServer.js

@@ -1,10 +1,161 @@
 import { FanControlServer } from '@matter/node/behaviors/fan-control';
+import { Status, StatusResponseError } from '@matter/types';
 import { FanControl } from '@matter/types/clusters/fan-control';
+import { getEnumDescription } from '@matterbridge/utils/enum';
 import { MatterbridgeServer } from './matterbridgeServer.js';
+const lookupStepDirection = ['Increase', 'Decrease'];
+const lookupFanMode = ['Off', 'Low', 'Medium', 'High', 'On', 'Auto', 'Auto', 'Smart'];
+const supportedFanModesBySequence = {
+    [FanControl.FanModeSequence.OffLowMedHigh]: new Set([FanControl.FanMode.Off, FanControl.FanMode.Low, FanControl.FanMode.Medium, FanControl.FanMode.High]),
+    [FanControl.FanModeSequence.OffLowHigh]: new Set([FanControl.FanMode.Off, FanControl.FanMode.Low, FanControl.FanMode.High]),
+    [FanControl.FanModeSequence.OffLowMedHighAuto]: new Set([
+        FanControl.FanMode.Off,
+        FanControl.FanMode.Low,
+        FanControl.FanMode.Medium,
+        FanControl.FanMode.High,
+        FanControl.FanMode.Auto,
+    ]),
+    [FanControl.FanModeSequence.OffLowHighAuto]: new Set([FanControl.FanMode.Off, FanControl.FanMode.Low, FanControl.FanMode.High, FanControl.FanMode.Auto]),
+    [FanControl.FanModeSequence.OffHighAuto]: new Set([FanControl.FanMode.Off, FanControl.FanMode.High, FanControl.FanMode.Auto]),
+    [FanControl.FanModeSequence.OffHigh]: new Set([FanControl.FanMode.Off, FanControl.FanMode.High]),
+};
+const steppedFanModes = [FanControl.FanMode.Low, FanControl.FanMode.Medium, FanControl.FanMode.High];
+function computePercentRanges(sequence) {
+    const supported = supportedFanModesBySequence[sequence];
+    const modes = steppedFanModes.filter((fanMode) => supported.has(fanMode));
+    const ranges = [];
+    let start = 1;
+    modes.forEach((fanMode, index) => {
+        const end = Math.floor((100 * (index + 1)) / modes.length);
+        ranges.push({ fanMode, start, end });
+        start = end + 1;
+    });
+    return ranges;
+}
+function percentToFanMode(percent, sequence) {
+    const ranges = computePercentRanges(sequence);
+    const range = ranges.find((candidate) => percent >= candidate.start && percent <= candidate.end);
+    return range?.fanMode ?? FanControl.FanMode.High;
+}
+function resolvePercentSettingForFanMode(fanMode, currentPercentSetting, sequence) {
+    if (fanMode === FanControl.FanMode.Off)
+        return 0;
+    const alreadyInRange = currentPercentSetting !== null && currentPercentSetting !== 0 && percentToFanMode(currentPercentSetting, sequence) === fanMode;
+    if (alreadyInRange)
+        return currentPercentSetting;
+    const range = computePercentRanges(sequence).find((candidate) => candidate.fanMode === fanMode);
+    return range ? Math.round((range.start + range.end) / 2) : (currentPercentSetting ?? 0);
+}
+function resolveStepPercentSettingForFanMode(fanMode, direction, currentPercentSetting, sequence) {
+    if (fanMode === FanControl.FanMode.Off)
+        return 0;
+    const alreadyInRange = currentPercentSetting !== null && currentPercentSetting !== 0 && percentToFanMode(currentPercentSetting, sequence) === fanMode;
+    if (alreadyInRange)
+        return currentPercentSetting;
+    const range = computePercentRanges(sequence).find((candidate) => candidate.fanMode === fanMode);
+    if (!range)
+        return currentPercentSetting ?? 0;
+    return direction === FanControl.StepDirection.Increase ? range.start : range.end;
+}
+function speedSettingForPercent(speedMax, percent) {
+    return Math.ceil((speedMax * percent) / 100);
+}
 export class MatterbridgeFanControlServer extends FanControlServer.with(FanControl.Feature.Auto, FanControl.Feature.Step) {
+    initialize() {
+        const result = super.initialize();
+        this.reactTo(this.events.fanMode$Changing, this.#handleFanModeChanging);
+        this.reactTo(this.events.percentSetting$Changing, this.#handlePercentSettingChanging);
+        this.maybeReactTo(this.events.speedSetting$Changing, this.#handleSpeedSettingChanging);
+        return result;
+    }
+    #handleFanModeChanging(fanMode) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (fanMode === FanControl.FanMode.On) {
+            this.state.fanMode = FanControl.FanMode.High;
+            device.log.debug(`handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> fanMode ${lookupFanMode[this.state.fanMode]} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        if (fanMode === FanControl.FanMode.Smart) {
+            this.state.fanMode = this.features.auto ? FanControl.FanMode.Auto : FanControl.FanMode.High;
+            device.log.debug(`handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> fanMode ${lookupFanMode[this.state.fanMode]} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        if (!supportedFanModesBySequence[this.state.fanModeSequence].has(fanMode)) {
+            throw new StatusResponseError(`FanMode ${getEnumDescription(FanControl.FanMode, fanMode)} is not supported by FanModeSequence ${getEnumDescription(FanControl.FanModeSequence, this.state.fanModeSequence)}`, Status.ConstraintError);
+        }
+        if (fanMode === FanControl.FanMode.Off) {
+            this.state.percentSetting = 0;
+            if (this.features.multiSpeed) {
+                this.state.speedSetting = 0;
+            }
+            this.agent.asLocalActor(() => {
+                this.state.percentCurrent = 0;
+                if (this.features.multiSpeed) {
+                    this.state.speedCurrent = 0;
+                }
+            });
+            device.log.debug(`handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> percentSetting ${this.state.percentSetting} percentCurrent ${this.state.percentCurrent} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            if (this.features.multiSpeed) {
+                device.log.debug(`handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> speedSetting ${this.state.speedSetting} speedCurrent ${this.state.speedCurrent} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            }
+        }
+        else if (fanMode === FanControl.FanMode.Auto) {
+            this.state.percentSetting = null;
+            if (this.features.multiSpeed) {
+                this.state.speedSetting = null;
+                device.log.debug(`handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> speedSetting ${this.state.speedSetting} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            }
+            device.log.debug(`handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> percentSetting ${this.state.percentSetting} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        }
+        else {
+            const resolved = resolvePercentSettingForFanMode(fanMode, this.state.percentSetting, this.state.fanModeSequence);
+            if (resolved !== this.state.percentSetting)
+                this.state.percentSetting = resolved;
+            device.log.debug(`handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> percentSetting ${this.state.percentSetting} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        }
+    }
+    #handlePercentSettingChanging(percentSetting, oldPercentSetting) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (percentSetting === null) {
+            if (this.state.fanMode === FanControl.FanMode.Auto)
+                return;
+            this.state.percentSetting = oldPercentSetting;
+            device.log.debug(`handlePercentSettingChanging percentSetting changed to ${percentSetting} >>> fanMode ${lookupFanMode[this.state.fanMode]} percentSetting ${this.state.percentSetting} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        const fanMode = percentSetting === 0 ? FanControl.FanMode.Off : percentToFanMode(percentSetting, this.state.fanModeSequence);
+        if (fanMode !== this.state.fanMode)
+            this.state.fanMode = fanMode;
+        if (this.features.multiSpeed) {
+            const state = this.state;
+            state.speedSetting = speedSettingForPercent(state.speedMax, percentSetting);
+        }
+        device.log.debug(`handlePercentSettingChanging percentSetting changed to ${percentSetting} >>> fanMode ${lookupFanMode[this.state.fanMode]} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    }
+    #handleSpeedSettingChanging(speedSetting, oldSpeedSetting) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const state = this.state;
+        if (speedSetting === null) {
+            if (this.state.fanMode === FanControl.FanMode.Auto)
+                return;
+            state.speedSetting = oldSpeedSetting;
+            device.log.debug(`handleSpeedSettingChanging speedSetting changed to ${speedSetting} >>> fanMode ${lookupFanMode[this.state.fanMode]} speedSetting ${state.speedSetting} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        const { percentSetting } = this.state;
+        if (percentSetting !== null && speedSettingForPercent(state.speedMax, percentSetting) === speedSetting)
+            return;
+        const percent = speedSetting === 0 ? 0 : Math.min(100, Math.round((speedSetting / state.speedMax) * 100));
+        const fanMode = percent === 0 ? FanControl.FanMode.Off : percentToFanMode(percent, this.state.fanModeSequence);
+        if (fanMode !== this.state.fanMode)
+            this.state.fanMode = fanMode;
+        if (percent !== this.state.percentSetting)
+            this.state.percentSetting = percent;
+        device.log.debug(`handleSpeedSettingChanging speedSetting changed to ${speedSetting} >>> fanMode ${lookupFanMode[this.state.fanMode]} percentSetting ${this.state.percentSetting} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    }
     async step(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping fan with direction ${request.direction} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`Stepping fan with direction ${lookupStepDirection[request.direction]} wrap: ${request.wrap} lowestOff: ${request.lowestOff} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('FanControl.step', {
             command: 'step',
             request,
@@ -13,23 +164,36 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
             endpoint: this.endpoint,
             context: this.context,
         });
-        const lookupStepDirection = ['Increase', 'Decrease'];
-        device.log.debug(`MatterbridgeFanControlServer: step called with direction: ${lookupStepDirection[request.direction]} wrap: ${request.wrap} lowestOff: ${request.lowestOff}`);
-        device.log.debug(`- current percentCurrent: ${this.state.percentCurrent}`);
+        const wrap = request.wrap ?? false;
+        const lowestOff = request.lowestOff ?? true;
+        const currentFanMode = this.state.fanMode;
+        const currentPercentSetting = this.state.percentSetting;
+        const fanModeSequence = this.state.fanModeSequence;
+        const supported = supportedFanModesBySequence[fanModeSequence];
+        const stepFanModes = [...(lowestOff ? [FanControl.FanMode.Off] : []), ...steppedFanModes.filter((fanMode) => supported.has(fanMode))];
+        let targetFanMode;
         if (request.direction === FanControl.StepDirection.Increase) {
-            if (request.wrap && this.state.percentCurrent === 100) {
-                this.state.percentCurrent = request.lowestOff ? 0 : 10;
-            }
-            else
-                this.state.percentCurrent = Math.min(this.state.percentCurrent + 10, 100);
+            const higher = stepFanModes.filter((fanMode) => fanMode > currentFanMode);
+            targetFanMode = higher.length > 0 ? Math.min(...higher) : wrap ? Math.min(...stepFanModes) : Math.max(...stepFanModes);
         }
         else if (request.direction === FanControl.StepDirection.Decrease) {
-            if (request.wrap && this.state.percentCurrent === (request.lowestOff ? 0 : 10)) {
-                this.state.percentCurrent = 100;
-            }
-            else
-                this.state.percentCurrent = Math.max(this.state.percentCurrent - 10, request.lowestOff ? 0 : 10);
+            const lower = stepFanModes.filter((fanMode) => fanMode < currentFanMode);
+            targetFanMode = lower.length > 0 ? Math.max(...lower) : wrap ? Math.max(...stepFanModes) : Math.min(...stepFanModes);
+        }
+        else {
+            return;
+        }
+        if (targetFanMode !== currentFanMode)
+            this.state.fanMode = targetFanMode;
+        const resolvedPercentSetting = resolveStepPercentSettingForFanMode(targetFanMode, request.direction, currentPercentSetting, fanModeSequence);
+        if (resolvedPercentSetting !== this.state.percentSetting)
+            this.state.percentSetting = resolvedPercentSetting;
+        this.state.percentCurrent = resolvedPercentSetting;
+        if (this.features.multiSpeed) {
+            const state = this.state;
+            state.speedCurrent = speedSettingForPercent(state.speedMax, resolvedPercentSetting);
         }
-        device.log.debug('Set percentCurrent to:', this.state.percentCurrent);
+        device.log.debug(`MatterbridgeFanControlServer: step applied fanMode ${lookupFanMode[this.state.fanMode]}, percentCurrent ${this.state.percentCurrent}` +
+            (this.features.multiSpeed ? `, speedCurrent ${this.state.speedCurrent}` : ''));
     }
 }

package/dist/behaviors/onOffServer.js

@@ -5,84 +5,96 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
     async on() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('OnOff.on', {
-            command: 'on',
-            request: {},
-            cluster: OnOffServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-            context: this.context,
-        });
+        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
+            await device.commandHandler.executeHandler('OnOff.on', {
+                command: 'on',
+                request: {},
+                cluster: OnOffServer.id,
+                attributes: this.state,
+                endpoint: this.endpoint,
+                context: this.context,
+            });
+        }
         device.log.debug(`MatterbridgeOnOffServer: on called`);
         await super.on();
     }
     async off() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('OnOff.off', {
-            command: 'off',
-            request: {},
-            cluster: OnOffServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-            context: this.context,
-        });
+        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
+            await device.commandHandler.executeHandler('OnOff.off', {
+                command: 'off',
+                request: {},
+                cluster: OnOffServer.id,
+                attributes: this.state,
+                endpoint: this.endpoint,
+                context: this.context,
+            });
+        }
         device.log.debug(`MatterbridgeOnOffServer: off called`);
         await super.off();
     }
     async toggle() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Toggle device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('OnOff.toggle', {
-            command: 'toggle',
-            request: {},
-            cluster: OnOffServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-            context: this.context,
-        });
+        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
+            await device.commandHandler.executeHandler('OnOff.toggle', {
+                command: 'toggle',
+                request: {},
+                cluster: OnOffServer.id,
+                attributes: this.state,
+                endpoint: this.endpoint,
+                context: this.context,
+            });
+        }
         device.log.debug(`MatterbridgeOnOffServer: toggle called`);
         await super.toggle();
     }
     async offWithEffect(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device off with effect ${request.effectIdentifier} and variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('OnOff.offWithEffect', {
-            command: 'offWithEffect',
-            request,
-            cluster: OnOffServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-            context: this.context,
-        });
+        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
+            await device.commandHandler.executeHandler('OnOff.offWithEffect', {
+                command: 'offWithEffect',
+                request,
+                cluster: OnOffServer.id,
+                attributes: this.state,
+                endpoint: this.endpoint,
+                context: this.context,
+            });
+        }
         device.log.debug(`MatterbridgeOnOffServer: offWithEffect called`);
         await super.offWithEffect(request);
     }
     async onWithRecallGlobalScene() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on with recall global scene (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('OnOff.onWithRecallGlobalScene', {
-            command: 'onWithRecallGlobalScene',
-            request: {},
-            cluster: OnOffServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-            context: this.context,
-        });
+        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
+            await device.commandHandler.executeHandler('OnOff.onWithRecallGlobalScene', {
+                command: 'onWithRecallGlobalScene',
+                request: {},
+                cluster: OnOffServer.id,
+                attributes: this.state,
+                endpoint: this.endpoint,
+                context: this.context,
+            });
+        }
         device.log.debug(`MatterbridgeOnOffServer: onWithRecallGlobalScene called`);
         await super.onWithRecallGlobalScene();
     }
     async onWithTimedOff(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on with timed off control ${JSON.stringify(request.onOffControl)}, offWaitTime ${request.offWaitTime} and onTime ${request.onTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('OnOff.onWithTimedOff', {
-            command: 'onWithTimedOff',
-            request,
-            cluster: OnOffServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-            context: this.context,
-        });
+        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
+            await device.commandHandler.executeHandler('OnOff.onWithTimedOff', {
+                command: 'onWithTimedOff',
+                request,
+                cluster: OnOffServer.id,
+                attributes: this.state,
+                endpoint: this.endpoint,
+                context: this.context,
+            });
+        }
         device.log.debug(`MatterbridgeOnOffServer: onWithTimedOff called`);
         await super.onWithTimedOff(request);
     }

package/dist/cli.js

@@ -141,6 +141,7 @@ function help() {
       --loginterfaces:         log the network interfaces (usefull for finding the name of the interface to use with -mdnsinterface option)
       --logstorage:            log the node storage
       --systemcheck:           perform a system check (check Node.js version and network interfaces)
+      --demo-devices:          create demo devices (only in bridge mode)
 
     Reset Commands:
       --reset:                 remove the commissioning for Matterbridge (bridge mode and childbridge mode). Shutdown Matterbridge before using it!

package/dist/demoDevices.d.ts

@@ -0,0 +1,2 @@
+import type { Matterbridge } from './matterbridge.js';
+export declare function createDemoDevices(matterbridge: Matterbridge): Promise<void>;

package/dist/{chipTestDevices.js → demoDevices.js}

@@ -1,25 +1,29 @@
 import { CommonNumberTag } from '@matter/node';
+import { AirQuality } from '@matter/types/clusters/air-quality';
+import { FanControl } from '@matter/types/clusters/fan-control';
+import { PowerSource } from '@matter/types/clusters/power-source';
 import { EndpointNumber } from '@matter/types/datatype';
+import { Closure } from './devices/closure.js';
 import { IrrigationSystem } from './devices/irrigationSystem.js';
 import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { getSemtag } from './matterbridgeEndpointHelpers.js';
-export async function createChipTestDevices(matterbridge) {
-    if (!process.env.MATTERBRIDGE_CHIP_TEST || !process.env.MATTERBRIDGE_CHIP_TEST_DEVICES || matterbridge.bridgeMode !== 'bridge' || !matterbridge.aggregatorNode)
+export async function createDemoDevices(matterbridge) {
+    if (matterbridge.bridgeMode !== 'bridge' || !matterbridge.serverNode || !matterbridge.aggregatorNode)
         return;
     const serverNode = matterbridge.serverNode;
     const aggregator = matterbridge.aggregatorNode;
     if (!serverNode || !aggregator) {
-        matterbridge.log.error('CHIP test devices can only be created when the server node and aggregator node are available');
+        matterbridge.log.error('Demo devices can only be created when the server node and aggregator node are available');
         return;
     }
     let ep;
     matterbridge.plugins.set({
-        name: 'matterbridge-chip',
+        name: 'matterbridge-demo-devices',
         path: '',
         type: 'DynamicPlatform',
         version: '1.0.0',
-        description: 'Chip test plugin',
+        description: 'Matterbridge demo devices',
         author: 'Matterbridge',
         enabled: false,
         private: false,
@@ -28,8 +32,8 @@ export async function createChipTestDevices(matterbridge) {
     const registerDevice = async (device, deviceName, serialNumber) => {
         device.createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber);
         device.addRequiredClusters();
-        device.plugin = 'matterbridge-chip';
-        await matterbridge.addBridgedEndpoint('matterbridge-chip', device);
+        device.plugin = 'matterbridge-demo-devices';
+        await matterbridge.addBridgedEndpoint('matterbridge-demo-devices', device);
     };
     const bridgedNode = getSupportedDeviceType('BridgedNode');
     const powerSource = getSupportedDeviceType('PowerSource');
@@ -157,31 +161,94 @@ export async function createChipTestDevices(matterbridge) {
     ep.createSmokeOnlySmokeCOAlarmClusterServer();
     await registerDevice(ep, 'Smoke Alarm', 'SENSOR-07-09-1');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('SmokeCOAlarm'), bridgedNode, powerSource], { id: 'COAlarm', number: EndpointNumber(7_09_2) });
-    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultPowerSourceBatteryClusterServer(90, PowerSource.BatChargeLevel.Ok);
     ep.createCoOnlySmokeCOAlarmClusterServer();
     await registerDevice(ep, 'CO Alarm', 'SENSOR-07-09-2');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('AirQualitySensor'), bridgedNode, powerSource], { id: 'AirQualitySensor', number: EndpointNumber(7_10) });
-    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultPowerSourceBatteryClusterServer(70, PowerSource.BatChargeLevel.Ok);
     ep.createDefaultTvocMeasurementClusterServer(50, undefined, undefined, undefined, 0, 1000);
     ep.addOptionalClusterServers();
     await registerDevice(ep, 'Air Quality Sensor', 'SENSOR-07-10');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterFreezeDetector'), bridgedNode, powerSource], { id: 'WaterFreezeDetector', number: EndpointNumber(7_11) });
-    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultPowerSourceBatteryClusterServer(50, PowerSource.BatChargeLevel.Ok);
     ep.createDefaultBooleanStateClusterServer(false);
     ep.createDefaultBooleanStateConfigurationClusterServer();
     await registerDevice(ep, 'Water Freeze Detector', 'SENSOR-07-11');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WaterLeakDetector'), bridgedNode, powerSource], { id: 'WaterLeakDetector', number: EndpointNumber(7_12) });
-    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultPowerSourceBatteryClusterServer(20, PowerSource.BatChargeLevel.Warning);
     ep.createDefaultBooleanStateClusterServer(false);
     ep.createDefaultBooleanStateConfigurationClusterServer();
     await registerDevice(ep, 'Water Leak Detector', 'SENSOR-07-12');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('RainSensor'), bridgedNode, powerSource], { id: 'RainSensor', number: EndpointNumber(7_13) });
-    ep.createDefaultPowerSourceRechargeableBatteryClusterServer();
+    ep.createDefaultPowerSourceRechargeableBatteryClusterServer(10, PowerSource.BatChargeLevel.Critical);
     ep.createDefaultBooleanStateClusterServer(false);
     ep.createDefaultBooleanStateConfigurationClusterServer();
     await registerDevice(ep, 'Rain Sensor', 'SENSOR-07-13');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('SoilSensor'), bridgedNode, powerSource], { id: 'SoilSensor', number: EndpointNumber(7_14) });
-    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createDefaultPowerSourceWiredClusterServer(PowerSource.WiredCurrentType.Dc);
     ep.createDefaultSoilMeasurementClusterServer(50);
     await registerDevice(ep, 'Soil Sensor', 'SENSOR-07-14');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('DoorLock'), bridgedNode, powerSource], { id: 'DoorLock', number: EndpointNumber(8_01) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    await registerDevice(ep, 'Door Lock', 'ENTRY-08-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('DoorLockController'), bridgedNode, powerSource], { id: 'DoorLockController', number: EndpointNumber(8_02) });
+    await registerDevice(ep, 'Door Lock Controller', 'ENTRY-08-02');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCovering', number: EndpointNumber(8_03) });
+    await registerDevice(ep, 'Window Covering', 'ENTRY-08-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCoveringController'), bridgedNode, powerSource], { id: 'WindowCoveringController', number: EndpointNumber(8_04) });
+    await registerDevice(ep, 'Window Covering Controller', 'ENTRY-08-04');
+    ep = new Closure('Closure', 'ENTRY-08-05', { id: 'Closure', number: EndpointNumber(8_05) });
+    await registerDevice(ep, 'Closure', 'ENTRY-08-05');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ClosureController'), bridgedNode, powerSource], { id: 'ClosureController', number: EndpointNumber(8_07) });
+    await registerDevice(ep, 'Closure Controller', 'ENTRY-08-07');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'Thermostat', number: EndpointNumber(9_01) });
+    await registerDevice(ep, 'Thermostat', 'HVAC-09-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatHeating', number: EndpointNumber(9_01_1) });
+    ep.createDefaultHeatingThermostatClusterServer();
+    await registerDevice(ep, 'Thermostat Heating', 'HVAC-09-01-1');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatCooling', number: EndpointNumber(9_01_2) });
+    ep.createDefaultCoolingThermostatClusterServer();
+    await registerDevice(ep, 'Thermostat Cooling', 'HVAC-09-01-2');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatPresets', number: EndpointNumber(9_01_3) });
+    ep.createDefaultPresetsThermostatClusterServer();
+    await registerDevice(ep, 'Thermostat Presets', 'HVAC-09-01-3');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatSchedules', number: EndpointNumber(9_01_4) });
+    ep.createDefaultSchedulesThermostatClusterServer();
+    await registerDevice(ep, 'Thermostat Schedules', 'HVAC-09-01-4');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatSuggestions', number: EndpointNumber(9_01_5) });
+    ep.createDefaultThermostatSuggestionsClusterServer();
+    await registerDevice(ep, 'Thermostat Suggestions', 'HVAC-09-01-5');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Fan'), bridgedNode, powerSource], { id: 'Fan', number: EndpointNumber(9_02) });
+    await registerDevice(ep, 'Fan OffLowMedHighAuto', 'HVAC-09-02');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Fan'), bridgedNode, powerSource], { id: 'FanOnOff', number: EndpointNumber(9_02_1) });
+    ep.createOnOffFanControlClusterServer(FanControl.FanMode.High);
+    await registerDevice(ep, 'Fan OffHigh', 'HVAC-09-02-1');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Fan'), bridgedNode, powerSource], { id: 'FanBase', number: EndpointNumber(9_02_2) });
+    ep.createBaseFanControlClusterServer(FanControl.FanMode.Low, undefined, 30, 30);
+    await registerDevice(ep, 'Fan OffLowMedHigh', 'HVAC-09-02-2');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Fan'), bridgedNode, powerSource], { id: 'FanMultiSpeed', number: EndpointNumber(9_02_3) });
+    ep.createMultiSpeedFanControlClusterServer(FanControl.FanMode.Medium, undefined, 50, 50, 10, 5, 5);
+    await registerDevice(ep, 'Fan MultiSpeed', 'HVAC-09-02-3');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Fan'), bridgedNode, powerSource], { id: 'FanComplete', number: EndpointNumber(9_02_4) });
+    ep.createCompleteFanControlClusterServer(FanControl.FanMode.Auto, undefined, 60, 60, 10, 5, 5);
+    await registerDevice(ep, 'Fan Complete', 'HVAC-09-02-4');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('AirPurifier'), bridgedNode, powerSource], {
+        id: 'AirPurifier',
+        number: EndpointNumber(9_03),
+    });
+    ep.createDefaultHepaFilterMonitoringClusterServer(85);
+    ep.createDefaultActivatedCarbonFilterMonitoringClusterServer(75);
+    ep.addChildDeviceType('AirQualitySensor', getSupportedDeviceType('AirQualitySensor'), { number: EndpointNumber(9_03_1) })
+        .createDefaultAirQualityClusterServer(AirQuality.AirQualityEnum.Good)
+        .addRequiredClusters();
+    ep.addChildDeviceType('Thermostat', getSupportedDeviceType('Thermostat'), { number: EndpointNumber(9_03_2) }).addRequiredClusters();
+    ep.addChildDeviceType('TemperatureSensor', getSupportedDeviceType('TemperatureSensor'), { number: EndpointNumber(9_03_3) })
+        .createDefaultTemperatureMeasurementClusterServer(2000, -4000, 8500)
+        .addRequiredClusters();
+    ep.addChildDeviceType('HumiditySensor', getSupportedDeviceType('HumiditySensor'), { number: EndpointNumber(9_03_4) })
+        .createDefaultRelativeHumidityMeasurementClusterServer(5000, 0, 10000)
+        .addRequiredClusters();
+    await registerDevice(ep, 'Air Purifier', 'HVAC-09-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ThermostatController'), bridgedNode, powerSource], { id: 'ThermostatController', number: EndpointNumber(9_04) });
+    await registerDevice(ep, 'Thermostat Controller', 'HVAC-09-04');
 }

package/dist/devices/closure.d.ts

@@ -1,4 +1,5 @@
 import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
+import { type EndpointNumber } from '@matter/types';
 import { ClosureControl } from '@matter/types/clusters/closure-control';
 import { Identify } from '@matter/types/clusters/identify';
 import type { Semtag } from '@matter/types/globals';
@@ -29,6 +30,8 @@ export interface ClosureOptions {
     overallCurrentState?: ClosureControl.OverallCurrentState;
     overallTargetState?: ClosureControl.OverallTargetState;
     latchControlModes?: ClosureControl.LatchControlModes;
+    id?: string;
+    number?: EndpointNumber;
     tagList?: Semtag[];
 }
 export declare class Closure extends MatterbridgeEndpoint {

package/dist/devices/closure.js

@@ -74,9 +74,10 @@ export class Closure extends MatterbridgeEndpoint {
             position: ClosureControl.TargetPosition.MoveToFullyClosed,
             latch: true,
             speed: ThreeLevelAuto.Auto,
-        }, latchControlModes = { remoteLatching: true, remoteUnlatching: true }, tagList = [getSemtag(ClosureTag.Covering)], } = options;
+        }, latchControlModes = { remoteLatching: true, remoteUnlatching: true }, id, number, tagList = [getSemtag(ClosureTag.Covering)], } = options;
         super(powerSourceType === 'None' ? [closure] : [closure, powerSource], {
-            id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number,
             tagList,
         });
         this.createDefaultIdentifyClusterServer(identifyTime, identifyType);

package/dist/frontend.js

@@ -4,16 +4,24 @@ import path from 'node:path';
 import { Diagnostic, Lifecycle, LogDestination, LogFormat as MatterLogFormat, Logger, LogLevel as MatterLogLevel } from '@matter/general';
 import { DeviceAdvertiser, DeviceCommissioner, FabricManager } from '@matter/protocol';
 import { getClusterNameById } from '@matter/types/cluster';
+import { AirQuality } from '@matter/types/clusters/air-quality';
 import { BridgedDeviceBasicInformation } from '@matter/types/clusters/bridged-device-basic-information';
+import { ClosureControl } from '@matter/types/clusters/closure-control';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import { FanControl } from '@matter/types/clusters/fan-control';
+import { OperationalState } from '@matter/types/clusters/operational-state';
 import { PowerSource } from '@matter/types/clusters/power-source';
+import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-state';
+import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 import { SoilMeasurement } from '@matter/types/clusters/soil-measurement';
+import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 import { CommissioningOptions } from '@matter/types/commissioning';
 import { FabricIndex } from '@matter/types/datatype';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
 import { isBun } from '@matterbridge/utils/bun';
 import { getParameter, hasParameter } from '@matterbridge/utils/cli';
+import { getEnumDescription } from '@matterbridge/utils/enum';
 import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
 import { formatBytes, formatPercent, formatUptime } from '@matterbridge/utils/format';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
@@ -1117,6 +1125,14 @@ export class Frontend extends EventEmitter {
                 attributes += `Cover position: ${attributeValue / 100}% `;
             if (clusterName === 'doorLock' && attributeName === 'lockState')
                 attributes += `State: ${attributeValue === 1 ? 'Locked' : 'Not locked'} `;
+            if (clusterName === 'closureControl' && attributeName === 'overallCurrentState' && attributeValue === null)
+                attributes += `Position: unknown Latch: unknown SecureState: unknown `;
+            if (clusterName === 'closureControl' && attributeName === 'overallCurrentState' && isValidObject(attributeValue)) {
+                const overallCurrentState = attributeValue;
+                attributes += `Position: ${getEnumDescription(ClosureControl.CurrentPosition, overallCurrentState.position, { fallback: 'unknown' })} `;
+                attributes += `Latch: ${overallCurrentState.latch ?? 'unknown'} `;
+                attributes += `SecureState: ${overallCurrentState.secureState ?? 'unknown'} `;
+            }
             if (clusterName === 'thermostat' && attributeName === 'localTemperature' && isValidNumber(attributeValue))
                 attributes += `Temperature: ${attributeValue / 100}°C `;
             if (clusterName === 'thermostat' && attributeName === 'occupiedHeatingSetpoint' && isValidNumber(attributeValue))
@@ -1132,13 +1148,14 @@ export class Frontend extends EventEmitter {
                 if (supportedMode)
                     attributes += `Mode: ${supportedMode.label} `;
             }
-            const operationalStateClusters = ['operationalState', 'rvcOperationalState'];
-            if (operationalStateClusters.includes(clusterName) && attributeName === 'operationalState')
-                attributes += `OpState: ${attributeValue} `;
+            if (clusterName === 'operationalState' && attributeName === 'operationalState')
+                attributes += `OpState: ${getEnumDescription(OperationalState.OperationalStateEnum, attributeValue)} `;
+            if (clusterName === 'rvcOperationalState' && attributeName === 'operationalState')
+                attributes += `OpState: ${getEnumDescription(RvcOperationalState.OperationalState, attributeValue)} `;
             if (clusterName === 'pumpConfigurationAndControl' && attributeName === 'operationMode')
                 attributes += `Mode: ${attributeValue} `;
             if (clusterName === 'valveConfigurationAndControl' && attributeName === 'currentState')
-                attributes += `State: ${attributeValue} `;
+                attributes += `State: ${getEnumDescription(ValveConfigurationAndControl.ValveState, attributeValue, { fallback: 'unknown' })} `;
             if (clusterName === 'levelControl' && attributeName === 'currentLevel')
                 attributes += `Level: ${attributeValue} `;
             if (clusterName === 'colorControl' && attributeName === 'colorMode' && isValidNumber(attributeValue, 0, 2))
@@ -1158,15 +1175,25 @@ export class Frontend extends EventEmitter {
             if (clusterName === 'booleanStateConfiguration' && attributeName === 'alarmsActive' && isValidObject(attributeValue))
                 attributes += `Active alarms: ${stringify(attributeValue)} `;
             if (clusterName === 'smokeCoAlarm' && attributeName === 'smokeState')
-                attributes += `Smoke: ${attributeValue} `;
+                attributes += `Smoke: ${getEnumDescription(SmokeCoAlarm.AlarmState, attributeValue)} `;
             if (clusterName === 'smokeCoAlarm' && attributeName === 'coState')
-                attributes += `Co: ${attributeValue} `;
+                attributes += `Co: ${getEnumDescription(SmokeCoAlarm.AlarmState, attributeValue)} `;
             if (clusterName === 'fanControl' && attributeName === 'fanMode')
-                attributes += `Mode: ${attributeValue} `;
+                attributes += `Mode: ${getEnumDescription(FanControl.FanMode, attributeValue)} `;
             if (clusterName === 'fanControl' && attributeName === 'percentCurrent')
-                attributes += `Percent: ${attributeValue} `;
+                attributes += `Percent: ${attributeValue}% `;
             if (clusterName === 'fanControl' && attributeName === 'speedCurrent')
                 attributes += `Speed: ${attributeValue} `;
+            if (clusterName === 'fanControl' && attributeName === 'rockSetting' && isValidObject(attributeValue))
+                attributes += `Rock: ${stringify(attributeValue)} `;
+            if (clusterName === 'fanControl' && attributeName === 'windSetting' && isValidObject(attributeValue))
+                attributes += `Wind: ${stringify(attributeValue)} `;
+            if (clusterName === 'fanControl' && attributeName === 'airflowDirection')
+                attributes += `Direction: ${getEnumDescription(FanControl.AirflowDirection, attributeValue)} `;
+            if (clusterName === 'hepaFilterMonitoring' && attributeName === 'condition')
+                attributes += `Hepa filter: ${attributeValue}% `;
+            if (clusterName === 'activatedCarbonFilterMonitoring' && attributeName === 'condition')
+                attributes += `Carbon filter: ${attributeValue}% `;
             if (clusterName === 'occupancySensing' && attributeName === 'occupancy' && isValidObject(attributeValue, 1))
                 attributes += `Occupancy: ${attributeValue.occupied} `;
             if (clusterName === 'illuminanceMeasurement' && attributeName === 'measuredValue') {
@@ -1176,47 +1203,27 @@ export class Frontend extends EventEmitter {
                     attributes += `Illuminance: ${Math.round(Math.max(Math.pow(10, attributeValue / 10000), 0))} lx`;
             }
             if (clusterName === 'airQuality' && attributeName === 'airQuality')
-                attributes += `Air quality: ${attributeValue} `;
+                attributes += `Air quality: ${getEnumDescription(AirQuality.AirQualityEnum, attributeValue)} `;
             if (clusterName === 'totalVolatileOrganicCompoundsConcentrationMeasurement' && attributeName === 'measuredValue')
-                attributes += `Voc: ${attributeValue} `;
+                appendMeasurement('Voc', getMeasurementText(attributeValue, 1, ''));
             if (clusterName === 'pm1ConcentrationMeasurement' && attributeName === 'measuredValue')
-                attributes += `Pm1: ${attributeValue} `;
+                appendMeasurement('Pm1', getMeasurementText(attributeValue, 1, ''));
             if (clusterName === 'pm25ConcentrationMeasurement' && attributeName === 'measuredValue')
-                attributes += `Pm2.5: ${attributeValue} `;
+                appendMeasurement('Pm2.5', getMeasurementText(attributeValue, 1, ''));
             if (clusterName === 'pm10ConcentrationMeasurement' && attributeName === 'measuredValue')
-                attributes += `Pm10: ${attributeValue} `;
+                appendMeasurement('Pm10', getMeasurementText(attributeValue, 1, ''));
             if (clusterName === 'formaldehydeConcentrationMeasurement' && attributeName === 'measuredValue')
-                attributes += `CH₂O: ${attributeValue} `;
-            if (clusterName === 'temperatureMeasurement' && attributeName === 'measuredValue') {
-                if (attributeValue === null)
-                    attributes += `Temperature: unknown `;
-                else if (isValidNumber(attributeValue))
-                    attributes += `Temperature: ${attributeValue / 100} °C `;
-            }
-            if (clusterName === 'relativeHumidityMeasurement' && attributeName === 'measuredValue') {
-                if (attributeValue === null)
-                    attributes += `Humidity: unknown `;
-                else if (isValidNumber(attributeValue))
-                    attributes += `Humidity: ${attributeValue / 100}% `;
-            }
-            if (clusterName === 'pressureMeasurement' && attributeName === 'measuredValue') {
-                if (attributeValue === null)
-                    attributes += `Pressure: unknown `;
-                else if (isValidNumber(attributeValue))
-                    attributes += `Pressure: ${attributeValue} hPa `;
-            }
-            if (clusterName === 'flowMeasurement' && attributeName === 'measuredValue') {
-                if (attributeValue === null)
-                    attributes += `Flow: unknown `;
-                else if (isValidNumber(attributeValue))
-                    attributes += `Flow: ${attributeValue / 10} m³/h `;
-            }
-            if (clusterId === SoilMeasurement.id && attributeName === 'soilMoistureMeasuredValue') {
-                if (attributeValue === null)
-                    attributes += `Soil moisture: unknown `;
-                else if (isValidNumber(attributeValue))
-                    attributes += `Soil moisture: ${attributeValue}% `;
-            }
+                appendMeasurement('CH₂O', getMeasurementText(attributeValue, 1, ''));
+            if (clusterName === 'temperatureMeasurement' && attributeName === 'measuredValue')
+                appendMeasurement('Temperature', getMeasurementText(attributeValue, 100, ' °C'));
+            if (clusterName === 'relativeHumidityMeasurement' && attributeName === 'measuredValue')
+                appendMeasurement('Humidity', getMeasurementText(attributeValue, 100, '%'));
+            if (clusterName === 'pressureMeasurement' && attributeName === 'measuredValue')
+                appendMeasurement('Pressure', getMeasurementText(attributeValue, 1, ' hPa'));
+            if (clusterName === 'flowMeasurement' && attributeName === 'measuredValue')
+                appendMeasurement('Flow', getMeasurementText(attributeValue, 10, ' m³/h'));
+            if (clusterId === SoilMeasurement.id && attributeName === 'soilMoistureMeasuredValue')
+                appendMeasurement('Soil moisture', getMeasurementText(attributeValue, 1, '%'));
             if (clusterName === 'electricalPowerMeasurement' && attributeName === 'voltage')
                 appendMeasurement('Voltage', getMeasurementText(attributeValue, 1_000, 'V'));
             if (clusterName === 'electricalPowerMeasurement' && attributeName === 'activeCurrent')

package/dist/matterNode.js

@@ -864,6 +864,7 @@ export class MatterNode extends EventEmitter {
             { cluster: 'FanControl', attribute: 'fanMode' },
             { cluster: 'FanControl', attribute: 'fanModeSequence' },
             { cluster: 'FanControl', attribute: 'percentSetting' },
+            { cluster: 'FanControl', attribute: 'percentCurrent' },
             { cluster: 'ModeSelect', attribute: 'currentMode' },
             { cluster: 'RvcRunMode', attribute: 'currentMode' },
             { cluster: 'RvcCleanMode', attribute: 'currentMode' },

package/dist/matterbridge.js

@@ -1569,12 +1569,18 @@ export class Matterbridge extends EventEmitter {
         this.aggregatorNode = await this.createAggregatorNode(this.matterbridgeContext);
         await this.serverNode.add(this.aggregatorNode);
         await addVirtualDevices(this, this.aggregatorNode);
-        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+        if (process.env.MATTERBRIDGE_DEMO_DEVICES || hasParameter('demo-devices')) {
+            this.log.warn(' *********************************************************************************');
+            this.log.warn(' * MATTERBRIDGE_DEMO_DEVICES environment variable is set. Creating demo devices. *');
+            this.log.warn(' *********************************************************************************');
+            const { createDemoDevices } = await import('./demoDevices.js');
+            await createDemoDevices(this);
+        }
+        if (process.env.MATTERBRIDGE_CHIP_TEST && fs.existsSync(path.join(path.dirname(fileURLToPath(import.meta.url)), 'chipTests.js'))) {
+            this.log.warn(' ***********************************************************************************');
+            this.log.warn(' * MATTERBRIDGE_CHIP_TEST environment variable is set. Running chip test app pipe. *');
+            this.log.warn(' ***********************************************************************************');
             const { createChipTestAppPipe } = await import('./chipTests.js');
-            if (process.env.MATTERBRIDGE_CHIP_TEST_DEVICES) {
-                const { createChipTestDevices } = await import('./chipTestDevices.js');
-                await createChipTestDevices(this);
-            }
             createChipTestAppPipe(this);
         }
         await this.startPlugins(false, true);
@@ -1887,7 +1893,10 @@ export class Matterbridge extends EventEmitter {
             discriminator = PaseClient.generateRandomDiscriminator(this.environment.get(Crypto));
         }
         let rootEndpoint = ServerNode.RootEndpoint.with(PowerSourceServer.with(PowerSource.Feature.Wired));
-        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+        if (process.env.MATTERBRIDGE_CHIP_TEST && fs.existsSync(path.join(path.dirname(fileURLToPath(import.meta.url)), 'chipTests.js'))) {
+            this.log.warn(' ****************************************************************************************');
+            this.log.warn(' * MATTERBRIDGE_CHIP_TEST environment variable is set. Running TestEventTrigger server. *');
+            this.log.warn(' ****************************************************************************************');
             const { MatterbridgeGeneralDiagnosticsServer } = await import('./chipTests.js');
             rootEndpoint = rootEndpoint.with(MatterbridgeGeneralDiagnosticsServer);
         }
@@ -2291,6 +2300,7 @@ export class Matterbridge extends EventEmitter {
             { cluster: 'FanControl', attribute: 'fanMode' },
             { cluster: 'FanControl', attribute: 'fanModeSequence' },
             { cluster: 'FanControl', attribute: 'percentSetting' },
+            { cluster: 'FanControl', attribute: 'percentCurrent' },
             { cluster: 'ModeSelect', attribute: 'currentMode' },
             { cluster: 'RvcRunMode', attribute: 'currentMode' },
             { cluster: 'RvcCleanMode', attribute: 'currentMode' },

package/dist/matterbridgeEndpoint.d.ts

@@ -9,6 +9,7 @@ import type { DeviceEnergyManagementMode } from '@matter/types/clusters/device-e
 import { DoorLock } from '@matter/types/clusters/door-lock';
 import { FanControl } from '@matter/types/clusters/fan-control';
 import { Identify } from '@matter/types/clusters/identify';
+import type { IlluminanceMeasurement } from '@matter/types/clusters/illuminance-measurement';
 import type { ModeSelect } from '@matter/types/clusters/mode-select';
 import { OnOff } from '@matter/types/clusters/on-off';
 import { OperationalState } from '@matter/types/clusters/operational-state';
@@ -217,11 +218,11 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     createDefaultOperationalStateClusterServer(operationalState?: OperationalState.OperationalStateEnum): this;
     createDefaultBooleanStateClusterServer(contact?: boolean): this;
     createDefaultBooleanStateConfigurationClusterServer(sensorFault?: boolean, currentSensitivityLevel?: number, supportedSensitivityLevels?: number, defaultSensitivityLevel?: number): this;
-    createDefaultTemperatureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
-    createDefaultRelativeHumidityMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
-    createDefaultPressureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
-    createDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
-    createDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
+    createDefaultTemperatureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): this;
+    createDefaultRelativeHumidityMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): this;
+    createDefaultPressureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): this;
+    createDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number, lightSensorType?: IlluminanceMeasurement.LightSensorType | null): this;
+    createDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): this;
     createDefaultOccupancySensingClusterServer(occupied?: boolean, holdTime?: number, holdTimeMin?: number, holdTimeMax?: number): this;
     createDefaultSoilMeasurementClusterServer(soilMoistureMeasuredValue?: number | null, soilMoistureMeasurementLimits?: MeasurementAccuracy): this;
     createDefaultAirQualityClusterServer(airQuality?: AirQuality.AirQualityEnum): this;

package/dist/matterbridgeEndpoint.js

@@ -1175,8 +1175,8 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(FanControlServer, {
             fanMode,
             fanModeSequence: FanControl.FanModeSequence.OffHigh,
-            percentSetting: 0,
-            percentCurrent: 0,
+            percentSetting: fanMode === FanControl.FanMode.Off ? 0 : 100,
+            percentCurrent: fanMode === FanControl.FanMode.Off ? 0 : 100,
         });
         return this;
     }
@@ -1487,7 +1487,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultBooleanStateConfigurationClusterServer(sensorFault = false, currentSensitivityLevel = 0, supportedSensitivityLevels = 2, defaultSensitivityLevel = 0) {
+    createDefaultBooleanStateConfigurationClusterServer(sensorFault = false, currentSensitivityLevel = 1, supportedSensitivityLevels = 3, defaultSensitivityLevel = 1) {
         this.behaviors.require(MatterbridgeBooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.AlarmSuppress, BooleanStateConfiguration.Feature.SensitivityLevel, BooleanStateConfiguration.Feature.FaultEvents).enable({
             events: { alarmsStateChanged: true, sensorFault: true },
         }), {
@@ -1502,24 +1502,24 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-        this.behaviors.require(TemperatureMeasurementServer, getDefaultTemperatureMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
+    createDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
+        this.behaviors.require(TemperatureMeasurementServer, getDefaultTemperatureMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue, tolerance));
         return this;
     }
-    createDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-        this.behaviors.require(RelativeHumidityMeasurementServer, getDefaultRelativeHumidityMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
+    createDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
+        this.behaviors.require(RelativeHumidityMeasurementServer, getDefaultRelativeHumidityMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue, tolerance));
         return this;
     }
-    createDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-        this.behaviors.require(PressureMeasurementServer, getDefaultPressureMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
+    createDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
+        this.behaviors.require(PressureMeasurementServer, getDefaultPressureMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue, tolerance));
         return this;
     }
-    createDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-        this.behaviors.require(IlluminanceMeasurementServer, getDefaultIlluminanceMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
+    createDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0, lightSensorType = null) {
+        this.behaviors.require(IlluminanceMeasurementServer, getDefaultIlluminanceMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue, tolerance, lightSensorType));
         return this;
     }
-    createDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-        this.behaviors.require(FlowMeasurementServer, getDefaultFlowMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
+    createDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
+        this.behaviors.require(FlowMeasurementServer, getDefaultFlowMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue, tolerance));
         return this;
     }
     createDefaultOccupancySensingClusterServer(occupied = false, holdTime = 30, holdTimeMin = 1, holdTimeMax = 300) {

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -143,11 +143,11 @@ export declare function getDefaultDeviceEnergyManagementModeClusterServer(curren
     onOff: false;
 }>, typeof MatterbridgeDeviceEnergyManagementModeServer>>;
 export declare function getDefaultOperationalStateClusterServer(operationalState?: OperationalState.OperationalStateEnum): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<OperationalState, {}>, typeof MatterbridgeOperationalStateServer>>;
-export declare function getDefaultTemperatureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<TemperatureMeasurement, typeof ClusterBehavior>>;
-export declare function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<RelativeHumidityMeasurement, typeof ClusterBehavior>>;
-export declare function getDefaultPressureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<PressureMeasurement, typeof ClusterBehavior>>;
-export declare function getDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<IlluminanceMeasurement, typeof ClusterBehavior>>;
-export declare function getDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<FlowMeasurement, typeof ClusterBehavior>>;
+export declare function getDefaultTemperatureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): Partial<import("@matter/node").ClusterState.Type<TemperatureMeasurement, typeof ClusterBehavior>>;
+export declare function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): Partial<import("@matter/node").ClusterState.Type<RelativeHumidityMeasurement, typeof ClusterBehavior>>;
+export declare function getDefaultPressureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): Partial<import("@matter/node").ClusterState.Type<PressureMeasurement, typeof ClusterBehavior>>;
+export declare function getDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number, lightSensorType?: IlluminanceMeasurement.LightSensorType | null): Partial<import("@matter/node").ClusterState.Type<IlluminanceMeasurement, typeof ClusterBehavior>>;
+export declare function getDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null, tolerance?: number): Partial<import("@matter/node").ClusterState.Type<FlowMeasurement, typeof ClusterBehavior>>;
 export declare function getDefaultOccupancySensingClusterServer(occupied?: boolean, holdTime?: number, holdTimeMin?: number, holdTimeMax?: number): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<OccupancySensing, {
     activeInfrared: false;
     occupancyEvent: false;

package/dist/matterbridgeEndpointHelpers.js

@@ -1055,44 +1055,45 @@ export function getDefaultOperationalStateClusterServer(operationalState = Opera
         operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
     });
 }
-export function getDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+export function getDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
     return optionsFor(TemperatureMeasurementServer, {
         measuredValue,
         minMeasuredValue,
         maxMeasuredValue,
-        tolerance: 0,
+        tolerance,
     });
 }
-export function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+export function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
     return optionsFor(RelativeHumidityMeasurementServer, {
         measuredValue,
         minMeasuredValue,
         maxMeasuredValue,
-        tolerance: 0,
+        tolerance,
     });
 }
-export function getDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+export function getDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
     return optionsFor(PressureMeasurementServer, {
         measuredValue,
         minMeasuredValue,
         maxMeasuredValue,
-        tolerance: 0,
+        tolerance,
     });
 }
-export function getDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+export function getDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0, lightSensorType = null) {
     return optionsFor(IlluminanceMeasurementServer, {
         measuredValue,
         minMeasuredValue,
         maxMeasuredValue,
-        tolerance: 0,
+        tolerance,
+        lightSensorType,
     });
 }
-export function getDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+export function getDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null, tolerance = 0) {
     return optionsFor(FlowMeasurementServer, {
         measuredValue,
         minMeasuredValue,
         maxMeasuredValue,
-        tolerance: 0,
+        tolerance,
     });
 }
 export function getDefaultOccupancySensingClusterServer(occupied = false, holdTime = 30, holdTimeMin = 1, holdTimeMax = 300) {

package/dist/pluginManager.js

@@ -428,7 +428,7 @@ export class PluginManager extends EventEmitter {
     }
     async loadFromStorage() {
         if (!this.matterbridge.nodeContext) {
-            throw new Error('loadFromStorage: node context is not available.');
+            throw new Error('PluginManager.loadFromStorage: node context is not available.');
         }
         const pluginsArray = await this.matterbridge.nodeContext.get('plugins', []);
         for (const plugin of pluginsArray)
@@ -438,10 +438,12 @@ export class PluginManager extends EventEmitter {
     }
     async saveToStorage() {
         if (!this.matterbridge.nodeContext) {
-            throw new Error('loadFromStorage: node context is not available.');
+            throw new Error('PluginManager.saveToStorage: node context is not available.');
         }
         const plugins = [];
         for (const plugin of this.array()) {
+            if (process.env.MATTERBRIDGE_DEMO_DEVICES && plugin.name === 'matterbridge-demo-devices')
+                continue;
             plugins.push({
                 name: plugin.name,
                 path: plugin.path,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.6-dev-20260818-c2c6349",
+  "version": "3.10.6-dev-20260820-36b52be",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.6-dev-20260818-c2c6349",
-    "@matterbridge/thread": "3.10.6-dev-20260818-c2c6349",
-    "@matterbridge/types": "3.10.6-dev-20260818-c2c6349",
-    "@matterbridge/utils": "3.10.6-dev-20260818-c2c6349",
+    "@matterbridge/dgram": "3.10.6-dev-20260820-36b52be",
+    "@matterbridge/thread": "3.10.6-dev-20260820-36b52be",
+    "@matterbridge/types": "3.10.6-dev-20260820-36b52be",
+    "@matterbridge/utils": "3.10.6-dev-20260820-36b52be",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",

package/dist/chipTestDevices.d.ts

@@ -1,2 +0,0 @@
-import type { Matterbridge } from './matterbridge.js';
-export declare function createChipTestDevices(matterbridge: Matterbridge): Promise<void>;