@fastybird/smart-panel-backend 1.1.0-alpha.3 → 1.1.0-alpha.30

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

@@ -8,16 +8,20 @@ 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 channel_input_occurrences_service_1 = require("../../../modules/devices/services/channel-input-occurrences.service");
 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");
@@ -27,10 +31,20 @@ const mappings_1 = require("../mappings");
 const transformers_1 = require("../mappings/transformers/transformers");
 const device_address_service_1 = require("../services/device-address.service");
 const device_manager_service_1 = require("../services/device-manager.service");
+const poll_placement_diagnostics_service_1 = require("../services/poll-placement-diagnostics.service");
 const transform_utils_2 = require("../utils/transform.utils");
 const shelly_device_delegate_1 = require("./shelly-device.delegate");
+const SHELLY_TO_PANEL_EVENT_MAP = {
+    single_push: 'press',
+    double_push: 'double_press',
+    triple_push: 'triple_press',
+    triple_press: 'triple_press',
+    long_push: 'long_press',
+    btn_down: 'down',
+    btn_up: 'up',
+};
 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(), pollPlacementDiagnostics = new poll_placement_diagnostics_service_1.PollPlacementDiagnosticsService(), channelInputOccurrencesService) {
         this.devicesService = devicesService;
         this.channelsService = channelsService;
         this.channelsPropertiesService = channelsPropertiesService;
@@ -39,14 +53,28 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.deviceAddressService = deviceAddressService;
         this.propertyMappingStorage = propertyMappingStorage;
         this.transformerRegistry = transformerRegistry;
+        this.commandLatencyTraceCollector = commandLatencyTraceCollector;
+        this.pollPlacementDiagnostics = pollPlacementDiagnostics;
+        this.channelInputOccurrencesService = channelInputOccurrencesService;
         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();
         this.delegateConnectionHandlers = new Map();
+        this.delegateEventHandlers = new Map();
+        this.delegateEventQueues = new Map();
+        this.delegateEventGenerations = new Map();
         this.changeHandlers = new Map();
         this.setChannelsHandlers = new Map();
         this.setPropertiesHandlers = new Map();
         this.pendingWrites = new Map();
+        this.delegatePendingWrites = new Map();
+        this.delegateActiveWrites = new Map();
+        this.pendingPollWrites = new Map();
+        this.activePollWrites = new Map();
+        this.activePollDrainPromises = new Map();
+        this.delegatePollDeviceIds = new Map();
+        this.delegatePollGenerations = new Map();
+        this.currentValueUpdateContext = null;
         this.propertiesMap = new Map();
         this.delegateDeviceIds = new Map();
         this.delegateToIdentifier = new Map();
@@ -67,7 +95,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
     async performInsert(shelly, force = false) {
         if (this.delegates.has(shelly.id)) {
             if (force) {
-                this.performRemove(shelly.id);
+                await this.performRemove(shelly.id);
             }
             else {
                 return this.delegates.get(shelly.id);
@@ -75,6 +103,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;
@@ -120,6 +149,12 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         let device = resolvedDevice;
         this.delegateDeviceIds.set(delegate.id, device.id);
         this.delegateToIdentifier.set(delegate.id, device.identifier);
+        this.pollPlacementDiagnostics.observeDelegate({
+            delegateId: delegate.id,
+            sourceDeviceId: device.id,
+            connected: delegate.connected,
+            generation,
+        });
         const delegateSet = this.identifierToDelegates.get(device.identifier) ?? new Set();
         delegateSet.add(delegate.id);
         this.identifierToDelegates.set(device.identifier, delegateSet);
@@ -808,12 +843,80 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
-        const valueHandler = (compKey, attr, val) => {
+        for (const comp of delegate.inputs.values()) {
+            const channel = await this.channelsService.findOneBy('identifier', `input:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (channel === null) {
+                continue;
+            }
+            if (channel.category === devices_constants_1.ChannelCategory.BUTTON) {
+                const detectedProp = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.DETECTED, channel.id);
+                if (detectedProp) {
+                    await this.setDefaultPropertyValue(device.id, detectedProp, Boolean(comp.state));
+                    this.changeHandlers.set(`${delegate.id}|${comp.key}|state`, (val) => {
+                        if (typeof val === 'boolean') {
+                            this.handleChange(detectedProp, val, false).catch((err) => {
+                                this.logger.error(`Failed to update detected for ${detectedProp.id}: ${err.message}`);
+                            });
+                        }
+                    });
+                }
+            }
+            else if (channel.category === devices_constants_1.ChannelCategory.BINARY_INPUT) {
+                const stateProp = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.STATE, channel.id);
+                if (stateProp) {
+                    await this.setDefaultPropertyValue(device.id, stateProp, Boolean(comp.state));
+                    this.changeHandlers.set(`${delegate.id}|${comp.key}|state`, (val) => {
+                        if (typeof val === 'boolean') {
+                            this.handleChange(stateProp, val, false).catch((err) => {
+                                this.logger.error(`Failed to update state for ${stateProp.id}: ${err.message}`);
+                            });
+                        }
+                    });
+                }
+            }
+            else if (channel.category === devices_constants_1.ChannelCategory.ANALOG_INPUT) {
+                const valueProp = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.VALUE, channel.id);
+                if (valueProp) {
+                    const hasExtendedPercent = typeof comp.xpercent === 'number';
+                    const hasExtendedCount = typeof comp.counts?.xtotal === 'number';
+                    let initialVal;
+                    if (comp.counts !== undefined) {
+                        initialVal = hasExtendedCount ? comp.counts.xtotal : (comp.counts.total ?? 0);
+                    }
+                    else {
+                        initialVal = hasExtendedPercent ? comp.xpercent : (comp.percent ?? 0);
+                    }
+                    await this.setDefaultPropertyValue(device.id, valueProp, initialVal);
+                    const percentAttr = hasExtendedPercent ? 'xpercent' : 'percent';
+                    this.changeHandlers.set(`${delegate.id}|${comp.key}|${percentAttr}`, (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n !== null) {
+                            this.handleChange(valueProp, n, false).catch((err) => {
+                                this.logger.error(`Failed to update value for ${valueProp.id}: ${err.message}`);
+                            });
+                        }
+                    });
+                    const countAttr = hasExtendedCount ? 'counts.xtotal' : 'counts.total';
+                    this.changeHandlers.set(`${delegate.id}|${comp.key}|${countAttr}`, (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n !== null) {
+                            this.handleChange(valueProp, n, false).catch((err) => {
+                                this.logger.error(`Failed to update counts for ${valueProp.id}: ${err.message}`);
+                            });
+                        }
+                    });
+                }
+            }
+        }
+        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) {
@@ -824,6 +927,9 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                     stack: err.stack,
                 });
             }
+            finally {
+                this.currentValueUpdateContext = null;
+            }
         };
         delegate.on('value', valueHandler);
         this.delegateValueHandlers.set(delegate.id, valueHandler);
@@ -834,6 +940,12 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 if (wasConnected)
                     return;
                 this.delegateConnectedState.set(delegate.id, true);
+                this.pollPlacementDiagnostics.observeDelegate({
+                    delegateId: delegate.id,
+                    sourceDeviceId: device.id,
+                    connected: true,
+                    generation,
+                });
                 const pendingTimer = this.disconnectTimers.get(deviceDbId);
                 if (pendingTimer) {
                     clearTimeout(pendingTimer);
@@ -855,6 +967,12 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 if (!wasConnected)
                     return;
                 this.delegateConnectedState.set(delegate.id, false);
+                this.pollPlacementDiagnostics.observeDelegate({
+                    delegateId: delegate.id,
+                    sourceDeviceId: device.id,
+                    connected: false,
+                    generation,
+                });
                 const count = Math.max(0, (this.connectedDelegatesPerDevice.get(deviceDbId) ?? 1) - 1);
                 this.connectedDelegatesPerDevice.set(deviceDbId, count);
                 if (count === 0) {
@@ -922,6 +1040,34 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         };
         delegate.on('connected', connectionHandler);
         this.delegateConnectionHandlers.set(delegate.id, connectionHandler);
+        const eventGeneration = (this.delegateEventGenerations.get(delegate.id) ?? 0) + 1;
+        this.delegateEventGenerations.set(delegate.id, eventGeneration);
+        const eventHandler = (params) => {
+            const previousPromise = this.delegateEventQueues.get(delegate.id) ?? Promise.resolve();
+            const nextPromise = previousPromise
+                .then(async () => {
+                if (this.delegateEventGenerations.get(delegate.id) !== eventGeneration) {
+                    return;
+                }
+                await this.handleDeviceEvent(delegate, device, params, eventGeneration);
+            })
+                .catch((error) => {
+                const err = error;
+                this.logger.error(`Shelly event error for device=${device.id}`, {
+                    resource: device.id,
+                    message: err.message,
+                    stack: err.stack,
+                });
+            })
+                .finally(() => {
+                if (this.delegateEventQueues.get(delegate.id) === nextPromise) {
+                    this.delegateEventQueues.delete(delegate.id);
+                }
+            });
+            this.delegateEventQueues.set(delegate.id, nextPromise);
+        };
+        delegate.on('event', eventHandler);
+        this.delegateEventHandlers.set(delegate.id, eventHandler);
         if (delegate.connected) {
             connectionHandler(true);
         }
@@ -929,17 +1075,45 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         return delegate;
     }
     remove(deviceId) {
-        return this.withDeviceLock(deviceId, () => {
-            this.performRemove(deviceId);
-            return Promise.resolve();
-        });
+        return this.withDeviceLock(deviceId, () => this.performRemove(deviceId));
+    }
+    async teardownDelegateEvents(delegate) {
+        const eventHandler = this.delegateEventHandlers.get(delegate.id);
+        if (eventHandler) {
+            delegate.off('event', eventHandler);
+        }
+        const pendingQueue = this.delegateEventQueues.get(delegate.id);
+        this.delegateEventHandlers.delete(delegate.id);
+        this.delegateEventQueues.delete(delegate.id);
+        this.delegateEventGenerations.set(delegate.id, (this.delegateEventGenerations.get(delegate.id) ?? 0) + 1);
+        if (pendingQueue !== undefined) {
+            try {
+                await pendingQueue;
+            }
+            catch (err) {
+                this.logger.error(`Error while awaiting event queue teardown for delegate=${delegate.id}`, {
+                    message: err.message,
+                    stack: err.stack,
+                });
+            }
+        }
     }
-    performRemove(deviceId) {
+    async performRemove(deviceId) {
         const delegate = this.delegates.get(deviceId);
         if (!delegate) {
             return;
         }
         const valueHandler = this.delegateValueHandlers.get(delegate.id);
+        if (valueHandler) {
+            delegate.off('value', valueHandler);
+            this.delegateValueHandlers.delete(delegate.id);
+        }
+        this.delegatePollGenerations.set(deviceId, (this.delegatePollGenerations.get(deviceId) ?? 0) + 1);
+        this.cancelPollWritesForDelegate(deviceId);
+        this.cancelPendingWritesForDelegate(deviceId);
+        await this.teardownDelegateEvents(delegate);
+        await this.awaitActiveWritesForDelegate(deviceId);
+        await this.awaitActivePollDrainsForDelegate(deviceId);
         const connectionHandler = this.delegateConnectionHandlers.get(delegate.id);
         if (connectionHandler) {
             connectionHandler(null);
@@ -962,14 +1136,10 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 });
             }
         }
-        if (valueHandler) {
-            delegate.off('value', valueHandler);
-        }
         if (connectionHandler) {
             delegate.off('connected', connectionHandler);
+            this.delegateConnectionHandlers.delete(delegate.id);
         }
-        this.delegateValueHandlers.delete(delegate.id);
-        this.delegateConnectionHandlers.delete(delegate.id);
         for (const key of Array.from(this.changeHandlers.keys())) {
             if (key.startsWith(`${deviceId}|`)) {
                 this.changeHandlers.delete(key);
@@ -1009,7 +1179,12 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
         this.delegateDeviceIds.delete(deviceId);
         this.delegateToIdentifier.delete(deviceId);
+        this.pollPlacementDiagnostics.removeDelegate(deviceId);
         this.insertGeneration.delete(deviceId);
+        this.delegatePendingWrites.delete(deviceId);
+        this.delegateActiveWrites.delete(deviceId);
+        this.delegatePollGenerations.delete(deviceId);
+        this.delegatePollDeviceIds.delete(deviceId);
         this.delegates.delete(deviceId);
         this.logger.log(`Detached Shelly device=${deviceId}`, { resource: deviceId });
     }
@@ -1074,12 +1249,149 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             return value;
         }
     }
-    async handleChange(property, value, immediately = true) {
+    async handleDeviceEvent(delegate, device, params, generation) {
+        if (this.delegateEventGenerations.get(delegate.id) !== generation) {
+            return;
+        }
+        if (typeof params !== 'object' || params === null) {
+            return;
+        }
+        const eventPayload = params;
+        const rawEvents = Array.isArray(eventPayload.events) ? eventPayload.events : [eventPayload];
+        for (const rawItem of rawEvents) {
+            if (this.delegateEventGenerations.get(delegate.id) !== generation) {
+                return;
+            }
+            if (typeof rawItem !== 'object' || rawItem === null) {
+                continue;
+            }
+            const item = rawItem;
+            const rawEvent = typeof item.event === 'string' ? item.event : undefined;
+            if (!rawEvent) {
+                continue;
+            }
+            const mappedEvent = SHELLY_TO_PANEL_EVENT_MAP[rawEvent];
+            if (!mappedEvent) {
+                this.logger.debug(`Unknown Shelly event=${rawEvent} from device=${device.id}`);
+                continue;
+            }
+            let channelIdentifier;
+            if (typeof item.component === 'string' && item.component.length > 0) {
+                channelIdentifier = item.component;
+            }
+            else if (typeof item.id === 'number' || typeof item.id === 'string') {
+                channelIdentifier = `input:${item.id}`;
+            }
+            else {
+                continue;
+            }
+            const channel = await this.channelsService.findOneBy('identifier', channelIdentifier, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (this.delegateEventGenerations.get(delegate.id) !== generation) {
+                return;
+            }
+            if (!channel) {
+                this.logger.debug(`No channel found for ${channelIdentifier} on device=${device.id}`);
+                continue;
+            }
+            if (rawEvent === 'btn_down' || rawEvent === 'btn_up') {
+                try {
+                    const detectedProp = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.DETECTED, channel.id);
+                    if (this.delegateEventGenerations.get(delegate.id) !== generation) {
+                        return;
+                    }
+                    if (detectedProp) {
+                        await this.handleChange(detectedProp, rawEvent === 'btn_down', true);
+                    }
+                }
+                catch (err) {
+                    this.logger.error(`Failed to update DETECTED property for channel=${channel.id} on device=${device.id}: ${err.message}`);
+                }
+            }
+            if (this.delegateEventGenerations.get(delegate.id) !== generation) {
+                return;
+            }
+            const eventProp = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.EVENT, channel.id);
+            if (this.delegateEventGenerations.get(delegate.id) !== generation) {
+                return;
+            }
+            if (!eventProp) {
+                this.logger.debug(`No EVENT property on channel=${channel.id} for device=${device.id}`);
+                continue;
+            }
+            if (this.channelInputOccurrencesService) {
+                const ts = typeof item.ts === 'number' ? item.ts : typeof eventPayload.ts === 'number' ? eventPayload.ts : undefined;
+                const timestamp = ts !== undefined ? new Date(ts < 1e11 ? Math.round(ts * 1000) : Math.round(ts)) : new Date();
+                const sourceOccurrenceId = `${channel.id}:${rawEvent}:${ts ?? timestamp.getTime()}`;
+                try {
+                    if (this.delegateEventGenerations.get(delegate.id) !== generation) {
+                        return;
+                    }
+                    await this.channelInputOccurrencesService.publishOccurrence({
+                        deviceId: device.id,
+                        channelId: channel.id,
+                        propertyId: eventProp.id,
+                        event: mappedEvent,
+                        nativeEventType: rawEvent,
+                        sourceTimestamp: timestamp.toISOString(),
+                        sourceOccurrenceId,
+                    });
+                }
+                catch (err) {
+                    this.logger.error(`Failed to publish occurrence for channel=${channel.id} on device=${device.id}: ${err.message}`);
+                }
+            }
+        }
+    }
+    async handleChange(property, value, immediately = true, delegateId) {
+        const context = this.currentValueUpdateContext;
+        const effectiveDelegateId = delegateId ?? context?.delegateId;
+        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) {
-            await this.writeValueToProperty(property, value);
+            this.cancelScheduledWrite(property.id);
+            this.cancelPollWrite(property.id);
+            if (effectiveDelegateId) {
+                let active = this.delegateActiveWrites.get(effectiveDelegateId);
+                if (!active) {
+                    active = new Set();
+                    this.delegateActiveWrites.set(effectiveDelegateId, active);
+                }
+                const writePromise = (async () => {
+                    await this.writeValueToProperty(property, value);
+                })();
+                void writePromise.catch(() => { });
+                active.add(writePromise);
+                try {
+                    await writePromise;
+                }
+                finally {
+                    const currentActive = this.delegateActiveWrites.get(effectiveDelegateId);
+                    if (currentActive) {
+                        currentActive.delete(writePromise);
+                        if (currentActive.size === 0) {
+                            this.delegateActiveWrites.delete(effectiveDelegateId);
+                        }
+                    }
+                }
+            }
+            else {
+                await this.writeValueToProperty(property, value);
+            }
         }
         else {
-            this.scheduleWrite(property, value);
+            this.scheduleWrite(property, value, effectiveDelegateId);
         }
     }
     async setDefaultPropertyValue(deviceId, property, value) {
@@ -1217,10 +1529,21 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             });
         });
     }
-    scheduleWrite(property, value) {
+    scheduleWrite(property, value, delegateId) {
         const existing = this.pendingWrites.get(property.id);
         if (existing) {
             clearTimeout(existing);
+            for (const set of this.delegatePendingWrites.values()) {
+                set.delete(property.id);
+            }
+        }
+        if (delegateId) {
+            let set = this.delegatePendingWrites.get(delegateId);
+            if (!set) {
+                set = new Set();
+                this.delegatePendingWrites.set(delegateId, set);
+            }
+            set.add(property.id);
         }
         const t = setTimeout(() => {
             const current = this.pendingWrites.get(property.id);
@@ -1228,15 +1551,301 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 clearTimeout(current);
                 this.pendingWrites.delete(property.id);
             }
-            this.writeValueToProperty(property, value).catch((err) => {
-                this.logger.error(`Failed to process scheduled write of value=${(0, transform_utils_1.safeToString)(value)} to property=${property.id}`, { message: err.message, stack: err.stack });
-            });
+            if (delegateId) {
+                const set = this.delegatePendingWrites.get(delegateId);
+                if (set) {
+                    set.delete(property.id);
+                    if (set.size === 0) {
+                        this.delegatePendingWrites.delete(delegateId);
+                    }
+                }
+                if (!this.delegates.has(delegateId)) {
+                    return;
+                }
+            }
+            const writePromise = (async () => {
+                try {
+                    await this.writeValueToProperty(property, value);
+                }
+                catch (err) {
+                    this.logger.error(`Failed to process scheduled write of value=${(0, transform_utils_1.safeToString)(value)} to property=${property.id}`, { message: err.message, stack: err.stack });
+                }
+            })();
+            if (delegateId) {
+                let active = this.delegateActiveWrites.get(delegateId);
+                if (!active) {
+                    active = new Set();
+                    this.delegateActiveWrites.set(delegateId, active);
+                }
+                active.add(writePromise);
+                void writePromise.finally(() => {
+                    const currentActive = this.delegateActiveWrites.get(delegateId);
+                    if (currentActive) {
+                        currentActive.delete(writePromise);
+                        if (currentActive.size === 0) {
+                            this.delegateActiveWrites.delete(delegateId);
+                        }
+                    }
+                });
+            }
         }, 250);
         this.pendingWrites.set(property.id, t);
     }
+    schedulePollWrite(context, property, value) {
+        let tracked = this.delegatePollDeviceIds.get(context.delegateId);
+        if (!tracked) {
+            tracked = new Set();
+            this.delegatePollDeviceIds.set(context.delegateId, tracked);
+        }
+        tracked.add(context.deviceId);
+        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);
+        const drainPromise = (async () => {
+            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);
+                }
+            }
+        })();
+        void drainPromise.catch(() => { });
+        let drains = this.activePollDrainPromises.get(deviceId);
+        if (!drains) {
+            drains = new Set();
+            this.activePollDrainPromises.set(deviceId, drains);
+        }
+        drains.add(drainPromise);
+        try {
+            await drainPromise;
+        }
+        finally {
+            const currentDrains = this.activePollDrainPromises.get(deviceId);
+            if (currentDrains) {
+                currentDrains.delete(drainPromise);
+                if (currentDrains.size === 0) {
+                    this.activePollDrainPromises.delete(deviceId);
+                }
+            }
+        }
+    }
+    cancelScheduledWrite(propertyId) {
+        const timer = this.pendingWrites.get(propertyId);
+        if (timer) {
+            clearTimeout(timer);
+            this.pendingWrites.delete(propertyId);
+        }
+        for (const [delegateId, set] of this.delegatePendingWrites.entries()) {
+            set.delete(propertyId);
+            if (set.size === 0) {
+                this.delegatePendingWrites.delete(delegateId);
+            }
+        }
+    }
+    cancelPendingWritesForDelegate(delegateId) {
+        const pendingPropertyIds = this.delegatePendingWrites.get(delegateId);
+        if (pendingPropertyIds) {
+            for (const propertyId of pendingPropertyIds) {
+                const timer = this.pendingWrites.get(propertyId);
+                if (timer) {
+                    clearTimeout(timer);
+                    this.pendingWrites.delete(propertyId);
+                }
+            }
+            this.delegatePendingWrites.delete(delegateId);
+        }
+    }
+    async awaitActiveWritesForDelegate(delegateId) {
+        while (true) {
+            const activeWrites = this.delegateActiveWrites.get(delegateId);
+            if (!activeWrites || activeWrites.size === 0) {
+                break;
+            }
+            const toAwait = Array.from(activeWrites);
+            await Promise.allSettled(toAwait);
+            for (const p of toAwait) {
+                activeWrites.delete(p);
+            }
+        }
+        this.delegateActiveWrites.delete(delegateId);
+    }
+    async awaitAllActiveWrites() {
+        while (true) {
+            const allPromises = [];
+            for (const activeWrites of this.delegateActiveWrites.values()) {
+                allPromises.push(...activeWrites);
+            }
+            if (allPromises.length === 0) {
+                break;
+            }
+            await Promise.allSettled(allPromises);
+            for (const activeWrites of this.delegateActiveWrites.values()) {
+                for (const p of allPromises) {
+                    activeWrites.delete(p);
+                }
+            }
+        }
+        this.delegateActiveWrites.clear();
+    }
+    async awaitActivePollDrainsForDelegate(delegateId) {
+        const deviceDbId = this.delegateDeviceIds.get(delegateId);
+        const relevantDeviceIds = new Set([delegateId]);
+        if (deviceDbId) {
+            relevantDeviceIds.add(deviceDbId);
+        }
+        const trackedPollDeviceIds = this.delegatePollDeviceIds.get(delegateId);
+        if (trackedPollDeviceIds) {
+            for (const devId of trackedPollDeviceIds) {
+                relevantDeviceIds.add(devId);
+            }
+        }
+        for (const [devId, buckets] of this.activePollWrites.entries()) {
+            for (const bucket of buckets) {
+                for (const pending of bucket.values.values()) {
+                    if (pending.delegateId === delegateId) {
+                        relevantDeviceIds.add(devId);
+                    }
+                }
+            }
+        }
+        while (true) {
+            const promises = [];
+            for (const devId of relevantDeviceIds) {
+                const drains = this.activePollDrainPromises.get(devId);
+                if (drains && drains.size > 0) {
+                    promises.push(...drains);
+                }
+            }
+            if (promises.length === 0) {
+                break;
+            }
+            await Promise.allSettled(promises);
+            for (const devId of relevantDeviceIds) {
+                const drains = this.activePollDrainPromises.get(devId);
+                if (drains) {
+                    for (const p of promises) {
+                        drains.delete(p);
+                    }
+                }
+            }
+        }
+    }
+    async awaitAllActivePollDrains() {
+        while (true) {
+            const allPromises = [];
+            for (const drains of this.activePollDrainPromises.values()) {
+                allPromises.push(...drains);
+            }
+            if (allPromises.length === 0) {
+                break;
+            }
+            await Promise.allSettled(allPromises);
+            for (const drains of this.activePollDrainPromises.values()) {
+                for (const p of allPromises) {
+                    drains.delete(p);
+                }
+            }
+        }
+    }
+    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,
         }));
     }
@@ -1270,7 +1879,8 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
         return fallback;
     }
-    detach() {
+    async detach() {
+        const teardownPromises = [];
         for (const [, delegate] of this.delegates.entries()) {
             const valueHandler = this.delegateValueHandlers.get(delegate.id);
             const connectionHandler = this.delegateConnectionHandlers.get(delegate.id);
@@ -1280,19 +1890,41 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             if (connectionHandler) {
                 delegate.off('connected', connectionHandler);
             }
+            teardownPromises.push(this.teardownDelegateEvents(delegate));
         }
+        for (const pendingWrite of this.pendingWrites.values()) {
+            clearTimeout(pendingWrite);
+        }
+        this.pendingWrites.clear();
+        this.delegatePendingWrites.clear();
+        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();
+            }
+        }
+        await Promise.all(teardownPromises);
+        await this.awaitAllActiveWrites();
+        await this.awaitAllActivePollDrains();
+        this.activePollWrites.clear();
+        this.activePollDrainPromises.clear();
+        this.delegatePollDeviceIds.clear();
         this.delegates.clear();
         this.delegateValueHandlers.clear();
         this.delegateConnectionHandlers.clear();
+        this.delegateEventHandlers.clear();
+        this.delegateEventQueues.clear();
+        this.delegateEventGenerations.clear();
         this.delegateDeviceIds.clear();
         this.changeHandlers.clear();
         this.setPropertiesHandlers.clear();
         this.setChannelsHandlers.clear();
         this.propertiesMap.clear();
-        for (const pendingWrite of this.pendingWrites.values()) {
-            clearTimeout(pendingWrite);
-        }
-        this.pendingWrites.clear();
+        this.delegatePollGenerations.clear();
+        this.currentValueUpdateContext = null;
         this.deviceLocks.clear();
         this.canonicalMacLocks.clear();
         this.connectedDelegatesPerDevice.clear();
@@ -1305,8 +1937,8 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.delegateConnectedState.clear();
         this.insertGeneration.clear();
     }
-    destroy() {
-        this.detach();
+    async destroy() {
+        await this.detach();
     }
     async checkHealth(pingTimeoutMs = 5_000) {
         const CONCURRENCY = 10;
@@ -1336,20 +1968,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()));
         }
@@ -1398,6 +2057,9 @@ 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)()),
+    __param(9, (0, common_1.Optional)()),
+    __param(10, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [devices_service_1.DevicesService,
         channels_service_1.ChannelsService,
         channels_properties_service_1.ChannelsPropertiesService,
@@ -1405,6 +2067,9 @@ 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,
+        poll_placement_diagnostics_service_1.PollPlacementDiagnosticsService,
+        channel_input_occurrences_service_1.ChannelInputOccurrencesService])
 ], DelegatesManagerService);
 //# sourceMappingURL=delegates-manager.service.js.map