@matterbridge/core 3.11.1-dev-20261030-56f9375 → 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);
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@matterbridge/core",
3
- "version": "3.11.1-dev-20261030-56f9375",
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-56f9375",
140
- "@matterbridge/thread": "3.11.1-dev-20261030-56f9375",
141
- "@matterbridge/types": "3.11.1-dev-20261030-56f9375",
142
- "@matterbridge/utils": "3.11.1-dev-20261030-56f9375",
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",