@fastybird/smart-panel-backend 1.1.0-alpha.63 → 1.1.0-alpha.65

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

@@ -24,6 +24,10 @@ const channels_service_1 = require("../../../modules/devices/services/channels.s
 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 property_value_service_1 = require("../../../modules/devices/services/property-value.service");
+const property_metadata_utils_1 = require("../../../modules/devices/utils/property-metadata.utils");
+const cover_action_contract_1 = require("../contracts/cover-action.contract");
+const native_temperature_contract_1 = require("../contracts/native-temperature.contract");
 const devices_shelly_ng_constants_1 = require("../devices-shelly-ng.constants");
 const devices_shelly_ng_exceptions_1 = require("../devices-shelly-ng.exceptions");
 const update_channel_property_dto_1 = require("../dto/update-channel-property.dto");
@@ -32,6 +36,9 @@ 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 shelly_cover_ordering_service_1 = require("../services/shelly-cover-ordering.service");
+const shelly_cover_recovery_lane_service_1 = require("../services/shelly-cover-recovery-lane.service");
+const shelly_sample_sources_service_1 = require("../services/shelly-sample-sources.service");
 const transform_utils_2 = require("../utils/transform.utils");
 const shelly_device_delegate_1 = require("./shelly-device.delegate");
 const SHELLY_TO_PANEL_EVENT_MAP = {
@@ -44,7 +51,40 @@ const SHELLY_TO_PANEL_EVENT_MAP = {
     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(), channelInputOccurrencesService) {
+    beginGuardedSessionAdmission(runtime) {
+        this.revokeGuardedSessionAdmission();
+        const admission = { runtime, open: false, revoked: false };
+        this.guardedSessionAdmission = admission;
+        return Object.freeze({
+            open: () => {
+                if (this.guardedSessionAdmission !== admission || admission.revoked || !runtime?.isCurrent())
+                    return false;
+                admission.open = true;
+                return true;
+            },
+            revoke: () => {
+                admission.revoked = true;
+                admission.open = false;
+            },
+        });
+    }
+    revokeGuardedSessionAdmission() {
+        const admission = this.guardedSessionAdmission;
+        if (admission) {
+            admission.revoked = true;
+            admission.open = false;
+        }
+    }
+    captureGuardedSessionAdmission() {
+        const admission = this.guardedSessionAdmission;
+        const isCurrent = () => this.guardedSessionAdmission === admission &&
+            admission !== null &&
+            admission.open &&
+            !admission.revoked &&
+            admission.runtime?.isCurrent() === true;
+        return isCurrent() ? Object.freeze({ isCurrent }) : null;
+    }
+    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, sampleSourcesRegistry, coverValues, coverOrdering, coverRecoveryLane) {
         this.devicesService = devicesService;
         this.channelsService = channelsService;
         this.channelsPropertiesService = channelsPropertiesService;
@@ -56,8 +96,17 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.commandLatencyTraceCollector = commandLatencyTraceCollector;
         this.pollPlacementDiagnostics = pollPlacementDiagnostics;
         this.channelInputOccurrencesService = channelInputOccurrencesService;
+        this.sampleSourcesRegistry = sampleSourcesRegistry;
+        this.coverValues = coverValues;
+        this.coverOrdering = coverOrdering;
+        this.coverRecoveryLane = coverRecoveryLane;
         this.logger = (0, logger_1.createExtensionLogger)(devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_PLUGIN_NAME, 'DelegatesManagerService');
         this.delegates = new Map();
+        this.sampleHandlers = new Map();
+        this.sampleSources = new Map();
+        this.sampleRevisions = new Map();
+        this.sampleGenerations = new Map();
+        this.activeSamples = new Map();
         this.delegateValueHandlers = new Map();
         this.delegateConnectionHandlers = new Map();
         this.delegateEventHandlers = new Map();
@@ -85,6 +134,8 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.canonicalMacLocks = new Map();
         this.connectedDelegatesPerDevice = new Map();
         this.disconnectTimers = new Map();
+        this.guardedSessionAdmission = null;
+        this.coverIssues = new Map();
     }
     get(id) {
         return this.delegates.get(id);
@@ -908,9 +959,14 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                 }
             }
         }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        await this.bindSampleSources(delegate, device);
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
         const valueHandler = (compKey, attr, val, origin = 'notify') => {
+            if ((this.sampleSources.get(delegate.id) ?? []).some((source) => source.componentKey === compKey && source.attribute === attr))
+                return;
             const handler = this.changeHandlers.get(`${delegate.id}|${compKey}|${attr}`);
             if (!handler) {
                 return;
@@ -934,11 +990,29 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         delegate.on('value', valueHandler);
         this.delegateValueHandlers.set(delegate.id, valueHandler);
         const connectionHandler = (state) => {
+            if (state !== true) {
+                this.sampleGenerations.set(delegate.id, (this.sampleGenerations.get(delegate.id) ?? 0) + 1);
+                for (const source of this.sampleSources.get(delegate.id) ?? []) {
+                    this.sampleSourcesRegistry?.revoke(source.property.id);
+                    void this.admitRawSample(source.property, null, {
+                        componentKey: source.componentKey,
+                        values: {},
+                        evidence: { sampledAt: new Date(), receivedAt: new Date(), observedAt: new Date(), provenance: 'live' },
+                    }).catch((error) => this.logger.error(`Failed to invalidate Shelly sample for property=${source.property.id}: ${error.message}`));
+                }
+            }
             const deviceDbId = this.delegateDeviceIds.get(delegate.id) ?? device.id;
             const wasConnected = this.delegateConnectedState.get(delegate.id) ?? false;
             if (state === true) {
                 if (wasConnected)
                     return;
+                for (const source of this.sampleSources.get(delegate.id) ?? []) {
+                    if ((0, native_temperature_contract_1.hasQualifiedFloorSourceIdentity)(source.channel.identifier) ||
+                        (0, native_temperature_contract_1.hasQualifiedRawVoltageIdentity)(source.channel.identifier))
+                        void this.sampleSourcesRegistry
+                            ?.get(source.property.id)
+                            .catch((error) => this.logger.error(`Failed to activate Shelly sample source=${source.property.id}: ${error.message}`));
+                }
                 this.delegateConnectedState.set(delegate.id, true);
                 this.pollPlacementDiagnostics.observeDelegate({
                     delegateId: delegate.id,
@@ -1098,11 +1172,283 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             }
         }
     }
+    async unbindSamples(delegate) {
+        this.sampleGenerations.set(delegate.id, (this.sampleGenerations.get(delegate.id) ?? 0) + 1);
+        const handler = this.sampleHandlers.get(delegate.id);
+        if (handler)
+            delegate.off('sample', handler);
+        this.sampleHandlers.delete(delegate.id);
+        delegate.setSampleComponentKeys([]);
+        for (const source of this.sampleSources.get(delegate.id) ?? []) {
+            const owner = this.delegateDeviceIds.get(delegate.id);
+            if (owner)
+                this.coverIssues.delete(`${owner}|${source.channel.id}`);
+            this.sampleSourcesRegistry?.revoke(source.property.id);
+            await this.admitRawSample(source.property, null, {
+                componentKey: source.componentKey,
+                values: {},
+                evidence: { sampledAt: new Date(), receivedAt: new Date(), observedAt: new Date(), provenance: 'live' },
+            }).catch((error) => this.logger.error(`Failed to invalidate Shelly sample for property=${source.property.id}: ${error.message}`));
+            this.sampleRevisions.delete(`${delegate.id}|${source.property.id}`);
+        }
+        this.sampleSources.delete(delegate.id);
+        await Promise.allSettled([...(this.activeSamples.get(delegate.id) ?? [])]);
+        this.activeSamples.delete(delegate.id);
+    }
+    async bindSampleSources(delegate, device) {
+        const sources = [];
+        for (const channel of await this.channelsService.findAll(device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE)) {
+            let componentKey;
+            let attribute;
+            if (/^temperature:\d+$/.test(channel.identifier)) {
+                componentKey = channel.identifier;
+                attribute = 'tC';
+            }
+            else if ((0, native_temperature_contract_1.hasQualifiedFloorSourceIdentity)(channel.identifier) ||
+                (0, native_temperature_contract_1.hasQualifiedRawVoltageIdentity)(channel.identifier)) {
+                componentKey = channel.identifier.split(':').slice(1, 3).join(':');
+                attribute = (0, native_temperature_contract_1.hasQualifiedRawVoltageIdentity)(channel.identifier)
+                    ? 'voltage'
+                    : componentKey.startsWith('input:')
+                        ? 'xpercent'
+                        : componentKey.startsWith('voltmeter:')
+                            ? 'xvoltage'
+                            : 'tC';
+            }
+            else if (/^cover:\d+$/.test(channel.identifier)) {
+                componentKey = channel.identifier;
+                attribute = 'state';
+            }
+            else if (/^(switch|light):\d+$/.test(channel.identifier)) {
+                componentKey = channel.identifier;
+                attribute = 'output';
+            }
+            else
+                continue;
+            let property = await this.channelsPropertiesService.findOneBy('identifier', attribute, channel.id);
+            if (!property && attribute === 'output')
+                property = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.ON, channel.id);
+            if (property) {
+                const sourceLease = (0, native_temperature_contract_1.hasQualifiedFloorSourceIdentity)(channel.identifier) || (0, native_temperature_contract_1.hasQualifiedRawVoltageIdentity)(channel.identifier)
+                    ? await this.sampleSourcesRegistry?.get(property.id)
+                    : undefined;
+                sources.push({ channel, property, componentKey, attribute, sourceLease: sourceLease ?? undefined });
+            }
+            if (/^cover:\d+$/.test(channel.identifier)) {
+                const position = await this.channelsPropertiesService.findOneBy('identifier', 'current_pos', channel.id);
+                if (position)
+                    sources.push({ channel, property: position, componentKey, attribute: 'current_pos' });
+                const tilt = await this.channelsPropertiesService.findOneBy('identifier', 'slat_pos', channel.id);
+                if (tilt)
+                    sources.push({ channel, property: tilt, componentKey, attribute: 'slat_pos' });
+            }
+            if (/^light:\d+$/.test(channel.identifier)) {
+                const brightness = await this.channelsPropertiesService.findOneBy('identifier', 'brightness', channel.id);
+                if (brightness)
+                    sources.push({ channel, property: brightness, componentKey, attribute: 'brightness' });
+            }
+        }
+        this.sampleSources.set(delegate.id, sources);
+        delegate.setSampleComponentKeys(sources.map((source) => source.componentKey));
+        const handler = (sample) => {
+            const generation = this.sampleGenerations.get(delegate.id) ?? 0;
+            for (const source of sources.filter((item) => item.componentKey === sample.componentKey)) {
+                const errors = sample.values.errors;
+                const fault = Array.isArray(errors) &&
+                    errors.length > 0 &&
+                    (source.attribute !== 'output' || errors.includes('source_missing'));
+                if (!Object.hasOwn(sample.values, source.attribute) && !fault && !/^cover:\d+$/.test(source.componentKey))
+                    continue;
+                const key = `${delegate.id}|${source.property.id}`;
+                const revision = (this.sampleRevisions.get(key) ?? 0) + 1;
+                this.sampleRevisions.set(key, revision);
+                const qualifiedIdentity = (0, native_temperature_contract_1.hasQualifiedFloorSourceIdentity)(source.channel.identifier) ||
+                    (0, native_temperature_contract_1.hasQualifiedRawVoltageIdentity)(source.channel.identifier);
+                const sourceIsCurrent = () => (this.sampleGenerations.get(delegate.id) ?? 0) === generation &&
+                    (sample.evidence.sourceIsCurrent?.() ?? sample.evidence.isCurrent?.() ?? true);
+                const isCurrent = () => sourceIsCurrent() && this.sampleRevisions.get(key) === revision;
+                const raw = sample.values[source.attribute];
+                const cover = /^cover:\d+$/.test(source.componentKey)
+                    ? (0, cover_action_contract_1.nativeCoverStatus)(sample.values, Number(source.componentKey.split(':')[1]))
+                    : null;
+                if (/^cover:\d+$/.test(source.componentKey)) {
+                    const key = `${device.id}|${source.channel.id}`;
+                    if (cover)
+                        this.coverIssues.delete(key);
+                    else
+                        this.coverIssues.set(key, (0, cover_action_contract_1.coverStatusReason)(sample.values));
+                }
+                const value = /^cover:\d+$/.test(source.componentKey)
+                    ? cover
+                        ? source.attribute === 'state'
+                            ? cover.state === 'open'
+                                ? 'opened'
+                                : cover.state
+                            : source.attribute === 'slat_pos'
+                                ? (0, cover_action_contract_1.nativeCoverPercentage)(source.property) &&
+                                    typeof cover.slat_pos === 'number' &&
+                                    Number.isFinite(cover.slat_pos) &&
+                                    cover.slat_pos >= 0 &&
+                                    cover.slat_pos <= 100
+                                    ? cover.slat_pos
+                                    : null
+                                : cover.current_pos
+                        : null
+                    : !fault &&
+                        ((source.attribute === 'output' && typeof raw === 'boolean') ||
+                            (typeof raw === 'number' && Number.isFinite(raw)))
+                        ? raw
+                        : null;
+                let lease;
+                let sourceProof = false;
+                const admit = (reported, report = sample) => {
+                    const sourceGuard = () => sourceIsCurrent() &&
+                        (reported === null ||
+                            !qualifiedIdentity ||
+                            (sourceProof &&
+                                Boolean(lease && this.sampleSourcesRegistry?.isCurrent(lease, sample.evidence.observedAt))));
+                    return this.admitRawSample(source.property, reported, {
+                        ...report,
+                        evidence: {
+                            ...report.evidence,
+                            isCurrent: () => isCurrent() && sourceGuard(),
+                            sourceIsCurrent: sourceGuard,
+                        },
+                    });
+                };
+                const task = (async () => {
+                    if (value !== null && qualifiedIdentity) {
+                        lease = await this.sampleSourcesRegistry?.get(source.property.id);
+                        if (!isCurrent())
+                            return;
+                        if (!lease ||
+                            lease.metadata.fingerprint !== source.channel.identifier.split(':').at(-1) ||
+                            lease.metadata.componentKey !== source.componentKey ||
+                            lease.metadata.deviceId !== device.id ||
+                            !this.sampleSourcesRegistry?.isCurrent(lease, sample.evidence.observedAt)) {
+                            await admit(null);
+                            return;
+                        }
+                        const current = await delegate.readNativeTemperatureIdentity(source.componentKey);
+                        if (!isCurrent())
+                            return;
+                        const identity = current &&
+                            ((0, native_temperature_contract_1.hasQualifiedRawVoltageIdentity)(source.channel.identifier)
+                                ? (0, native_temperature_contract_1.nativeVoltmeterVoltageIdentity)(source.componentKey, current.config, current.peripherals, device.canonicalMac)
+                                : (0, native_temperature_contract_1.nativeTemperatureIdentity)(source.componentKey, current.config, current.peripherals));
+                        if (!identity ||
+                            identity.channelIdentifier !== source.channel.identifier ||
+                            !this.sampleSourcesRegistry.isCurrent(lease, sample.evidence.observedAt)) {
+                            await admit(null);
+                            return;
+                        }
+                        sourceProof = true;
+                    }
+                    if (!isCurrent())
+                        return;
+                    const evidence = sample.evidence;
+                    const observedAt = evidence.observedAt;
+                    const invalidDeviceClock = !Number.isFinite(evidence.sampledAt.getTime()) ||
+                        evidence.sampledAt.getTime() > evidence.receivedAt.getTime();
+                    const ordinarySample = !qualifiedIdentity &&
+                        invalidDeviceClock &&
+                        evidence.provenance === 'live' &&
+                        (evidence.sourceIsCurrent?.() ?? evidence.isCurrent?.()) === true &&
+                        sourceIsCurrent() &&
+                        observedAt instanceof Date &&
+                        Number.isFinite(observedAt.getTime()) &&
+                        observedAt.getTime() <= evidence.receivedAt.getTime()
+                        ? { ...sample, evidence: { ...evidence, sampledAt: observedAt } }
+                        : sample;
+                    const admitted = value !== null && /^temperature:1\d\d$/.test(source.channel.identifier)
+                        ? { ...sample, evidence: { ...sample.evidence, provenance: 'cached' } }
+                        : ordinarySample;
+                    await admit(value, admitted);
+                })();
+                let active = this.activeSamples.get(delegate.id);
+                if (!active) {
+                    active = new Set();
+                    this.activeSamples.set(delegate.id, active);
+                }
+                active.add(task);
+                void task
+                    .catch((error) => this.logger.error(`Shelly sample admission failed: ${error.message}`))
+                    .finally(() => active.delete(task));
+            }
+        };
+        delegate.on('sample', handler);
+        this.sampleHandlers.set(delegate.id, handler);
+    }
+    async admitRawSample(property, value, sample) {
+        await this.channelsPropertiesService.reportSample(property.id, (0, transform_utils_1.toInstance)(update_channel_property_dto_1.UpdateShellyNgChannelPropertyDto, { type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE, value }), {
+            ...sample.evidence,
+            ...(property.category === devices_constants_1.PropertyCategory.TILT && property.identifier === 'slat_pos'
+                ? { semanticOrigin: 'native_cover_tilt_percentage' }
+                : {}),
+            ...(property.category === devices_constants_1.PropertyCategory.STATUS &&
+                /^cover:\d+$/.test(sample.componentKey) &&
+                (0, cover_action_contract_1.nativeCoverStatus)(sample.values, Number(sample.componentKey.split(':')[1]))
+                ? {
+                    semanticOrigin: 'native_cover_status',
+                    nativeCoverTagPresent: Object.hasOwn(sample.values, 'tag') &&
+                        (sample.values.tag === null || typeof sample.values.tag === 'string'),
+                }
+                : {}),
+        });
+    }
+    prepareGuardRpcSession(device, componentId, qualification) {
+        const admission = this.captureGuardedSessionAdmission();
+        if (!admission)
+            return null;
+        if (!device.identifier ||
+            qualification.guardScript?.canonicalMac.toUpperCase() !== device.canonicalMac?.toUpperCase())
+            return null;
+        for (const id of this.identifierToDelegates.get(device.identifier) ?? []) {
+            const delegate = this.delegates.get(id);
+            if (!delegate?.guardedTransportActive || this.delegateDeviceIds.get(id) !== device.id)
+                continue;
+            const generation = this.sampleGenerations.get(id) ?? 0;
+            const lease = delegate.prepareGuardRpcSession(componentId, qualification, () => admission.isCurrent() &&
+                this.delegates.get(id) === delegate &&
+                this.delegateDeviceIds.get(id) === device.id &&
+                (this.sampleGenerations.get(id) ?? 0) === generation);
+            if (lease?.isCurrent())
+                return lease;
+        }
+        return null;
+    }
+    async admitGuardFenceSample(property, readback) {
+        if (!readback.isCurrent())
+            return;
+        await this.channelsPropertiesService.reportSample(property.id, (0, transform_utils_1.toInstance)(update_channel_property_dto_1.UpdateShellyNgChannelPropertyDto, { type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE, value: false }), readback.evidence);
+    }
+    async protectiveSwitch(deviceIdentifier, componentId, command, timeoutMs, isAdmitted) {
+        if (!command.on) {
+            for (const id of this.identifierToDelegates.get(deviceIdentifier) ?? [])
+                this.delegates.get(id)?.revokePendingProtectiveOn();
+        }
+        for (const id of this.identifierToDelegates.get(deviceIdentifier) ?? []) {
+            const delegate = this.delegates.get(id);
+            if (delegate?.rpcConnected) {
+                if (command.on) {
+                    const deviceId = this.delegateDeviceIds.get(id);
+                    const device = deviceId && (await this.devicesService.findOne(deviceId, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE));
+                    if (!device?.enabled)
+                        return { outcome: 'refused', reasons: ['source_disabled_or_missing'] };
+                    if (this.delegates.get(id) !== delegate || this.delegateDeviceIds.get(id) !== deviceId)
+                        return { outcome: 'refused', reasons: ['source_generation_changed'] };
+                }
+                return delegate.protectiveSwitch(componentId, command, timeoutMs, isAdmitted);
+            }
+        }
+        return { outcome: 'refused', reasons: ['source_unavailable'] };
+    }
     async performRemove(deviceId) {
         const delegate = this.delegates.get(deviceId);
         if (!delegate) {
             return;
         }
+        await this.unbindSamples(delegate);
         const valueHandler = this.delegateValueHandlers.get(delegate.id);
         if (valueHandler) {
             delegate.off('value', valueHandler);
@@ -1188,6 +1534,336 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.delegates.delete(deviceId);
         this.logger.log(`Detached Shelly device=${deviceId}`, { resource: deviceId });
     }
+    captureThermostatSetupMetadata(device, componentId) {
+        for (const id of this.identifierToDelegates.get(device.identifier) ?? []) {
+            const delegate = this.delegates.get(id);
+            if (this.delegateDeviceIds.get(id) !== device.id)
+                continue;
+            const snapshot = delegate?.captureThermostatSetupMetadata(componentId);
+            if (snapshot?.isCurrent())
+                return {
+                    ...snapshot,
+                    isCurrent: () => this.delegates.get(id) === delegate && this.delegateDeviceIds.get(id) === device.id && snapshot.isCurrent(),
+                };
+        }
+        return null;
+    }
+    hasGuardedTransport(deviceIdentifier) {
+        return [...(this.identifierToDelegates.get(deviceIdentifier) ?? [])].some((id) => this.delegates.get(id)?.guardedTransportActive === true);
+    }
+    async coverCommandReadiness(update) {
+        if (![devices_constants_1.PropertyCategory.COMMAND, devices_constants_1.PropertyCategory.POSITION, devices_constants_1.PropertyCategory.TILT].includes(update.property.category))
+            return { commandable: false, reasons: ['qualified_cover_position_or_tilt_adapter_unavailable'] };
+        const canonicalMac = update.device.canonicalMac;
+        if (update.device.type === 'devices-shelly-ng' &&
+            canonicalMac &&
+            /^cover:\d+$/.test(update.channel.identifier ?? '') &&
+            this.coverOrdering) {
+            const componentId = Number(update.channel.identifier.split(':')[1]);
+            for (const id of this.identifierToDelegates.get(update.device.identifier) ?? []) {
+                const delegate = this.delegates.get(id);
+                if (delegate?.covers.has(componentId) &&
+                    this.delegateDeviceIds.get(id) === update.device.id &&
+                    (await this.coverOrdering.blocked(`${canonicalMac.toUpperCase()}|cover:${componentId}`)))
+                    return { commandable: false, reasons: ['cover_ordering_unresolved_operator_recovery_required'] };
+            }
+        }
+        const properties = await this.channelsPropertiesService.findAll(update.channel.id);
+        const issue = this.coverIssues.get(`${update.device.id}|${update.channel.id}`);
+        if (issue)
+            return { commandable: false, reasons: [issue] };
+        if (!(0, cover_action_contract_1.configuredCoverType)(properties))
+            return { commandable: false, reasons: ['cover_type_unconfigured'] };
+        const status = properties.find((property) => property.category === devices_constants_1.PropertyCategory.STATUS);
+        if (!status || this.coverValues?.readQualifiedSample(status, 300_000)?.nativeCoverTagPresent !== true)
+            return { commandable: false, reasons: ['cover_action_tag_field_not_observed_in_qualified_status'] };
+        for (const id of this.identifierToDelegates.get(update.device.identifier) ?? []) {
+            const delegate = this.delegates.get(id);
+            if (!delegate || this.delegateDeviceIds.get(id) !== update.device.id)
+                continue;
+            const componentId = Number(update.channel.identifier?.split(':')[1]);
+            const component = delegate.covers.get(componentId);
+            if (component && !(0, cover_action_contract_1.nativeCoverStatus)(component, componentId))
+                return { commandable: false, reasons: [(0, cover_action_contract_1.coverStatusReason)(component)] };
+        }
+        const prepared = await this.prepareCoverAction(update);
+        if (!prepared)
+            return { commandable: false, reasons: ['qualified_cover_adapter_or_ordering_unavailable'] };
+        prepared.dispose?.();
+        return { commandable: true, reasons: [] };
+    }
+    async captureCoverRecoveryTarget(update) {
+        if (!this.coverValues ||
+            !this.coverOrdering ||
+            !this.coverRecoveryLane ||
+            update.property.category !== devices_constants_1.PropertyCategory.COMMAND ||
+            !/^cover:\d+$/.test(update.channel.identifier ?? ''))
+            return null;
+        const properties = await this.channelsPropertiesService.findAll(update.channel.id);
+        const status = properties.find((property) => property.category === devices_constants_1.PropertyCategory.STATUS);
+        const position = properties.find((property) => property.category === devices_constants_1.PropertyCategory.POSITION);
+        if (!(0, cover_action_contract_1.configuredCoverType)(properties) ||
+            status?.identifier !== 'state' ||
+            status.dataType !== devices_constants_1.DataTypeType.ENUM ||
+            position?.identifier !== 'current_pos' ||
+            position.dataType !== devices_constants_1.DataTypeType.UCHAR ||
+            JSON.stringify(position.format) !== '[0,100]' ||
+            update.property.dataType !== devices_constants_1.DataTypeType.ENUM ||
+            JSON.stringify(update.property.format) !== '["open","close","stop"]')
+            return null;
+        const mac = update.device.canonicalMac?.toUpperCase();
+        if (!mac)
+            return null;
+        for (const id of this.identifierToDelegates.get(update.device.identifier) ?? []) {
+            const delegate = this.delegates.get(id);
+            if (!delegate || this.delegateDeviceIds.get(id) !== update.device.id)
+                continue;
+            const connection = delegate.captureCoverRecoveryConnection(update.channel.identifier, mac);
+            if (!connection)
+                continue;
+            const generation = this.sampleGenerations.get(id) ?? 0;
+            const mappings = () => JSON.stringify(properties.map((property) => ({
+                id: property.id,
+                category: property.category,
+                identifier: property.identifier,
+                format: property.format,
+                dataType: property.dataType,
+                step: property.step,
+                permissions: property.permissions,
+                mapping: this.propertyMappingStorage.get(property.id),
+            })));
+            const mapping = mappings();
+            const isCurrent = () => connection.isCurrent() &&
+                this.delegates.get(id) === delegate &&
+                this.delegateDeviceIds.get(id) === update.device.id &&
+                (this.sampleGenerations.get(id) ?? 0) === generation &&
+                mappings() === mapping;
+            return {
+                physicalIdentity: `${mac}|cover:${Number(update.channel.identifier.split(':')[1])}`,
+                revision: JSON.stringify([id, connection.revision, generation, mapping]),
+                isCurrent,
+                retire: () => delegate.retireCoverSession(update.channel.identifier),
+                begin: () => {
+                    if (!isCurrent())
+                        throw new Error('Cover connection/mapping changed');
+                    return delegate.beginCoverRecoverySession(update.channel.identifier, mac, this.coverOrdering);
+                },
+            };
+        }
+        return null;
+    }
+    async prepareCoverAction(update) {
+        if (!this.coverValues ||
+            !this.coverOrdering ||
+            ![devices_constants_1.PropertyCategory.COMMAND, devices_constants_1.PropertyCategory.POSITION, devices_constants_1.PropertyCategory.TILT].includes(update.property.category) ||
+            (update.property.category === devices_constants_1.PropertyCategory.COMMAND
+                ? !['open', 'close', 'stop'].includes(String(update.value))
+                : typeof update.value !== 'number' ||
+                    !Number.isInteger(update.value) ||
+                    update.value < 0 ||
+                    update.value > 100) ||
+            !/^cover:\d+$/.test(update.channel.identifier ?? ''))
+            return null;
+        const properties = await this.channelsPropertiesService.findAll(update.channel.id);
+        const status = properties.find((property) => property.category === devices_constants_1.PropertyCategory.STATUS);
+        const position = properties.find((property) => property.category === devices_constants_1.PropertyCategory.POSITION);
+        const command = properties.find((property) => property.id === update.property.id);
+        const tilt = properties.find((property) => property.category === devices_constants_1.PropertyCategory.TILT && (0, cover_action_contract_1.nativeCoverPercentage)(property));
+        if (!(0, cover_action_contract_1.configuredCoverType)(properties) ||
+            !status ||
+            !position ||
+            !command ||
+            status.identifier !== 'state' ||
+            status.dataType !== devices_constants_1.DataTypeType.ENUM ||
+            position.identifier !== 'current_pos' ||
+            position.dataType !== devices_constants_1.DataTypeType.UCHAR ||
+            JSON.stringify(position.format) !== '[0,100]' ||
+            (update.property.category === devices_constants_1.PropertyCategory.COMMAND
+                ? command.dataType !== devices_constants_1.DataTypeType.ENUM || JSON.stringify(command.format) !== '["open","close","stop"]'
+                : command.dataType !== devices_constants_1.DataTypeType.UCHAR ||
+                    (0, property_metadata_utils_1.resolvePropertyUnit)(command) !== '%' ||
+                    JSON.stringify(command.format) !== '[0,100]' ||
+                    (command.step != null && command.step !== 1) ||
+                    !command.permissions.includes(devices_constants_1.PermissionType.READ_WRITE) ||
+                    (update.property.category === devices_constants_1.PropertyCategory.POSITION
+                        ? command.id !== position.id
+                        : command.id !== tilt?.id)))
+            return null;
+        if (this.coverValues.readQualifiedSample(status, 300_000)?.nativeCoverTagPresent !== true)
+            return null;
+        for (const id of this.identifierToDelegates.get(update.device.identifier) ?? []) {
+            const delegate = this.delegates.get(id);
+            if (!delegate || this.delegateDeviceIds.get(id) !== update.device.id)
+                continue;
+            const componentId = Number(update.channel.identifier.split(':')[1]);
+            const component = delegate.covers.get(componentId);
+            if (!(0, cover_action_contract_1.nativeCoverStatus)(component, componentId))
+                continue;
+            const slat = component.slat_pos;
+            if (update.property.category === devices_constants_1.PropertyCategory.TILT &&
+                (typeof slat !== 'number' || !Number.isFinite(slat) || slat < 0 || slat > 100))
+                continue;
+            const canonicalMac = update.device.canonicalMac;
+            if (!canonicalMac || (await this.coverOrdering.blocked(`${canonicalMac.toUpperCase()}|cover:${componentId}`)))
+                continue;
+            const recoveryLease = this.coverRecoveryLane?.prepare(`${canonicalMac.toUpperCase()}|cover:${Number(update.channel.identifier.split(':')[1])}`);
+            if (this.coverRecoveryLane && !recoveryLease)
+                continue;
+            const session = delegate.prepareCoverSession(update.channel.identifier, canonicalMac, this.coverOrdering);
+            if (!session?.isReady()) {
+                recoveryLease?.dispose();
+                continue;
+            }
+            const generation = this.sampleGenerations.get(id) ?? 0;
+            const mappings = () => JSON.stringify(properties.map((property) => ({
+                id: property.id,
+                category: property.category,
+                dataType: property.dataType,
+                format: property.format,
+                step: property.step,
+                permissions: property.permissions,
+                identifier: property.identifier,
+                mapping: this.propertyMappingStorage.get(property.id),
+            })));
+            const snapshot = mappings();
+            let disposed = false;
+            const sourceCurrent = () => snapshot === mappings() &&
+                this.delegates.get(id) === delegate &&
+                this.delegateDeviceIds.get(id) === update.device.id &&
+                (this.sampleGenerations.get(id) ?? 0) === generation &&
+                delegate.guardedTransportActive &&
+                update.device.enabled;
+            const isCurrent = () => !disposed && sourceCurrent() && (!recoveryLease || recoveryLease.isCurrent());
+            const action = {
+                kind: 'cover_action',
+                effectScope: `shelly-ng:${canonicalMac.toUpperCase()}|cover:${componentId}`,
+                commandPropertyId: command.id,
+                status,
+                position,
+                ...(update.property.category === devices_constants_1.PropertyCategory.TILT ? { tilt } : {}),
+                effects: properties.filter((property) => [devices_constants_1.PropertyCategory.POSITION, devices_constants_1.PropertyCategory.TILT].includes(property.category)),
+            };
+            return {
+                updates: [update],
+                coverAction: action,
+                isCurrent,
+                dispose: () => {
+                    disposed = true;
+                    recoveryLease?.dispose();
+                },
+                dispatch: async (guard, context) => {
+                    if (!context || !guard() || !isCurrent())
+                        return false;
+                    const current = () => isCurrent() && guard() && context.isCurrent();
+                    const leave = recoveryLease?.enter();
+                    try {
+                        return await session.dispatch(update.property.category === devices_constants_1.PropertyCategory.POSITION
+                            ? { position: update.value }
+                            : update.property.category === devices_constants_1.PropertyCategory.TILT
+                                ? { tilt: update.value }
+                                : update.value, { ...context, isCurrent: current }, async (raw, observedAt, preflightState) => {
+                            if (!current())
+                                return false;
+                            this.coverIssues.delete(`${update.device.id}|${update.channel.id}`);
+                            const acceptanceBoundary = this.coverValues.currentSampleGeneration();
+                            const sample = {
+                                componentKey: update.channel.identifier,
+                                values: raw,
+                                evidence: {
+                                    sampledAt: observedAt,
+                                    observedAt,
+                                    receivedAt: new Date(),
+                                    provenance: 'live',
+                                    isCurrent: current,
+                                    sourceIsCurrent: sourceCurrent,
+                                    commandObservation: context.observationToken,
+                                },
+                            };
+                            await this.admitRawSample(status, raw.state === 'open' ? 'opened' : raw.state, sample);
+                            await this.admitRawSample(position, raw.current_pos, sample);
+                            if (tilt)
+                                await this.admitRawSample(tilt, typeof raw.slat_pos === 'number' &&
+                                    Number.isFinite(raw.slat_pos) &&
+                                    raw.slat_pos >= 0 &&
+                                    raw.slat_pos <= 100
+                                    ? raw.slat_pos
+                                    : null, sample);
+                            const statusSample = this.coverValues.readQualifiedSample(status, 30_000);
+                            const positionSample = this.coverValues.readQualifiedSample(position, 30_000);
+                            if (!current() || !statusSample || !positionSample)
+                                return false;
+                            return context.observe({
+                                state: raw.state,
+                                position: raw.current_pos,
+                                tag: raw.tag,
+                                observedAt,
+                                preflightState,
+                                acceptanceBoundary,
+                                statusAcceptance: statusSample.acceptanceGeneration,
+                                positionAcceptance: positionSample.acceptanceGeneration,
+                                tilt: raw.slat_pos ?? undefined,
+                                tiltAcceptance: tilt
+                                    ? this.coverValues.readQualifiedSample(tilt, 30_000)?.acceptanceGeneration
+                                    : undefined,
+                            });
+                        }, async (raw, observedAt) => {
+                            if (!current())
+                                return;
+                            this.coverIssues.set(`${update.device.id}|${update.channel.id}`, (0, cover_action_contract_1.coverStatusReason)(raw));
+                            const sample = {
+                                componentKey: update.channel.identifier,
+                                values: raw,
+                                evidence: {
+                                    observedAt,
+                                    sampledAt: observedAt,
+                                    receivedAt: new Date(),
+                                    provenance: 'live',
+                                    isCurrent: current,
+                                    sourceIsCurrent: sourceCurrent,
+                                },
+                            };
+                            await this.admitRawSample(status, null, sample);
+                            await this.admitRawSample(position, null, sample);
+                        });
+                    }
+                    finally {
+                        leave?.();
+                    }
+                },
+            };
+        }
+        return null;
+    }
+    async prepareLightingCommand(device, componentKey, on, brightness, properties = []) {
+        const mappings = () => JSON.stringify(properties.map((property) => this.propertyMappingStorage.get(property.id)));
+        const mappingSnapshot = mappings();
+        for (const property of properties) {
+            const mapping = this.propertyMappingStorage.get(property.id);
+            const value = property.identifier === 'output' ? on : brightness;
+            if (mapping && this.applyTransformer(mapping, value, 'write') !== value)
+                return null;
+        }
+        for (const id of this.identifierToDelegates.get(device.identifier) ?? []) {
+            const delegate = this.delegates.get(id);
+            if (!delegate || this.delegateDeviceIds.get(id) !== device.id)
+                continue;
+            const prepared = delegate.prepareLightingCommand(componentKey, on, brightness);
+            if (!prepared)
+                continue;
+            const identifier = device.identifier;
+            const isCurrent = () => mappingSnapshot === mappings() &&
+                device.enabled &&
+                device.identifier === identifier &&
+                this.delegates.get(id) === delegate &&
+                this.delegateDeviceIds.get(id) === device.id &&
+                prepared.isCurrent();
+            const current = await this.devicesService.findOne(device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (!current?.enabled || current.identifier !== identifier || !isCurrent())
+                return null;
+            return { isCurrent, dispatch: (isAdmitted) => prepared.dispatch(() => isCurrent() && isAdmitted()) };
+        }
+        return null;
+    }
     async setChannelValue(device, channel, updates) {
         const handler = this.resolveChannelHandler(device.identifier, channel.id);
         if (!handler) {
@@ -1880,8 +2556,10 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         return fallback;
     }
     async detach() {
+        this.revokeGuardedSessionAdmission();
         const teardownPromises = [];
         for (const [, delegate] of this.delegates.entries()) {
+            teardownPromises.push(this.unbindSamples(delegate));
             const valueHandler = this.delegateValueHandlers.get(delegate.id);
             const connectionHandler = this.delegateConnectionHandlers.get(delegate.id);
             if (valueHandler) {
@@ -2060,6 +2738,10 @@ exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerServ
     __param(8, (0, common_1.Optional)()),
     __param(9, (0, common_1.Optional)()),
     __param(10, (0, common_1.Optional)()),
+    __param(11, (0, common_1.Optional)()),
+    __param(12, (0, common_1.Optional)()),
+    __param(13, (0, common_1.Optional)()),
+    __param(14, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [devices_service_1.DevicesService,
         channels_service_1.ChannelsService,
         channels_properties_service_1.ChannelsPropertiesService,
@@ -2070,6 +2752,10 @@ exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerServ
         mappings_1.TransformerRegistry,
         command_latency_trace_collector_service_1.CommandLatencyTraceCollectorService,
         poll_placement_diagnostics_service_1.PollPlacementDiagnosticsService,
-        channel_input_occurrences_service_1.ChannelInputOccurrencesService])
+        channel_input_occurrences_service_1.ChannelInputOccurrencesService,
+        shelly_sample_sources_service_1.ShellySampleSourcesService,
+        property_value_service_1.PropertyValueService,
+        shelly_cover_ordering_service_1.ShellyCoverOrderingService,
+        shelly_cover_recovery_lane_service_1.ShellyCoverRecoveryLaneService])
 ], DelegatesManagerService);
 //# sourceMappingURL=delegates-manager.service.js.map