@matterbridge/core 3.11.1-dev-20261030-e12e668 → 3.11.1-dev-20261030-65deb56

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/chipTests.js CHANGED
@@ -21,6 +21,9 @@ import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-stat
21
21
  import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
22
22
  import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
23
23
  import { Switch } from '@matter/types/clusters/switch';
24
+ import { Thermostat } from '@matter/types/clusters/thermostat';
25
+ import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
26
+ import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
24
27
  import { StatusResponseError } from '@matter/types/common';
25
28
  import { Status, TariffPriceType, TariffUnit } from '@matter/types/globals';
26
29
  import { MATTER_EPOCH_OFFSET_S } from '@matter/types/tlv';
@@ -28,6 +31,7 @@ import { wait } from '@matterbridge/utils/wait';
28
31
  import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensingServer.js';
29
32
  import { cliEmitter } from './cliEmitter.js';
30
33
  import { MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer } from './devices/roboticVacuumCleaner.js';
34
+ import { MatterbridgeWaterHeaterManagementServer } from './devices/waterHeater.js';
31
35
  import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
32
36
  import { featuresFor } from './matterbridgeEndpointHelpers.js';
33
37
  const chipTestAppPipePath = '/tmp/matterbridge-chip-test-app-pipe';
@@ -62,6 +66,14 @@ const smokeCoAlarmDeviceMutedClearTrigger = 0x005c0000000000abn;
62
66
  const electricalPowerMeasurementStartFakeLoadTrigger = 0x0091000000000001n;
63
67
  const electricalEnergyMeasurementStartFakeGeneratorTrigger = 0x0091000000000002n;
64
68
  const electricalPowerMeasurementStopFakeReadingsTrigger = 0x0091000000000000n;
69
+ const waterHeaterBasicInstallationTrigger = 0x0094000000000000n;
70
+ const waterHeaterBasicInstallationClearTrigger = 0x0094000000000001n;
71
+ const waterHeaterWaterTemperature20CTrigger = 0x0094000000000002n;
72
+ const waterHeaterWaterTemperature61CTrigger = 0x0094000000000003n;
73
+ const waterHeaterWaterTemperature66CTrigger = 0x0094000000000004n;
74
+ const waterHeaterManualModeTrigger = 0x0094000000000005n;
75
+ const waterHeaterOffModeTrigger = 0x0094000000000006n;
76
+ const waterHeaterDrawOffHotWaterTrigger = 0x0094000000000007n;
65
77
  const deviceEnergyManagementPowerAdjustmentTrigger = 0x0098000000000000n;
66
78
  const deviceEnergyManagementPowerAdjustmentClearTrigger = 0x0098000000000001n;
67
79
  const deviceEnergyManagementUserOptOutLocalTrigger = 0x0098000000000002n;
@@ -353,6 +365,7 @@ async function handleChipTestEventTrigger(eventTrigger) {
353
365
  normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmDeviceMutedTrigger) &&
354
366
  normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmDeviceMutedClearTrigger)) {
355
367
  return ((await handleElectricalEnergyTestEventTrigger(normalizedEventTrigger)) ||
368
+ (await handleWaterHeaterManagementTestEventTrigger(normalizedEventTrigger)) ||
356
369
  (await handleDeviceEnergyManagementTestEventTrigger(normalizedEventTrigger)) ||
357
370
  (await handleEnergyEvseTestEventTrigger(normalizedEventTrigger)) ||
358
371
  (await handleMeterIdentificationTestEventTrigger(normalizedEventTrigger)) ||
@@ -950,6 +963,87 @@ async function handleCommodityTariffTestEventTrigger(eventTrigger) {
950
963
  await endpoint.setCluster(CommodityTariff, buildCommodityTariffFakeValues(commodityTariffDayOffset, commodityTariffEntryIndex), log);
951
964
  return true;
952
965
  }
966
+ async function handleWaterHeaterManagementTestEventTrigger(eventTrigger) {
967
+ const supportedTriggers = [
968
+ normalizeTestEventTrigger(waterHeaterBasicInstallationTrigger),
969
+ normalizeTestEventTrigger(waterHeaterBasicInstallationClearTrigger),
970
+ normalizeTestEventTrigger(waterHeaterWaterTemperature20CTrigger),
971
+ normalizeTestEventTrigger(waterHeaterWaterTemperature61CTrigger),
972
+ normalizeTestEventTrigger(waterHeaterWaterTemperature66CTrigger),
973
+ normalizeTestEventTrigger(waterHeaterManualModeTrigger),
974
+ normalizeTestEventTrigger(waterHeaterOffModeTrigger),
975
+ normalizeTestEventTrigger(waterHeaterDrawOffHotWaterTrigger),
976
+ ];
977
+ if (!supportedTriggers.includes(eventTrigger) || !chipTestMatterbridge || chipTestActiveEndpointId === undefined)
978
+ return false;
979
+ const endpoint = getChipTestEndpoint(chipTestMatterbridge, chipTestActiveEndpointId);
980
+ if (!endpoint?.hasClusterServer(WaterHeaterManagement.id))
981
+ return false;
982
+ const log = chipTestMatterbridge.log;
983
+ switch (eventTrigger) {
984
+ case normalizeTestEventTrigger(waterHeaterBasicInstallationTrigger):
985
+ if (endpoint.getAttribute(WaterHeaterManagement.id, 'boostState') === WaterHeaterManagement.BoostState.Active) {
986
+ await endpoint.invokeBehaviorCommand(WaterHeaterManagement.id, 'cancelBoost', {});
987
+ }
988
+ await endpoint.setCluster(Thermostat, { localTemperature: 2000, occupiedHeatingSetpoint: 6000 }, log);
989
+ await endpoint.setCluster(WaterHeaterMode, { currentMode: 11 }, log);
990
+ await endpoint.setCluster(WaterHeaterManagement, {
991
+ heatDemand: {},
992
+ tankVolume: 100,
993
+ estimatedHeatRequired: 4_646_667,
994
+ tankPercentage: 0,
995
+ boostState: WaterHeaterManagement.BoostState.Inactive,
996
+ }, log);
997
+ return true;
998
+ case normalizeTestEventTrigger(waterHeaterBasicInstallationClearTrigger):
999
+ if (endpoint.getAttribute(WaterHeaterManagement.id, 'boostState') === WaterHeaterManagement.BoostState.Active) {
1000
+ await endpoint.invokeBehaviorCommand(WaterHeaterManagement.id, 'cancelBoost', {});
1001
+ }
1002
+ await endpoint.setCluster(Thermostat, { localTemperature: 5000, occupiedHeatingSetpoint: 5500 }, log);
1003
+ await endpoint.setCluster(WaterHeaterMode, { currentMode: 1 }, log);
1004
+ await endpoint.setCluster(WaterHeaterManagement, {
1005
+ heatDemand: {},
1006
+ tankVolume: 100,
1007
+ estimatedHeatRequired: 0,
1008
+ tankPercentage: 90,
1009
+ boostState: WaterHeaterManagement.BoostState.Inactive,
1010
+ }, log);
1011
+ return true;
1012
+ case normalizeTestEventTrigger(waterHeaterWaterTemperature20CTrigger):
1013
+ await endpoint.setCluster(Thermostat, { localTemperature: 2000 }, log);
1014
+ await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: 0 }, log);
1015
+ await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
1016
+ return true;
1017
+ case normalizeTestEventTrigger(waterHeaterWaterTemperature61CTrigger):
1018
+ await endpoint.setCluster(Thermostat, { localTemperature: 6100 }, log);
1019
+ await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: 100 }, log);
1020
+ await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
1021
+ return true;
1022
+ case normalizeTestEventTrigger(waterHeaterWaterTemperature66CTrigger):
1023
+ await endpoint.setCluster(Thermostat, { localTemperature: 6600 }, log);
1024
+ await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: 100 }, log);
1025
+ await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
1026
+ return true;
1027
+ case normalizeTestEventTrigger(waterHeaterManualModeTrigger):
1028
+ await endpoint.setCluster(WaterHeaterMode, { currentMode: 12 }, log);
1029
+ await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
1030
+ return true;
1031
+ case normalizeTestEventTrigger(waterHeaterOffModeTrigger):
1032
+ await endpoint.setCluster(WaterHeaterMode, { currentMode: 11 }, log);
1033
+ await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
1034
+ return true;
1035
+ case normalizeTestEventTrigger(waterHeaterDrawOffHotWaterTrigger): {
1036
+ const currentTankPercentageAttribute = endpoint.getAttribute(WaterHeaterManagement.id, 'tankPercentage');
1037
+ const currentTankPercentage = typeof currentTankPercentageAttribute === 'number' ? currentTankPercentageAttribute : 100;
1038
+ const nextTankPercentage = currentTankPercentage === 100 ? 76 : Math.floor((currentTankPercentage * 75) / 100);
1039
+ await endpoint.setCluster(WaterHeaterManagement, { tankPercentage: nextTankPercentage }, log);
1040
+ await endpoint.act((agent) => agent.get(MatterbridgeWaterHeaterManagementServer).evaluateWaterHeaterState());
1041
+ return true;
1042
+ }
1043
+ default:
1044
+ return false;
1045
+ }
1046
+ }
953
1047
  async function handleDeviceEnergyManagementTestEventTrigger(eventTrigger) {
954
1048
  if (eventTrigger !== deviceEnergyManagementPowerAdjustmentTrigger &&
955
1049
  eventTrigger !== deviceEnergyManagementPowerAdjustmentClearTrigger &&
@@ -1,3 +1,4 @@
1
+ import { type Timer } from '@matter/general';
1
2
  import { WaterHeaterManagementServer } from '@matter/node/behaviors/water-heater-management';
2
3
  import { WaterHeaterModeServer } from '@matter/node/behaviors/water-heater-mode';
3
4
  import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -24,6 +25,8 @@ export interface WaterHeaterOptions {
24
25
  maxHeatSetpointLimit?: number;
25
26
  heaterTypes?: WaterHeaterTypes;
26
27
  tankPercentage?: number;
28
+ tankVolume?: number;
29
+ estimatedHeatRequired?: number | bigint;
27
30
  voltage?: number | bigint | null;
28
31
  current?: number | bigint | null;
29
32
  power?: number | bigint | null;
@@ -33,7 +36,7 @@ export interface WaterHeaterOptions {
33
36
  }
34
37
  export declare class WaterHeater extends MatterbridgeEndpoint {
35
38
  constructor(name: string, serial: string, options?: WaterHeaterOptions);
36
- constructor(name: string, serial: string, waterTemperature?: number, targetWaterTemperature?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, heaterTypes?: WaterHeaterTypes, tankPercentage?: number, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energy?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
39
+ constructor(name: string, serial: string, waterTemperature?: number, targetWaterTemperature?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, heaterTypes?: WaterHeaterTypes, tankPercentage?: number, tankVolume?: number, estimatedHeatRequired?: number | bigint, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energy?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
37
40
  createDefaultWaterHeaterManagementClusterServer(heaterTypes?: {
38
41
  immersionElement1?: boolean;
39
42
  immersionElement2?: boolean;
@@ -46,13 +49,23 @@ export declare class WaterHeater extends MatterbridgeEndpoint {
46
49
  heatPump?: boolean;
47
50
  boiler?: boolean;
48
51
  other?: boolean;
49
- }, tankPercentage?: number, boostState?: WaterHeaterManagement.BoostState): this;
52
+ }, tankPercentage?: number, boostState?: WaterHeaterManagement.BoostState, tankVolume?: number, estimatedHeatRequired?: number | bigint): this;
50
53
  createDefaultWaterHeaterModeClusterServer(currentMode?: number, supportedModes?: WaterHeaterMode.ModeOption[]): this;
51
54
  }
52
55
  export declare class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
56
+ #private;
53
57
  readonly endpoint: MatterbridgeEndpoint;
58
+ protected internal: MatterbridgeWaterHeaterManagementServer.Internal;
54
59
  boost(request: WaterHeaterManagement.BoostRequest): Promise<void>;
55
60
  cancelBoost(): Promise<void>;
61
+ evaluateWaterHeaterState(): void;
62
+ }
63
+ export declare namespace MatterbridgeWaterHeaterManagementServer {
64
+ class Internal {
65
+ activeBoostInfo: WaterHeaterManagement.WaterHeaterBoostInfo | undefined;
66
+ boostTargetReached: boolean;
67
+ boostExpiryTimer: Timer | undefined;
68
+ }
56
69
  }
57
70
  export declare class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
58
71
  readonly endpoint: MatterbridgeEndpoint;
@@ -1,15 +1,18 @@
1
+ import { Seconds, Time } from '@matter/general';
1
2
  import { WaterHeaterManagementServer } from '@matter/node/behaviors/water-heater-management';
2
3
  import { WaterHeaterModeServer } from '@matter/node/behaviors/water-heater-mode';
3
4
  import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
4
5
  import { ModeBase } from '@matter/types/clusters/mode-base';
6
+ import { Thermostat } from '@matter/types/clusters/thermostat';
5
7
  import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
6
8
  import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
7
9
  import { fireAndForget } from '@matterbridge/utils/wait';
8
10
  import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
11
+ import { MatterbridgeThermostatServer } from '../behaviors/thermostatServer.js';
9
12
  import { deviceEnergyManagement, electricalSensor, powerSource, waterHeater } from '../matterbridgeDeviceTypes.js';
10
13
  import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
11
14
  export class WaterHeater extends MatterbridgeEndpoint {
12
- constructor(name, serial, optionsOrWaterTemperature, targetWaterTemperature = 55, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }, tankPercentage = 90, voltage = null, current = null, power = null, energy = null, absMinPower = 0, absMaxPower = 0) {
15
+ constructor(name, serial, optionsOrWaterTemperature, targetWaterTemperature = 55, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }, tankPercentage = 90, tankVolume = 100, estimatedHeatRequired = 0, voltage = null, current = null, power = null, energy = null, absMinPower = 0, absMaxPower = 0) {
13
16
  const options = typeof optionsOrWaterTemperature === 'object'
14
17
  ? optionsOrWaterTemperature
15
18
  : {
@@ -19,6 +22,8 @@ export class WaterHeater extends MatterbridgeEndpoint {
19
22
  maxHeatSetpointLimit,
20
23
  heaterTypes,
21
24
  tankPercentage,
25
+ tankVolume,
26
+ estimatedHeatRequired,
22
27
  voltage,
23
28
  current,
24
29
  power,
@@ -30,7 +35,7 @@ export class WaterHeater extends MatterbridgeEndpoint {
30
35
  this.createDefaultIdentifyClusterServer()
31
36
  .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Water Heater')
32
37
  .createDefaultHeatingThermostatClusterServer(options.waterTemperature ?? 50, options.targetWaterTemperature ?? 55, options.minHeatSetpointLimit ?? 20, options.maxHeatSetpointLimit ?? 80)
33
- .createDefaultWaterHeaterManagementClusterServer(options.heaterTypes ?? { immersionElement1: true }, {}, options.tankPercentage ?? 90)
38
+ .createDefaultWaterHeaterManagementClusterServer(options.heaterTypes ?? { immersionElement1: true }, {}, options.tankPercentage ?? 90, undefined, options.tankVolume ?? 100, options.estimatedHeatRequired ?? 0)
34
39
  .createDefaultWaterHeaterModeClusterServer();
35
40
  fireAndForget(this.addFixedLabel('composed', 'Water Heater'), this.log, 'WaterHeater addFixedLabel');
36
41
  this.addChildDeviceType('PowerSource', powerSource).createDefaultPowerSourceWiredClusterServer().addRequiredClusterServers();
@@ -44,12 +49,14 @@ export class WaterHeater extends MatterbridgeEndpoint {
44
49
  .createDefaultDeviceEnergyManagementModeClusterServer()
45
50
  .addRequiredClusterServers();
46
51
  }
47
- createDefaultWaterHeaterManagementClusterServer(heaterTypes, heatDemand, tankPercentage, boostState) {
48
- this.behaviors.require(MatterbridgeWaterHeaterManagementServer.with(WaterHeaterManagement.Feature.TankPercent), {
52
+ createDefaultWaterHeaterManagementClusterServer(heaterTypes, heatDemand, tankPercentage, boostState, tankVolume, estimatedHeatRequired) {
53
+ this.behaviors.require(MatterbridgeWaterHeaterManagementServer.with(WaterHeaterManagement.Feature.TankPercent, WaterHeaterManagement.Feature.EnergyManagement), {
49
54
  heaterTypes: heaterTypes ?? { immersionElement1: true },
50
55
  heatDemand: heatDemand ?? {},
51
56
  tankPercentage: tankPercentage ?? 100,
52
57
  boostState: boostState ?? WaterHeaterManagement.BoostState.Inactive,
58
+ tankVolume: tankVolume ?? 100,
59
+ estimatedHeatRequired: estimatedHeatRequired ?? 0,
53
60
  });
54
61
  return this;
55
62
  }
@@ -88,7 +95,21 @@ export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManageme
88
95
  context: this.context,
89
96
  });
90
97
  device.log.debug(`MatterbridgeWaterHeaterManagementServer: boost called with: ${JSON.stringify(request)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
98
+ this.internal.boostExpiryTimer?.stop();
99
+ const boostInfo = {
100
+ duration: request.boostInfo.duration,
101
+ oneShot: request.boostInfo.oneShot === true ? true : undefined,
102
+ emergencyBoost: request.boostInfo.emergencyBoost === true ? true : undefined,
103
+ temporarySetpoint: request.boostInfo.temporarySetpoint,
104
+ targetPercentage: request.boostInfo.targetPercentage,
105
+ targetReheat: request.boostInfo.targetReheat,
106
+ };
107
+ this.internal.activeBoostInfo = boostInfo;
108
+ this.internal.boostTargetReached = false;
91
109
  this.state.boostState = WaterHeaterManagement.BoostState.Active;
110
+ this.#updateHeatDemand();
111
+ this.events.boostStarted.emit({ boostInfo }, this.context);
112
+ this.internal.boostExpiryTimer = Time.getTimer('WaterHeaterManagement boost expiry', Seconds(request.boostInfo.duration), this.callback(this.#expireBoost, { lock: true })).start();
92
113
  this.endpoint.emitCommand(WaterHeaterManagement, 'boost', request, this.context);
93
114
  }
94
115
  async cancelBoost() {
@@ -103,10 +124,84 @@ export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManageme
103
124
  context: this.context,
104
125
  });
105
126
  device.log.debug(`MatterbridgeWaterHeaterManagementServer: cancelBoost called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
106
- this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
127
+ this.internal.boostExpiryTimer?.stop();
128
+ this.internal.boostExpiryTimer = undefined;
129
+ this.internal.activeBoostInfo = undefined;
130
+ this.internal.boostTargetReached = false;
131
+ if (this.state.boostState === WaterHeaterManagement.BoostState.Active) {
132
+ this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
133
+ this.#updateHeatDemand();
134
+ this.events.boostEnded.emit(undefined, this.context);
135
+ }
107
136
  this.endpoint.emitCommand(WaterHeaterManagement, 'cancelBoost', {}, this.context);
108
137
  }
138
+ evaluateWaterHeaterState() {
139
+ const boostInfo = this.internal.activeBoostInfo;
140
+ if (this.state.boostState === WaterHeaterManagement.BoostState.Active && boostInfo && this.#isBoostTargetMet(boostInfo)) {
141
+ this.internal.boostTargetReached = true;
142
+ if (boostInfo.oneShot) {
143
+ this.#expireBoost();
144
+ return;
145
+ }
146
+ }
147
+ this.#updateHeatDemand();
148
+ }
149
+ #expireBoost() {
150
+ this.internal.boostExpiryTimer?.stop();
151
+ this.internal.boostExpiryTimer = undefined;
152
+ this.internal.activeBoostInfo = undefined;
153
+ this.internal.boostTargetReached = false;
154
+ this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
155
+ this.#updateHeatDemand();
156
+ this.events.boostEnded.emit(undefined, this.context);
157
+ }
158
+ #isBoostTargetMet(boostInfo) {
159
+ const state = this.state;
160
+ if (boostInfo.targetPercentage !== undefined && state.tankPercentage !== undefined) {
161
+ return state.tankPercentage >= boostInfo.targetPercentage;
162
+ }
163
+ const thermostatState = this.endpoint.stateOf(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating));
164
+ const localTemperature = thermostatState.localTemperature ?? 0;
165
+ const targetSetpoint = boostInfo.temporarySetpoint ?? thermostatState.occupiedHeatingSetpoint;
166
+ return localTemperature >= targetSetpoint;
167
+ }
168
+ #updateHeatDemand() {
169
+ const state = this.state;
170
+ const thermostatState = this.endpoint.stateOf(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating));
171
+ const localTemperature = thermostatState.localTemperature ?? 0;
172
+ const modeState = this.endpoint.stateOf(MatterbridgeWaterHeaterModeServer);
173
+ const isManualMode = modeState.supportedModes.some((mode) => mode.mode === modeState.currentMode && mode.modeTags.some((tag) => tag.value === WaterHeaterMode.ModeTag.Manual));
174
+ let heatingRequired = isManualMode && localTemperature < thermostatState.occupiedHeatingSetpoint;
175
+ const boostInfo = this.internal.activeBoostInfo;
176
+ if (this.state.boostState === WaterHeaterManagement.BoostState.Active && boostInfo) {
177
+ if (boostInfo.targetPercentage !== undefined && state.tankPercentage !== undefined) {
178
+ const reheatThreshold = this.internal.boostTargetReached && boostInfo.targetReheat !== undefined ? boostInfo.targetReheat : boostInfo.targetPercentage;
179
+ heatingRequired = heatingRequired || state.tankPercentage < reheatThreshold;
180
+ }
181
+ else {
182
+ const targetSetpoint = boostInfo.temporarySetpoint ?? thermostatState.occupiedHeatingSetpoint;
183
+ heatingRequired = heatingRequired || localTemperature < targetSetpoint;
184
+ }
185
+ }
186
+ this.state.heatDemand = heatingRequired
187
+ ? {
188
+ immersionElement1: this.state.heaterTypes.immersionElement1,
189
+ immersionElement2: this.state.heaterTypes.immersionElement2,
190
+ heatPump: this.state.heaterTypes.heatPump,
191
+ boiler: this.state.heaterTypes.boiler,
192
+ other: this.state.heaterTypes.other,
193
+ }
194
+ : {};
195
+ }
109
196
  }
197
+ (function (MatterbridgeWaterHeaterManagementServer) {
198
+ class Internal {
199
+ activeBoostInfo;
200
+ boostTargetReached = false;
201
+ boostExpiryTimer;
202
+ }
203
+ MatterbridgeWaterHeaterManagementServer.Internal = Internal;
204
+ })(MatterbridgeWaterHeaterManagementServer || (MatterbridgeWaterHeaterManagementServer = {}));
110
205
  export class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
111
206
  async changeToMode(request) {
112
207
  const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -0,0 +1,3 @@
1
+ import { type Environment } from '@matter/general';
2
+ import type { Matterbridge } from './matterbridge.js';
3
+ export declare function startController(matterbridge: Matterbridge, environment: Environment): Promise<void>;
@@ -0,0 +1,287 @@
1
+ import path from 'node:path';
2
+ import { Logger, UINT16_MAX, UINT32_MAX } from '@matter/general';
3
+ import { ControllerBehavior, NetworkClient, ServerNode } from '@matter/node';
4
+ import { BasicInformationClient } from '@matter/node/behaviors/basic-information';
5
+ import { Read, Subscribe } from '@matter/protocol';
6
+ import { VendorId } from '@matter/types/datatype';
7
+ import { ManualPairingCodeCodec } from '@matter/types/schema';
8
+ import { MATTER_STORAGE_DIR } from '@matterbridge/types';
9
+ import { getIntParameter, getParameter, hasParameter } from '@matterbridge/utils/cli';
10
+ import { createDirectory } from '@matterbridge/utils/create-dir';
11
+ import { getErrorMessage } from '@matterbridge/utils/error';
12
+ import { isValidInteger, isValidString, parseVersionString } from '@matterbridge/utils/validate';
13
+ import { debugStringify } from 'node-ansi-logger';
14
+ export async function startController(matterbridge, environment) {
15
+ if (!matterbridge.matterStorageService) {
16
+ throw new Error('No storage service initialized');
17
+ }
18
+ await createDirectory(path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR, 'MatterbridgeController'), `Matter node storage directory for MatterbridgeController`, matterbridge.log);
19
+ matterbridge.controllerStorageManager = await matterbridge.matterStorageService.open('MatterbridgeController');
20
+ matterbridge.log.info('Matter node storage manager "MatterbridgeController" created');
21
+ if (hasParameter('reset')) {
22
+ const driver = matterbridge.controllerStorageManager.driver;
23
+ for (const context of await driver.contexts([])) {
24
+ await driver.clearAll([context]);
25
+ }
26
+ for (const key of await driver.keys([])) {
27
+ await driver.delete([], key);
28
+ }
29
+ matterbridge.log.notice('MatterbridgeController storage reset; remote device fabrics are unchanged');
30
+ return;
31
+ }
32
+ matterbridge.log.info('Creating context controllerContext...');
33
+ matterbridge.controllerContext = matterbridge.controllerStorageManager.createContext('controllerContext');
34
+ if (!matterbridge.controllerContext) {
35
+ matterbridge.log.error('No storage context controllerContext initialized');
36
+ return;
37
+ }
38
+ const { randomBytes } = await import('node:crypto');
39
+ const storeId = 'MatterbridgeController';
40
+ const random = randomBytes(8).toString('hex');
41
+ await matterbridge.controllerContext.set('storeId', storeId);
42
+ await matterbridge.controllerContext.set('vendorId', matterbridge.controllerVendorId);
43
+ await matterbridge.controllerContext.set('vendorName', matterbridge.controllerVendorName.slice(0, 32));
44
+ await matterbridge.controllerContext.set('productId', matterbridge.controllerProductId);
45
+ await matterbridge.controllerContext.set('productName', matterbridge.controllerProductName.slice(0, 32));
46
+ await matterbridge.controllerContext.set('productLabel', matterbridge.controllerProductName.replace(matterbridge.controllerVendorName, '').trim().slice(0, 32));
47
+ await matterbridge.controllerContext.set('nodeLabel', storeId.slice(0, 32));
48
+ await matterbridge.controllerContext.set('serialNumber', await matterbridge.controllerContext.get('serialNumber', 'SN' + random));
49
+ await matterbridge.controllerContext.set('uniqueId', await matterbridge.controllerContext.get('uniqueId', 'UI' + random));
50
+ await matterbridge.controllerContext.set('softwareVersion', isValidInteger(parseVersionString(matterbridge.matterbridgeVersion), 0, UINT32_MAX) ? parseVersionString(matterbridge.matterbridgeVersion) : 1);
51
+ await matterbridge.controllerContext.set('softwareVersionString', isValidString(matterbridge.matterbridgeVersion, 5, 64) ? matterbridge.matterbridgeVersion : '1.0.0');
52
+ await matterbridge.controllerContext.set('hardwareVersion', isValidInteger(parseVersionString(matterbridge.systemInformation.osRelease), 0, UINT16_MAX) ? parseVersionString(matterbridge.systemInformation.osRelease) : 1);
53
+ await matterbridge.controllerContext.set('hardwareVersionString', isValidString(matterbridge.systemInformation.osRelease, 5, 64) ? matterbridge.systemInformation.osRelease : '1.0.0');
54
+ matterbridge.log.info('Creating matter commissioning controller...');
55
+ matterbridge.controllerNode = await ServerNode.create(ServerNode.RootEndpointWithoutGroupcast.with(ControllerBehavior), {
56
+ commissioning: { enabled: false },
57
+ controller: { adminFabricLabel: matterbridge.controllerProductName.slice(0, 32) },
58
+ subscriptions: { persistenceEnabled: false },
59
+ id: storeId,
60
+ environment: environment,
61
+ network: {
62
+ autoStartCommissionedPeers: false,
63
+ listeningAddressIpv4: matterbridge.ipv4Address,
64
+ listeningAddressIpv6: matterbridge.ipv6Address,
65
+ port: getIntParameter('port'),
66
+ },
67
+ basicInformation: {
68
+ nodeLabel: await matterbridge.controllerContext.get('nodeLabel'),
69
+ vendorId: VendorId(await matterbridge.controllerContext.get('vendorId')),
70
+ vendorName: await matterbridge.controllerContext.get('vendorName'),
71
+ productId: await matterbridge.controllerContext.get('productId'),
72
+ productName: await matterbridge.controllerContext.get('productName'),
73
+ productLabel: await matterbridge.controllerContext.get('productLabel'),
74
+ serialNumber: await matterbridge.controllerContext.get('serialNumber'),
75
+ uniqueId: await matterbridge.controllerContext.get('uniqueId'),
76
+ softwareVersion: await matterbridge.controllerContext.get('softwareVersion'),
77
+ softwareVersionString: await matterbridge.controllerContext.get('softwareVersionString'),
78
+ hardwareVersion: await matterbridge.controllerContext.get('hardwareVersion'),
79
+ hardwareVersionString: await matterbridge.controllerContext.get('hardwareVersionString'),
80
+ reachable: true,
81
+ },
82
+ });
83
+ await matterbridge.controllerNode.start();
84
+ matterbridge.log.info(`Loaded matter commissioning controller with ${matterbridge.controllerNode.peers.size} peer nodes.`);
85
+ const requestedNodeId = getIntParameter('node');
86
+ const nodeLabel = requestedNodeId === undefined ? undefined : `Node ${requestedNodeId}`;
87
+ const peerId = requestedNodeId === undefined ? undefined : `peer${requestedNodeId}`;
88
+ if (hasParameter('pair')) {
89
+ let options;
90
+ if (hasParameter('pairingcode')) {
91
+ const pairingCode = getParameter('pairingcode');
92
+ if (!pairingCode) {
93
+ matterbridge.log.error('Missing parameter --pairingcode');
94
+ return;
95
+ }
96
+ matterbridge.log.info(`Pairing device ${nodeLabel} with pairingcode: ${pairingCode}`);
97
+ const pairingData = ManualPairingCodeCodec.decode(pairingCode);
98
+ matterbridge.log.info(`- passcode: ${pairingData.passcode}`);
99
+ matterbridge.log.info(`- shortDiscriminator: ${pairingData.shortDiscriminator ?? 'n/a (should never be n/a, short discriminator is encoded in the manual pairing code)'} `);
100
+ matterbridge.log.info(`- longDiscriminator: ${pairingData.discriminator ?? 'n/a (manual pairing code encodes short discriminator only)'}`);
101
+ matterbridge.log.info(`- vendorId: ${pairingData.vendorId ?? 'n/a'}`);
102
+ matterbridge.log.info(`- productId: ${pairingData.productId ?? 'n/a'}`);
103
+ options = {
104
+ id: peerId,
105
+ pairingCode,
106
+ ...(pairingData.shortDiscriminator === undefined ? {} : { shortDiscriminator: pairingData.shortDiscriminator }),
107
+ ...(pairingData.vendorId === undefined ? {} : { vendorId: pairingData.vendorId }),
108
+ ...(pairingData.productId === undefined ? {} : { productId: pairingData.productId }),
109
+ };
110
+ }
111
+ else {
112
+ const discriminator = getIntParameter('discriminator');
113
+ const passcode = getIntParameter('passcode') ?? 0;
114
+ matterbridge.log.info(`Pairing device ${nodeLabel} with discriminator: ${discriminator}, passcode: ${passcode}`);
115
+ options = { id: peerId, discriminator, passcode };
116
+ }
117
+ matterbridge.log.notice(`Commissioning node ${nodeLabel} with options: ${debugStringify(options)}`);
118
+ try {
119
+ const commissionedNode = await matterbridge.controllerNode.peers.commission(options);
120
+ matterbridge.log.notice(`Commissioning successfully done for node ${commissionedNode.id}`);
121
+ }
122
+ catch (error) {
123
+ matterbridge.log.error(`Commissioning failed for node ${nodeLabel}: ${getErrorMessage(error)}`);
124
+ }
125
+ }
126
+ else if (hasParameter('discover')) {
127
+ matterbridge.log.info('Discovering commissionable devices...');
128
+ const discovery = matterbridge.controllerNode.peers.discover();
129
+ discovery.catch((error) => matterbridge.log.error(`Discovery failed: ${getErrorMessage(error)}`));
130
+ discovery.discovered.on((node) => {
131
+ matterbridge.log.info(`Discovered commissionable device: ${node.id}`);
132
+ });
133
+ }
134
+ else if (hasParameter('peers')) {
135
+ const peers = matterbridge.controllerNode.peers;
136
+ matterbridge.log.info(`Matter commissioning controller known nodes: ${peers.size}, paired nodes: ${peers.commissioned.length}`);
137
+ for (const peer of peers) {
138
+ const match = /^peer(\d+)$/.exec(peer.id);
139
+ const status = peer.lifecycle.isCommissioned ? 'commissioned' : 'discovered';
140
+ matterbridge.log.info(`- ${match ? `Node ${match[1]}` : peer.id} (${status})`);
141
+ }
142
+ }
143
+ else if (hasParameter('unpair')) {
144
+ const requestedNodeId = getIntParameter('node');
145
+ if (requestedNodeId === undefined) {
146
+ matterbridge.log.error('Missing parameter --node for --unpair');
147
+ return;
148
+ }
149
+ const nodeLabel = `Node ${requestedNodeId}`;
150
+ const peerId = `peer${requestedNodeId}`;
151
+ matterbridge.log.info(`Matter commissioning controller decommissioning node: ${nodeLabel}`);
152
+ const peers = matterbridge.controllerNode.peers;
153
+ for (const peer of peers) {
154
+ if (peer.id === peerId) {
155
+ await (peer.stateOf(NetworkClient).isDisabled ? peer.enable() : peer.start());
156
+ await peer.decommission();
157
+ matterbridge.log.info(`Matter commissioning controller decommissioned node: ${nodeLabel}`);
158
+ return;
159
+ }
160
+ }
161
+ matterbridge.log.warn(`Matter commissioning controller node not found: ${nodeLabel}`);
162
+ }
163
+ else if (hasParameter('unpairall')) {
164
+ matterbridge.log.info('Matter commissioning controller decommissioning all nodes...');
165
+ const nodeIds = [...matterbridge.controllerNode.peers.commissioned];
166
+ for (const nodeId of nodeIds) {
167
+ matterbridge.log.info('Matter commissioning controller decommissioning node:', nodeId.id);
168
+ await (nodeId.stateOf(NetworkClient).isDisabled ? nodeId.enable() : nodeId.start());
169
+ await nodeId.decommission();
170
+ }
171
+ matterbridge.log.info('Matter commissioning controller decommissioned all nodes');
172
+ }
173
+ else {
174
+ matterbridge.log.info('Starting matter commissioning controller...');
175
+ matterbridge.log.info(`Matter commissioning controller started with ${matterbridge.controllerNode.peers.commissioned.length} paired nodes`);
176
+ const tracerSubscriptions = new Map();
177
+ const peersToStart = [];
178
+ if (peerId) {
179
+ const peer = matterbridge.controllerNode.peers.get(peerId);
180
+ if (peer) {
181
+ peersToStart.push(peer);
182
+ }
183
+ else {
184
+ matterbridge.log.warn(`Matter commissioning controller peer not found: ${nodeLabel}`);
185
+ }
186
+ }
187
+ else {
188
+ for (const peer of matterbridge.controllerNode.peers.commissioned) {
189
+ peersToStart.push(peer);
190
+ }
191
+ }
192
+ for (const peer of peersToStart) {
193
+ const match = /^peer(\d+)$/.exec(peer.id);
194
+ const startedLabel = match ? `Node ${match[1]}` : peer.id;
195
+ peer.lifecycle.online.on(() => {
196
+ matterbridge.log.notice(`Matter commissioning controller peer ${startedLabel} is online`);
197
+ if (peer.stateOf(NetworkClient).autoSubscribe) {
198
+ matterbridge.log.info(`Matter commissioning controller autoSubscribe is enabled for peer ${startedLabel}`);
199
+ }
200
+ else {
201
+ matterbridge.log.info(`Matter commissioning controller setting autoSubscribe for peer ${startedLabel}`);
202
+ peer.setStateOf(NetworkClient, { autoSubscribe: true }).catch((error) => {
203
+ matterbridge.log.error(`Failed to set autoSubscribe for peer ${startedLabel}: ${getErrorMessage(error)}`);
204
+ });
205
+ }
206
+ if (hasParameter('trace-peer') && !tracerSubscriptions.has(peer.id)) {
207
+ matterbridge.log.info(`Matter commissioning controller enabling trace-peer for ${startedLabel}`);
208
+ const subscribe = Subscribe({
209
+ fabricFilter: true,
210
+ keepSubscriptions: true,
211
+ attributes: [{}],
212
+ events: [{ isUrgent: true }],
213
+ });
214
+ const subscriptionPromise = peer.interaction.subscribe({
215
+ ...subscribe,
216
+ updated: async (update) => {
217
+ for await (const chunk of update) {
218
+ for await (const report of chunk) {
219
+ if (report.kind === 'attr-value') {
220
+ matterbridge.log.info(`Peer ${startedLabel} attr ${report.path.endpointId}/${report.path.clusterId}/${report.path.attributeId} v${report.version}: ${debugStringify(report.value ?? { none: true })}`);
221
+ }
222
+ else if (report.kind === 'event-value') {
223
+ matterbridge.log.info(`Peer ${startedLabel} event ${report.path.endpointId}/${report.path.clusterId}/${report.path.eventId} #${report.number}: ${debugStringify(report.value ?? { none: true })}`);
224
+ }
225
+ else if (report.kind === 'attr-status') {
226
+ matterbridge.log.warn(`Peer ${startedLabel} attr-status ${report.path.endpointId}/${report.path.clusterId}/${report.path.attributeId}: ${String(report.status)}`);
227
+ }
228
+ else if (report.kind === 'event-status') {
229
+ matterbridge.log.warn(`Peer ${startedLabel} event-status ${report.path.endpointId}/${report.path.clusterId}/${report.path.eventId}: ${String(report.status)}`);
230
+ }
231
+ }
232
+ }
233
+ },
234
+ closed: () => {
235
+ matterbridge.log.warn(`Matter commissioning controller trace-peer subscription closed for ${startedLabel}`);
236
+ tracerSubscriptions.delete(peer.id);
237
+ },
238
+ });
239
+ tracerSubscriptions.set(peer.id, subscriptionPromise);
240
+ subscriptionPromise.catch((error) => {
241
+ tracerSubscriptions.delete(peer.id);
242
+ matterbridge.log.error(`Matter commissioning controller trace-peer subscription failed for ${startedLabel}: ${getErrorMessage(error)}`);
243
+ });
244
+ }
245
+ if (hasParameter('dump-peer')) {
246
+ void (async () => {
247
+ try {
248
+ for await (const chunk of peer.interaction.read(Read({ fabricFilter: true, attributes: [{}] }))) {
249
+ for await (const _report of chunk) {
250
+ }
251
+ }
252
+ const basicInfo = peer.stateOf(BasicInformationClient);
253
+ Logger.get(`BasicInformation: ${startedLabel}`).info(basicInfo);
254
+ }
255
+ catch (error) {
256
+ matterbridge.log.error(`Matter commissioning controller dump-peer failed for ${startedLabel}: ${getErrorMessage(error)}`);
257
+ }
258
+ })();
259
+ }
260
+ });
261
+ peer.lifecycle.offline.on(() => {
262
+ matterbridge.log.warn(`Matter commissioning controller peer ${startedLabel} is offline`);
263
+ });
264
+ peer.eventsOf(NetworkClient).autoSubscribe$Changed.on((value, oldValue) => {
265
+ matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} autoSubscribe changed from ${oldValue ? 'active' : 'inactive'} to ${value ? 'active' : 'inactive'}`);
266
+ });
267
+ peer.eventsOf(NetworkClient).defaultSubscription$Changed.on((value, oldValue) => {
268
+ matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} defaultSubscription changed from ${oldValue ? 'active' : 'inactive'} to ${value ? 'active' : 'inactive'}`);
269
+ });
270
+ peer.eventsOf(NetworkClient).subscriptionStatusChanged.on((isActive) => {
271
+ matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} subscription is ${isActive ? 'active' : 'inactive'}`);
272
+ });
273
+ peer.eventsOf(NetworkClient).subscriptionAlive.on(() => {
274
+ matterbridge.log.info(`Matter commissioning controller peer ${startedLabel} subscription alive event received`);
275
+ });
276
+ matterbridge.log.notice(`Starting matter commissioning controller peer ${startedLabel}...`);
277
+ (peer.stateOf(NetworkClient).isDisabled ? peer.enable() : peer.start())
278
+ .then(() => {
279
+ matterbridge.log.notice(`Matter commissioning controller peer ${startedLabel} started successfully`);
280
+ return;
281
+ })
282
+ .catch((error) => {
283
+ matterbridge.log.error(`Matter commissioning controller failed to start peer ${startedLabel}: ${getErrorMessage(error)}`);
284
+ });
285
+ }
286
+ }
287
+ }
@@ -100,6 +100,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
100
100
  matterStorageManager: StorageManager | undefined;
101
101
  private serverNodeStorageManagers;
102
102
  matterbridgeContext: StorageContext | undefined;
103
+ controllerStorageManager: StorageManager | undefined;
103
104
  controllerContext: StorageContext | undefined;
104
105
  mdnsInterface: string | undefined;
105
106
  ipv4Address: string | undefined;
@@ -152,7 +153,6 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
152
153
  private sendPluginStatusUpdate;
153
154
  private startBridge;
154
155
  private startChildbridge;
155
- private startController;
156
156
  private startMatterStorage;
157
157
  private backupMatterStorage;
158
158
  private stopMatterStorage;
@@ -33,6 +33,7 @@ import { Frontend } from './frontend.js';
33
33
  import { addVirtualDevice, addVirtualDevices, resolveRootDirectory } from './helpers.js';
34
34
  import { bridge } from './matterbridgeDeviceTypes.js';
35
35
  import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
36
+ import { startController } from './matterController.js';
36
37
  import { clearAdvertisingNodes, deleteAdvertisingNode, getServerNodeData, setAdvertisingNode } from './matterNodeHelpers.js';
37
38
  import { PluginManager } from './pluginManager.js';
38
39
  logModuleLoaded('Matterbridge');
@@ -141,6 +142,7 @@ export class Matterbridge extends EventEmitter {
141
142
  matterStorageManager;
142
143
  serverNodeStorageManagers = new Map();
143
144
  matterbridgeContext;
145
+ controllerStorageManager;
144
146
  controllerContext;
145
147
  mdnsInterface;
146
148
  ipv4Address;
@@ -950,8 +952,9 @@ export class Matterbridge extends EventEmitter {
950
952
  this.shutdown = true;
951
953
  return;
952
954
  }
953
- if ((getIntParameter('frontend') !== 0 || getIntParameter('frontend') === undefined) && !hasParameter('experimental-backend'))
955
+ if (!hasParameter('controller') && !hasParameter('experimental-backend') && getIntParameter('frontend') !== 0) {
954
956
  await this.frontend.start(getIntParameter('frontend'));
957
+ }
955
958
  if (!hasParameter('experimental-node')) {
956
959
  try {
957
960
  await this.startMatterStorage();
@@ -968,6 +971,13 @@ export class Matterbridge extends EventEmitter {
968
971
  throw new Error(`Fatal error creating matter storage: ${getErrorMessage(error)}`, { cause: error });
969
972
  }
970
973
  }
974
+ if (hasParameter('controller') && hasParameter('reset')) {
975
+ this.bridgeMode = 'controller';
976
+ await startController(this, this.environment);
977
+ await this.stopMatterStorage();
978
+ this.shutdown = true;
979
+ return;
980
+ }
971
981
  if (hasParameter('reset') && getParameter('reset') === undefined) {
972
982
  this.initialized = true;
973
983
  await this.shutdownProcessAndReset();
@@ -1026,7 +1036,7 @@ export class Matterbridge extends EventEmitter {
1026
1036
  }
1027
1037
  if (hasParameter('controller')) {
1028
1038
  this.bridgeMode = 'controller';
1029
- await this.startController();
1039
+ await startController(this, this.environment);
1030
1040
  return;
1031
1041
  }
1032
1042
  if (!hasParameter('bridge') && !hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === '') {
@@ -1873,8 +1883,6 @@ export class Matterbridge extends EventEmitter {
1873
1883
  })();
1874
1884
  }, Number(process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS']) || this.startMatterIntervalMs);
1875
1885
  }
1876
- async startController() {
1877
- }
1878
1886
  async startMatterStorage() {
1879
1887
  this.log.info(`Starting matter node storage...`);
1880
1888
  this.matterStorageService = this.environment.get(StorageService);
@@ -1904,6 +1912,9 @@ export class Matterbridge extends EventEmitter {
1904
1912
  }
1905
1913
  async stopMatterStorage() {
1906
1914
  this.log.info('Closing matter node storage...');
1915
+ await this.controllerStorageManager?.close();
1916
+ this.controllerStorageManager = undefined;
1917
+ this.controllerContext = undefined;
1907
1918
  await this.matterStorageManager?.close();
1908
1919
  for (const [storeId, storageManager] of this.serverNodeStorageManagers) {
1909
1920
  this.log.debug(`Closing server node storage context manager for ${plg}${storeId}${db}...`);
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@matterbridge/core",
3
- "version": "3.11.1-dev-20261030-e12e668",
3
+ "version": "3.11.1-dev-20261030-65deb56",
4
4
  "description": "Matterbridge core library",
5
5
  "author": "https://github.com/Luligu",
6
6
  "homepage": "https://matterbridge.io/",
@@ -136,10 +136,10 @@
136
136
  },
137
137
  "dependencies": {
138
138
  "@matter/main": "0.18.0",
139
- "@matterbridge/dgram": "3.11.1-dev-20261030-e12e668",
140
- "@matterbridge/thread": "3.11.1-dev-20261030-e12e668",
141
- "@matterbridge/types": "3.11.1-dev-20261030-e12e668",
142
- "@matterbridge/utils": "3.11.1-dev-20261030-e12e668",
139
+ "@matterbridge/dgram": "3.11.1-dev-20261030-65deb56",
140
+ "@matterbridge/thread": "3.11.1-dev-20261030-65deb56",
141
+ "@matterbridge/types": "3.11.1-dev-20261030-65deb56",
142
+ "@matterbridge/utils": "3.11.1-dev-20261030-65deb56",
143
143
  "escape-html": "1.0.3",
144
144
  "express": "5.3.0",
145
145
  "express-rate-limit": "8.7.1",