@fastybird/smart-panel-backend 1.1.0-alpha.1 → 1.1.0-alpha.10

package/dist/plugins/devices-shelly-ng/delegates/delegates-manager.service.js

@@ -8,16 +8,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var DelegatesManagerService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DelegatesManagerService = void 0;
-const class_transformer_1 = require("class-transformer");
 const common_1 = require("@nestjs/common");
 const logger_1 = require("../../../common/logger");
 const transform_utils_1 = require("../../../common/utils/transform.utils");
 const devices_constants_1 = require("../../../modules/devices/devices.constants");
 const channels_properties_service_1 = require("../../../modules/devices/services/channels.properties.service");
 const channels_service_1 = require("../../../modules/devices/services/channels.service");
+const command_latency_trace_collector_service_1 = require("../../../modules/devices/services/command-latency-trace-collector.service");
 const device_connectivity_service_1 = require("../../../modules/devices/services/device-connectivity.service");
 const devices_service_1 = require("../../../modules/devices/services/devices.service");
 const devices_shelly_ng_constants_1 = require("../devices-shelly-ng.constants");
@@ -30,7 +33,7 @@ const device_manager_service_1 = require("../services/device-manager.service");
 const transform_utils_2 = require("../utils/transform.utils");
 const shelly_device_delegate_1 = require("./shelly-device.delegate");
 let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManagerService {
-    constructor(devicesService, channelsService, channelsPropertiesService, deviceConnectivityService, deviceManagerService, deviceAddressService, propertyMappingStorage, transformerRegistry) {
+    constructor(devicesService, channelsService, channelsPropertiesService, deviceConnectivityService, deviceManagerService, deviceAddressService, propertyMappingStorage, transformerRegistry, commandLatencyTraceCollector = new command_latency_trace_collector_service_1.CommandLatencyTraceCollectorService()) {
         this.devicesService = devicesService;
         this.channelsService = channelsService;
         this.channelsPropertiesService = channelsPropertiesService;
@@ -39,6 +42,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.deviceAddressService = deviceAddressService;
         this.propertyMappingStorage = propertyMappingStorage;
         this.transformerRegistry = transformerRegistry;
+        this.commandLatencyTraceCollector = commandLatencyTraceCollector;
         this.logger = (0, logger_1.createExtensionLogger)(devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_PLUGIN_NAME, 'DelegatesManagerService');
         this.delegates = new Map();
         this.delegateValueHandlers = new Map();
@@ -47,6 +51,10 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.setChannelsHandlers = new Map();
         this.setPropertiesHandlers = new Map();
         this.pendingWrites = new Map();
+        this.pendingPollWrites = new Map();
+        this.activePollWrites = new Map();
+        this.delegatePollGenerations = new Map();
+        this.currentValueUpdateContext = null;
         this.propertiesMap = new Map();
         this.delegateDeviceIds = new Map();
         this.delegateToIdentifier = new Map();
@@ -75,6 +83,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
         const generation = (this.insertGeneration.get(shelly.id) ?? 0) + 1;
         this.insertGeneration.set(shelly.id, generation);
+        this.delegatePollGenerations.set(shelly.id, (this.delegatePollGenerations.get(shelly.id) ?? 0) + 1);
         const delegate = new shelly_device_delegate_1.ShellyDeviceDelegate(shelly);
         this.delegates.set(shelly.id, delegate);
         const wifiIp = shelly.wifi?.sta_ip ?? null;
@@ -199,60 +208,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 await comp.set(val);
                 return true;
             });
-            if (typeof comp.aenergy !== 'undefined') {
-                const electricalEnergy = await this.channelsService.findOneBy('identifier', `energy:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
-                if (electricalEnergy === null) {
-                }
-                else {
-                    const consumption = await this.channelsPropertiesService.findOneBy('identifier', 'aenergy', electricalEnergy.id);
-                    if (consumption === null) {
-                    }
-                    else {
-                        await this.setDefaultPropertyValue(device.id, consumption, (0, transform_utils_2.toEnergy)(comp.aenergy));
-                        this.changeHandlers.set(`${delegate.id}|${comp.key}|aenergy`, (val) => {
-                            this.handleNumericChange(comp.key, 'aenergy', consumption.id, val, (n) => this.handleChange(consumption, (0, transform_utils_2.toEnergy)(n), false));
-                        });
-                    }
-                }
-            }
-            if (typeof comp.apower !== 'undefined') {
-                const electricalPower = await this.channelsService.findOneBy('identifier', `power:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
-                if (electricalPower === null) {
-                }
-                else {
-                    const power = await this.channelsPropertiesService.findOneBy('identifier', 'apower', electricalPower.id);
-                    if (power === null) {
-                    }
-                    else {
-                        await this.setDefaultPropertyValue(device.id, power, Math.max(0, comp.apower));
-                        this.changeHandlers.set(`${delegate.id}|${comp.key}|apower`, (val) => {
-                            this.handleNumericChange(comp.key, 'apower', power.id, val, (n) => this.handleChange(power, Math.max(0, n), false));
-                        });
-                        if (typeof comp.voltage !== 'undefined') {
-                            const voltage = await this.channelsPropertiesService.findOneBy('identifier', 'voltage', electricalPower.id);
-                            if (voltage === null) {
-                            }
-                            else {
-                                await this.setDefaultPropertyValue(device.id, voltage, comp.voltage);
-                                this.changeHandlers.set(`${delegate.id}|${comp.key}|voltage`, (val) => {
-                                    this.handleNumericChange(comp.key, 'voltage', voltage.id, val, (n) => this.handleChange(voltage, n, false));
-                                });
-                            }
-                        }
-                        if (typeof comp.current !== 'undefined') {
-                            const current = await this.channelsPropertiesService.findOneBy('identifier', 'current', electricalPower.id);
-                            if (current === null) {
-                            }
-                            else {
-                                await this.setDefaultPropertyValue(device.id, current, comp.current);
-                                this.changeHandlers.set(`${delegate.id}|${comp.key}|current`, (val) => {
-                                    this.handleNumericChange(comp.key, 'current', current.id, val, (n) => this.handleChange(current, n, false));
-                                });
-                            }
-                        }
-                    }
-                }
-            }
+            await this.wireElectricalChannels(delegate, device, comp);
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
@@ -314,6 +270,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                     await comp.stop();
                 return true;
             });
+            await this.wireElectricalChannels(delegate, device, comp);
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
@@ -362,6 +319,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                     return true;
                 });
             }
+            await this.wireElectricalChannels(delegate, device, comp);
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
@@ -495,6 +453,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 ]);
                 return true;
             });
+            await this.wireElectricalChannels(delegate, device, comp);
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
@@ -653,6 +612,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 ], Math.round((0, transform_utils_1.clampNumber)(whiteValue, 0, 255)));
                 return true;
             });
+            await this.wireElectricalChannels(delegate, device, comp);
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
@@ -746,6 +706,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 await comp.set(outputValue, Math.round((0, transform_utils_1.clampNumber)(brightnessValue, 0, 100)), Math.round((0, transform_utils_1.clampNumber)(ctValue, 2_700, 6_500)));
                 return true;
             });
+            await this.wireElectricalChannels(delegate, device, comp);
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
@@ -800,63 +761,69 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
         for (const comp of delegate.pm1.values()) {
-            const electricalPower = await this.channelsService.findOneBy('identifier', `power:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
-            if (electricalPower === null) {
-                continue;
-            }
-            const power = await this.channelsPropertiesService.findOneBy('identifier', 'apower', electricalPower.id);
-            if (power === null) {
-                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load electrical power channel property');
-            }
-            await this.setDefaultPropertyValue(device.id, power, Math.max(0, comp.apower));
-            this.changeHandlers.set(`${delegate.id}|${comp.key}|apower`, (val) => {
-                this.handleNumericChange(comp.key, 'apower', power.id, val, (n) => this.handleChange(power, Math.max(0, n), false));
-            });
-            if (typeof comp.voltage !== 'undefined') {
-                const voltage = await this.channelsPropertiesService.findOneBy('identifier', 'voltage', electricalPower.id);
-                if (voltage === null) {
-                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load electrical power voltage channel property');
-                }
-                await this.setDefaultPropertyValue(device.id, voltage, comp.voltage);
-                this.changeHandlers.set(`${delegate.id}|${comp.key}|voltage`, (val) => {
-                    this.handleNumericChange(comp.key, 'voltage', voltage.id, val, (n) => this.handleChange(voltage, n, false));
-                });
-            }
-            if (typeof comp.current !== 'undefined') {
-                const current = await this.channelsPropertiesService.findOneBy('identifier', 'current', electricalPower.id);
-                if (current === null) {
-                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load electrical power current channel property');
-                }
-                await this.setDefaultPropertyValue(device.id, current, comp.current);
-                this.changeHandlers.set(`${delegate.id}|${comp.key}|current`, (val) => {
-                    this.handleNumericChange(comp.key, 'current', current.id, val, (n) => this.handleChange(current, n, false));
-                });
-            }
-            if (typeof comp.aenergy !== 'undefined') {
-                const electricalEnergy = await this.channelsService.findOneBy('identifier', `energy:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
-                if (electricalEnergy === null) {
-                }
-                else {
-                    const consumption = await this.channelsPropertiesService.findOneBy('identifier', 'aenergy', electricalEnergy.id);
-                    if (consumption === null) {
-                    }
-                    else {
-                        await this.setDefaultPropertyValue(device.id, consumption, (0, transform_utils_2.toEnergy)(comp.aenergy));
-                        this.changeHandlers.set(`${delegate.id}|${comp.key}|aenergy`, (val) => {
-                            this.handleNumericChange(comp.key, 'aenergy', consumption.id, val, (n) => this.handleChange(consumption, (0, transform_utils_2.toEnergy)(n), false));
-                        });
-                    }
-                }
-            }
+            await this.wireElectricalChannels(delegate, device, comp);
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.em.values()) {
+            const phases = [
+                { id: 'a', power: comp.a_act_power, voltage: comp.a_voltage, current: comp.a_current, freq: comp.a_freq },
+                { id: 'b', power: comp.b_act_power, voltage: comp.b_voltage, current: comp.b_current, freq: comp.b_freq },
+                { id: 'c', power: comp.c_act_power, voltage: comp.c_voltage, current: comp.c_current, freq: comp.c_freq },
+            ];
+            for (const phase of phases) {
+                const channelIdentifier = `power:${comp.id}:${phase.id}`;
+                await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, `${phase.id}_act_power`, `${phase.id}_act_power`, phase.power, true);
+                await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, `${phase.id}_voltage`, `${phase.id}_voltage`, phase.voltage, true);
+                await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, `${phase.id}_current`, `${phase.id}_current`, phase.current, true);
+                await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, `${phase.id}_freq`, `${phase.id}_freq`, phase.freq, true);
+            }
+            const totalChannelIdentifier = `power:${comp.id}:total`;
+            await this.wireMeterProperty(delegate, device, comp.key, totalChannelIdentifier, 'total_act_power', 'total_act_power', comp.total_act_power, true);
+            await this.wireMeterProperty(delegate, device, comp.key, totalChannelIdentifier, 'total_current', 'total_current', comp.total_current, true);
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.emData.values()) {
+            const phases = [
+                { id: 'a', energy: comp.a_total_act_energy, returned: comp.a_total_act_ret_energy },
+                { id: 'b', energy: comp.b_total_act_energy, returned: comp.b_total_act_ret_energy },
+                { id: 'c', energy: comp.c_total_act_energy, returned: comp.c_total_act_ret_energy },
+            ];
+            for (const phase of phases) {
+                const channelIdentifier = `energy:${comp.id}:${phase.id}`;
+                await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, `${phase.id}_total_act_energy`, `${phase.id}_total_act_energy`, phase.energy, false);
+                await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, `${phase.id}_total_act_ret_energy`, `${phase.id}_total_act_ret_energy`, phase.returned, false);
+            }
+            const totalChannelIdentifier = `energy:${comp.id}:total`;
+            await this.wireMeterProperty(delegate, device, comp.key, totalChannelIdentifier, 'total_act', 'total_act', comp.total_act, false);
+            await this.wireMeterProperty(delegate, device, comp.key, totalChannelIdentifier, 'total_act_ret', 'total_act_ret', comp.total_act_ret, false);
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
-        const valueHandler = (compKey, attr, val) => {
+        for (const comp of delegate.em1.values()) {
+            const channelIdentifier = `power:${comp.id}`;
+            await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, 'act_power', 'act_power', comp.act_power, true);
+            await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, 'voltage', 'voltage', comp.voltage, true);
+            await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, 'current', 'current', comp.current, true);
+            await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, 'freq', 'freq', comp.freq, true);
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.em1Data.values()) {
+            const channelIdentifier = `energy:${comp.id}`;
+            await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, 'total_act_energy', 'total_act_energy', comp.total_act_energy, false);
+            await this.wireMeterProperty(delegate, device, comp.key, channelIdentifier, 'total_act_ret_energy', 'total_act_ret_energy', comp.total_act_ret_energy, false);
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        const valueHandler = (compKey, attr, val, origin = 'notify') => {
             const handler = this.changeHandlers.get(`${delegate.id}|${compKey}|${attr}`);
             if (!handler) {
                 return;
             }
             try {
+                this.currentValueUpdateContext = { delegateId: delegate.id, deviceId: device.id, origin };
                 handler(val);
             }
             catch (error) {
@@ -867,6 +834,9 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                     stack: err.stack,
                 });
             }
+            finally {
+                this.currentValueUpdateContext = null;
+            }
         };
         delegate.on('value', valueHandler);
         this.delegateValueHandlers.set(delegate.id, valueHandler);
@@ -982,6 +952,8 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         if (!delegate) {
             return;
         }
+        this.delegatePollGenerations.set(deviceId, (this.delegatePollGenerations.get(deviceId) ?? 0) + 1);
+        this.cancelPollWritesForDelegate(deviceId);
         const valueHandler = this.delegateValueHandlers.get(delegate.id);
         const connectionHandler = this.delegateConnectionHandlers.get(delegate.id);
         if (connectionHandler) {
@@ -1118,7 +1090,24 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
     }
     async handleChange(property, value, immediately = true) {
+        const context = this.currentValueUpdateContext;
+        if (context !== null) {
+            this.commandLatencyTraceCollector.recordProviderReceipt(property.id, value, context.origin, {
+                delegateId: context.delegateId,
+                deviceId: context.deviceId,
+            });
+        }
+        if (context?.origin === 'poll') {
+            this.commandLatencyTraceCollector.recordPollActivity(property.id, 'poll-coalescer-admission', {
+                delegateId: context.delegateId,
+                deviceId: context.deviceId,
+            });
+            this.schedulePollWrite(context, property, value);
+            return;
+        }
         if (immediately) {
+            this.cancelScheduledWrite(property.id);
+            this.cancelPollWrite(property.id);
             await this.writeValueToProperty(property, value);
         }
         else {
@@ -1142,6 +1131,87 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
         set.add(property.id);
     }
+    async wireElectricalChannels(delegate, device, comp) {
+        if (typeof comp.aenergy !== 'undefined') {
+            const electricalEnergy = await this.channelsService.findOneBy('identifier', `energy:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (electricalEnergy === null) {
+            }
+            else {
+                const consumption = await this.channelsPropertiesService.findOneBy('identifier', 'aenergy', electricalEnergy.id);
+                if (consumption === null) {
+                }
+                else {
+                    await this.setDefaultPropertyValue(device.id, consumption, (0, transform_utils_2.toEnergy)(comp.aenergy));
+                    this.changeHandlers.set(`${delegate.id}|${comp.key}|aenergy.total`, (val) => {
+                        this.handleNumericChange(comp.key, 'aenergy.total', consumption.id, val, (n) => this.handleChange(consumption, (0, transform_utils_2.toEnergy)(n), false));
+                    });
+                }
+            }
+        }
+        if (typeof comp.apower !== 'undefined' ||
+            typeof comp.voltage !== 'undefined' ||
+            typeof comp.current !== 'undefined') {
+            const electricalPower = await this.channelsService.findOneBy('identifier', `power:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (electricalPower === null) {
+            }
+            else {
+                if (typeof comp.apower !== 'undefined') {
+                    const power = await this.channelsPropertiesService.findOneBy('identifier', 'apower', electricalPower.id);
+                    if (power === null) {
+                    }
+                    else {
+                        await this.setDefaultPropertyValue(device.id, power, Math.max(0, comp.apower));
+                        this.changeHandlers.set(`${delegate.id}|${comp.key}|apower`, (val) => {
+                            this.handleNumericChange(comp.key, 'apower', power.id, val, (n) => this.handleChange(power, Math.max(0, n), false));
+                        });
+                    }
+                }
+                if (typeof comp.voltage !== 'undefined') {
+                    const voltage = await this.channelsPropertiesService.findOneBy('identifier', 'voltage', electricalPower.id);
+                    if (voltage === null) {
+                    }
+                    else {
+                        await this.setDefaultPropertyValue(device.id, voltage, comp.voltage);
+                        this.changeHandlers.set(`${delegate.id}|${comp.key}|voltage`, (val) => {
+                            this.handleNumericChange(comp.key, 'voltage', voltage.id, val, (n) => this.handleChange(voltage, n, false));
+                        });
+                    }
+                }
+                if (typeof comp.current !== 'undefined') {
+                    const current = await this.channelsPropertiesService.findOneBy('identifier', 'current', electricalPower.id);
+                    if (current === null) {
+                    }
+                    else {
+                        await this.setDefaultPropertyValue(device.id, current, comp.current);
+                        this.changeHandlers.set(`${delegate.id}|${comp.key}|current`, (val) => {
+                            this.handleNumericChange(comp.key, 'current', current.id, val, (n) => this.handleChange(current, n, false));
+                        });
+                    }
+                }
+            }
+        }
+    }
+    async wireMeterProperty(delegate, device, compKey, channelIdentifier, attr, propertyIdentifier, value, allowNull) {
+        if (typeof value === 'undefined') {
+            return;
+        }
+        const channel = await this.channelsService.findOneBy('identifier', channelIdentifier, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+        if (channel === null) {
+            return;
+        }
+        const property = await this.channelsPropertiesService.findOneBy('identifier', propertyIdentifier, channel.id);
+        if (property === null) {
+            return;
+        }
+        if (value !== null) {
+            await this.setDefaultPropertyValue(device.id, property, value);
+        }
+        this.changeHandlers.set(`${delegate.id}|${compKey}|${attr}`, (val) => {
+            this.handleNumericChange(compKey, attr, property.id, val, (n) => this.handleChange(property, n, false), {
+                allowNull,
+            });
+        });
+    }
     determineCategory(delegate) {
         if (delegate.descriptor && delegate.descriptor.categories.length > 0) {
             return delegate.descriptor.categories[0];
@@ -1164,6 +1234,9 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         return devices_constants_1.DeviceCategory.GENERIC;
     }
     handleNumericChange(compKey, attr, propertyId, val, write, opts) {
+        if (val === null && opts?.allowNull) {
+            return;
+        }
         const n = (0, transform_utils_1.coerceNumberSafe)(val, opts);
         if (n === null || Number.isNaN(n)) {
             this.logger.warn(`Dropping invalid numeric update for ${compKey}.${attr} -> ${(0, transform_utils_1.safeToString)(val)} (property=${propertyId})`);
@@ -1193,9 +1266,123 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }, 250);
         this.pendingWrites.set(property.id, t);
     }
+    schedulePollWrite(context, property, value) {
+        let bucket = this.pendingPollWrites.get(context.deviceId);
+        if (!bucket) {
+            const values = new Map();
+            const timer = setTimeout(() => {
+                void this.flushPollWrites(context.deviceId);
+            }, 250);
+            bucket = { timer, values };
+            this.pendingPollWrites.set(context.deviceId, bucket);
+        }
+        bucket.values.set(property.id, {
+            delegateId: context.delegateId,
+            delegateGeneration: this.delegatePollGenerations.get(context.delegateId) ?? 0,
+            property,
+            value,
+        });
+    }
+    async flushPollWrites(deviceId) {
+        const bucket = this.pendingPollWrites.get(deviceId);
+        if (!bucket) {
+            return;
+        }
+        this.pendingPollWrites.delete(deviceId);
+        clearTimeout(bucket.timer);
+        let activeBuckets = this.activePollWrites.get(deviceId);
+        if (activeBuckets === undefined) {
+            activeBuckets = new Set();
+            this.activePollWrites.set(deviceId, activeBuckets);
+        }
+        activeBuckets.add(bucket);
+        try {
+            for (const [propertyId, pending] of [...bucket.values.entries()]) {
+                if (bucket.values.get(propertyId) !== pending) {
+                    continue;
+                }
+                if (!this.delegates.has(pending.delegateId) ||
+                    (this.delegatePollGenerations.get(pending.delegateId) ?? 0) !== pending.delegateGeneration) {
+                    continue;
+                }
+                try {
+                    this.commandLatencyTraceCollector.recordPollActivity(pending.property.id, 'poll-drain', {
+                        delegateId: pending.delegateId,
+                        deviceId,
+                    });
+                    await this.writeValueToProperty(pending.property, pending.value);
+                }
+                catch (error) {
+                    const err = error;
+                    this.logger.error(`Failed to process poll write of value=${(0, transform_utils_1.safeToString)(pending.value)} to property=${pending.property.id}`, { message: err.message, stack: err.stack });
+                }
+            }
+        }
+        finally {
+            activeBuckets.delete(bucket);
+            if (activeBuckets.size === 0 && this.activePollWrites.get(deviceId) === activeBuckets) {
+                this.activePollWrites.delete(deviceId);
+            }
+        }
+    }
+    cancelScheduledWrite(propertyId) {
+        const timer = this.pendingWrites.get(propertyId);
+        if (timer) {
+            clearTimeout(timer);
+            this.pendingWrites.delete(propertyId);
+        }
+    }
+    cancelPollWrite(propertyId) {
+        for (const [deviceId, bucket] of this.pendingPollWrites.entries()) {
+            bucket.values.delete(propertyId);
+            if (bucket.values.size === 0) {
+                clearTimeout(bucket.timer);
+                this.pendingPollWrites.delete(deviceId);
+            }
+        }
+        for (const buckets of this.activePollWrites.values()) {
+            for (const bucket of buckets) {
+                bucket.values.delete(propertyId);
+            }
+        }
+    }
+    cancelPollWritesForDelegate(delegateId) {
+        for (const [deviceId, bucket] of this.pendingPollWrites.entries()) {
+            for (const [propertyId, pending] of bucket.values.entries()) {
+                if (pending.delegateId === delegateId) {
+                    bucket.values.delete(propertyId);
+                }
+            }
+            if (bucket.values.size === 0) {
+                clearTimeout(bucket.timer);
+                this.pendingPollWrites.delete(deviceId);
+            }
+        }
+        for (const buckets of this.activePollWrites.values()) {
+            for (const bucket of buckets) {
+                for (const [propertyId, pending] of bucket.values.entries()) {
+                    if (pending.delegateId === delegateId) {
+                        bucket.values.delete(propertyId);
+                    }
+                }
+            }
+        }
+    }
+    clearPollWrites() {
+        for (const bucket of this.pendingPollWrites.values()) {
+            clearTimeout(bucket.timer);
+        }
+        this.pendingPollWrites.clear();
+        for (const buckets of this.activePollWrites.values()) {
+            for (const bucket of buckets) {
+                bucket.values.clear();
+            }
+        }
+        this.activePollWrites.clear();
+    }
     async writeValueToProperty(property, value) {
         return await this.channelsPropertiesService.update(property.id, (0, transform_utils_1.toInstance)(update_channel_property_dto_1.UpdateShellyNgChannelPropertyDto, {
-            ...(0, class_transformer_1.instanceToPlain)(property),
+            type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
             value,
         }));
     }
@@ -1252,6 +1439,9 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             clearTimeout(pendingWrite);
         }
         this.pendingWrites.clear();
+        this.clearPollWrites();
+        this.delegatePollGenerations.clear();
+        this.currentValueUpdateContext = null;
         this.deviceLocks.clear();
         this.canonicalMacLocks.clear();
         this.connectedDelegatesPerDevice.clear();
@@ -1295,20 +1485,47 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             await Promise.all(tasks.slice(i, i + CONCURRENCY).map((fn) => fn()));
         }
     }
-    async pollAllDevices(timeoutMs = 10_000) {
-        const CONCURRENCY = 10;
-        const tasks = [];
-        for (const [id, delegate] of this.delegates.entries()) {
-            if (!delegate.connected) {
-                continue;
-            }
-            tasks.push(async () => {
-                const ok = await delegate.pollStatus(timeoutMs);
-                if (!ok) {
-                    this.logger.warn(`Status poll failed for device=${id}`);
-                }
+    getConnectedDelegateIds() {
+        return Array.from(this.delegates.entries())
+            .filter(([, delegate]) => delegate.connected)
+            .map(([id]) => id)
+            .sort();
+    }
+    invalidateStatusPolls() {
+        for (const delegateId of this.delegates.keys()) {
+            this.delegatePollGenerations.set(delegateId, (this.delegatePollGenerations.get(delegateId) ?? 0) + 1);
+        }
+        this.clearPollWrites();
+    }
+    async pollDevice(deviceId, timeoutMs = 10_000) {
+        const delegate = this.delegates.get(deviceId);
+        if (!delegate || !delegate.connected) {
+            return;
+        }
+        const generation = this.delegatePollGenerations.get(deviceId) ?? 0;
+        const traceDeviceId = this.delegateDeviceIds.get(deviceId) ?? deviceId;
+        this.commandLatencyTraceCollector.recordPollRpc(traceDeviceId, 'poll-rpc-start', { timeoutMs });
+        let ok;
+        try {
+            ok = await delegate.pollStatus(timeoutMs, () => this.delegates.get(deviceId) === delegate &&
+                delegate.connected &&
+                this.delegatePollGenerations.get(deviceId) === generation);
+        }
+        catch (error) {
+            this.commandLatencyTraceCollector.recordPollRpc(traceDeviceId, 'poll-rpc-complete', {
+                ok: false,
+                error: error instanceof Error ? error.message : 'unknown failure',
             });
+            throw error;
+        }
+        this.commandLatencyTraceCollector.recordPollRpc(traceDeviceId, 'poll-rpc-complete', { ok });
+        if (!ok && this.delegates.get(deviceId) === delegate && this.delegatePollGenerations.get(deviceId) === generation) {
+            this.logger.warn(`Status poll failed for device=${deviceId}`);
         }
+    }
+    async pollAllDevices(timeoutMs = 10_000) {
+        const CONCURRENCY = 10;
+        const tasks = this.getConnectedDelegateIds().map((id) => () => this.pollDevice(id, timeoutMs));
         for (let i = 0; i < tasks.length; i += CONCURRENCY) {
             await Promise.all(tasks.slice(i, i + CONCURRENCY).map((fn) => fn()));
         }
@@ -1357,6 +1574,7 @@ exports.DelegatesManagerService = DelegatesManagerService;
 DelegatesManagerService.DISCONNECT_GRACE_MS = 15_000;
 exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerService_1 = __decorate([
     (0, common_1.Injectable)(),
+    __param(8, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [devices_service_1.DevicesService,
         channels_service_1.ChannelsService,
         channels_properties_service_1.ChannelsPropertiesService,
@@ -1364,6 +1582,7 @@ exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerServ
         device_manager_service_1.DeviceManagerService,
         device_address_service_1.DeviceAddressService,
         mappings_1.PropertyMappingStorageService,
-        mappings_1.TransformerRegistry])
+        mappings_1.TransformerRegistry,
+        command_latency_trace_collector_service_1.CommandLatencyTraceCollectorService])
 ], DelegatesManagerService);
 //# sourceMappingURL=delegates-manager.service.js.map