@matterbridge/core 3.9.1-dev-20260614-18d1a2e → 3.9.1-dev-20260617-b1e1b99

package/README.md

@@ -6,10 +6,12 @@
 [![Docker Pulls](https://img.shields.io/docker/pulls/luligu/matterbridge?label=docker%20pulls)](https://hub.docker.com/r/luligu/matterbridge)
 ![Node.js CI](https://github.com/Luligu/matterbridge/actions/workflows/build.yml/badge.svg)
 ![CodeQL](https://github.com/Luligu/matterbridge/actions/workflows/codeql.yml/badge.svg)
-[![codecov](https://codecov.io/gh/Luligu/matterbridge/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge)
-[![styled with prettier](https://img.shields.io/badge/styled_with-Prettier-f8bc45.svg?logo=prettier)](https://prettier.io/)
-[![linted with eslint](https://img.shields.io/badge/linted_with-ES_Lint-4B32C3.svg?logo=eslint)](https://eslint.org/)
+[![Codecov](https://codecov.io/gh/Luligu/matterbridge/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge)
+[![tested with Vitest](https://img.shields.io/badge/tested_with-Vitest-6E9F18.svg?logo=vitest&logoColor=white)](https://vitest.dev)
+[![styled with Oxc](https://img.shields.io/badge/styled_with-Oxc-9BE4E0.svg?logo=oxc&logoColor=white)](https://oxc.rs/docs/guide/usage/formatter.html)
+[![linted with Oxc](https://img.shields.io/badge/linted_with-Oxc-9BE4E0.svg?logo=oxc&logoColor=white)](https://oxc.rs/docs/guide/usage/linter.html)
 [![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![TypeScript Native](https://img.shields.io/badge/TypeScript_Native-3178C6?logo=typescript&logoColor=white)](https://github.com/microsoft/typescript-go)
 [![ESM](https://img.shields.io/badge/ESM-Node.js-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
 [![matterbridge.io](https://img.shields.io/badge/matterbridge.io-online-brightgreen)](https://matterbridge.io)
 

package/dist/backend.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import { BroadcastServer } from '@matterbridge/thread';
 import { getParameter, hasParameter } from '@matterbridge/utils/cli';
 import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
-if (hasParameter('loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] Backend loaded.\u001B[40;0m');
+logModuleLoaded('Backend');
 export class Backend extends EventEmitter {
     debug;
     verbose;
@@ -36,7 +36,6 @@ export class Backend extends EventEmitter {
         this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
     }
     destroy() {
-        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
         this.server.close();
     }
     async broadcastMsgHandler(msg) {
@@ -61,6 +60,7 @@ export class Backend extends EventEmitter {
         this.backendWsServer = new BackendWsServer(this.matterbridge, this);
         if (!hasParameter('ssl')) {
             const http = await import('node:http');
+            await this.backendExpress.start();
             try {
                 this.log.debug(`Creating HTTP server...`);
                 this.httpServer = http.createServer(this.backendExpress.expressApp);
@@ -68,8 +68,10 @@ export class Backend extends EventEmitter {
             catch (error) {
                 logError(this.log, `Failed to create HTTP server`, error);
                 this.emit('server_error', error);
+                await this.backendExpress.stop();
                 return;
             }
+            await this.backendWsServer.start();
             this.httpServer.listen(this.port, getParameter('bind'), () => {
                 const addr = this.httpServer?.address();
                 if (addr && typeof addr !== 'string') {
@@ -110,7 +112,7 @@ export class Backend extends EventEmitter {
                         socket.destroy();
                     }
                 }
-                return;
+                return undefined;
             });
             this.httpServer.on('error', (error) => {
                 this.log.error(`Frontend http server error listening on ${this.port}`);
@@ -123,7 +125,7 @@ export class Backend extends EventEmitter {
                         break;
                 }
                 this.emit('server_error', error);
-                return;
+                return undefined;
             });
         }
         else {
@@ -191,6 +193,7 @@ export class Backend extends EventEmitter {
                 httpsServerOptions.rejectUnauthorized = true;
             }
             const https = await import('node:https');
+            await this.backendExpress.start();
             try {
                 this.log.debug(`Creating HTTPS server...`);
                 this.httpsServer = https.createServer(httpsServerOptions, this.backendExpress.expressApp);
@@ -198,8 +201,10 @@ export class Backend extends EventEmitter {
             catch (error) {
                 logError(this.log, `Failed to create HTTPS server`, error);
                 this.emit('server_error', error);
+                await this.backendExpress.stop();
                 return;
             }
+            await this.backendWsServer.start();
             this.httpsServer.listen(this.port, getParameter('bind'), () => {
                 const addr = this.httpsServer?.address();
                 if (addr && typeof addr !== 'string') {
@@ -239,7 +244,7 @@ export class Backend extends EventEmitter {
                         socket.destroy();
                     }
                 }
-                return;
+                return undefined;
             });
             this.httpsServer.on('error', (error) => {
                 this.log.error(`Frontend https server error listening on ${this.port}`);
@@ -259,6 +264,7 @@ export class Backend extends EventEmitter {
     }
     async stop() {
         this.log.debug('Stopping backend...');
+        await this.backendWsServer?.stop();
         if (this.httpServer) {
             this.log.debug('Closing http server...');
             this.httpServer.close();
@@ -279,6 +285,11 @@ export class Backend extends EventEmitter {
             this.httpsServer = undefined;
             this.log.debug('Backend https server closed successfully');
         }
+        await this.backendExpress?.stop();
+        this.backendWsServer?.destroy();
+        this.backendExpress?.destroy();
+        this.backendWsServer = undefined;
+        this.backendExpress = undefined;
         this.log.debug('Backend stopped');
     }
     getApiSettings() {

package/dist/backendExpress.d.ts

@@ -1,6 +1,6 @@
 import { type SharedMatterbridge } from '@matterbridge/types';
 import express from 'express';
-import { type Backend } from './backend.js';
+import type { Backend } from './backend.js';
 export declare class BackendExpress {
     private debug;
     private verbose;

package/dist/backendExpress.js

@@ -5,13 +5,13 @@ import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_BACKUP_FILE, MATTE
 import { hasParameter } from '@matterbridge/utils/cli';
 import { getErrorMessage } from '@matterbridge/utils/error';
 import { formatBytes } from '@matterbridge/utils/format';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import escapeHtml from 'escape-html';
 import express from 'express';
 import { rateLimit } from 'express-rate-limit';
 import multer from 'multer';
 import { AnsiLogger, er, nf } from 'node-ansi-logger';
-if (hasParameter('loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] BackendExpress loaded.\u001B[40;0m');
+logModuleLoaded('BackendExpress');
 export class BackendExpress {
     debug;
     verbose;
@@ -40,7 +40,6 @@ export class BackendExpress {
         this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
     }
     destroy() {
-        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
         this.server.close();
     }
     async broadcastMsgHandler(msg) {
@@ -53,6 +52,7 @@ export class BackendExpress {
                     this.log.logLevel = msg.params.logLevel;
                     this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
+                default:
             }
         }
     }
@@ -76,7 +76,7 @@ export class BackendExpress {
             });
         }
         this.expressApp.use(express.static(path.join(this.matterbridge.rootDirectory, 'apps', 'frontend', 'build')));
-        this.expressApp.post('/api/login', express.json(), async (req, res) => {
+        this.expressApp.post('/api/login', express.json(), (req, res) => {
             const { password } = req.body;
             this.log.debug(`The frontend sent /api/login with password ${password ? '[redacted]' : '(empty)'}`);
             if (this.backend.storedPassword === '' || password === this.backend.storedPassword) {
@@ -131,19 +131,19 @@ export class BackendExpress {
             };
             res.status(200).json(memoryReport);
         });
-        this.expressApp.get('/api/settings', async (req, res) => {
+        this.expressApp.get('/api/settings', (req, res) => {
             this.log.debug('The frontend sent /api/settings');
             if (!this.validateReq(req, res))
                 return;
             res.json(this.backend.getApiSettings());
         });
-        this.expressApp.get('/api/plugins', async (req, res) => {
+        this.expressApp.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             if (!this.validateReq(req, res))
                 return;
             res.json(this.backend.getApiPlugins());
         });
-        this.expressApp.get('/api/devices', async (req, res) => {
+        this.expressApp.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             if (!this.validateReq(req, res))
                 return;
@@ -310,7 +310,7 @@ export class BackendExpress {
                 res.status(500).send('Error reading history file.');
             }
         });
-        this.expressApp.get('/api/download-backup', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-backup', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-backup');
             if (!this.validateReq(req, res))
                 return;
@@ -325,7 +325,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-mbstorage', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-mbstorage', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-mbstorage');
             if (!this.validateReq(req, res))
                 return;
@@ -340,7 +340,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-mjstorage', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-mjstorage', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-mjstorage');
             if (!this.validateReq(req, res))
                 return;
@@ -355,7 +355,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-pluginstorage', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-pluginstorage', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-pluginstorage');
             if (!this.validateReq(req, res))
                 return;
@@ -370,7 +370,7 @@ export class BackendExpress {
                 }
             });
         });
-        this.expressApp.get('/api/download-pluginconfig', this.fileLimiter, async (req, res) => {
+        this.expressApp.get('/api/download-pluginconfig', this.fileLimiter, (req, res) => {
             this.log.debug('The frontend sent /api/download-pluginconfig');
             if (!this.validateReq(req, res))
                 return;

package/dist/backendWsServer.d.ts

@@ -1,7 +1,7 @@
 import type { EndpointNumber } from '@matter/types/datatype';
 import type { ApiMatter, RefreshRequiredChanged, SharedMatterbridge, WsMessageBroadcast } from '@matterbridge/types';
 import { WebSocketServer } from 'ws';
-import { type Backend } from './backend.js';
+import type { Backend } from './backend.js';
 export declare class BackendWsServer {
     private debug;
     private verbose;

package/dist/backendWsServer.js

@@ -2,12 +2,12 @@ import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
 import { BroadcastServer } from '@matterbridge/thread';
 import { hasParameter } from '@matterbridge/utils/cli';
 import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidNumber, isValidString } from '@matterbridge/utils/validate';
 import { fireAndForget, withTimeout } from '@matterbridge/utils/wait';
 import { AnsiLogger, CYAN, debugStringify, nf } from 'node-ansi-logger';
 import { WebSocket, WebSocketServer } from 'ws';
-if (hasParameter('loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] BackendWsServer loaded.\u001B[40;0m');
+logModuleLoaded('BackendWsServer');
 export class BackendWsServer {
     debug;
     verbose;
@@ -31,7 +31,6 @@ export class BackendWsServer {
         this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
     }
     destroy() {
-        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
         this.server.close();
     }
     broadcastMsgHandler(msg) {
@@ -44,6 +43,7 @@ export class BackendWsServer {
                     this.log.logLevel = msg.params.logLevel;
                     this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
+                default:
             }
         }
     }

package/dist/behaviors/activatedCarbonFilterMonitoringServer.d.ts

@@ -1,5 +1,5 @@
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
-import { type ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
+import type { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
 declare const MatterbridgeActivatedCarbonFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof ActivatedCarbonFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<ActivatedCarbonFilterMonitoring, {
     warning: false;
     condition: true;

package/dist/behaviors/bindingServer.d.ts

@@ -1,11 +1,11 @@
-import { type Endpoint } from '@matter/main/node';
+import type { Endpoint } from '@matter/main/node';
 import { BindingBehavior, BindingServer } from '@matter/node/behaviors/binding';
-import { type ClusterId } from '@matter/types';
-import { type Binding } from '@matter/types/clusters/binding';
+import type { ClusterId } from '@matter/types';
+import type { Binding } from '@matter/types/clusters/binding';
 export declare class MatterbridgeBindingServer extends BindingServer {
     protected internal: MatterbridgeBindingServer.Internal;
     state: MatterbridgeBindingServer.State;
-    initialize(): Promise<void>;
+    initialize(): void;
     [Symbol.asyncDispose](): Promise<void>;
     getEndpoint(clusterId: ClusterId): Endpoint | undefined;
 }

package/dist/behaviors/bindingServer.js

@@ -3,7 +3,7 @@ import { DescriptorServer } from '@matter/node/behaviors/descriptor';
 import { debugStringify, nt } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeBindingServer extends BindingServer {
-    async initialize() {
+    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(', ')}`);
@@ -31,7 +31,7 @@ export class MatterbridgeBindingServer extends BindingServer {
                 return;
             await resolution.node.set({ network: { autoSubscribe: true } });
         });
-        this.reactTo(this.events.removed, async (resolution) => {
+        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}`);
             this.internal.boundEndpoints.delete(resolution.entry);
         });

package/dist/behaviors/booleanStateConfigurationServer.js

@@ -1,10 +1,11 @@
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
+import { debugStringify } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
     async enableDisableAlarm(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Enabling/disabling alarm ${request.alarmsToEnableDisable} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`Enabling/disabling alarm ${debugStringify(request.alarmsToEnableDisable)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('BooleanStateConfiguration.enableDisableAlarm', {
             command: 'enableDisableAlarm',
             request,

package/dist/behaviors/doorLockServer.d.ts

@@ -30,7 +30,7 @@ declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBeh
     aliroBleuwb: false;
 }>, "doorLockAlarm" | "lockOperation" | "lockOperationError">, never>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">;
 export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
-    initialize(): Promise<void>;
+    initialize(): void;
     lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
     unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
     unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;

package/dist/behaviors/doorLockServer.js

@@ -6,10 +6,10 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
     events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
     commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
 }) {
-    async initialize() {
+    initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Initializing MatterbridgeDoorLockServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await super.initialize();
+        super.initialize();
     }
     async lockDoor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

@@ -1,5 +1,5 @@
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
-import { type HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
+import type { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof HepaFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<HepaFilterMonitoring, {
     warning: false;
     condition: true;

package/dist/behaviors/identifyServer.d.ts

@@ -1,5 +1,5 @@
 import { IdentifyServer } from '@matter/node/behaviors/identify';
-import { type Identify } from '@matter/types/clusters/identify';
+import type { Identify } from '@matter/types/clusters/identify';
 export declare class MatterbridgeIdentifyServer extends IdentifyServer {
     identify(request: Identify.IdentifyRequest): Promise<void>;
     triggerEffect(request: Identify.TriggerEffectRequest): Promise<void>;

package/dist/behaviors/levelControlServer.d.ts

@@ -1,5 +1,5 @@
 import { LevelControlServer } from '@matter/node/behaviors/level-control';
-import { type LevelControl } from '@matter/types/clusters/level-control';
+import type { LevelControl } from '@matter/types/clusters/level-control';
 export declare class MatterbridgeLevelControlServer extends LevelControlServer {
     moveToLevel(request: LevelControl.MoveToLevelRequest): Promise<void>;
     moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): Promise<void>;

package/dist/behaviors/matterbridgeServer.d.ts

@@ -1,6 +1,6 @@
 import { Behavior } from '@matter/node';
-import { type AnsiLogger } from 'node-ansi-logger';
-import { type CommandHandler } from '../matterbridgeEndpointCommandHandler.js';
+import type { AnsiLogger } from 'node-ansi-logger';
+import type { CommandHandler } from '../matterbridgeEndpointCommandHandler.js';
 export declare class MatterbridgeServer extends Behavior {
     static readonly id = "matterbridge";
     state: MatterbridgeServer.State;

package/dist/behaviors/modeSelectServer.d.ts

@@ -1,5 +1,5 @@
 import { ModeSelectServer } from '@matter/node/behaviors/mode-select';
-import { type ModeSelect } from '@matter/types/clusters/mode-select';
+import type { ModeSelect } from '@matter/types/clusters/mode-select';
 export declare class MatterbridgeModeSelectServer extends ModeSelectServer {
     changeToMode(request: ModeSelect.ChangeToModeRequest): Promise<void>;
 }

package/dist/behaviors/operationalStateServer.d.ts

@@ -1,4 +1,4 @@
-import { type MaybePromise } from '@matter/general';
+import type { MaybePromise } from '@matter/general';
 import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 export declare class MatterbridgeOperationalStateServer extends OperationalStateServer {

package/dist/behaviors/serviceAreaServer.d.ts

@@ -1,5 +1,5 @@
 import { ServiceAreaServer } from '@matter/node/behaviors/service-area';
-import { type ServiceArea } from '@matter/types/clusters/service-area';
+import type { ServiceArea } from '@matter/types/clusters/service-area';
 export declare class MatterbridgeServiceAreaServer extends ServiceAreaServer {
     selectAreas(request: ServiceArea.SelectAreasRequest): Promise<ServiceArea.SelectAreasResponse>;
 }

package/dist/behaviors/windowCoveringServer.d.ts

@@ -10,13 +10,13 @@ export declare class MatterbridgeWindowCoveringServer extends MatterbridgeWindow
     protected internal: WindowCoveringBaseServer.Internal;
     lookupMovementStatus: string[];
     private getMovementStatusLabel;
-    initialize(): Promise<void>;
+    initialize(): void;
     upOrOpen(): Promise<void>;
     downOrClose(): Promise<void>;
     stopMotion(): Promise<void>;
     goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): Promise<void>;
     goToTiltPercentage(request: WindowCovering.GoToTiltPercentageRequest): Promise<void>;
-    handleMovement(): Promise<void>;
+    handleMovement(): void;
 }
 declare const MatterbridgeLiftWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof MatterbridgeWindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
     lift: true;

package/dist/behaviors/windowCoveringServer.js

@@ -6,11 +6,11 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
     getMovementStatusLabel(status) {
         return this.lookupMovementStatus[status ?? 3];
     }
-    async initialize() {
+    initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Initializing MatterbridgeWindowCoveringServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.internal.disableOperationalModeHandling = true;
-        await super.initialize();
+        super.initialize();
     }
     async upOrOpen() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -87,7 +87,7 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
         await super.goToTiltPercentage(request);
         device.log.debug(`MatterbridgeWindowCoveringServer: goToTiltPercentage result target ${this.state.targetPositionTiltPercent100ths} current ${this.state.currentPositionTiltPercent100ths} status global ${this.getMovementStatusLabel(this.state.operationalStatus.global)} lift ${this.getMovementStatusLabel(this.state.operationalStatus.lift)} tilt ${this.getMovementStatusLabel(this.state.operationalStatus.tilt)}`);
     }
-    async handleMovement() {
+    handleMovement() {
     }
 }
 export class MatterbridgeLiftWindowCoveringServer extends MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {

package/dist/cli.js

@@ -1,18 +1,18 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] Cli loaded.\u001B[40;0m');
 import { ThreadsManager } from '@matterbridge/thread/manager';
 import { hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
 import { inspectError } from '@matterbridge/utils/error';
 import { formatBytes, formatUptime } from '@matterbridge/utils/format';
 import { Inspector } from '@matterbridge/utils/inspector';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { Tracker } from '@matterbridge/utils/tracker';
 import { AnsiLogger } from 'node-ansi-logger';
 import { cliEmitter } from './cliEmitter.js';
+logModuleLoaded('Cli');
 export let instance;
 export const tracker = new Tracker('Cli', false, false);
 export const inspector = new Inspector('Cli', false, false);
 const manager = new ThreadsManager();
-const colorEnabled = Boolean(!process.env.NO_COLOR && process.env.TERM !== 'dumb' && process.env.FORCE_COLOR !== '0' && !hasParameter('no-ansi'));
+const colorEnabled = !process.env.NO_COLOR && process.env.TERM !== 'dumb' && process.env.FORCE_COLOR !== '0' && !hasParameter('no-ansi');
 if (!colorEnabled)
     process.env.NO_COLOR = '1';
 const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
@@ -50,14 +50,14 @@ function registerHandlers() {
     log.debug('Registering event handlers...');
     if (!instance)
         return;
-    instance.on('shutdown', async () => shutdown());
-    instance.on('restart', async () => restart());
-    instance.on('update', async () => update());
+    instance.on('shutdown', () => void shutdown().catch((error) => inspectError(log, 'Failed to shutdown', error)));
+    instance.on('restart', () => void restart().catch((error) => inspectError(log, 'Failed to restart', error)));
+    instance.on('update', () => void update().catch((error) => inspectError(log, 'Failed to update', error)));
     instance.on('startmemorycheck', () => start());
     instance.on('stopmemorycheck', () => stop());
-    instance.on('startinspector', async () => startInspector());
-    instance.on('stopinspector', async () => stopInspector());
-    instance.on('takeheapsnapshot', async () => takeHeapSnapshot());
+    instance.on('startinspector', () => void startInspector().catch((error) => inspectError(log, 'Failed to start inspector', error)));
+    instance.on('stopinspector', () => void stopInspector().catch((error) => inspectError(log, 'Failed to stop inspector', error)));
+    instance.on('takeheapsnapshot', () => void takeHeapSnapshot().catch((error) => inspectError(log, 'Failed to take heap snapshot', error)));
     instance.on('triggergarbagecollection', () => triggerGarbageCollection());
     log.debug('Registered event handlers');
 }

package/dist/cliEmitter.js

@@ -1,6 +1,6 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] Cli emitter loaded.\u001B[40;0m');
 import { EventEmitter } from 'node:events';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
+logModuleLoaded('CliEmitter');
 export const cliEmitter = new EventEmitter();
 export let lastOsCpuUsage = 0;
 export let lastProcessCpuUsage = 0;

package/dist/cliHistory.js

@@ -1,9 +1,9 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] Cli history loaded.\u001B[40;0m');
 import { writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { Tracker } from '@matterbridge/utils/tracker';
+logModuleLoaded('CliHistory');
 export function generateHistoryPage(options = {}) {
     const pageTitle = options.pageTitle ?? 'Matterbridge CPU & Memory History';
     const hostname = options.hostname ?? os.hostname();

package/dist/clusters/export.d.ts

@@ -1 +1 @@
-export {};
+export declare const noop: () => void;

package/dist/clusters/export.js

@@ -1 +1 @@
-export {};
+export const noop = () => undefined;

package/dist/deviceManager.d.ts

@@ -21,7 +21,7 @@ export declare class DeviceManager {
     private toBaseDevice;
     array(): MatterbridgeEndpoint[];
     baseArray(pluginName?: string): BaseDevice[];
-    [Symbol.iterator](): MapIterator<MatterbridgeEndpoint>;
+    [Symbol.iterator](): IterableIterator<MatterbridgeEndpoint>;
     forEach(callback: (device: MatterbridgeEndpoint) => Promise<void>): Promise<void>;
     set logLevel(logLevel: LogLevel);
 }

package/dist/deviceManager.js

@@ -1,9 +1,9 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] Device Manager loaded.\u001B[40;0m');
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { dev } from '@matterbridge/types';
 import { hasParameter } from '@matterbridge/utils/cli';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, BLUE, CYAN, db, debugStringify, er } from 'node-ansi-logger';
+logModuleLoaded('Device Manager');
 export function toBaseDevice(device) {
     return {
         mode: device.mode,
@@ -43,10 +43,9 @@ export class DeviceManager {
         this.log.debug('Matterbridge device manager started');
     }
     destroy() {
-        this.server.off('broadcast_message', this.msgHandler.bind(this));
         this.server.close();
     }
-    async msgHandler(msg) {
+    msgHandler(msg) {
         if (this.server.isWorkerRequest(msg)) {
             if (this.verbose)
                 this.log.debug(`Received request message ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);

package/dist/devices/batteryStorage.js

@@ -3,6 +3,7 @@ import { ElectricalPowerMeasurementServer } from '@matter/node/behaviors/electri
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { ElectricalPowerMeasurement } from '@matter/types/clusters/electrical-power-measurement';
 import { PowerSource } from '@matter/types/clusters/power-source';
+import { fireAndForget } from '@matterbridge/utils/wait';
 import { batteryStorage, deviceEnergyManagement, electricalSensor, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { getDefaultElectricalPowerMeasurementClusterServer, getSemtag } from '../matterbridgeEndpointHelpers.js';
@@ -21,7 +22,7 @@ export class BatteryStorage extends MatterbridgeEndpoint {
             .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.BatteryStorage, true, DeviceEnergyManagement.EsaState.Online, absMinPower, absMaxPower)
             .createDefaultDeviceEnergyManagementModeClusterServer()
             .addRequiredClusterServers();
-        void this.addFixedLabel('composed', 'Battery Storage').catch(() => { });
+        fireAndForget(this.addFixedLabel('composed', 'Battery Storage'), this.log, 'BatteryStorage addFixedLabel');
         const battery = this.addChildDeviceType('Battery', [powerSource, electricalSensor], {
             tagList: [getSemtag(PowerSourceTag.Battery)],
         })

package/dist/devices/cooktop.d.ts

@@ -1,4 +1,4 @@
-import { type Semtag } from '@matter/types';
+import type { Semtag } from '@matter/types';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class Cooktop extends MatterbridgeEndpoint {
     constructor(name: string, serial: string);

package/dist/devices/cooktop.js

@@ -1,3 +1,4 @@
+import { fireAndForget } from '@matterbridge/utils/wait';
 import { cookSurface, cooktop, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
@@ -8,7 +9,7 @@ export class Cooktop extends MatterbridgeEndpoint {
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Cooktop');
         this.createDefaultPowerSourceWiredClusterServer();
         this.createOffOnlyOnOffClusterServer(true);
-        void this.addFixedLabel('composed', 'Cooktop').catch(() => { });
+        fireAndForget(this.addFixedLabel('composed', 'Cooktop'), this.log, 'Error adding composed label to cooktop');
     }
     addSurface(name, tagList, selectedTemperatureLevel = 2, supportedTemperatureLevels = ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']) {
         const surface = this.addChildDeviceType(name, cookSurface, { tagList });

package/dist/devices/dishwasher.d.ts

@@ -1,7 +1,7 @@
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
-import { type OperationalState } from '@matter/types/clusters/operational-state';
+import type { OperationalState } from '@matter/types/clusters/operational-state';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class Dishwasher extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: DishwasherMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);