@fastybird/smart-panel-backend 1.0.0-beta.3 → 1.1.0-alpha.0

package/dist/plugins/devices-homey/services/homey.service.js

@@ -0,0 +1,1216 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomeyService = void 0;
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const logger_1 = require("../../../common/logger");
+const config_service_1 = require("../../../modules/config/services/config.service");
+const devices_constants_1 = require("../../../modules/devices/devices.constants");
+const devices_entity_1 = require("../../../modules/devices/entities/devices.entity");
+const base_managed_extension_service_1 = require("../../../modules/extensions/services/base-managed-extension.service");
+const devices_homey_constants_1 = require("../devices-homey.constants");
+const homey_connector_error_1 = require("../errors/homey-connector.error");
+const homey_inventory_error_1 = require("../errors/homey-inventory.error");
+const config_model_1 = require("../models/config.model");
+const homey_event_model_1 = require("../models/homey-event.model");
+const status_model_1 = require("../models/status.model");
+const homey_command_value_1 = require("../platforms/homey-command-value");
+const homey_failure_log_limiter_1 = require("./homey-failure-log-limiter");
+const homey_reconnect_backoff_1 = require("./homey-reconnect-backoff");
+const homey_synchronizer_service_1 = require("./homey-synchronizer.service");
+const HOMEY_EVENT_OBSERVATION_REVISION = Symbol('homeyEventObservationRevision');
+let HomeyService = class HomeyService extends base_managed_extension_service_1.BaseManagedExtensionService {
+    constructor(configService, synchronizer, connectorFactory = null) {
+        super();
+        this.configService = configService;
+        this.synchronizer = synchronizer;
+        this.connectorFactory = connectorFactory;
+        this.logger = (0, logger_1.createExtensionLogger)(devices_homey_constants_1.DEVICES_HOMEY_PLUGIN_NAME, 'HomeyService');
+        this.failureLogLimiter = new homey_failure_log_limiter_1.HomeyFailureLogLimiter();
+        this.owner = { kind: 'plugin', type: devices_homey_constants_1.DEVICES_HOMEY_PLUGIN_NAME };
+        this.serviceId = devices_homey_constants_1.DEVICES_HOMEY_CONNECTOR_SERVICE_ID;
+        this.pluginConfig = null;
+        this.lastError = null;
+        this.connectionState = devices_homey_constants_1.HomeyConnectionState.STOPPED;
+        this.healthy = false;
+        this.connector = null;
+        this.unsubscribe = null;
+        this.systemInfo = null;
+        this.lastSystemInfo = null;
+        this.zones = [];
+        this.devices = new Map();
+        this.startupEvents = null;
+        this.generation = 0;
+        this.synchronizationTail = Promise.resolve();
+        this.reconciliationTimer = null;
+        this.reconnectTimer = null;
+        this.reconnectAttempt = 0;
+        this.reconnectCount = 0;
+        this.liveEvents = [];
+        this.liveEventFlush = null;
+        this.lastConnectedAt = null;
+        this.lastInventorySyncAt = null;
+        this.lastEventAt = null;
+        this.lastErrorCategory = null;
+        this.reconciliationCount = 0;
+        this.reconciliationFailureCount = 0;
+        this.lastReconciliationDurationMs = null;
+        this.operationalDiagnostics = {
+            adopted: 0,
+            adoptedDevices: [],
+            missing: 0,
+            unsupported: 0,
+            unavailable: 0,
+        };
+        this.operationalInventoryDeviceIds = new Set();
+        this.operationalAdoptedDeviceOverrides = new Map();
+        this.commandTails = new Map();
+        this.pendingCommandConfirmations = new Map();
+        this.commandCancellationListeners = new Set();
+        this.capabilityCommandRevisions = new Map();
+        this.capabilityObservationRevisions = new Map();
+        this.deviceInventoryRevisions = new Map();
+        this.acceptedCapabilityStates = new Map();
+        this.capabilityObservationRevision = 0;
+        this.capabilityCommandRevision = 0;
+        this.deviceInventoryRevision = 0;
+        this.acceptedCapabilityRevision = 0;
+    }
+    async start() {
+        await this.withLock(async () => {
+            if (this.state === 'started') {
+                return;
+            }
+            await this.cleanupPreviousGeneration();
+            this.state = 'starting';
+            this.pluginConfig = null;
+            this.resetReconnectState();
+            this.resetRuntimeHealth();
+            this.lastError = null;
+            this.healthy = false;
+            this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.CONNECTING, 'service_start');
+            const generation = ++this.generation;
+            try {
+                const config = this.getPluginConfig();
+                const connector = this.createConnector(config);
+                this.connector = connector;
+                await connector.connect();
+                this.recordSuccessfulConnection();
+                const subscriptionFailure = await this.synchronizeStartup(connector, generation, 'startup');
+                this.state = 'started';
+                if (subscriptionFailure) {
+                    this.markRuntimeDegraded(subscriptionFailure, generation);
+                    this.logger.warn('Homey inventory synchronized with event delivery unavailable');
+                }
+                else {
+                    this.markRuntimeHealthy(connector, generation);
+                    this.logger.log('Homey connector started and initial inventory synchronized');
+                }
+            }
+            catch (error) {
+                this.applyFailureState(error, 'Homey service failed to start');
+                const retryable = this.isRetryableFailure(error);
+                const retryGeneration = ++this.generation;
+                await this.cleanupRuntime();
+                if (retryable) {
+                    this.state = 'started';
+                    this.scheduleReconnect(retryGeneration);
+                    this.logger.warn('Homey service startup is unavailable; reconnect scheduled');
+                    return;
+                }
+                this.state = 'error';
+                this.healthy = false;
+                this.logger.error(this.lastError ?? 'Homey service failed to start');
+                throw new Error(this.lastError ?? 'Homey service failed to start');
+            }
+        });
+    }
+    async stop() {
+        await this.withLock(async () => {
+            if (this.state === 'stopped' && !this.hasRuntimeResources()) {
+                return;
+            }
+            this.state = 'stopping';
+            this.generation += 1;
+            this.healthy = false;
+            this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.STOPPED, 'service_stop');
+            const cleaned = await this.cleanupRuntime();
+            this.pluginConfig = null;
+            this.resetReconnectState();
+            if (!cleaned) {
+                this.state = 'error';
+                this.lastError = 'Homey service failed to stop';
+                this.lastErrorCategory = null;
+                this.logger.error(this.lastError);
+                throw new Error(this.lastError);
+            }
+            this.state = 'stopped';
+            this.lastError = null;
+            this.lastErrorCategory = null;
+            this.logger.log('Homey connector stopped');
+        });
+    }
+    onConfigChanged() {
+        if (this.state === 'started' && this.pluginConfig) {
+            const previous = this.pluginConfig;
+            const next = this.configService.getPluginConfig(devices_homey_constants_1.DEVICES_HOMEY_PLUGIN_NAME);
+            const restartRequired = previous.url !== next.url ||
+                previous.apiKey !== next.apiKey ||
+                previous.connectionTimeout !== next.connectionTimeout ||
+                previous.reconciliationInterval !== next.reconciliationInterval;
+            return Promise.resolve({ restartRequired });
+        }
+        this.pluginConfig = null;
+        return Promise.resolve({ restartRequired: false });
+    }
+    isHealthy() {
+        return Promise.resolve(this.healthy && this.state === 'started');
+    }
+    getStatus() {
+        const config = this.getCurrentPluginConfigOrDefault();
+        const status = new status_model_1.HomeyStatusModel();
+        status.serviceState = this.getState();
+        status.connectionState = this.connectionState;
+        status.enabled = config.enabled;
+        status.configured = this.isConfigured(config);
+        status.healthy = this.healthy;
+        status.degraded = this.connectionState === devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING;
+        status.homeyId = this.lastSystemInfo?.id ?? null;
+        status.homeyName = this.lastSystemInfo?.name ?? null;
+        status.homeyVersion = this.lastSystemInfo?.version ?? null;
+        status.lastConnectedAt = this.lastConnectedAt;
+        status.lastInventorySyncAt = this.lastInventorySyncAt;
+        status.lastEventAt = this.lastEventAt;
+        status.lastEventAgeMs = this.calculateLastEventAgeMs();
+        status.adoptedDeviceCount = this.operationalDiagnostics.adopted;
+        status.missingDeviceCount = this.operationalDiagnostics.missing;
+        status.unsupportedDeviceCount = this.operationalDiagnostics.unsupported;
+        status.unavailableDeviceCount = this.operationalDiagnostics.unavailable;
+        status.reconnectCount = this.reconnectCount;
+        status.reconciliationCount = this.reconciliationCount;
+        status.reconciliationFailureCount = this.reconciliationFailureCount;
+        status.lastReconciliationDurationMs = this.lastReconciliationDurationMs;
+        status.lastErrorCategory = this.lastErrorCategory;
+        status.lastError = this.lastError;
+        return status;
+    }
+    getInventorySnapshot() {
+        if (this.state !== 'started' ||
+            this.lastInventorySyncAt === null ||
+            (this.connectionState !== devices_homey_constants_1.HomeyConnectionState.CONNECTED &&
+                this.connectionState !== devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING)) {
+            return null;
+        }
+        return structuredClone([...this.devices.values()]);
+    }
+    onAdoptedDeviceUpserted(device) {
+        if (device.type !== devices_homey_constants_1.DEVICES_HOMEY_TYPE) {
+            return;
+        }
+        this.synchronizer.invalidateIndex();
+        const adoptedDevices = new Map(this.operationalDiagnostics.adoptedDevices.map((adopted) => [adopted.panelDeviceId, adopted.homeyDeviceId]));
+        if (device.enabled && typeof device.identifier === 'string') {
+            adoptedDevices.set(device.id, device.identifier);
+            this.operationalAdoptedDeviceOverrides.set(device.id, device.identifier);
+        }
+        else {
+            adoptedDevices.delete(device.id);
+            this.operationalAdoptedDeviceOverrides.set(device.id, null);
+        }
+        this.recordLocalAdoptedDiagnostics(adoptedDevices);
+    }
+    onAdoptedDeviceDeleted(device) {
+        if (device.type !== devices_homey_constants_1.DEVICES_HOMEY_TYPE) {
+            return;
+        }
+        this.synchronizer.invalidateIndex();
+        const adoptedDevices = new Map(this.operationalDiagnostics.adoptedDevices.map((adopted) => [adopted.panelDeviceId, adopted.homeyDeviceId]));
+        adoptedDevices.delete(device.id);
+        this.operationalAdoptedDeviceOverrides.set(device.id, null);
+        this.recordLocalAdoptedDiagnostics(adoptedDevices);
+    }
+    async executeCapabilityCommand(deviceId, capabilityId, value) {
+        const key = this.commandKey(deviceId, capabilityId);
+        const generation = this.generation;
+        const successful = await this.enqueueCapabilityCommand(key, (retainWrite) => this.executeSerializedCapabilityCommand(key, deviceId, capabilityId, value, generation, retainWrite));
+        if (!successful) {
+            this.logRateLimitedFailure('command', 'warn', 'Homey capability command failed or could not be confirmed', {
+                outcome: 'rejected_or_unconfirmed',
+            });
+        }
+        return successful;
+    }
+    async executeDerivedCapabilityCommand(deviceId, capabilityId, deriveValue) {
+        const key = this.commandKey(deviceId, capabilityId);
+        const generation = this.generation;
+        const successful = await this.enqueueCapabilityCommand(key, (retainWrite) => {
+            const device = this.devices.get(deviceId);
+            const capability = device?.capabilities.find((candidate) => candidate.id === capabilityId);
+            if (device === undefined || !device.available || capability === undefined || capability.available === false) {
+                return Promise.resolve(false);
+            }
+            const value = deriveValue(capability);
+            if (value === undefined) {
+                return Promise.resolve(false);
+            }
+            return this.executeSerializedCapabilityCommand(key, deviceId, capabilityId, value, generation, retainWrite);
+        });
+        if (!successful) {
+            this.logRateLimitedFailure('command', 'warn', 'Homey capability command failed or could not be confirmed', {
+                outcome: 'rejected_or_unconfirmed',
+            });
+        }
+        return successful;
+    }
+    async waitForCapabilityCommandIdle(deviceId, capabilityId) {
+        const key = this.commandKey(deviceId, capabilityId);
+        while (true) {
+            const tail = this.commandTails.get(key);
+            if (tail === undefined) {
+                return;
+            }
+            await tail;
+            if (this.commandTails.get(key) === tail) {
+                return;
+            }
+        }
+    }
+    async getFreshDevice(deviceId) {
+        const connector = this.connector;
+        if (this.state !== 'started' ||
+            connector === null ||
+            (this.connectionState !== devices_homey_constants_1.HomeyConnectionState.CONNECTED &&
+                this.connectionState !== devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING)) {
+            throw new homey_inventory_error_1.HomeyInventoryUnavailableError();
+        }
+        const device = await connector.getDevice(deviceId);
+        return device === null ? null : structuredClone(device);
+    }
+    getPluginConfig() {
+        if (!this.pluginConfig) {
+            this.pluginConfig = this.configService.getPluginConfig(devices_homey_constants_1.DEVICES_HOMEY_PLUGIN_NAME);
+        }
+        return this.pluginConfig;
+    }
+    createConnector(config) {
+        if (!this.isConfigured(config)) {
+            throw new homey_connector_error_1.HomeyConnectorError(homey_connector_error_1.HomeyConnectorErrorCategory.VALIDATION, homey_connector_error_1.HomeyConnectorOperation.CONNECT);
+        }
+        if (!this.connectorFactory) {
+            throw new homey_connector_error_1.HomeyConnectorError(homey_connector_error_1.HomeyConnectorErrorCategory.UNSUPPORTED, homey_connector_error_1.HomeyConnectorOperation.CONNECT);
+        }
+        return this.connectorFactory.create({
+            url: config.url,
+            apiKey: config.apiKey,
+            connectionTimeout: config.connectionTimeout,
+        });
+    }
+    async synchronizeStartup(connector, generation, source) {
+        let subscriptionFailure = null;
+        await this.runInventoryReconciliation(source, async () => {
+            this.systemInfo = await connector.getSystemInfo();
+            this.lastSystemInfo = this.systemInfo;
+            this.zones = await connector.getZones();
+            this.startupEvents = [];
+            try {
+                this.unsubscribe = await connector.subscribe((event) => this.onConnectorEvent(connector, generation, event));
+            }
+            catch (error) {
+                this.startupEvents = null;
+                if (!this.isDegradableSubscriptionFailure(error)) {
+                    throw error;
+                }
+                subscriptionFailure = error;
+            }
+            await this.enqueueSynchronization(async () => {
+                this.replaceDevices(await connector.getDevices());
+                const result = await this.synchronizer.synchronizeSnapshot([...this.devices.values()]);
+                this.recordSynchronizationResult(result);
+                this.recordCapabilityEvidence(result.acceptedCapabilityValues ?? []);
+                await this.refreshOperationalDiagnostics([...this.devices.values()]);
+                if (this.startupEvents) {
+                    await this.reconcileStartupEvents(connector, generation);
+                }
+                this.recordSuccessfulInventorySync(connector, generation);
+            });
+        });
+        return subscriptionFailure;
+    }
+    async reconcileStartupEvents(connector, generation) {
+        let cursor = 0;
+        let pass = 0;
+        while (this.startupEvents && cursor < this.startupEvents.length && pass < 10) {
+            const events = this.startupEvents.slice(cursor);
+            cursor += events.length;
+            pass += 1;
+            await this.reconcileEvents(connector, generation, events, true);
+        }
+        const remainingEvents = this.startupEvents?.slice(cursor) ?? [];
+        this.startupEvents = null;
+        if (remainingEvents.length > 0) {
+            await this.reconcileEvents(connector, generation, remainingEvents, true);
+        }
+    }
+    onConnectorEvent(connector, generation, event) {
+        if (!this.isCurrentGeneration(connector, generation)) {
+            return;
+        }
+        let observedEvent = event;
+        if (event.type === homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED) {
+            const observationRevision = ++this.capabilityObservationRevision;
+            this.capabilityObservationRevisions.set(this.commandKey(event.deviceId, event.capabilityId), observationRevision);
+            observedEvent = { ...event, [HOMEY_EVENT_OBSERVATION_REVISION]: observationRevision };
+        }
+        if (this.startupEvents) {
+            this.startupEvents.push(observedEvent);
+            return;
+        }
+        this.liveEvents.push(observedEvent);
+        if (this.liveEventFlush !== null) {
+            return;
+        }
+        this.liveEventFlush = setImmediate(() => {
+            this.liveEventFlush = null;
+            const events = this.liveEvents;
+            this.liveEvents = [];
+            void this.flushLiveEvents(connector, generation, events);
+        });
+    }
+    flushLiveEvents(connector, generation, events) {
+        return this.enqueueSynchronization(async () => {
+            try {
+                const authoritativeTraffic = await this.reconcileEvents(connector, generation, events);
+                if (authoritativeTraffic) {
+                    this.markRuntimeHealthy(connector, generation);
+                }
+            }
+            catch (error) {
+                if (this.isCurrentGeneration(connector, generation)) {
+                    this.handleRuntimeFailure(error, 'Homey event synchronization failed', generation);
+                    this.logRateLimitedFailure('event-synchronization', 'error', this.lastError ?? 'Homey event synchronization failed', { category: this.lastErrorCategory });
+                }
+            }
+        });
+    }
+    async reconcileEvents(connector, generation, events, authoritativeReadback = false) {
+        if (!this.isCurrentGeneration(connector, generation)) {
+            return false;
+        }
+        const containsZoneEvent = events.some((event) => this.isZoneEvent(event));
+        let inventoryReplaced = false;
+        let authoritativeTraffic = false;
+        if (containsZoneEvent) {
+            const zones = await connector.getZones();
+            const devices = await connector.getDevices();
+            if (!this.isCurrentGeneration(connector, generation)) {
+                return false;
+            }
+            this.zones = zones;
+            this.replaceDevices(devices);
+            inventoryReplaced = true;
+            authoritativeTraffic = true;
+        }
+        const deviceIds = [...new Set(events.flatMap((event) => ('deviceId' in event ? [event.deviceId] : [])))];
+        const refreshedDevices = [];
+        const missingDeviceIds = [];
+        const selectedEvents = inventoryReplaced || authoritativeReadback ? events : this.synchronizer.filterEvents(events);
+        const targetedDeviceIds = new Set(authoritativeReadback
+            ? deviceIds
+            : selectedEvents.flatMap((event) => event.type === homey_event_model_1.HomeyEventType.DEVICE_ADDED || event.type === homey_event_model_1.HomeyEventType.DEVICE_UPDATED
+                ? [event.deviceId]
+                : []));
+        if (!inventoryReplaced) {
+            for (const deviceId of targetedDeviceIds) {
+                const device = await connector.getDevice(deviceId);
+                if (!this.isCurrentGeneration(connector, generation)) {
+                    return false;
+                }
+                authoritativeTraffic = true;
+                if (device) {
+                    this.setDevice(device);
+                    refreshedDevices.push(device);
+                }
+                else {
+                    this.deleteDevice(deviceId);
+                    missingDeviceIds.push(deviceId);
+                }
+            }
+            for (const event of selectedEvents) {
+                if ('deviceId' in event && targetedDeviceIds.has(event.deviceId)) {
+                    continue;
+                }
+                authoritativeTraffic =
+                    (await this.updateInventoryFromEvent(connector, generation, event)) || authoritativeTraffic;
+            }
+        }
+        if (events.length > 0 && this.isCurrentGeneration(connector, generation)) {
+            this.logger.debug('Processing normalized Homey event batch', { eventCount: events.length });
+            const confirmationEvents = [];
+            if (inventoryReplaced) {
+                const result = await this.synchronizer.synchronizeSnapshot([...this.devices.values()], events);
+                this.recordSynchronizationResult(result);
+                this.recordCapabilityEvidence(result.acceptedCapabilityValues ?? []);
+                confirmationEvents.push(...result.acceptedEvents);
+            }
+            else if (targetedDeviceIds.size > 0) {
+                const readbackEvents = selectedEvents.filter((event) => 'deviceId' in event && targetedDeviceIds.has(event.deviceId));
+                const result = await this.synchronizer.synchronizeDevices(refreshedDevices, missingDeviceIds, readbackEvents);
+                this.recordSynchronizationResult(result);
+                this.recordCapabilityEvidence(result.acceptedCapabilityValues ?? []);
+                confirmationEvents.push(...result.acceptedEvents);
+                const remainingEvents = selectedEvents.filter((event) => !('deviceId' in event) || !targetedDeviceIds.has(event.deviceId));
+                if (remainingEvents.length > 0) {
+                    const result = await this.synchronizer.synchronizeEvents(remainingEvents, this.devices);
+                    this.recordSynchronizationResult(result);
+                    confirmationEvents.push(...result.acceptedEvents);
+                }
+            }
+            else if (selectedEvents.length > 0) {
+                const result = await this.synchronizer.synchronizeEvents(selectedEvents, this.devices);
+                this.recordSynchronizationResult(result);
+                confirmationEvents.push(...result.acceptedEvents);
+            }
+            this.lastEventAt = this.now();
+            this.recordAcceptedCapabilityEvents(confirmationEvents, generation);
+            if (events.some((event) => event.type !== homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED)) {
+                await this.refreshOperationalDiagnostics([...this.devices.values()]);
+            }
+        }
+        return authoritativeTraffic;
+    }
+    async updateInventoryFromEvent(connector, generation, event) {
+        switch (event.type) {
+            case homey_event_model_1.HomeyEventType.DEVICE_ADDED:
+            case homey_event_model_1.HomeyEventType.DEVICE_UPDATED: {
+                const device = await connector.getDevice(event.deviceId);
+                if (!this.isCurrentGeneration(connector, generation)) {
+                    return false;
+                }
+                if (device === null) {
+                    this.deleteDevice(event.deviceId);
+                }
+                else {
+                    this.setDevice(device);
+                }
+                return true;
+            }
+            case homey_event_model_1.HomeyEventType.DEVICE_REMOVED:
+                this.deleteDevice(event.deviceId);
+                return false;
+            case homey_event_model_1.HomeyEventType.DEVICE_AVAILABILITY_CHANGED: {
+                const device = this.devices.get(event.deviceId);
+                if (device !== undefined) {
+                    this.setDevice({
+                        ...device,
+                        available: event.available,
+                        availabilityMessage: event.availabilityMessage,
+                    });
+                }
+                return false;
+            }
+            case homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED: {
+                return false;
+            }
+            case homey_event_model_1.HomeyEventType.ZONE_ADDED:
+            case homey_event_model_1.HomeyEventType.ZONE_UPDATED:
+            case homey_event_model_1.HomeyEventType.ZONE_REMOVED:
+                return false;
+        }
+    }
+    isZoneEvent(event) {
+        return (event.type === homey_event_model_1.HomeyEventType.ZONE_ADDED ||
+            event.type === homey_event_model_1.HomeyEventType.ZONE_UPDATED ||
+            event.type === homey_event_model_1.HomeyEventType.ZONE_REMOVED);
+    }
+    replaceDevices(devices) {
+        for (const deviceId of new Set([...this.devices.keys(), ...devices.map((device) => device.id)])) {
+            this.deviceInventoryRevisions.set(deviceId, ++this.deviceInventoryRevision);
+        }
+        this.devices = new Map(devices.map((device) => [device.id, device]));
+    }
+    setDevice(device) {
+        this.devices.set(device.id, device);
+        this.deviceInventoryRevisions.set(device.id, ++this.deviceInventoryRevision);
+    }
+    deleteDevice(deviceId) {
+        if (this.devices.delete(deviceId)) {
+            this.deviceInventoryRevisions.set(deviceId, ++this.deviceInventoryRevision);
+        }
+    }
+    scheduleReconciliation(generation) {
+        this.clearReconciliationTimer();
+        const interval = this.pluginConfig?.reconciliationInterval;
+        if (!interval || (this.reconnectTimer !== null && this.connectionState !== devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING)) {
+            return;
+        }
+        this.reconciliationTimer = setTimeout(() => {
+            this.reconciliationTimer = null;
+            void this.runPeriodicReconciliation(generation);
+        }, interval);
+    }
+    async runPeriodicReconciliation(generation) {
+        const connector = this.connector;
+        if (!connector || !this.isCurrentGeneration(connector, generation) || this.state !== 'started') {
+            return;
+        }
+        await this.enqueueSynchronization(async () => {
+            try {
+                await this.runInventoryReconciliation('periodic', async () => {
+                    const [zonesResult, devicesResult] = await Promise.allSettled([connector.getZones(), connector.getDevices()]);
+                    if (zonesResult.status === 'rejected') {
+                        throw zonesResult.reason;
+                    }
+                    if (devicesResult.status === 'rejected') {
+                        throw devicesResult.reason;
+                    }
+                    if (!this.isCurrentGeneration(connector, generation)) {
+                        return;
+                    }
+                    this.zones = zonesResult.value;
+                    this.replaceDevices(devicesResult.value);
+                    const result = await this.synchronizer.synchronizeSnapshot(devicesResult.value);
+                    this.recordSynchronizationResult(result);
+                    this.recordCapabilityEvidence(result.acceptedCapabilityValues ?? []);
+                    await this.refreshOperationalDiagnostics(devicesResult.value);
+                    this.recordSuccessfulInventorySync(connector, generation);
+                    if (this.unsubscribe) {
+                        this.markRuntimeHealthy(connector, generation);
+                    }
+                    else {
+                        this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING, 'subscription_unavailable');
+                        this.healthy = false;
+                    }
+                });
+            }
+            catch (error) {
+                if (this.isCurrentGeneration(connector, generation)) {
+                    this.handleRuntimeFailure(error, 'Homey inventory reconciliation failed', generation);
+                }
+            }
+        });
+        if (this.isCurrentGeneration(connector, generation) &&
+            this.state === 'started' &&
+            (this.reconnectTimer === null || this.connectionState === devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING)) {
+            this.scheduleReconciliation(generation);
+        }
+    }
+    scheduleReconnect(generation, preserveDegradedPolling = false) {
+        if (this.reconnectTimer || this.state !== 'started' || this.generation !== generation) {
+            return;
+        }
+        if (!preserveDegradedPolling) {
+            this.clearReconciliationTimer();
+            this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.RECONNECTING, 'reconnect_scheduled');
+        }
+        this.healthy = false;
+        const delay = (0, homey_reconnect_backoff_1.calculateHomeyReconnectDelay)(this.reconnectAttempt);
+        this.reconnectAttempt += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.runReconnect(generation);
+        }, delay);
+    }
+    async runReconnect(expectedGeneration) {
+        await this.withLock(async () => {
+            if (this.state !== 'started' || this.generation !== expectedGeneration) {
+                return;
+            }
+            this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.RECONNECTING, 'reconnect_started');
+            this.healthy = false;
+            this.reconnectCount += 1;
+            const generation = ++this.generation;
+            if (!(await this.cleanupRuntime())) {
+                this.lastError = 'Homey connector cleanup failed before reconnect';
+                this.lastErrorCategory = null;
+                this.scheduleReconnect(generation);
+                return;
+            }
+            try {
+                const connector = this.createConnector(this.getPluginConfig());
+                this.connector = connector;
+                await connector.connect();
+                this.recordSuccessfulConnection();
+                const subscriptionFailure = await this.synchronizeStartup(connector, generation, 'reconnect');
+                if (subscriptionFailure) {
+                    this.markRuntimeDegraded(subscriptionFailure, generation);
+                    this.logger.warn('Homey reconnected in degraded polling mode');
+                }
+                else {
+                    this.markRuntimeHealthy(connector, generation);
+                    this.logger.log('Homey connector reconnected and inventory synchronized');
+                }
+            }
+            catch (error) {
+                this.applyFailureState(error, 'Homey service failed to reconnect', devices_homey_constants_1.HomeyConnectionState.RECONNECTING);
+                const retryGeneration = ++this.generation;
+                await this.cleanupRuntime();
+                if (this.isRetryableFailure(error)) {
+                    this.scheduleReconnect(retryGeneration);
+                }
+                this.logRateLimitedFailure('reconnect', 'error', this.lastError ?? 'Homey service failed to reconnect', {
+                    category: this.lastErrorCategory,
+                });
+            }
+        });
+    }
+    enqueueSynchronization(operation) {
+        const result = this.synchronizationTail.then(async () => {
+            await operation();
+        });
+        this.synchronizationTail = this.settleSynchronization(result);
+        return result;
+    }
+    enqueueCapabilityCommand(key, operation) {
+        const previous = this.commandTails.get(key) ?? Promise.resolve();
+        let retainedWrite = Promise.resolve();
+        const result = this.waitForCommandTail(previous, devices_homey_constants_1.HOMEY_COMMAND_WRITE_TIMEOUT_MS).then((ready) => {
+            if (!ready) {
+                return false;
+            }
+            return operation((write) => {
+                retainedWrite = write.then(() => undefined, () => undefined);
+            });
+        });
+        const retainBarrier = () => result.then(() => retainedWrite, () => retainedWrite);
+        const tail = previous.then(retainBarrier, retainBarrier);
+        this.commandTails.set(key, tail);
+        void tail.then(() => {
+            if (this.commandTails.get(key) === tail) {
+                this.commandTails.delete(key);
+            }
+        });
+        return result;
+    }
+    waitForCommandTail(tail, timeoutMs) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const complete = (ready) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                this.commandCancellationListeners.delete(cancel);
+                resolve(ready);
+            };
+            const cancel = () => complete(false);
+            const timer = setTimeout(() => complete(false), timeoutMs);
+            this.commandCancellationListeners.add(cancel);
+            void tail.then(() => complete(true), () => complete(true));
+        });
+    }
+    async executeSerializedCapabilityCommand(key, deviceId, capabilityId, value, expectedGeneration, retainWrite) {
+        if (this.generation !== expectedGeneration) {
+            return false;
+        }
+        const connector = this.connector;
+        const generation = expectedGeneration;
+        if (connector === null ||
+            this.state !== 'started' ||
+            (this.connectionState !== devices_homey_constants_1.HomeyConnectionState.CONNECTED &&
+                this.connectionState !== devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING)) {
+            return false;
+        }
+        const commandRevision = ++this.capabilityCommandRevision;
+        this.capabilityCommandRevisions.set(key, commandRevision);
+        let resolveConfirmation = (_confirmed) => undefined;
+        const confirmation = new Promise((resolve) => {
+            resolveConfirmation = resolve;
+        });
+        const pending = {
+            generation,
+            observationRevision: this.capabilityObservationRevisions.get(key) ?? 0,
+            value,
+            resolve: resolveConfirmation,
+        };
+        this.pendingCommandConfirmations.set(key, pending);
+        try {
+            const writeOperation = connector.setCapabilityValue(deviceId, capabilityId, value);
+            retainWrite(writeOperation);
+            const write = await this.settleWithin(writeOperation, devices_homey_constants_1.HOMEY_COMMAND_WRITE_TIMEOUT_MS);
+            if (write.status !== 'fulfilled' || !this.isCurrentGeneration(connector, generation)) {
+                return false;
+            }
+            const confirmed = await this.settleWithin(confirmation, devices_homey_constants_1.HOMEY_COMMAND_CONFIRMATION_TIMEOUT_MS);
+            if (confirmed.status === 'fulfilled') {
+                return confirmed.value;
+            }
+            if (confirmed.status === 'cancelled' || !this.isCurrentGeneration(connector, generation)) {
+                return false;
+            }
+            this.removePendingCommandConfirmation(key, pending);
+            const observedRevision = this.capabilityObservationRevisions.get(key) ?? 0;
+            const inventoryRevision = this.deviceInventoryRevisions.get(deviceId) ?? 0;
+            const acceptedRevision = this.acceptedCapabilityStates.get(key)?.revision ?? 0;
+            const readback = await this.settleWithin(connector.getDevice(deviceId), devices_homey_constants_1.HOMEY_COMMAND_WRITE_TIMEOUT_MS);
+            if (readback.status !== 'fulfilled' ||
+                readback.value === null ||
+                !readback.value.available ||
+                !this.isCurrentGeneration(connector, generation)) {
+                return false;
+            }
+            const capability = readback.value.capabilities.find((candidate) => candidate.id === capabilityId);
+            if (capability === undefined || !(0, homey_command_value_1.homeyCapabilityValuesEqual)(capability.value, value)) {
+                return false;
+            }
+            const confirmedDevice = readback.value;
+            const readbackEvent = {
+                type: homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED,
+                deviceId,
+                capabilityId,
+                value: capability.value,
+                lastUpdatedAt: capability.lastUpdatedAt,
+                occurredAt: null,
+                sequence: null,
+            };
+            let readbackAccepted = false;
+            const synchronization = this.enqueueSynchronization(async () => {
+                if (!this.isCurrentGeneration(connector, generation) ||
+                    this.capabilityCommandRevisions.get(key) !== commandRevision) {
+                    return;
+                }
+                const currentDevice = this.devices.get(deviceId);
+                if (currentDevice === undefined || !currentDevice.available) {
+                    return;
+                }
+                const hasReadableCapabilityBinding = await this.synchronizer.hasReadableCapabilityBinding(deviceId, capabilityId);
+                if (!hasReadableCapabilityBinding && (this.deviceInventoryRevisions.get(deviceId) ?? 0) !== inventoryRevision) {
+                    return;
+                }
+                const currentAcceptedState = this.acceptedCapabilityStates.get(key);
+                const observationChanged = (this.capabilityObservationRevisions.get(key) ?? 0) !== observedRevision;
+                const acceptanceChanged = (currentAcceptedState?.revision ?? 0) !== acceptedRevision;
+                if (observationChanged || acceptanceChanged) {
+                    readbackAccepted =
+                        acceptanceChanged &&
+                            currentAcceptedState !== undefined &&
+                            (0, homey_command_value_1.homeyCapabilityValuesEqual)(currentAcceptedState.value, value);
+                    return;
+                }
+                if (currentAcceptedState !== undefined && (0, homey_command_value_1.homeyCapabilityValuesEqual)(currentAcceptedState.value, value)) {
+                    readbackAccepted = true;
+                    return;
+                }
+                if (!hasReadableCapabilityBinding) {
+                    readbackAccepted = true;
+                    this.recordAcceptedCapabilityEvents([readbackEvent], generation);
+                    return;
+                }
+                const result = await this.synchronizer.synchronizeEvents([readbackEvent], new Map([[confirmedDevice.id, confirmedDevice]]));
+                this.recordSynchronizationResult(result);
+                readbackAccepted = result.acceptedEvents.includes(readbackEvent);
+                if (readbackAccepted) {
+                    this.recordAcceptedCapabilityEvents(result.acceptedEvents, generation);
+                }
+            });
+            const synchronized = await this.settleWithin(synchronization, devices_homey_constants_1.HOMEY_COMMAND_WRITE_TIMEOUT_MS);
+            if (synchronized.status !== 'fulfilled') {
+                return false;
+            }
+            return readbackAccepted && this.isCurrentGeneration(connector, generation);
+        }
+        finally {
+            this.removePendingCommandConfirmation(key, pending);
+        }
+    }
+    settleWithin(operation, timeoutMs) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const complete = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                this.commandCancellationListeners.delete(cancel);
+                resolve(result);
+            };
+            const cancel = () => complete({ status: 'cancelled' });
+            const timer = setTimeout(() => complete({ status: 'timed_out' }), timeoutMs);
+            this.commandCancellationListeners.add(cancel);
+            void operation.then((value) => complete({ status: 'fulfilled', value }), () => complete({ status: 'rejected' }));
+        });
+    }
+    recordAcceptedCapabilityEvents(events, generation) {
+        for (const event of events) {
+            if (event.type !== homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED) {
+                continue;
+            }
+            const key = this.commandKey(event.deviceId, event.capabilityId);
+            const device = this.devices.get(event.deviceId);
+            if (device !== undefined) {
+                this.setDevice({
+                    ...device,
+                    capabilities: device.capabilities.map((capability) => capability.id === event.capabilityId
+                        ? { ...capability, value: event.value, lastUpdatedAt: event.lastUpdatedAt }
+                        : capability),
+                });
+            }
+            this.acceptedCapabilityStates.set(key, {
+                revision: ++this.acceptedCapabilityRevision,
+                value: event.value,
+            });
+            const pending = this.pendingCommandConfirmations.get(key);
+            const observationRevision = event[HOMEY_EVENT_OBSERVATION_REVISION] ?? 0;
+            if (pending !== undefined &&
+                pending.generation === generation &&
+                observationRevision > pending.observationRevision &&
+                (0, homey_command_value_1.homeyCapabilityValuesEqual)(pending.value, event.value)) {
+                this.pendingCommandConfirmations.delete(key);
+                pending.resolve(true);
+            }
+        }
+    }
+    recordCapabilityEvidence(values) {
+        for (const value of values) {
+            this.acceptedCapabilityStates.set(this.commandKey(value.deviceId, value.capabilityId), {
+                revision: ++this.acceptedCapabilityRevision,
+                value: value.value,
+            });
+        }
+    }
+    removePendingCommandConfirmation(key, pending) {
+        if (this.pendingCommandConfirmations.get(key) === pending) {
+            this.pendingCommandConfirmations.delete(key);
+        }
+    }
+    cancelCommandOperations() {
+        for (const pending of this.pendingCommandConfirmations.values()) {
+            pending.resolve(false);
+        }
+        this.pendingCommandConfirmations.clear();
+        for (const cancel of [...this.commandCancellationListeners]) {
+            cancel();
+        }
+        this.commandCancellationListeners.clear();
+    }
+    commandKey(deviceId, capabilityId) {
+        return `${deviceId}\u0000${capabilityId}`;
+    }
+    async settleSynchronization(operation) {
+        try {
+            await operation;
+        }
+        catch {
+        }
+    }
+    async cleanupPreviousGeneration() {
+        if (!this.hasRuntimeResources()) {
+            return;
+        }
+        this.generation += 1;
+        if (!(await this.cleanupRuntime())) {
+            throw new Error('Homey service could not clean up its previous connector');
+        }
+    }
+    async cleanupRuntime() {
+        this.clearReconciliationTimer();
+        this.clearReconnectTimer();
+        this.clearLiveEventFlush();
+        this.startupEvents = null;
+        this.cancelCommandOperations();
+        const unsubscribe = this.unsubscribe;
+        const connector = this.connector;
+        let unsubscribeSucceeded = true;
+        let disconnectSucceeded = connector === null;
+        if (unsubscribe) {
+            try {
+                await unsubscribe();
+                this.unsubscribe = null;
+            }
+            catch {
+                unsubscribeSucceeded = false;
+            }
+        }
+        await this.synchronizationTail;
+        this.synchronizer.reset();
+        this.capabilityCommandRevisions.clear();
+        this.capabilityObservationRevisions.clear();
+        this.deviceInventoryRevisions.clear();
+        this.acceptedCapabilityStates.clear();
+        if (connector) {
+            try {
+                await connector.disconnect();
+                disconnectSucceeded = true;
+            }
+            catch {
+                disconnectSucceeded = false;
+            }
+        }
+        if (disconnectSucceeded && (unsubscribeSucceeded || connector !== null)) {
+            this.unsubscribe = null;
+            this.connector = null;
+            this.systemInfo = null;
+            this.zones = [];
+            this.devices.clear();
+        }
+        return disconnectSucceeded && (unsubscribeSucceeded || connector !== null);
+    }
+    clearReconciliationTimer() {
+        if (this.reconciliationTimer) {
+            clearTimeout(this.reconciliationTimer);
+            this.reconciliationTimer = null;
+        }
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    clearLiveEventFlush() {
+        if (this.liveEventFlush !== null) {
+            clearImmediate(this.liveEventFlush);
+            this.liveEventFlush = null;
+        }
+        this.liveEvents = [];
+    }
+    hasRuntimeResources() {
+        return (this.connector !== null ||
+            this.unsubscribe !== null ||
+            this.reconciliationTimer !== null ||
+            this.reconnectTimer !== null ||
+            this.liveEventFlush !== null);
+    }
+    recordSynchronizationResult(result) {
+        if (result.failed > 0) {
+            this.logRateLimitedFailure('synchronization-result', 'warn', 'Homey synchronization completed with isolated property failures', {
+                failed: result.failed,
+            });
+        }
+    }
+    recordOperationalDiagnostics(diagnostics) {
+        this.operationalDiagnostics = diagnostics;
+    }
+    async refreshOperationalDiagnostics(devices) {
+        const diagnostics = await this.synchronizer.getOperationalDiagnostics(devices);
+        const upstreamIds = new Set(devices.map((device) => device.id));
+        this.operationalInventoryDeviceIds = upstreamIds;
+        const adoptedDevices = new Map(diagnostics.adoptedDevices.map((adopted) => [adopted.panelDeviceId, adopted.homeyDeviceId]));
+        for (const [panelDeviceId, homeyDeviceId] of this.operationalAdoptedDeviceOverrides) {
+            if (homeyDeviceId === null) {
+                adoptedDevices.delete(panelDeviceId);
+            }
+            else {
+                adoptedDevices.set(panelDeviceId, homeyDeviceId);
+            }
+        }
+        const adopted = [...adoptedDevices].map(([panelDeviceId, homeyDeviceId]) => ({ panelDeviceId, homeyDeviceId }));
+        this.recordOperationalDiagnostics({
+            ...diagnostics,
+            adopted: adopted.length,
+            adoptedDevices: adopted,
+            missing: adopted.filter((device) => !upstreamIds.has(device.homeyDeviceId)).length,
+        });
+    }
+    recordLocalAdoptedDiagnostics(adoptedDevices) {
+        const adopted = [...adoptedDevices].map(([panelDeviceId, homeyDeviceId]) => ({ panelDeviceId, homeyDeviceId }));
+        this.operationalDiagnostics = {
+            ...this.operationalDiagnostics,
+            adopted: adopted.length,
+            adoptedDevices: adopted,
+            missing: adopted.filter((device) => !this.operationalInventoryDeviceIds.has(device.homeyDeviceId)).length,
+        };
+    }
+    async runInventoryReconciliation(source, operation) {
+        const startedAt = Date.now();
+        this.reconciliationCount += 1;
+        try {
+            await operation();
+            this.lastReconciliationDurationMs = Math.max(0, Date.now() - startedAt);
+            this.logger.log('Homey inventory reconciliation completed', {
+                adopted: this.operationalDiagnostics.adopted,
+                count: this.reconciliationCount,
+                deviceCount: this.devices.size,
+                durationMs: this.lastReconciliationDurationMs,
+                failureCount: this.reconciliationFailureCount,
+                missing: this.operationalDiagnostics.missing,
+                source,
+                unavailable: this.operationalDiagnostics.unavailable,
+                unsupported: this.operationalDiagnostics.unsupported,
+            });
+        }
+        catch (error) {
+            this.reconciliationFailureCount += 1;
+            this.lastReconciliationDurationMs = Math.max(0, Date.now() - startedAt);
+            this.logRateLimitedFailure('reconciliation', 'warn', 'Homey inventory reconciliation attempt failed', {
+                count: this.reconciliationCount,
+                durationMs: this.lastReconciliationDurationMs,
+                failureCount: this.reconciliationFailureCount,
+                source,
+            });
+            throw error;
+        }
+    }
+    isCurrentGeneration(connector, generation) {
+        return this.connector === connector && this.generation === generation;
+    }
+    applyFailureState(error, fallback, transientState = devices_homey_constants_1.HomeyConnectionState.ERROR) {
+        this.healthy = false;
+        this.lastErrorCategory = error instanceof homey_connector_error_1.HomeyConnectorError ? error.category : null;
+        if (error instanceof homey_connector_error_1.HomeyConnectorError) {
+            switch (error.category) {
+                case homey_connector_error_1.HomeyConnectorErrorCategory.AUTHENTICATION:
+                case homey_connector_error_1.HomeyConnectorErrorCategory.AUTHORIZATION:
+                    this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.AUTHENTICATION_FAILED, 'authentication_failed');
+                    this.lastError = 'Homey authentication or authorization failed';
+                    this.logRateLimitedFailure('authentication', 'warn', 'Homey reconnect retries suspended until configuration changes', { category: error.category });
+                    return;
+                case homey_connector_error_1.HomeyConnectorErrorCategory.TIMEOUT:
+                case homey_connector_error_1.HomeyConnectorErrorCategory.UNAVAILABLE:
+                    this.transitionConnectionState(transientState, 'transient_failure');
+                    this.lastError = 'Homey connection is temporarily unavailable';
+                    return;
+                default:
+                    this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.ERROR, 'connector_failure');
+                    this.lastError = fallback;
+                    return;
+            }
+        }
+        this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.ERROR, 'unexpected_failure');
+        this.lastError = fallback;
+    }
+    markRuntimeHealthy(connector, generation) {
+        if (!this.isCurrentGeneration(connector, generation)) {
+            return;
+        }
+        const recovered = this.connectionState !== devices_homey_constants_1.HomeyConnectionState.CONNECTED;
+        this.clearReconnectTimer();
+        this.reconnectAttempt = 0;
+        this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.CONNECTED, 'runtime_healthy');
+        this.healthy = true;
+        this.lastError = null;
+        this.lastErrorCategory = null;
+        if (recovered && this.state === 'started') {
+            this.scheduleReconciliation(generation);
+        }
+    }
+    isRetryableFailure(error) {
+        return error instanceof homey_connector_error_1.HomeyConnectorError && error.retryable;
+    }
+    isDegradableSubscriptionFailure(error) {
+        return (error instanceof homey_connector_error_1.HomeyConnectorError &&
+            error.category !== homey_connector_error_1.HomeyConnectorErrorCategory.AUTHENTICATION &&
+            error.category !== homey_connector_error_1.HomeyConnectorErrorCategory.AUTHORIZATION &&
+            error.category !== homey_connector_error_1.HomeyConnectorErrorCategory.VALIDATION);
+    }
+    markRuntimeDegraded(error, generation) {
+        this.transitionConnectionState(devices_homey_constants_1.HomeyConnectionState.DEGRADED_POLLING, 'subscription_unavailable');
+        this.healthy = false;
+        this.lastErrorCategory = error.category;
+        this.lastError = error.retryable
+            ? 'Homey event subscription is temporarily unavailable; polling is active'
+            : 'Homey event subscription is unavailable; polling is active';
+        this.scheduleReconciliation(generation);
+        if (error.retryable) {
+            this.scheduleReconnect(generation, true);
+        }
+    }
+    handleRuntimeFailure(error, fallback, generation) {
+        this.applyFailureState(error, fallback, devices_homey_constants_1.HomeyConnectionState.RECONNECTING);
+        if (this.isRetryableFailure(error)) {
+            this.scheduleReconnect(generation);
+        }
+        else {
+            this.clearReconciliationTimer();
+        }
+    }
+    resetReconnectState() {
+        this.clearReconnectTimer();
+        this.reconnectAttempt = 0;
+    }
+    resetRuntimeHealth() {
+        this.failureLogLimiter.reset();
+        this.lastSystemInfo = null;
+        this.lastConnectedAt = null;
+        this.lastInventorySyncAt = null;
+        this.lastEventAt = null;
+        this.lastErrorCategory = null;
+        this.reconnectCount = 0;
+        this.reconciliationCount = 0;
+        this.reconciliationFailureCount = 0;
+        this.lastReconciliationDurationMs = null;
+        this.operationalDiagnostics = { adopted: 0, adoptedDevices: [], missing: 0, unsupported: 0, unavailable: 0 };
+        this.operationalInventoryDeviceIds.clear();
+        this.operationalAdoptedDeviceOverrides.clear();
+    }
+    recordSuccessfulConnection() {
+        this.lastConnectedAt = this.now();
+    }
+    recordSuccessfulInventorySync(connector, generation) {
+        if (this.isCurrentGeneration(connector, generation)) {
+            this.lastInventorySyncAt = this.now();
+        }
+    }
+    now() {
+        return new Date().toISOString();
+    }
+    calculateLastEventAgeMs() {
+        if (this.lastEventAt === null) {
+            return null;
+        }
+        return Math.max(0, Date.now() - new Date(this.lastEventAt).getTime());
+    }
+    transitionConnectionState(next, reason) {
+        const previous = this.connectionState;
+        if (previous === next) {
+            return;
+        }
+        this.connectionState = next;
+        this.logger.log('Homey connection state changed', { from: previous, reason, to: next });
+    }
+    logRateLimitedFailure(key, level, message, context) {
+        const decision = this.failureLogLimiter.consume(key);
+        if (decision.log) {
+            this.logger[level](message, { ...context, suppressed: decision.suppressed });
+        }
+    }
+    getCurrentPluginConfigOrDefault() {
+        try {
+            return this.configService.getPluginConfig(devices_homey_constants_1.DEVICES_HOMEY_PLUGIN_NAME);
+        }
+        catch {
+            return new config_model_1.HomeyConfigModel();
+        }
+    }
+    isConfigured(config) {
+        return (typeof config.url === 'string' &&
+            config.url.trim().length > 0 &&
+            typeof config.apiKey === 'string' &&
+            config.apiKey.trim().length > 0);
+    }
+};
+exports.HomeyService = HomeyService;
+__decorate([
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_CREATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_UPDATED),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [devices_entity_1.DeviceEntity]),
+    __metadata("design:returntype", void 0)
+], HomeyService.prototype, "onAdoptedDeviceUpserted", null);
+__decorate([
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_DELETED),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [devices_entity_1.DeviceEntity]),
+    __metadata("design:returntype", void 0)
+], HomeyService.prototype, "onAdoptedDeviceDeleted", null);
+exports.HomeyService = HomeyService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)(devices_homey_constants_1.HOMEY_CONNECTOR_FACTORY)),
+    __metadata("design:paramtypes", [config_service_1.ConfigService,
+        homey_synchronizer_service_1.HomeySynchronizerService, Object])
+], HomeyService);
+//# sourceMappingURL=homey.service.js.map