@fastybird/smart-panel-backend 1.1.0-alpha.12 → 1.1.0-alpha.13

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

@@ -18,6 +18,7 @@ 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");
@@ -33,8 +34,17 @@ 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, commandLatencyTraceCollector = new command_latency_trace_collector_service_1.CommandLatencyTraceCollectorService(), pollPlacementDiagnostics = new poll_placement_diagnostics_service_1.PollPlacementDiagnosticsService()) {
+    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;
@@ -45,16 +55,24 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         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();
@@ -77,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);
@@ -823,6 +841,73 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             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;
+        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') => {
@@ -955,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);
         }
@@ -962,19 +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);
-        const valueHandler = this.delegateValueHandlers.get(delegate.id);
+        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);
@@ -997,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);
@@ -1046,6 +1181,10 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         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 });
     }
@@ -1110,8 +1249,102 @@ 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,
@@ -1129,10 +1362,36 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         if (immediately) {
             this.cancelScheduledWrite(property.id);
             this.cancelPollWrite(property.id);
-            await this.writeValueToProperty(property, value);
+            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) {
@@ -1270,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);
@@ -1281,13 +1551,53 @@ 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();
@@ -1317,32 +1627,53 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             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);
+        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 });
+                    }
                 }
-                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 {
-            activeBuckets.delete(bucket);
-            if (activeBuckets.size === 0 && this.activePollWrites.get(deviceId) === activeBuckets) {
-                this.activePollWrites.delete(deviceId);
+            const currentDrains = this.activePollDrainPromises.get(deviceId);
+            if (currentDrains) {
+                currentDrains.delete(drainPromise);
+                if (currentDrains.size === 0) {
+                    this.activePollDrainPromises.delete(deviceId);
+                }
             }
         }
     }
@@ -1352,6 +1683,117 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             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()) {
@@ -1437,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);
@@ -1447,20 +1890,39 @@ 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.clearPollWrites();
         this.delegatePollGenerations.clear();
         this.currentValueUpdateContext = null;
         this.deviceLocks.clear();
@@ -1475,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;
@@ -1597,6 +2059,7 @@ exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerServ
     (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,
@@ -1606,6 +2069,7 @@ exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerServ
         mappings_1.PropertyMappingStorageService,
         mappings_1.TransformerRegistry,
         command_latency_trace_collector_service_1.CommandLatencyTraceCollectorService,
-        poll_placement_diagnostics_service_1.PollPlacementDiagnosticsService])
+        poll_placement_diagnostics_service_1.PollPlacementDiagnosticsService,
+        channel_input_occurrences_service_1.ChannelInputOccurrencesService])
 ], DelegatesManagerService);
 //# sourceMappingURL=delegates-manager.service.js.map