@matterbridge/core 3.10.7-dev-20260825-7ebac36 → 3.10.7-dev-20260827-957ddcc

package/dist/behaviors/booleanStateConfigurationServer.js

@@ -1,7 +1,7 @@
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { Status, StatusResponseError } from '@matter/types';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
-import { debugStringify } from 'node-ansi-logger';
+import { debugStringify, nf } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.AlarmSuppress, BooleanStateConfiguration.Feature.SensitivityLevel, BooleanStateConfiguration.Feature.FaultEvents) {
     initialize() {
@@ -44,7 +44,7 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
     }
     #assertAlarmModesSupported(alarms) {
         if ([Boolean(alarms.visual && !this.state.alarmsSupported.visual), Boolean(alarms.audible && !this.state.alarmsSupported.audible)].some(Boolean)) {
-            throw new StatusResponseError('Requested alarm mode is not supported', Status.ConstraintError);
+            throw new StatusResponseError(`MatterbridgeBooleanStateConfigurationServer: requested alarm mode is not supported (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
         }
     }
     #assertSuppressAlarmAllowed(alarmsToSuppress) {
@@ -52,12 +52,12 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
             Boolean(alarmsToSuppress.visual && (!this.state.alarmsActive.visual || !this.state.alarmsEnabled?.visual)),
             Boolean(alarmsToSuppress.audible && (!this.state.alarmsActive.audible || !this.state.alarmsEnabled?.audible)),
         ].some(Boolean)) {
-            throw new StatusResponseError('Requested alarm mode is not active', Status.InvalidInState);
+            throw new StatusResponseError(`MatterbridgeBooleanStateConfigurationServer: requested alarm mode is not active (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
         }
     }
     async suppressAlarm(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Suppressing alarm ${debugStringify(request.alarmsToSuppress)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeBooleanStateConfigurationServer: suppressing alarm ${debugStringify(request.alarmsToSuppress)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('BooleanStateConfiguration.suppressAlarm', {
             command: 'suppressAlarm',
             request,
@@ -69,11 +69,11 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
         this.#assertAlarmModesSupported(request.alarmsToSuppress);
         this.#assertSuppressAlarmAllowed(request.alarmsToSuppress);
         this.state.alarmsSuppressed = this.#mergeAlarmsSuppressed(request.alarmsToSuppress);
-        device.log.debug(`MatterbridgeBooleanStateConfigurationServer: suppressAlarm called`);
+        device.log.debug(`MatterbridgeBooleanStateConfigurationServer: suppressAlarm called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
     async enableDisableAlarm(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Enabling/disabling alarm ${debugStringify(request.alarmsToEnableDisable)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeBooleanStateConfigurationServer: enabling/disabling alarm ${debugStringify(request.alarmsToEnableDisable)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('BooleanStateConfiguration.enableDisableAlarm', {
             command: 'enableDisableAlarm',
             request,
@@ -84,6 +84,6 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
         });
         this.#assertAlarmModesSupported(request.alarmsToEnableDisable);
         this.#applyAlarmsEnabled(request.alarmsToEnableDisable);
-        device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called`);
+        device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
 }

package/dist/chipTests.js

@@ -11,9 +11,14 @@ import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-man
 import { ElectricalEnergyMeasurement } from '@matter/types/clusters/electrical-energy-measurement';
 import { ElectricalPowerMeasurement } from '@matter/types/clusters/electrical-power-measurement';
 import { OperationalState } from '@matter/types/clusters/operational-state';
+import { RefrigeratorAlarm } from '@matter/types/clusters/refrigerator-alarm';
+import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-state';
+import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensingServer.js';
 import { cliEmitter } from './cliEmitter.js';
+import { MatterbridgeRefrigeratorAlarmServer } from './devices/refrigerator.js';
+import { MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer } from './devices/roboticVacuumCleaner.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 const chipTestAppPipePath = '/tmp/matterbridge-chip-test-app-pipe';
 const chipTestValidEventTrigger = 0xfffffffffff10000n;
@@ -564,6 +569,73 @@ async function handleChipTestAppPipeCommand(matterbridge, command) {
         return;
     }
     switch (command.Name) {
+        case 'Reset': {
+            if (!endpoint.behaviors.has(MatterbridgeRvcRunModeServer) || !endpoint.behaviors.has(MatterbridgeRvcOperationalStateServer)) {
+                matterbridge.log.warn(`Ignoring RVC Reset CHIP test app pipe command on non-RVC endpoint ${endpointId}`);
+                return;
+            }
+            const runModeState = endpoint.stateOf(MatterbridgeRvcRunModeServer);
+            const idleMode = runModeState.supportedModes.find((mode) => mode.modeTags.some((tag) => tag.value === RvcRunMode.ModeTag.Idle));
+            if (!idleMode) {
+                matterbridge.log.warn(`Ignoring RVC Reset CHIP test app pipe command because endpoint ${endpointId} has no Idle run mode`);
+                return;
+            }
+            await endpoint.setStateOf(MatterbridgeRvcRunModeServer, { currentMode: idleMode.mode });
+            await endpoint.setStateOf(MatterbridgeRvcOperationalStateServer, {
+                operationalState: RvcOperationalState.OperationalState.Stopped,
+                operationalError: { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
+            });
+            matterbridge.log.info(`CHIP test app pipe reset RVC endpoint ${endpointId}`);
+            return;
+        }
+        case 'ErrorEvent': {
+            const errorStates = {
+                UnableToStartOrResume: RvcOperationalState.ErrorState.UnableToStartOrResume,
+                UnableToCompleteOperation: RvcOperationalState.ErrorState.UnableToCompleteOperation,
+                CommandInvalidInState: RvcOperationalState.ErrorState.CommandInvalidInState,
+                FailedToFindChargingDock: RvcOperationalState.ErrorState.FailedToFindChargingDock,
+                Stuck: RvcOperationalState.ErrorState.Stuck,
+                DustBinMissing: RvcOperationalState.ErrorState.DustBinMissing,
+                DustBinFull: RvcOperationalState.ErrorState.DustBinFull,
+                WaterTankEmpty: RvcOperationalState.ErrorState.WaterTankEmpty,
+                WaterTankMissing: RvcOperationalState.ErrorState.WaterTankMissing,
+                WaterTankLidOpen: RvcOperationalState.ErrorState.WaterTankLidOpen,
+                MopCleaningPadMissing: RvcOperationalState.ErrorState.MopCleaningPadMissing,
+                BatteryLow: RvcOperationalState.ErrorState.LowBattery,
+                CannotReachTargetArea: RvcOperationalState.ErrorState.CannotReachTargetArea,
+                DirtyWaterTankFull: RvcOperationalState.ErrorState.DirtyWaterTankFull,
+                DirtyWaterTankMissing: RvcOperationalState.ErrorState.DirtyWaterTankMissing,
+                WheelsJammed: RvcOperationalState.ErrorState.WheelsJammed,
+                BrushJammed: RvcOperationalState.ErrorState.BrushJammed,
+                NavigationSensorObscured: RvcOperationalState.ErrorState.NavigationSensorObscured,
+            };
+            const errorStateId = command.Error === undefined ? undefined : errorStates[command.Error];
+            if (errorStateId === undefined) {
+                matterbridge.log.warn(`Ignoring unsupported RVC ErrorEvent CHIP test app pipe command: ${JSON.stringify(command)}`);
+                return;
+            }
+            await endpoint.setStateOf(MatterbridgeRvcOperationalStateServer, {
+                operationalState: RvcOperationalState.OperationalState.Error,
+                operationalError: { errorStateId, errorStateDetails: 'Simulated CHIP test fault' },
+            });
+            matterbridge.log.info(`CHIP test app pipe set RVC OperationalError to ${command.Error} on endpoint ${endpointId}`);
+            return;
+        }
+        case 'ChargerFound':
+        case 'Charging':
+            await endpoint.setStateOf(MatterbridgeRvcOperationalStateServer, { operationalState: RvcOperationalState.OperationalState.Charging });
+            matterbridge.log.info(`CHIP test app pipe set RVC OperationalState to Charging on endpoint ${endpointId}`);
+            return;
+        case 'Charged':
+        case 'Docked': {
+            const runModeState = endpoint.stateOf(MatterbridgeRvcRunModeServer);
+            const idleMode = runModeState.supportedModes.find((mode) => mode.modeTags.some((tag) => tag.value === RvcRunMode.ModeTag.Idle));
+            if (idleMode)
+                await endpoint.setStateOf(MatterbridgeRvcRunModeServer, { currentMode: idleMode.mode });
+            await endpoint.setStateOf(MatterbridgeRvcOperationalStateServer, { operationalState: RvcOperationalState.OperationalState.Docked });
+            matterbridge.log.info(`CHIP test app pipe set RVC OperationalState to Docked on endpoint ${endpointId}`);
+            return;
+        }
         case 'SetBooleanState':
             await endpoint.setStateOf(endpoint.behaviors.supported.booleanState, { stateValue: Boolean(command.NewState) });
             matterbridge.log.info(`CHIP test app pipe set BooleanState.StateValue to ${Boolean(command.NewState)} on endpoint ${endpointId}`);
@@ -580,6 +652,26 @@ async function handleChipTestAppPipeCommand(matterbridge, command) {
             await endpoint.setStateOf(endpoint.behaviors.supported.soilMeasurement, { soilMoistureMeasuredValue: command.SoilMoistureValue ?? null });
             matterbridge.log.info(`CHIP test app pipe set SoilMeasurement.SoilMoistureMeasuredValue to ${command.SoilMoistureValue ?? null} on endpoint ${endpointId}`);
             return;
+        case 'SetRefrigeratorDoorStatus': {
+            const doorOpen = Boolean(command.DoorOpen);
+            const wasDoorOpen = Boolean(endpoint.stateOf(MatterbridgeRefrigeratorAlarmServer).state.doorOpen);
+            await endpoint.setCluster(RefrigeratorAlarm, { state: { doorOpen } }, matterbridge.log);
+            await endpoint.triggerEvent('RefrigeratorAlarm', 'notify', {
+                active: { doorOpen: doorOpen && !wasDoorOpen },
+                inactive: { doorOpen: !doorOpen && wasDoorOpen },
+                state: { doorOpen },
+                mask: endpoint.stateOf(MatterbridgeRefrigeratorAlarmServer).mask,
+            }, matterbridge.log);
+            matterbridge.log.info(`CHIP test app pipe set RefrigeratorAlarm.State.DoorOpen to ${doorOpen} on endpoint ${endpointId}`);
+            return;
+        }
+        case 'ModeChange':
+            if (command.Device === 'DishWasher' && command.Type === 'ToggleFailTransition') {
+                matterbridge.log.info(`CHIP test app pipe prepared DishwasherMode for a successful transition on endpoint ${endpointId}`);
+                return;
+            }
+            matterbridge.log.warn(`Ignoring unsupported ModeChange CHIP test app pipe command: ${JSON.stringify(command)}`);
+            return;
         case 'OperationalStateChange':
             switch (command.Operation) {
                 case 'Stop':

package/dist/demoDevices.js

@@ -1,8 +1,14 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
 import { ClosureTag, ClosureWindowTag, CommonNumberTag, CommonPositionTag, RefrigeratorTag } 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 { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
+import { RvcCleanMode } from '@matter/types/clusters/rvc-clean-mode';
+import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { EndpointNumber } from '@matter/types/datatype';
+import { getErrorMessage } from '@matterbridge/utils/error';
 import { AirConditioner } from './devices/airConditioner.js';
 import { BasicVideoPlayer } from './devices/basicVideoPlayer.js';
 import { CastingVideoClient } from './devices/castingVideoClient.js';
@@ -24,32 +30,138 @@ import { VideoRemoteControl } from './devices/videoRemoteControl.js';
 import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { getSemtag } from './matterbridgeEndpointHelpers.js';
+const demoPluginName = 'matterbridge-demo-devices';
+const demoPluginType = 'DynamicPlatform';
+const demoPluginVersion = '1.0.0';
+const demoPluginSchema = {
+    title: 'Matterbridge Demo Devices',
+    description: `${demoPluginName} v. ${demoPluginVersion} by Matterbridge`,
+    type: 'object',
+    properties: {
+        name: {
+            'description': 'Plugin name',
+            'type': 'string',
+            'readOnly': true,
+            'ui:widget': 'hidden',
+        },
+        type: {
+            'description': 'Plugin type',
+            'type': 'string',
+            'readOnly': true,
+            'ui:widget': 'hidden',
+        },
+        version: {
+            'description': 'Plugin version',
+            'type': 'string',
+            'readOnly': true,
+            'default': demoPluginVersion,
+            'ui:widget': 'hidden',
+        },
+        whiteList: {
+            description: 'Only the devices in the list will be exposed. If the list is empty, all devices will be exposed.',
+            type: 'array',
+            items: { type: 'string' },
+            default: [],
+            uniqueItems: true,
+            selectFrom: 'name',
+        },
+        blackList: {
+            description: 'The devices in the list will not be exposed. If the list is empty, no devices will be excluded.',
+            type: 'array',
+            items: { type: 'string' },
+            default: [],
+            uniqueItems: true,
+            selectFrom: 'name',
+        },
+        debug: {
+            description: 'Enable debug logging for the plugin.',
+            type: 'boolean',
+            default: false,
+        },
+        unregisterOnShutdown: {
+            description: 'Unregister all devices when the plugin is stopped.',
+            type: 'boolean',
+            default: false,
+        },
+    },
+};
 export async function createDemoDevices(matterbridge) {
-    if (matterbridge.bridgeMode !== 'bridge' || !matterbridge.serverNode || !matterbridge.aggregatorNode)
+    if (matterbridge.bridgeMode !== 'bridge') {
+        matterbridge.log.error('Demo devices can only be created in bridge mode');
         return;
+    }
     const serverNode = matterbridge.serverNode;
     const aggregator = matterbridge.aggregatorNode;
     if (!serverNode || !aggregator) {
         matterbridge.log.error('Demo devices can only be created when the server node and aggregator node are available');
         return;
     }
+    const configFile = path.join(matterbridge.matterbridgeDirectory, `${demoPluginName}.config.json`);
+    const schemaFile = path.join(matterbridge.matterbridgeDirectory, `${demoPluginName}.schema.json`);
+    const defaultConfig = {
+        name: demoPluginName,
+        type: demoPluginType,
+        version: demoPluginVersion,
+        debug: false,
+        unregisterOnShutdown: false,
+        whiteList: [],
+        blackList: [],
+    };
+    let config = defaultConfig;
+    try {
+        const storedConfig = JSON.parse(await readFile(configFile, 'utf8'));
+        config = {
+            ...defaultConfig,
+            ...storedConfig,
+            name: demoPluginName,
+            type: demoPluginType,
+            version: demoPluginVersion,
+            whiteList: Array.isArray(storedConfig.whiteList) ? storedConfig.whiteList : [],
+            blackList: Array.isArray(storedConfig.blackList) ? storedConfig.blackList : [],
+        };
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            matterbridge.log.error(`Failed to read demo devices config ${configFile}: ${getErrorMessage(error)}`);
+    }
+    try {
+        await writeFile(configFile, JSON.stringify(config, null, 2), 'utf8');
+        await writeFile(schemaFile, JSON.stringify(demoPluginSchema, null, 2), 'utf8');
+    }
+    catch (error) {
+        matterbridge.log.error(`Failed to write demo devices config or schema: ${getErrorMessage(error)}`);
+    }
     let ep;
     matterbridge.plugins.set({
-        name: 'matterbridge-demo-devices',
+        name: demoPluginName,
         path: '',
-        type: 'DynamicPlatform',
-        version: '1.0.0',
+        type: demoPluginType,
+        version: demoPluginVersion,
         description: 'Matterbridge demo devices',
         author: 'Matterbridge',
         enabled: false,
         private: true,
         registeredDevices: 0,
+        configJson: config,
+        schemaJson: demoPluginSchema,
+        hasWhiteList: true,
+        hasBlackList: true,
     });
     const registerDevice = async (device, deviceName, serialNumber) => {
+        const whiteList = config.whiteList;
+        const blackList = config.blackList;
+        if (blackList.includes(deviceName)) {
+            matterbridge.log.info(`Skipping demo device ${deviceName} because it is in the blacklist`);
+            return;
+        }
+        if (whiteList.length > 0 && !whiteList.includes(deviceName)) {
+            matterbridge.log.info(`Skipping demo device ${deviceName} because it is not in the whitelist`);
+            return;
+        }
         device.createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber);
         device.addRequiredClusters();
-        device.plugin = 'matterbridge-demo-devices';
-        await matterbridge.addBridgedEndpoint('matterbridge-demo-devices', device);
+        device.plugin = demoPluginName;
+        await matterbridge.addBridgedEndpoint(demoPluginName, device);
     };
     const bridgedNode = getSupportedDeviceType('BridgedNode');
     const powerSource = getSupportedDeviceType('PowerSource');
@@ -353,14 +465,37 @@ export async function createDemoDevices(matterbridge) {
         id: 'RoboticVacuumCleaner',
         number: EndpointNumber(12_01),
         tagList: [getSemtag(CommonNumberTag.One)],
+        currentRunMode: 0,
+        supportedRunModes: [
+            { label: 'Idle', mode: 0, modeTags: [{ value: RvcRunMode.ModeTag.Idle }] },
+            { label: 'Cleaning', mode: 1, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
+            { label: 'Mapping', mode: 2, modeTags: [{ value: RvcRunMode.ModeTag.Mapping }] },
+            { label: 'SpotCleaning', mode: 3, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }, { value: RvcRunMode.ModeTag.Max }] },
+        ],
+        currentCleanMode: 1,
+        supportedCleanModes: [
+            { label: 'Vacuum', mode: 1, modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }] },
+            { label: 'Mop', mode: 2, modeTags: [{ value: RvcCleanMode.ModeTag.Mop }] },
+            { label: 'DeepClean', mode: 3, modeTags: [{ value: RvcCleanMode.ModeTag.DeepClean }] },
+        ],
     });
     await registerDevice(ep, 'Robotic Vacuum Cleaner', 'ROBOTIC-12-01');
-    ep = new LaundryWasher('Laundry Washer', 'APPLIANCE-13-01', {
+    ep = new LaundryWasher('Laundry Washer Level Temperature', 'APPLIANCE-13-01', {
         id: 'LaundryWasher',
         number: EndpointNumber(13_01),
         tagList: [getSemtag(CommonNumberTag.One)],
     });
     await registerDevice(ep, 'Laundry Washer', 'APPLIANCE-13-01');
+    ep = new LaundryWasher('Laundry Washer Number Temperature', 'APPLIANCE-13-01-2', {
+        id: 'LaundryWasherNumberTemperature',
+        number: EndpointNumber(13_01_2),
+        tagList: [getSemtag(CommonNumberTag.Two)],
+        temperatureSetpoint: 40 * 100,
+        minTemperature: 30 * 100,
+        maxTemperature: 60 * 100,
+        step: 10 * 100,
+    });
+    await registerDevice(ep, 'Laundry Washer Number Temperature', 'APPLIANCE-13-01-2');
     const refrigeratorDevice = new Refrigerator('Refrigerator', 'APPLIANCE-13-02', {
         id: 'Refrigerator',
         number: EndpointNumber(13_02),
@@ -461,6 +596,24 @@ export async function createDemoDevices(matterbridge) {
         id: 'ExtractorHood',
         number: EndpointNumber(13_10),
         tagList: [getSemtag(CommonNumberTag.One)],
+        hepaCondition: 30,
+        hepaChangeIndication: ResourceMonitoring.ChangeIndication.Warning,
+        hepaLastChangedTime: 1_735_689_600,
+        hepaReplacementProductList: [
+            {
+                productIdentifierType: ResourceMonitoring.ProductIdentifierType.Upc,
+                productIdentifierValue: '012345678905',
+            },
+        ],
+        activatedCarbonCondition: 30,
+        activatedCarbonChangeIndication: ResourceMonitoring.ChangeIndication.Warning,
+        activatedCarbonLastChangedTime: 1_735_689_600,
+        activatedCarbonReplacementProductList: [
+            {
+                productIdentifierType: ResourceMonitoring.ProductIdentifierType.Ean,
+                productIdentifierValue: '4006381333931',
+            },
+        ],
     });
     await registerDevice(ep, 'Extractor Hood', 'APPLIANCE-13-10');
     ep = new MicrowaveOven('Microwave Oven', 'APPLIANCE-13-11', {

package/dist/devices/dishwasher.d.ts

@@ -1,3 +1,4 @@
+import { DishwasherAlarmServer } from '@matter/node/behaviors/dishwasher-alarm';
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
 import type { EndpointNumber } from '@matter/types';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
@@ -31,3 +32,6 @@ export declare class MatterbridgeDishwasherModeServer extends DishwasherModeServ
     protected handleOnOffChange(onOff: boolean): void;
     changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }
+export declare class MatterbridgeDishwasherAlarmServer extends DishwasherAlarmServer {
+    static readonly schema: import("@matter/model").ClusterModel;
+}

package/dist/devices/dishwasher.js

@@ -1,3 +1,4 @@
+import { AttributeElement, EventElement, FieldElement } from '@matter/model';
 import { DishwasherAlarmServer } from '@matter/node/behaviors/dishwasher-alarm';
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
@@ -53,10 +54,10 @@ export class Dishwasher extends MatterbridgeEndpoint {
         return this;
     }
     createDefaultDishwasherAlarmClusterServer() {
-        this.behaviors.require(DishwasherAlarmServer, {
-            mask: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+        this.behaviors.require(MatterbridgeDishwasherAlarmServer, {
+            mask: { inflowError: false, drainError: false, doorError: true, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
             state: { inflowError: false, drainError: false, doorError: false, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
-            supported: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+            supported: { inflowError: false, drainError: false, doorError: true, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
         });
         return this;
     }
@@ -92,8 +93,12 @@ export class MatterbridgeDishwasherModeServer extends DishwasherModeServer {
             return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }
         else {
-            device.log.error(`DishwasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
-            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+            device.log.error(`DishwasherModeServer: changeToMode called with unsupported mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: '' };
         }
     }
 }
+const MatterbridgeDishwasherAlarmSchema = DishwasherAlarmServer.schema.extend({}, AttributeElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Supported', id: 0x0003, type: 'AlarmBitmap', access: 'R V', conformance: 'M', quality: 'F' }), EventElement({ name: 'Notify', id: 0x0000, access: 'V', conformance: 'M', priority: 'info' }, FieldElement({ name: 'Active', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Inactive', id: 0x0001, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Mask', id: 0x0003, type: 'AlarmBitmap', conformance: 'M' })));
+export class MatterbridgeDishwasherAlarmServer extends DishwasherAlarmServer {
+    static schema = MatterbridgeDishwasherAlarmSchema;
+}

package/dist/devices/laundryWasher.d.ts

@@ -1,5 +1,6 @@
+import { LaundryWasherControlsServer } from '@matter/node/behaviors/laundry-washer-controls';
 import { LaundryWasherModeServer } from '@matter/node/behaviors/laundry-washer-mode';
-import type { EndpointNumber } from '@matter/types';
+import { type EndpointNumber } from '@matter/types';
 import { LaundryWasherControls } from '@matter/types/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -31,8 +32,17 @@ export declare class LaundryWasher extends MatterbridgeEndpoint {
     createDefaultLaundryWasherModeClusterServer(currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[]): this;
     createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent?: number, spinSpeeds?: string[], numberOfRinses?: LaundryWasherControls.NumberOfRinses, supportedRinses?: LaundryWasherControls.NumberOfRinses[]): this;
 }
+declare const MatterbridgeLaundryWasherControlsServer_base: import("@matter/node").ClusterBehavior.Type<typeof LaundryWasherControlsServer, import("@matter/types").ClusterType.WithSupportedFeatures<LaundryWasherControls, {
+    rinse: true;
+    spin: true;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "laundryWasherControls">;
+export declare class MatterbridgeLaundryWasherControlsServer extends MatterbridgeLaundryWasherControlsServer_base {
+    #private;
+    initialize(): void;
+}
 export declare class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
     initialize(): void;
     protected handleOnOffChange(onOff: boolean): void;
     changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }
+export {};

package/dist/devices/laundryWasher.js

@@ -1,5 +1,6 @@
 import { LaundryWasherControlsServer } from '@matter/node/behaviors/laundry-washer-controls';
 import { LaundryWasherModeServer } from '@matter/node/behaviors/laundry-washer-mode';
+import { Status, StatusResponseError } from '@matter/types';
 import { LaundryWasherControls } from '@matter/types/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -64,7 +65,7 @@ export class LaundryWasher extends MatterbridgeEndpoint {
         LaundryWasherControls.NumberOfRinses.Max,
         LaundryWasherControls.NumberOfRinses.Extra,
     ]) {
-        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin, LaundryWasherControls.Feature.Rinse), {
+        this.behaviors.require(MatterbridgeLaundryWasherControlsServer, {
             spinSpeeds,
             spinSpeedCurrent,
             supportedRinses,
@@ -73,6 +74,16 @@ export class LaundryWasher extends MatterbridgeEndpoint {
         return this;
     }
 }
+export class MatterbridgeLaundryWasherControlsServer extends LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin, LaundryWasherControls.Feature.Rinse) {
+    initialize() {
+        this.reactTo(this.events.spinSpeedCurrent$Changing, this.#validateSpinSpeedCurrent);
+    }
+    #validateSpinSpeedCurrent(spinSpeedCurrent) {
+        if (spinSpeedCurrent !== null && spinSpeedCurrent >= this.state.spinSpeeds.length) {
+            throw new StatusResponseError(`SpinSpeedCurrent ${spinSpeedCurrent} is not a valid SpinSpeeds index`, Status.ConstraintError);
+        }
+    }
+}
 export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -98,14 +109,12 @@ export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer
             endpoint: this.endpoint,
         });
         const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
-        if (supportedMode) {
-            device.log.debug(`MatterbridgeLaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} => ${supportedMode.label}`);
-            this.state.currentMode = request.newMode;
-            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
-        }
-        else {
-            device.log.error(`MatterbridgeLaundryWasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
-            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        if (!supportedMode) {
+            device.log.error(`MatterbridgeLaundryWasherModeServer: changeToMode called with unsupported mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: '' };
         }
+        device.log.debug(`MatterbridgeLaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} => ${supportedMode.label}`);
+        this.state.currentMode = request.newMode;
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }

package/dist/devices/microwaveOven.d.ts

@@ -1,5 +1,5 @@
 import { MicrowaveOvenControlServer } from '@matter/node/behaviors/microwave-oven-control';
-import type { EndpointNumber } from '@matter/types';
+import { type EndpointNumber } from '@matter/types';
 import { MicrowaveOvenControl } from '@matter/types/clusters/microwave-oven-control';
 import { MicrowaveOvenMode } from '@matter/types/clusters/microwave-oven-mode';
 import type { Semtag } from '@matter/types/globals';

package/dist/devices/microwaveOven.js

@@ -1,5 +1,6 @@
 import { MicrowaveOvenControlServer } from '@matter/node/behaviors/microwave-oven-control';
 import { MicrowaveOvenModeServer } from '@matter/node/behaviors/microwave-oven-mode';
+import { Status, StatusResponseError } from '@matter/types';
 import { MicrowaveOvenControl } from '@matter/types/clusters/microwave-oven-control';
 import { MicrowaveOvenMode } from '@matter/types/clusters/microwave-oven-mode';
 import { OperationalState } from '@matter/types/clusters/operational-state';
@@ -62,6 +63,13 @@ export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControl
     async setCookingParameters(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (request.cookTime !== undefined && (request.cookTime < 1 || request.cookTime > this.state.maxCookTime)) {
+            throw new StatusResponseError(`CookTime ${request.cookTime} must be between 1 and MaxCookTime ${this.state.maxCookTime}`, Status.ConstraintError);
+        }
+        if (request.powerSetting !== undefined &&
+            (request.powerSetting < this.state.minPower || request.powerSetting > this.state.maxPower || (request.powerSetting - this.state.minPower) % this.state.powerStep !== 0)) {
+            throw new StatusResponseError(`PowerSetting ${request.powerSetting} must be between MinPower ${this.state.minPower} and MaxPower ${this.state.maxPower} in steps of ${this.state.powerStep}`, Status.ConstraintError);
+        }
         await device.commandHandler.executeHandler('MicrowaveOvenControl.setCookingParameters', {
             command: 'setCookingParameters',
             request,
@@ -79,7 +87,7 @@ export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControl
             const normalMode = supportedModes.find((mode) => mode.modeTags.some((tag) => tag.value === MicrowaveOvenMode.ModeTag.Normal));
             await this.endpoint.setStateOf(MicrowaveOvenModeServer, { currentMode: normalMode?.mode });
         }
-        if (request.cookTime !== undefined && request.cookTime >= 0 && request.cookTime <= this.state.maxCookTime) {
+        if (request.cookTime !== undefined) {
             device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting cookTime to ${request.cookTime}`);
             this.state.cookTime = request.cookTime;
         }
@@ -87,7 +95,7 @@ export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControl
             device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no cookTime so set to 30sec.`);
             this.state.cookTime = 30;
         }
-        if (request.powerSetting !== undefined && request.powerSetting >= this.state.minPower && request.powerSetting <= this.state.maxPower) {
+        if (request.powerSetting !== undefined) {
             device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting powerSetting to ${request.powerSetting}`);
             this.state.powerSetting = request.powerSetting;
         }

package/dist/devices/oven.d.ts

@@ -6,6 +6,7 @@ import { ModeBase } from '@matter/types/clusters/mode-base';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { OvenMode } from '@matter/types/clusters/oven-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+declare const MatterbridgeOvenCavityOperationalStateServerBase: import("@matter/node").ClusterBehavior.Type<typeof OvenCavityOperationalStateServer, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<import("@matter/types/clusters/oven-cavity-operational-state").OvenCavityOperationalState, "operationCompletion">, never>, import("@matter/types").ClusterType.Concrete, new () => {}, "ovenCavityOperationalState">;
 export interface OvenOptions {
     mode?: 'server' | 'matter';
     id?: string;
@@ -38,8 +39,15 @@ export declare class MatterbridgeOvenModeServer extends OvenModeServer {
     initialize(): void;
     changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
 }
-export declare class MatterbridgeOvenCavityOperationalStateServer extends OvenCavityOperationalStateServer {
+export declare class MatterbridgeOvenCavityOperationalStateServer extends MatterbridgeOvenCavityOperationalStateServerBase {
+    protected internal: MatterbridgeOvenCavityOperationalStateServer.Internal;
     initialize(): void;
     stop(): MaybePromise<OperationalState.OperationalCommandResponse>;
     start(): MaybePromise<OperationalState.OperationalCommandResponse>;
 }
+export declare namespace MatterbridgeOvenCavityOperationalStateServer {
+    class Internal extends MatterbridgeOvenCavityOperationalStateServerBase.Internal {
+        operationStartedAt: number | undefined;
+    }
+}
+export {};

package/dist/devices/oven.js

@@ -8,6 +8,7 @@ import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
 import { oven, powerSource, temperatureControlledCabinetHeater } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createNumberTemperatureControlClusterServer } from './temperatureControl.js';
+const MatterbridgeOvenCavityOperationalStateServerBase = OvenCavityOperationalStateServer.enable({ events: { operationCompletion: true } });
 export class Oven extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
         super([oven, powerSource], {
@@ -71,6 +72,7 @@ export class Oven extends MatterbridgeEndpoint {
             operationalStateList: [
                 { operationalStateId: OperationalState.OperationalStateEnum.Stopped },
                 { operationalStateId: OperationalState.OperationalStateEnum.Running },
+                { operationalStateId: OperationalState.OperationalStateEnum.Paused },
                 { operationalStateId: OperationalState.OperationalStateEnum.Error },
             ],
             operationalState,
@@ -93,21 +95,31 @@ export class MatterbridgeOvenModeServer extends OvenModeServer {
             return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }
         else {
-            device.log.error(`MatterbridgeOvenModeServer: changeToMode (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) called with invalid mode ${request.newMode}`);
-            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+            device.log.error(`MatterbridgeOvenModeServer: changeToMode (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) called with unsupported mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: '' };
         }
     }
 }
-export class MatterbridgeOvenCavityOperationalStateServer extends OvenCavityOperationalStateServer {
+export class MatterbridgeOvenCavityOperationalStateServer extends MatterbridgeOvenCavityOperationalStateServerBase {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info('MatterbridgeOvenCavityOperationalStateServer initialized: setting operational state to Stopped and operational error to No error');
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
+        super.initialize();
     }
     stop() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeOvenCavityOperationalStateServer: stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) called setting operational state to Stopped and operational error to No error`);
+        if (this.internal.operationStartedAt !== undefined) {
+            const totalOperationalTime = Math.round((Date.now() - this.internal.operationStartedAt) / 1000);
+            this.events.operationCompletion.emit({
+                completionErrorCode: this.state.operationalError.errorStateId,
+                totalOperationalTime,
+                pausedTime: 0,
+            }, this.context);
+            this.internal.operationStartedAt = undefined;
+        }
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
@@ -117,6 +129,7 @@ export class MatterbridgeOvenCavityOperationalStateServer extends OvenCavityOper
     start() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeOvenCavityOperationalStateServer: start (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) called setting operational state to Running and operational error to No error`);
+        this.internal.operationStartedAt ??= Date.now();
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
@@ -124,3 +137,9 @@ export class MatterbridgeOvenCavityOperationalStateServer extends OvenCavityOper
         };
     }
 }
+(function (MatterbridgeOvenCavityOperationalStateServer) {
+    class Internal extends MatterbridgeOvenCavityOperationalStateServerBase.Internal {
+        operationStartedAt;
+    }
+    MatterbridgeOvenCavityOperationalStateServer.Internal = Internal;
+})(MatterbridgeOvenCavityOperationalStateServer || (MatterbridgeOvenCavityOperationalStateServer = {}));

package/dist/devices/refrigerator.d.ts

@@ -1,4 +1,5 @@
 import type { MaybePromise } from '@matter/general';
+import { RefrigeratorAlarmServer } from '@matter/node/behaviors/refrigerator-alarm';
 import { RefrigeratorAndTemperatureControlledCabinetModeServer } from '@matter/node/behaviors/refrigerator-and-temperature-controlled-cabinet-mode';
 import type { EndpointNumber, Semtag } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -36,3 +37,6 @@ export declare class MatterbridgeRefrigeratorAndTemperatureControlledCabinetMode
     initialize(): void;
     changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
 }
+export declare class MatterbridgeRefrigeratorAlarmServer extends RefrigeratorAlarmServer {
+    static readonly schema: import("@matter/model").ClusterModel;
+}

package/dist/devices/refrigerator.js

@@ -1,3 +1,4 @@
+import { AttributeElement, EventElement, FieldElement } from '@matter/model';
 import { RefrigeratorAlarmServer } from '@matter/node/behaviors/refrigerator-alarm';
 import { RefrigeratorAndTemperatureControlledCabinetModeServer } from '@matter/node/behaviors/refrigerator-and-temperature-controlled-cabinet-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -46,7 +47,7 @@ export class Refrigerator extends MatterbridgeEndpoint {
         return endpoint;
     }
     createDefaultRefrigeratorAlarmClusterServer(endpoint, doorOpen = false) {
-        endpoint.behaviors.require(RefrigeratorAlarmServer, {
+        endpoint.behaviors.require(MatterbridgeRefrigeratorAlarmServer, {
             mask: { doorOpen: true },
             supported: { doorOpen: true },
             state: { doorOpen },
@@ -59,10 +60,20 @@ export class Refrigerator extends MatterbridgeEndpoint {
     }
     async triggerDoorOpenState(doorOpen) {
         if (doorOpen) {
-            await this.triggerEvent('RefrigeratorAlarm', 'notify', { active: { doorOpen: true }, inactive: { doorOpen: false }, state: { doorOpen: true }, mask: { doorOpen: true } }, this.log);
+            await this.triggerEvent('RefrigeratorAlarm', 'notify', {
+                active: { doorOpen: true },
+                inactive: { doorOpen: false },
+                state: { doorOpen: true },
+                mask: { doorOpen: true },
+            }, this.log);
         }
         else {
-            await this.triggerEvent('RefrigeratorAlarm', 'notify', { active: { doorOpen: false }, inactive: { doorOpen: true }, state: { doorOpen: false }, mask: { doorOpen: true } }, this.log);
+            await this.triggerEvent('RefrigeratorAlarm', 'notify', {
+                active: { doorOpen: false },
+                inactive: { doorOpen: true },
+                state: { doorOpen: false },
+                mask: { doorOpen: true },
+            }, this.log);
         }
         return this;
     }
@@ -86,3 +97,7 @@ export class MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer e
         }
     }
 }
+const MatterbridgeRefrigeratorAlarmSchema = RefrigeratorAlarmServer.schema.extend({}, AttributeElement({ name: 'Mask', id: 0x0000, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', access: 'R V', conformance: 'M' }), AttributeElement({ name: 'Supported', id: 0x0003, type: 'AlarmBitmap', access: 'R V', conformance: 'M', quality: 'F' }), EventElement({ name: 'Notify', id: 0x0000, access: 'V', conformance: 'M', priority: 'info' }, FieldElement({ name: 'Active', id: 0x0000, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Inactive', id: 0x0001, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'State', id: 0x0002, type: 'AlarmBitmap', conformance: 'M' }), FieldElement({ name: 'Mask', id: 0x0003, type: 'AlarmBitmap', conformance: 'M' })));
+export class MatterbridgeRefrigeratorAlarmServer extends RefrigeratorAlarmServer {
+    static schema = MatterbridgeRefrigeratorAlarmSchema;
+}

package/dist/devices/roboticVacuumCleaner.d.ts

@@ -10,6 +10,7 @@ import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { ServiceArea } from '@matter/types/clusters/service-area';
 import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+declare const MatterbridgeRvcOperationalStateServerBase: import("@matter/node").ClusterBehavior.Type<typeof RvcOperationalStateServer, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<RvcOperationalState, "operationCompletion">, "countdownTime">, import("@matter/types").ClusterType.Concrete, new () => {}, "rvcOperationalState">;
 export interface RoboticVacuumCleanerOptions {
     mode?: 'server' | 'matter';
     id?: string;
@@ -42,8 +43,20 @@ export declare class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
 export declare class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
     changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }
-export declare class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
+export declare class MatterbridgeRvcOperationalStateServer extends MatterbridgeRvcOperationalStateServerBase {
+    protected internal: MatterbridgeRvcOperationalStateServer.Internal;
+    beginOperation(): void;
+    completeOperation(): void;
     pause(): Promise<OperationalState.OperationalCommandResponse>;
     resume(): Promise<OperationalState.OperationalCommandResponse>;
     goHome(): Promise<OperationalState.OperationalCommandResponse>;
 }
+export declare namespace MatterbridgeRvcOperationalStateServer {
+    class Internal extends MatterbridgeRvcOperationalStateServerBase.Internal {
+        operationalStateBeforePause: RvcOperationalState.OperationalState | OperationalState.OperationalStateEnum;
+        operationStartedAt: number | undefined;
+        pausedAccumulatedMs: number;
+        pausedSinceMs: number | undefined;
+    }
+}
+export {};

package/dist/devices/roboticVacuumCleaner.js

@@ -13,6 +13,10 @@ import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
 import { MatterbridgeServiceAreaServer } from '../behaviors/serviceAreaServer.js';
 import { powerSource, roboticVacuumCleaner } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+const MatterbridgeRvcOperationalStateServerBase = RvcOperationalStateServer.enable({
+    attributes: { countdownTime: true },
+    events: { operationCompletion: true },
+});
 export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
     constructor(name, serial, modeOrOptions, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
         const options = typeof modeOrOptions === 'object'
@@ -104,6 +108,7 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
         this.behaviors.require(MatterbridgeRvcOperationalStateServer, {
             phaseList,
             currentPhase,
+            countdownTime: null,
             operationalStateList: operationalStateList ?? [
                 { operationalStateId: RvcOperationalState.OperationalState.Stopped },
                 { operationalStateId: RvcOperationalState.OperationalState.Running },
@@ -135,19 +140,34 @@ export class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
             device.log.error(`MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
+        const currentIsIdle = this.state.supportedModes.some((mode) => mode.mode === this.state.currentMode && mode.modeTags.some((tag) => tag.value === RvcRunMode.ModeTag.Idle));
+        const requestedIsIdle = supported.modeTags.some((tag) => tag.value === RvcRunMode.ModeTag.Idle);
+        if (request.newMode !== this.state.currentMode && !this.features.directModeChange && !currentIsIdle && !requestedIsIdle) {
+            device.log.debug(`MatterbridgeRvcRunModeServer changeToMode rejected direct non-Idle mode change from ${this.state.currentMode} to ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Direct mode change is not supported while operating' };
+        }
+        if (request.newMode === this.state.currentMode) {
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Already in requested mode' };
+        }
         this.state.currentMode = request.newMode;
         if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
             device.log.debug('MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
-            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+            const operationalState = this.agent.get(MatterbridgeRvcOperationalStateServer);
+            operationalState.beginOperation();
+            operationalState.state.operationalState = RvcOperationalState.OperationalState.Running;
             return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Running' };
         }
         else if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
-            device.log.debug('MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
-            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Docked;
-            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Docked' };
+            device.log.debug('MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => SeekingCharger');
+            const operationalState = this.agent.get(MatterbridgeRvcOperationalStateServer);
+            operationalState.completeOperation();
+            operationalState.state.operationalState = RvcOperationalState.OperationalState.SeekingCharger;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Seeking charger' };
         }
         device.log.debug(`MatterbridgeRvcRunModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
-        this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+        const operationalState = this.agent.get(MatterbridgeRvcOperationalStateServer);
+        operationalState.beginOperation();
+        operationalState.state.operationalState = RvcOperationalState.OperationalState.Running;
         return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }
@@ -167,12 +187,40 @@ export class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
             device.log.error(`MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
+        if (request.newMode === this.state.currentMode) {
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Already in requested mode' };
+        }
+        const runModeState = this.agent.get(MatterbridgeRvcRunModeServer).state;
+        const runModeIsIdle = runModeState.supportedModes.some((mode) => mode.mode === runModeState.currentMode && mode.modeTags.some((tag) => tag.value === RvcRunMode.ModeTag.Idle));
+        if (!this.features.directModeChange && !runModeIsIdle) {
+            device.log.debug(`MatterbridgeRvcCleanModeServer changeToMode rejected while RVC Run Mode ${runModeState.currentMode} is non-Idle`);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Clean mode cannot change while operating' };
+        }
         this.state.currentMode = request.newMode;
         device.log.debug(`MatterbridgeRvcCleanModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
         return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }
-export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
+export class MatterbridgeRvcOperationalStateServer extends MatterbridgeRvcOperationalStateServerBase {
+    beginOperation() {
+        if (this.internal.operationStartedAt === undefined) {
+            this.internal.operationStartedAt = Date.now();
+            this.internal.pausedAccumulatedMs = 0;
+        }
+    }
+    completeOperation() {
+        if (this.internal.operationStartedAt === undefined)
+            return;
+        if (this.internal.pausedSinceMs !== undefined) {
+            this.internal.pausedAccumulatedMs += Date.now() - this.internal.pausedSinceMs;
+            this.internal.pausedSinceMs = undefined;
+        }
+        const totalOperationalTime = Math.round((Date.now() - this.internal.operationStartedAt) / 1000);
+        const pausedTime = Math.round(this.internal.pausedAccumulatedMs / 1000);
+        this.events.operationCompletion.emit({ completionErrorCode: OperationalState.ErrorState.NoError, totalOperationalTime, pausedTime }, this.context);
+        this.internal.operationStartedAt = undefined;
+        this.internal.pausedAccumulatedMs = 0;
+    }
     async pause() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -183,8 +231,17 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        device.log.debug('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+        if (this.state.operationalState === RvcOperationalState.OperationalState.Paused) {
+            return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already paused' } };
+        }
+        if (this.state.operationalState !== RvcOperationalState.OperationalState.Running && this.state.operationalState !== RvcOperationalState.OperationalState.SeekingCharger) {
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.CommandInvalidInState, errorStateDetails: 'Not Pause-compatible in the current operational state' },
+            };
+        }
+        device.log.debug('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused');
+        this.internal.operationalStateBeforePause = this.state.operationalState;
+        this.internal.pausedSinceMs = Date.now();
         this.state.operationalState = RvcOperationalState.OperationalState.Paused;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
@@ -201,9 +258,20 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        device.log.debug('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
-        this.state.operationalState = RvcOperationalState.OperationalState.Running;
+        if (this.state.operationalState === RvcOperationalState.OperationalState.Running) {
+            return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already running' } };
+        }
+        if (this.state.operationalState !== RvcOperationalState.OperationalState.Paused) {
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.CommandInvalidInState, errorStateDetails: 'Not Resume-compatible in the current operational state' },
+            };
+        }
+        device.log.debug(`MatterbridgeRvcOperationalStateServer: resume called restoring operational state to ${this.internal.operationalStateBeforePause}`);
+        if (this.internal.pausedSinceMs !== undefined) {
+            this.internal.pausedAccumulatedMs += Date.now() - this.internal.pausedSinceMs;
+            this.internal.pausedSinceMs = undefined;
+        }
+        this.state.operationalState = this.internal.operationalStateBeforePause;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
@@ -219,12 +287,34 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        device.log.debug('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
-        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
+        if (this.state.operationalState === RvcOperationalState.OperationalState.SeekingCharger) {
+            return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already seeking charger' } };
+        }
+        if (this.state.operationalState === RvcOperationalState.OperationalState.Error ||
+            this.state.operationalState === RvcOperationalState.OperationalState.Charging ||
+            this.state.operationalState === RvcOperationalState.OperationalState.Docked ||
+            this.state.operationalState === RvcOperationalState.OperationalState.EmptyingDustBin ||
+            this.state.operationalState === RvcOperationalState.OperationalState.CleaningMop ||
+            this.state.operationalState === RvcOperationalState.OperationalState.FillingWaterTank ||
+            this.state.operationalState === RvcOperationalState.OperationalState.UpdatingMaps) {
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.CommandInvalidInState, errorStateDetails: 'Cannot seek the charger in the current operational state' },
+            };
+        }
+        device.log.debug('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to SeekingCharger');
+        this.state.operationalState = RvcOperationalState.OperationalState.SeekingCharger;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
     }
 }
+(function (MatterbridgeRvcOperationalStateServer) {
+    class Internal extends MatterbridgeRvcOperationalStateServerBase.Internal {
+        operationalStateBeforePause = RvcOperationalState.OperationalState.Running;
+        operationStartedAt;
+        pausedAccumulatedMs = 0;
+        pausedSinceMs;
+    }
+    MatterbridgeRvcOperationalStateServer.Internal = Internal;
+})(MatterbridgeRvcOperationalStateServer || (MatterbridgeRvcOperationalStateServer = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.7-dev-20260825-7ebac36",
+  "version": "3.10.7-dev-20260827-957ddcc",
   "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.7-dev-20260825-7ebac36",
-    "@matterbridge/thread": "3.10.7-dev-20260825-7ebac36",
-    "@matterbridge/types": "3.10.7-dev-20260825-7ebac36",
-    "@matterbridge/utils": "3.10.7-dev-20260825-7ebac36",
+    "@matterbridge/dgram": "3.10.7-dev-20260827-957ddcc",
+    "@matterbridge/thread": "3.10.7-dev-20260827-957ddcc",
+    "@matterbridge/types": "3.10.7-dev-20260827-957ddcc",
+    "@matterbridge/utils": "3.10.7-dev-20260827-957ddcc",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",