@matterbridge/core 3.10.9-dev-20260904-cbaddbb → 3.10.9-dev-20260906-2a9dc0e

package/dist/behaviors/bindingServer.js

@@ -6,33 +6,33 @@ export class MatterbridgeBindingServer extends BindingServer {
     initialize() {
         super.initialize();
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Initializing MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) with clientList: ${this.state.clientList.join(', ')}`);
+        device.log.info(`MatterbridgeBindingServer: initializing with clientList ${this.state.clientList.join(', ')} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         const clientList = this.state.clientList;
         this.endpoint.construction.onSuccess(async () => {
             const currentClientList = this.endpoint.stateOf(DescriptorServer).clientList;
             const toAddClientList = clientList.filter((id) => !currentClientList.includes(id));
             if (toAddClientList.length > 0) {
-                device.log.info(`Adding client clusters to endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}: ${toAddClientList.join(', ')}`);
+                device.log.info(`MatterbridgeBindingServer: adding client clusters ${toAddClientList.join(', ')} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
                 await this.endpoint.setStateOf(DescriptorServer, { clientList: [...currentClientList, ...toAddClientList] });
             }
             const targets = this.endpoint.stateOf(BindingServer).binding;
             for (const target of targets) {
-                device.log.info(`Active binding for endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}: target ${debugStringify(target)}`);
+                device.log.info(`MatterbridgeBindingServer: active binding target ${debugStringify(target)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
             }
         });
         this.reactTo(this.events.binding$Changed, (value) => {
             this.internal.bound = value.length > 0;
-            device.log.notice(`MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) binding changed: ${debugStringify(value)}${nt}, bound: ${this.internal.bound}`);
+            device.log.notice(`MatterbridgeBindingServer: binding changed to ${debugStringify(value)}${nt}, bound ${this.internal.bound} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         });
         this.reactTo(this.events.established, async (resolution) => {
-            device.log.notice(`MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) binding established: kind ${resolution.kind} entry ${debugStringify(resolution.entry)}${nt}`);
+            device.log.notice(`MatterbridgeBindingServer: binding established with kind ${resolution.kind} entry ${debugStringify(resolution.entry)}${nt} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
             this.internal.boundEndpoints.set(resolution.entry, resolution.endpoint);
             if (resolution.kind !== 'client')
                 return;
             await resolution.node.set({ network: { autoSubscribe: true } });
         });
         this.reactTo(this.events.removed, (resolution) => {
-            device.log.notice(`MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) binding removed: kind ${resolution.kind} entry ${debugStringify(resolution.entry)}${nt}`);
+            device.log.notice(`MatterbridgeBindingServer: binding removed with kind ${resolution.kind} entry ${debugStringify(resolution.entry)}${nt} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
             this.internal.boundEndpoints.delete(resolution.entry);
         });
     }

package/dist/behaviors/colorControlServer.js

@@ -8,12 +8,12 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
         return super.initialize();
     }
     async moveToHue(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveToHue(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveToHue', {
             command: 'moveToHue',
             request,
@@ -22,16 +22,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveToHue called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveToHue(request);
     }
     async moveHue(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Moving hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveHue(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: moving hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveHue', {
             command: 'moveHue',
             request,
@@ -40,16 +40,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveHue called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveHue called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveHue(request);
     }
     async stepHue(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stepHue(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: stepping hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.stepHue', {
             command: 'stepHue',
             request,
@@ -58,16 +58,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: stepHue called`);
+        device.log.debug(`MatterbridgeColorControlServer: stepHue called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stepHue(request);
     }
     async enhancedMoveToHue(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting enhanced hue to ${request.enhancedHue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.enhancedMoveToHue(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: setting enhanced hue to ${request.enhancedHue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHue', {
             command: 'enhancedMoveToHue',
             request,
@@ -76,16 +76,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHue called`);
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHue called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.enhancedMoveToHue(request);
     }
     async enhancedMoveHue(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Moving enhanced hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.enhancedMoveHue(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: moving enhanced hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.enhancedMoveHue', {
             command: 'enhancedMoveHue',
             request,
@@ -94,16 +94,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveHue called`);
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveHue called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.enhancedMoveHue(request);
     }
     async enhancedStepHue(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping enhanced hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.enhancedStepHue(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: stepping enhanced hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.enhancedStepHue', {
             command: 'enhancedStepHue',
             request,
@@ -112,16 +112,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: enhancedStepHue called`);
+        device.log.debug(`MatterbridgeColorControlServer: enhancedStepHue called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.enhancedStepHue(request);
     }
     async moveToSaturation(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveToSaturation(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveToSaturation', {
             command: 'moveToSaturation',
             request,
@@ -130,16 +130,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveToSaturation(request);
     }
     async moveSaturation(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Moving saturation with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveSaturation(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: moving saturation with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveSaturation', {
             command: 'moveSaturation',
             request,
@@ -148,16 +148,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveSaturation called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveSaturation called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveSaturation(request);
     }
     async stepSaturation(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping saturation with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stepSaturation(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: stepping saturation with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.stepSaturation', {
             command: 'stepSaturation',
             request,
@@ -166,16 +166,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: stepSaturation called`);
+        device.log.debug(`MatterbridgeColorControlServer: stepSaturation called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stepSaturation(request);
     }
     async moveToHueAndSaturation(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveToHueAndSaturation(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveToHueAndSaturation', {
             command: 'moveToHueAndSaturation',
             request,
@@ -184,16 +184,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveToHueAndSaturation(request);
     }
     async enhancedMoveToHueAndSaturation(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting enhanced hue to ${request.enhancedHue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.enhancedMoveToHueAndSaturation(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: setting enhanced hue to ${request.enhancedHue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHueAndSaturation', {
             command: 'enhancedMoveToHueAndSaturation',
             request,
@@ -202,16 +202,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHueAndSaturation called`);
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHueAndSaturation called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.enhancedMoveToHueAndSaturation(request);
     }
     async moveToColor(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveToColor(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveToColor', {
             command: 'moveToColor',
             request,
@@ -220,16 +220,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveToColor called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveToColor(request);
     }
     async moveColor(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Moving color with rateX ${request.rateX} and rateY ${request.rateY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveColor(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: moving color with rateX ${request.rateX} and rateY ${request.rateY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveColor', {
             command: 'moveColor',
             request,
@@ -238,16 +238,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveColor called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveColor called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveColor(request);
     }
     async stepColor(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping color with stepX ${request.stepX} and stepY ${request.stepY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stepColor(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: stepping color with stepX ${request.stepX} and stepY ${request.stepY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.stepColor', {
             command: 'stepColor',
             request,
@@ -256,16 +256,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: stepColor called`);
+        device.log.debug(`MatterbridgeColorControlServer: stepColor called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stepColor(request);
     }
     async moveToColorTemperature(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveToColorTemperature(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveToColorTemperature', {
             command: 'moveToColorTemperature',
             request,
@@ -274,16 +274,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveToColorTemperature(request);
     }
     async moveColorTemperature(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Moving color temperature with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveColorTemperature(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: moving color temperature with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.moveColorTemperature', {
             command: 'moveColorTemperature',
             request,
@@ -292,16 +292,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: moveColorTemperature called`);
+        device.log.debug(`MatterbridgeColorControlServer: moveColorTemperature called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveColorTemperature(request);
     }
     async stepColorTemperature(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping color temperature with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stepColorTemperature(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: stepping color temperature with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.stepColorTemperature', {
             command: 'stepColorTemperature',
             request,
@@ -310,16 +310,16 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: stepColorTemperature called`);
+        device.log.debug(`MatterbridgeColorControlServer: stepColorTemperature called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stepColorTemperature(request);
     }
     async stopMoveStep(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stopping color move/step (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stopMoveStep(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeColorControlServer: stopping color move/step (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ColorControl.stopMoveStep', {
             command: 'stopMoveStep',
             request,
@@ -328,7 +328,7 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeColorControlServer: stopMoveStep called`);
+        device.log.debug(`MatterbridgeColorControlServer: stopMoveStep called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stopMoveStep(request);
     }
 }

package/dist/behaviors/deviceEnergyManagementModeServer.js

@@ -7,7 +7,7 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyManagementModeServer {
     async changeToMode(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeDeviceEnergyManagementModeServer: changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('DeviceEnergyManagementMode.changeToMode', {
             command: 'changeToMode',
             request,
@@ -18,7 +18,7 @@ export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyMa
         });
         const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
-            device.log.error(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
+            device.log.error(`MatterbridgeDeviceEnergyManagementModeServer: changeToMode called with unsupported newMode ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
         this.state.currentMode = request.newMode;
@@ -36,7 +36,7 @@ export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyMa
                 });
             }
         }
-        device.log.debug(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with newMode ${request.newMode} => ${supported.label}`);
+        device.log.debug(`MatterbridgeDeviceEnergyManagementModeServer: changeToMode called with newMode ${request.newMode} => ${supported.label} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         return await super.changeToMode(request);
     }
 }

package/dist/behaviors/deviceEnergyManagementServer.d.ts

@@ -22,7 +22,6 @@ export declare namespace MatterbridgeDeviceEnergyManagementServer {
         powerAdjustActivationTimeMs: number | undefined;
         powerAdjustPowerMw: number | undefined;
         powerAdjustCompletionTimer: Timer | undefined;
-        powerAdjustCompletionCallback: (() => void) | undefined;
     }
 }
 export {};

package/dist/behaviors/deviceEnergyManagementServer.js

@@ -6,13 +6,12 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment) {
     async initialize() {
         await super.initialize();
-        this.internal.powerAdjustCompletionCallback = this.callback(this.#completePowerAdjustmentOnTimeout, { lock: true });
         this.reactTo(this.events.optOutState$Changed, this.#handleOptOutStateChanged);
     }
     async powerAdjustRequest(request) {
         const { power, duration, cause } = request;
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Adjusting power to ${power} duration ${duration} cause ${cause} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeDeviceEnergyManagementServer: adjusting power to ${power} duration ${duration} cause ${cause} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('DeviceEnergyManagement.powerAdjustRequest', {
             command: 'powerAdjustRequest',
             request,
@@ -21,21 +20,21 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDeviceEnergyManagementServer powerAdjustRequest called with power ${power} duration ${duration} cause ${cause}`);
+        device.log.debug(`MatterbridgeDeviceEnergyManagementServer: powerAdjustRequest called with power ${power} duration ${duration} cause ${cause} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         const entries = (this.state.powerAdjustmentCapability?.powerAdjustCapability ?? []);
         if (entries.length === 0) {
-            throw new StatusResponseError('No power adjustment capability available', Status.ConstraintError);
+            throw new StatusResponseError(`MatterbridgeDeviceEnergyManagementServer: no power adjustment capability available (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
         }
         const minPower = Math.min(...entries.map((entry) => entry.minPower));
         const maxPower = Math.max(...entries.map((entry) => entry.maxPower));
         const minDuration = Math.min(...entries.map((entry) => entry.minDuration));
         const maxDuration = Math.max(...entries.map((entry) => entry.maxDuration));
         if (power < minPower || power > maxPower || duration < minDuration || duration > maxDuration) {
-            throw new StatusResponseError('Power or duration out of range', Status.ConstraintError);
+            throw new StatusResponseError(`MatterbridgeDeviceEnergyManagementServer: power or duration out of range (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
         }
         const optOutBit = cause === DeviceEnergyManagement.AdjustmentCause.LocalOptimization ? DeviceEnergyManagement.OptOutState.LocalOptOut : DeviceEnergyManagement.OptOutState.GridOptOut;
         if ((this.state.optOutState & optOutBit) !== 0) {
-            throw new StatusResponseError('User has opted out of this adjustment cause', Status.ConstraintError);
+            throw new StatusResponseError(`MatterbridgeDeviceEnergyManagementServer: user has opted out of this adjustment cause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
         }
         const wasActive = this.state.esaState === DeviceEnergyManagement.EsaState.PowerAdjustActive;
         const adjustReason = cause === DeviceEnergyManagement.AdjustmentCause.LocalOptimization
@@ -49,13 +48,11 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
             this.internal.powerAdjustActivationTimeMs = Time.nowMs;
             this.events.powerAdjustStart.emit(undefined, this.context);
         }
-        if (this.internal.powerAdjustCompletionCallback) {
-            this.internal.powerAdjustCompletionTimer = Time.getTimer('DeviceEnergyManagement power adjust completion', Seconds(duration), this.internal.powerAdjustCompletionCallback).start();
-        }
+        this.internal.powerAdjustCompletionTimer = Time.getTimer('DeviceEnergyManagement power adjust completion', Seconds(duration), this.callback(this.#completePowerAdjustmentOnTimeout, { lock: true })).start();
     }
     async cancelPowerAdjustRequest() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Cancelling power adjustment (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeDeviceEnergyManagementServer: cancelling power adjustment (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('DeviceEnergyManagement.cancelPowerAdjustRequest', {
             command: 'cancelPowerAdjustRequest',
             request: {},
@@ -64,9 +61,9 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDeviceEnergyManagementServer cancelPowerAdjustRequest called`);
+        device.log.debug(`MatterbridgeDeviceEnergyManagementServer: cancelPowerAdjustRequest called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (this.state.esaState !== DeviceEnergyManagement.EsaState.PowerAdjustActive) {
-            throw new StatusResponseError('No power adjustment is currently active', Status.InvalidInState);
+            throw new StatusResponseError(`MatterbridgeDeviceEnergyManagementServer: no power adjustment is currently active (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
         }
         this.#endPowerAdjustment(DeviceEnergyManagement.Cause.Cancelled);
     }
@@ -104,7 +101,6 @@ export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManage
         powerAdjustActivationTimeMs;
         powerAdjustPowerMw;
         powerAdjustCompletionTimer;
-        powerAdjustCompletionCallback;
     }
     MatterbridgeDeviceEnergyManagementServer.Internal = Internal;
 })(MatterbridgeDeviceEnergyManagementServer || (MatterbridgeDeviceEnergyManagementServer = {}));

package/dist/behaviors/fanControlServer.js

@@ -72,16 +72,16 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
         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})`);
+            device.log.debug(`MatterbridgeFanControlServer: 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})`);
+            device.log.debug(`MatterbridgeFanControlServer: 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);
+            throw new StatusResponseError(`MatterbridgeFanControlServer: fanMode ${getEnumDescription(FanControl.FanMode, fanMode)} is not supported by fanModeSequence ${getEnumDescription(FanControl.FanModeSequence, this.state.fanModeSequence)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
         }
         if (fanMode === FanControl.FanMode.Off) {
             this.state.percentSetting = 0;
@@ -94,24 +94,24 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
                     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})`);
+            device.log.debug(`MatterbridgeFanControlServer: 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})`);
+                device.log.debug(`MatterbridgeFanControlServer: 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(`MatterbridgeFanControlServer: 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})`);
+            device.log.debug(`MatterbridgeFanControlServer: 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})`);
+            device.log.debug(`MatterbridgeFanControlServer: handleFanModeChanging fanMode changed to ${lookupFanMode[fanMode]} >>> percentSetting ${this.state.percentSetting} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
     }
     #handlePercentSettingChanging(percentSetting, oldPercentSetting) {
@@ -120,7 +120,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
             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})`);
+            device.log.debug(`MatterbridgeFanControlServer: 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);
@@ -130,7 +130,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
             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})`);
+        device.log.debug(`MatterbridgeFanControlServer: 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);
@@ -139,7 +139,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
             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})`);
+            device.log.debug(`MatterbridgeFanControlServer: 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;
@@ -151,11 +151,11 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
             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})`);
+        device.log.debug(`MatterbridgeFanControlServer: 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 ${lookupStepDirection[request.direction]} wrap: ${request.wrap} lowestOff: ${request.lowestOff} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeFanControlServer: 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,
@@ -194,6 +194,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
             state.speedCurrent = speedSettingForPercent(state.speedMax, resolvedPercentSetting);
         }
         device.log.debug(`MatterbridgeFanControlServer: step applied fanMode ${lookupFanMode[this.state.fanMode]}, percentCurrent ${this.state.percentCurrent}` +
-            (this.features.multiSpeed ? `, speedCurrent ${this.state.speedCurrent}` : ''));
+            (this.features.multiSpeed ? `, speedCurrent ${this.state.speedCurrent}` : '') +
+            ` (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
 }

package/dist/behaviors/identifyServer.js

@@ -3,7 +3,7 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeIdentifyServer extends IdentifyServer {
     async identify(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Identifying device for ${request.identifyTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeIdentifyServer: identifying device for ${request.identifyTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('Identify.identify', {
             command: 'identify',
             request,
@@ -12,12 +12,12 @@ export class MatterbridgeIdentifyServer extends IdentifyServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeIdentifyServer: identify called`);
+        device.log.debug(`MatterbridgeIdentifyServer: identify called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.identify(request);
     }
     async triggerEffect(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Triggering effect ${request.effectIdentifier} variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeIdentifyServer: triggering effect ${request.effectIdentifier} variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('Identify.triggerEffect', {
             command: 'triggerEffect',
             request,
@@ -26,7 +26,7 @@ export class MatterbridgeIdentifyServer extends IdentifyServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called`);
+        device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.triggerEffect(request);
     }
 }

package/dist/behaviors/levelControlServer.js

@@ -7,12 +7,12 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
         return super.initialize();
     }
     async moveToLevel(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveToLevel(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.moveToLevel', {
             command: 'moveToLevel',
             request,
@@ -21,16 +21,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called`);
+        device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveToLevel(request);
     }
     async moveToLevelWithOnOff(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveToLevelWithOnOff(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: setting level with on/off to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.moveToLevelWithOnOff', {
             command: 'moveToLevelWithOnOff',
             request,
@@ -39,16 +39,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
+        device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveToLevelWithOnOff(request);
     }
     async move(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.move(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.move', {
             command: 'move',
             request,
@@ -57,16 +57,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: move called`);
+        device.log.debug(`MatterbridgeLevelControlServer: move called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.move(request);
     }
     async moveWithOnOff(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.moveWithOnOff(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: moving level with on/off with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.moveWithOnOff', {
             command: 'moveWithOnOff',
             request,
@@ -75,16 +75,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: moveWithOnOff called`);
+        device.log.debug(`MatterbridgeLevelControlServer: moveWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.moveWithOnOff(request);
     }
     async step(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.step(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.step', {
             command: 'step',
             request,
@@ -93,16 +93,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: step called`);
+        device.log.debug(`MatterbridgeLevelControlServer: step called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.step(request);
     }
     async stepWithOnOff(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stepWithOnOff(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: stepping level with on/off with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.stepWithOnOff', {
             command: 'stepWithOnOff',
             request,
@@ -111,16 +111,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: stepWithOnOff called`);
+        device.log.debug(`MatterbridgeLevelControlServer: stepWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stepWithOnOff(request);
     }
     async stop(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stop(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.stop', {
             command: 'stop',
             request,
@@ -129,16 +129,16 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: stop called`);
+        device.log.debug(`MatterbridgeLevelControlServer: stop called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stop(request);
     }
     async stopWithOnOff(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.stopWithOnOff(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelControlServer: stopping level change with on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('LevelControl.stopWithOnOff', {
             command: 'stopWithOnOff',
             request,
@@ -147,7 +147,7 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeLevelControlServer: stopWithOnOff called`);
+        device.log.debug(`MatterbridgeLevelControlServer: stopWithOnOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stopWithOnOff(request);
     }
 }

package/dist/behaviors/matterbridgeServer.js

@@ -2,7 +2,7 @@ import { Behavior } from '@matter/node';
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
     initialize() {
-        this.state.log.debug(`MatterbridgeServer initialized (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.state.log.debug(`MatterbridgeServer: initialized (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         super.initialize();
     }
 }

package/dist/behaviors/modeSelectServer.js

@@ -3,7 +3,7 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeModeSelectServer extends ModeSelectServer {
     async changeToMode(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeModeSelectServer: changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ModeSelect.changeToMode', {
             command: 'changeToMode',
             request,
@@ -12,7 +12,7 @@ export class MatterbridgeModeSelectServer extends ModeSelectServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode: ${request.newMode}`);
+        device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.changeToMode(request);
     }
 }

package/dist/behaviors/occupancySensingServer.js

@@ -1,9 +1,12 @@
 import { OccupancySensingServer } from '@matter/node/behaviors/occupancy-sensing';
 import { OccupancySensing } from '@matter/types/clusters/occupancy-sensing';
+import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeOccupancySensingServer extends OccupancySensingServer.with(OccupancySensing.Feature.PassiveInfrared) {
     #syncingHoldTime = false;
     initialize() {
         const result = super.initialize();
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOccupancySensingServer: initializing (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (this.events.holdTime$Changing)
             this.reactTo(this.events.holdTime$Changing, this.#syncPirOccupiedToUnoccupiedDelay);
         if (this.events.pirOccupiedToUnoccupiedDelay$Changing)

package/dist/behaviors/onOffServer.js

@@ -3,12 +3,12 @@ import { OnOff } from '@matter/types/clusters/on-off';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Lighting) {
     async on() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.on();
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOnOffServer: switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('OnOff.on', {
             command: 'on',
             request: {},
@@ -17,16 +17,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeOnOffServer: on called`);
+        device.log.debug(`MatterbridgeOnOffServer: on called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.on();
     }
     async off() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.off();
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOnOffServer: switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('OnOff.off', {
             command: 'off',
             request: {},
@@ -35,16 +35,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeOnOffServer: off called`);
+        device.log.debug(`MatterbridgeOnOffServer: off called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         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})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.toggle();
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOnOffServer: toggling device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('OnOff.toggle', {
             command: 'toggle',
             request: {},
@@ -53,16 +53,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeOnOffServer: toggle called`);
+        device.log.debug(`MatterbridgeOnOffServer: toggle called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         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})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.offWithEffect(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOnOffServer: 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,
@@ -71,16 +71,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeOnOffServer: offWithEffect called`);
+        device.log.debug(`MatterbridgeOnOffServer: offWithEffect called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         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})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.onWithRecallGlobalScene();
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOnOffServer: switching device on with recall global scene (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('OnOff.onWithRecallGlobalScene', {
             command: 'onWithRecallGlobalScene',
             request: {},
@@ -89,16 +89,16 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeOnOffServer: onWithRecallGlobalScene called`);
+        device.log.debug(`MatterbridgeOnOffServer: onWithRecallGlobalScene called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         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})`);
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.onWithTimedOff(request);
             return;
         }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOnOffServer: 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,
@@ -107,7 +107,7 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeOnOffServer: onWithTimedOff called`);
+        device.log.debug(`MatterbridgeOnOffServer: onWithTimedOff called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.onWithTimedOff(request);
     }
 }

package/dist/behaviors/pumpConfigurationAndControlServer.js

@@ -66,7 +66,7 @@ export class MatterbridgePumpConfigurationAndControlServer extends PumpConfigura
     }
     #handleOperationModeChanging() {
         if (this.state.pumpStatus?.localOverride) {
-            throw new StatusResponseError('OperationMode cannot be changed while PumpStatus.LocalOverride is set', Status.Failure);
+            throw new StatusResponseError(`MatterbridgePumpConfigurationAndControlServer: operationMode cannot be changed while PumpStatus.LocalOverride is set (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Failure);
         }
     }
     #handleOperationModeChanged(operationMode, oldOperationMode) {

package/dist/behaviors/serviceAreaServer.js

@@ -3,7 +3,7 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
     async selectAreas(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Selecting areas [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeServiceAreaServer: selecting areas [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ServiceArea.selectAreas', {
             command: 'selectAreas',
             request,
@@ -12,7 +12,7 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeServiceAreaServer selectAreas called with: [${request.newAreas.join(', ')}]`);
+        device.log.debug(`MatterbridgeServiceAreaServer: selectAreas called with [${request.newAreas.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         return await super.selectAreas(request);
     }
 }

package/dist/behaviors/smokeCoAlarmServer.js

@@ -7,7 +7,7 @@ export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(Smok
     static selfTestDurationSeconds = 5;
     async selfTestRequest() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Testing SmokeCOAlarm (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeSmokeCoAlarmServer: testing SmokeCOAlarm (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('SmokeCoAlarm.selfTestRequest', {
             command: 'selfTestRequest',
             request: {},
@@ -17,12 +17,12 @@ export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(Smok
             context: this.context,
         });
         if (this.state.expressedState !== SmokeCoAlarm.ExpressedState.Normal || this.state.testInProgress) {
-            throw new StatusResponseError('SmokeCOAlarm self-test is busy', Status.Busy);
+            throw new StatusResponseError(`MatterbridgeSmokeCoAlarmServer: SmokeCOAlarm self-test is busy (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Busy);
         }
         this.state.testInProgress = true;
         this.state.expressedState = SmokeCoAlarm.ExpressedState.Testing;
         this.#scheduleSelfTestComplete();
-        device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called`);
+        device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
     #stopSelfTestTimer() {
         this.internal.selfTestTimer?.stop();

package/dist/behaviors/switchServer.js

@@ -3,6 +3,6 @@ import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeSwitchServer extends SwitchServer {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Initializing MatterbridgeSwitchServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeSwitchServer: initializing (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
 }

package/dist/behaviors/valveConfigurationAndControlServer.js

@@ -14,7 +14,7 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
     }
     async open(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Opening valve to ${request.targetLevel ? request.targetLevel + '%' : 'fully opened'} ${request.openDuration ? 'for ' + request.openDuration + 's' : 'until closed'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeValveConfigurationAndControlServer: opening valve to ${request.targetLevel ? request.targetLevel + '%' : 'fully opened'} ${request.openDuration ? 'for ' + request.openDuration + 's' : 'until closed'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ValveConfigurationAndControl.open', {
             command: 'open',
             request,
@@ -23,9 +23,9 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel}`);
+        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (this.#hasFault()) {
-            throw new ValveConfigurationAndControl.FailureDueToFaultError('Open ignored: the valve has a registered fault');
+            throw new ValveConfigurationAndControl.FailureDueToFaultError(`MatterbridgeValveConfigurationAndControlServer: open ignored, the valve has a registered fault (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
         this.#stopMovementTimer();
         this.#stopAutoCloseTimer();
@@ -35,7 +35,7 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
         this.state.remainingDuration = this.state.openDuration;
         if (this.features.level) {
             if (request.targetLevel !== undefined && request.targetLevel !== 100 && this.state.levelStep !== undefined && request.targetLevel % this.state.levelStep !== 0) {
-                throw new StatusResponseError(`Open TargetLevel ${request.targetLevel} is not a multiple of LevelStep ${this.state.levelStep}`, Status.ConstraintError);
+                throw new StatusResponseError(`MatterbridgeValveConfigurationAndControlServer: open targetLevel ${request.targetLevel} is not a multiple of levelStep ${this.state.levelStep} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
             }
             this.state.targetLevel = request.targetLevel ?? this.state.defaultOpenLevel ?? 100;
         }
@@ -46,7 +46,7 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
     }
     async close() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Closing valve (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeValveConfigurationAndControlServer: closing valve (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('ValveConfigurationAndControl.close', {
             command: 'close',
             request: {},
@@ -55,9 +55,9 @@ export class MatterbridgeValveConfigurationAndControlServer extends Matterbridge
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called`);
+        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         if (this.#hasFault()) {
-            throw new ValveConfigurationAndControl.FailureDueToFaultError('Close ignored: the valve has a registered fault');
+            throw new ValveConfigurationAndControl.FailureDueToFaultError(`MatterbridgeValveConfigurationAndControlServer: close ignored, the valve has a registered fault (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
         this.#stopMovementTimer();
         this.#stopAutoCloseTimer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.9-dev-20260904-cbaddbb",
+  "version": "3.10.9-dev-20260906-2a9dc0e",
   "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.9-dev-20260904-cbaddbb",
-    "@matterbridge/thread": "3.10.9-dev-20260904-cbaddbb",
-    "@matterbridge/types": "3.10.9-dev-20260904-cbaddbb",
-    "@matterbridge/utils": "3.10.9-dev-20260904-cbaddbb",
+    "@matterbridge/dgram": "3.10.9-dev-20260906-2a9dc0e",
+    "@matterbridge/thread": "3.10.9-dev-20260906-2a9dc0e",
+    "@matterbridge/types": "3.10.9-dev-20260906-2a9dc0e",
+    "@matterbridge/utils": "3.10.9-dev-20260906-2a9dc0e",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",