@fastybird/smart-panel-backend 1.1.0-alpha.64 → 1.1.0-alpha.66

package/dist/plugins/devices-virtual/services/native-thermostat.service.js

@@ -0,0 +1,932 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeThermostatService = void 0;
+const class_transformer_1 = require("class-transformer");
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
+const devices_constants_1 = require("../../../modules/devices/devices.constants");
+const devices_exceptions_1 = require("../../../modules/devices/devices.exceptions");
+const devices_entity_1 = require("../../../modules/devices/entities/devices.entity");
+const device_creation_context_1 = require("../../../modules/devices/services/device-creation-context");
+const device_structure_lock_service_1 = require("../../../modules/devices/services/device-structure-lock.service");
+const devices_service_1 = require("../../../modules/devices/services/devices.service");
+const platform_registry_service_1 = require("../../../modules/devices/services/platform.registry.service");
+const property_command_admission_registry_service_1 = require("../../../modules/devices/services/property-command-admission.registry.service");
+const property_producer_registry_service_1 = require("../../../modules/devices/services/property-producer.registry.service");
+const property_value_service_1 = require("../../../modules/devices/services/property-value.service");
+const schema_utils_1 = require("../../../modules/devices/utils/schema.utils");
+const create_device_dto_1 = require("../dto/create-device.dto");
+const native_thermostat_dto_1 = require("../dto/native-thermostat.dto");
+const devices_virtual_entity_1 = require("../entities/devices-virtual.entity");
+const native_thermostat_entity_1 = require("../entities/native-thermostat.entity");
+const virtual_thermostat_entity_1 = require("../entities/virtual-thermostat.entity");
+const virtual_dependency_graph_service_1 = require("./virtual-dependency-graph.service");
+const fail = (reason) => {
+    throw new devices_exceptions_1.DevicesValidationException(reason);
+};
+let NativeThermostatService = class NativeThermostatService {
+    constructor(database, lock, graph, devices, platforms, admission, values, producers) {
+        this.database = database;
+        this.lock = lock;
+        this.graph = graph;
+        this.devices = devices;
+        this.platforms = platforms;
+        this.admission = admission;
+        this.values = values;
+        this.producers = producers;
+        this.reservations = [];
+        this.ready = false;
+        this.destroyed = false;
+        this.units = new Map();
+        this.epoch = 0;
+        this.refreshing = false;
+        this.leases = new Map();
+        this.generations = new Map();
+        this.requestedPublications = new Map();
+        this.work = new Set();
+        this.observations = new Map();
+        this.attempts = new Map();
+        this.releaseOwners = new Map();
+        this.pendingReleaseAdmissions = new Map();
+        this.originalRequests = new Map();
+    }
+    async onApplicationBootstrap() {
+        if (process.env.FB_CLI === 'on' || this.stop !== undefined || this.destroyed)
+            return;
+        this.stop = this.admission.register({
+            capture: () => {
+                const epoch = this.epoch;
+                return {
+                    isCurrent: () => this.ready && epoch === this.epoch,
+                    assertAllowed: (update) => this.assertAllowed(update),
+                };
+            },
+            requiresGuardedDispatch: (update) => this.requiresGuardedDispatch(update),
+            assertAllowed: (update) => this.assertAllowed(update),
+        });
+        await this.lock.runExclusive(async () => {
+            await this.database.manager.update(native_thermostat_entity_1.NativeThermostatRequestEntity, { state: 'pending' }, { state: 'interrupted' });
+            const releasing = await this.database.manager.findBy(native_thermostat_entity_1.NativeThermostatEntity, { bindingState: 'releasing' });
+            if (releasing.length)
+                await this.graph.withStructuralWrite(async (manager) => {
+                    for (const row of releasing) {
+                        if (!Number.isSafeInteger(row.revision) || row.revision >= Number.MAX_SAFE_INTEGER)
+                            fail('Native release recovery revision is invalid.');
+                        const result = await manager.update(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: row.controllerId, revision: row.revision, bindingState: 'releasing' }, { bindingState: 'released', revision: row.revision + 1 });
+                        if (result.affected !== 1)
+                            fail('Native release recovery owner changed.');
+                    }
+                });
+            await this.reload();
+        });
+        this.timer = setInterval(() => {
+            void this.refresh().catch(() => undefined);
+        }, 1000);
+        this.timer.unref();
+        await this.refresh();
+    }
+    async onModuleDestroy() {
+        this.destroyed = true;
+        this.units.clear();
+        this.ready = false;
+        this.epoch++;
+        this.stop?.();
+        if (this.timer)
+            clearInterval(this.timer);
+        for (const lease of this.leases.values())
+            this.producers.unregister(lease);
+        this.leases.clear();
+        await Promise.allSettled([...this.work]);
+    }
+    onCatalogChanged(entity) {
+        if (entity.id)
+            this.units.delete(entity.id);
+        for (const row of this.reservations) {
+            if (entity.id !== row.controllerId &&
+                entity.id !== row.sourceDeviceId &&
+                !row.ownedPropertyIds.includes(entity.id ?? '') &&
+                !Object.values(row.propertyIds).includes(entity.id ?? ''))
+                continue;
+            this.epoch++;
+            this.generations.set(row.controllerId, (this.generations.get(row.controllerId) ?? 0) + 1);
+            for (const id of Object.values(row.propertyIds)) {
+                const lease = this.leases.get(id);
+                if (lease)
+                    this.producers.invalidate(lease, ['native_catalog_changed']);
+                this.observations.delete(id);
+            }
+        }
+    }
+    reserved(propertyId) {
+        return this.reservations.some((row) => row.ownedPropertyIds.includes(propertyId));
+    }
+    requiresGuardedDispatch(update) {
+        if (this.reserved(update.property.id))
+            return true;
+        const modeOrSetpoint = [devices_constants_1.ChannelCategory.THERMOSTAT, devices_constants_1.ChannelCategory.HEATER, devices_constants_1.ChannelCategory.COOLER].includes(update.channel.category) &&
+            [devices_constants_1.PropertyCategory.MODE, devices_constants_1.PropertyCategory.ON, devices_constants_1.PropertyCategory.TEMPERATURE].includes(update.property.category);
+        return (modeOrSetpoint &&
+            this.reservations.some((row) => row.sourceDeviceId === update.device.id ||
+                this.units.get(update.device.id)?.physicalIdentity === row.physicalIdentity));
+    }
+    async assertAllowed(update) {
+        let native = this.units.get(update.device.id);
+        if (!native?.isCurrent())
+            native = await this.platforms.get(update.device)?.captureNativeClimateUnit?.(update.device);
+        const reservedCanonical = native &&
+            this.reservations.some((row) => row.physicalIdentity === native.physicalIdentity && native.ownedPropertyIds.includes(update.property.id));
+        if (!this.ready || this.requiresGuardedDispatch(update) || reservedCanonical)
+            fail('Native thermostat mode/setpoint bundle is reserved; use its controller.');
+    }
+    async reload() {
+        this.reservations = await this.database.manager.find(native_thermostat_entity_1.NativeThermostatEntity, {
+            where: { bindingState: (0, typeorm_1.Not)('released') },
+        });
+        this.ready = !this.destroyed;
+        this.epoch++;
+    }
+    async capture(id, manager = this.database.manager, fresh = false) {
+        const device = await manager.findOneBy(devices_entity_1.DeviceEntity, { id });
+        if (!device || !device.enabled)
+            fail('Native source device is missing or disabled.');
+        if (this.destroyed)
+            fail('Native runtime is stopped.');
+        let unit = fresh ? null : this.units.get(id);
+        if (!unit?.isCurrent())
+            unit = await this.platforms.get(device)?.captureNativeClimateUnit?.(device);
+        if (!unit || !unit.isCurrent())
+            fail('Source is not a supported current canonical native climate unit.');
+        this.units.set(id, unit);
+        return unit;
+    }
+    conflictsWithBinding(row, unit, controllerId) {
+        return (row.bindingState !== 'released' &&
+            row.controllerId !== controllerId &&
+            (row.physicalIdentity === unit.physicalIdentity ||
+                row.sourceDeviceId === unit.deviceId ||
+                row.ownedPropertyIds.some((id) => unit.ownedPropertyIds.includes(id))));
+    }
+    async candidates() {
+        return this.lock.runShared(async () => {
+            const result = [];
+            for (const device of await this.database.manager.find(devices_entity_1.DeviceEntity)) {
+                if (!device.enabled)
+                    continue;
+                let unit;
+                try {
+                    unit = await this.capture(device.id);
+                }
+                catch {
+                    continue;
+                }
+                result.push({
+                    device: device.id,
+                    name: device.name,
+                    provider: unit.provider,
+                    physical_identity: unit.physicalIdentity,
+                    fingerprint: unit.fingerprint,
+                    capabilities: unit.capabilities,
+                    reasons: this.reservations.some((row) => this.conflictsWithBinding(row, unit)) ? ['reserved'] : [],
+                });
+            }
+            return result;
+        });
+    }
+    async preview(dto) {
+        return this.lock.runShared(async () => {
+            const unit = await this.capture(dto.sourceDevice);
+            await this.assertUnbound(this.database.manager, unit);
+            return {
+                controller: null,
+                binding_state: 'bound',
+                control_strategy: 'native_unit',
+                revision: 0,
+                source_device: unit.deviceId,
+                provider: unit.provider,
+                physical_identity: unit.physicalIdentity,
+                fingerprint: unit.fingerprint,
+                requested: {},
+                drift: [],
+                observed: unit.observe(),
+                capabilities: unit.capabilities,
+                properties: {},
+                latest_request: null,
+            };
+        });
+    }
+    async assertUnbound(manager, unit, controllerId) {
+        for (const row of await manager.find(native_thermostat_entity_1.NativeThermostatEntity))
+            if (this.conflictsWithBinding(row, unit, controllerId))
+                fail('Native unit is already reserved.');
+        if (controllerId && (await manager.existsBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId })))
+            fail('Guarded branches and native units are mutually exclusive.');
+    }
+    async create(dto) {
+        return this.lock.runExclusive(async () => {
+            const unit = await this.capture(dto.sourceDevice);
+            const id = (0, uuid_1.v4)();
+            const propertyIds = {};
+            await device_creation_context_1.DeviceCreationContext.run((work) => this.graph.withStructuralWrite(work, dto.expectedGraphRevision), 'virtual', async (context) => {
+                await this.assertUnbound(context.manager, unit, id);
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(context.manager, () => unit.isCurrent());
+                await this.devices.create((0, class_transformer_1.plainToInstance)(create_device_dto_1.CreateVirtualDeviceDto, {
+                    id,
+                    type: 'virtual',
+                    category: devices_constants_1.DeviceCategory.THERMOSTAT,
+                    mode: devices_virtual_entity_1.VirtualDeviceMode.CLIMATE_CONTROLLER,
+                    name: dto.name,
+                    room_id: dto.room,
+                }), context);
+                const add = async (category, fields) => {
+                    const channel = await context.manager.save(devices_virtual_entity_1.VirtualChannelEntity, context.manager.create(devices_virtual_entity_1.VirtualChannelEntity, {
+                        id: (0, uuid_1.v4)(),
+                        device: { id },
+                        name: category,
+                        category,
+                    }));
+                    for (const [key, propertyCategory, dataType, writable] of fields) {
+                        const metadata = (0, schema_utils_1.getPropertyMetadata)(category, propertyCategory);
+                        const limits = key === 'heating_setpoint'
+                            ? unit.capabilities.heating
+                            : key === 'cooling_setpoint'
+                                ? unit.capabilities.cooling
+                                : null;
+                        propertyIds[key] = (0, uuid_1.v4)();
+                        await context.manager.save(devices_virtual_entity_1.VirtualChannelPropertyEntity, context.manager.create(devices_virtual_entity_1.VirtualChannelPropertyEntity, {
+                            id: propertyIds[key],
+                            channel,
+                            name: key,
+                            category: propertyCategory,
+                            dataType: metadata?.data_type ?? dataType,
+                            permissions: [writable ? devices_constants_1.PermissionType.READ_WRITE : devices_constants_1.PermissionType.READ_ONLY],
+                            valueOrigin: devices_virtual_entity_1.VirtualValueOrigin.LOCAL,
+                            sourcePropertyId: null,
+                            format: key === 'mode'
+                                ? [...unit.capabilities.modes]
+                                : limits
+                                    ? [limits.minimum, limits.maximum]
+                                    : (metadata?.format ?? null),
+                            step: limits?.step ?? metadata?.step ?? null,
+                        }));
+                    }
+                };
+                await add(devices_constants_1.ChannelCategory.THERMOSTAT, [
+                    ['mode', devices_constants_1.PropertyCategory.MODE, devices_constants_1.DataTypeType.ENUM, true],
+                    ['locked', devices_constants_1.PropertyCategory.LOCKED, devices_constants_1.DataTypeType.BOOL, false],
+                ]);
+                await add(devices_constants_1.ChannelCategory.TEMPERATURE, [
+                    ['temperature', devices_constants_1.PropertyCategory.TEMPERATURE, devices_constants_1.DataTypeType.FLOAT, false],
+                ]);
+                for (const [kind, category] of [
+                    ['heating', devices_constants_1.ChannelCategory.HEATER],
+                    ['cooling', devices_constants_1.ChannelCategory.COOLER],
+                ]) {
+                    if (!unit.capabilities[kind])
+                        continue;
+                    await add(category, [
+                        [`${kind}_enabled`, devices_constants_1.PropertyCategory.ON, devices_constants_1.DataTypeType.BOOL, true],
+                        [`${kind}_setpoint`, devices_constants_1.PropertyCategory.TEMPERATURE, devices_constants_1.DataTypeType.FLOAT, true],
+                        [`${kind}_activity`, devices_constants_1.PropertyCategory.STATUS, devices_constants_1.DataTypeType.BOOL, false],
+                    ]);
+                }
+                await context.manager.insert(native_thermostat_entity_1.NativeThermostatEntity, {
+                    controllerId: id,
+                    sourceDeviceId: unit.deviceId,
+                    physicalIdentity: unit.physicalIdentity,
+                    fingerprint: unit.fingerprint,
+                    provider: unit.provider,
+                    bindingState: 'bound',
+                    revision: 1,
+                    requested: {},
+                    propertyIds,
+                    ownedPropertyIds: [...unit.ownedPropertyIds],
+                    latestRequestId: null,
+                });
+                return id;
+            }, () => this.reload());
+            return this.get(id);
+        });
+    }
+    async get(id) {
+        return this.lock.runShared(async () => {
+            const row = await this.database.manager.findOneBy(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+            if (!row)
+                return null;
+            let unit = null;
+            if (row.bindingState === 'bound') {
+                try {
+                    unit = await this.capture(row.sourceDeviceId);
+                }
+                catch {
+                }
+            }
+            if (unit?.fingerprint !== row.fingerprint || unit?.physicalIdentity !== row.physicalIdentity)
+                unit = null;
+            const observed = unit?.observe() ?? {
+                available: false,
+                temperature: null,
+                mode: null,
+                heatingSetpoint: null,
+                coolingSetpoint: null,
+                activity: null,
+                observedAt: null,
+                reasons: ['binding_unavailable'],
+            };
+            const drift = [];
+            if (observed.available) {
+                if (row.requested.mode !== undefined && observed.mode !== null && row.requested.mode !== observed.mode)
+                    drift.push('mode');
+                for (const [field, code, range] of [
+                    ['heatingSetpoint', 'heating_setpoint', unit?.capabilities.heating],
+                    ['coolingSetpoint', 'cooling_setpoint', unit?.capabilities.cooling],
+                ]) {
+                    const requested = row.requested[field];
+                    const actual = observed[field];
+                    if (requested !== undefined &&
+                        actual !== null &&
+                        Math.abs(requested - actual) > Math.max((range?.step ?? 0) / 2, 1e-6))
+                        drift.push(code);
+                }
+            }
+            const latest = row.latestRequestId
+                ? await this.database.manager.findOneBy(native_thermostat_entity_1.NativeThermostatRequestEntity, { id: row.latestRequestId })
+                : null;
+            return {
+                controller: id,
+                binding_state: row.bindingState,
+                control_strategy: 'native_unit',
+                revision: row.revision,
+                source_device: row.sourceDeviceId,
+                provider: row.provider,
+                physical_identity: row.physicalIdentity,
+                fingerprint: row.fingerprint,
+                requested: row.requested,
+                observed,
+                drift,
+                capabilities: unit?.capabilities ?? null,
+                properties: row.propertyIds,
+                latest_request: latest
+                    ? {
+                        id: latest.id,
+                        revision: latest.revision,
+                        state: latest.state,
+                        request: latest.request,
+                        operations: latest.operations,
+                        created_at: latest.createdAt.toISOString(),
+                    }
+                    : null,
+            };
+        });
+    }
+    async syncPropertyContracts(manager, row, unit) {
+        const contracts = [
+            {
+                key: 'mode',
+                channel: devices_constants_1.ChannelCategory.THERMOSTAT,
+                category: devices_constants_1.PropertyCategory.MODE,
+                dataType: devices_constants_1.DataTypeType.ENUM,
+                format: [...unit.capabilities.modes],
+                step: null,
+            },
+        ];
+        for (const [branch, channel] of [
+            ['heating', devices_constants_1.ChannelCategory.HEATER],
+            ['cooling', devices_constants_1.ChannelCategory.COOLER],
+        ]) {
+            const range = unit.capabilities[branch];
+            if (range)
+                contracts.push({
+                    key: `${branch}_setpoint`,
+                    channel,
+                    category: devices_constants_1.PropertyCategory.TEMPERATURE,
+                    dataType: devices_constants_1.DataTypeType.FLOAT,
+                    format: [range.minimum, range.maximum],
+                    step: range.step,
+                });
+        }
+        for (const contract of contracts) {
+            const propertyId = row.propertyIds[contract.key];
+            if (!propertyId)
+                fail('Native controller property changed; repair its original local contract first.');
+            const property = await manager.findOne(devices_virtual_entity_1.VirtualChannelPropertyEntity, {
+                where: {
+                    id: propertyId,
+                    category: contract.category,
+                    channel: { category: contract.channel, device: { id: row.controllerId } },
+                },
+            });
+            if (!property ||
+                property.valueOrigin !== devices_virtual_entity_1.VirtualValueOrigin.LOCAL ||
+                property.sourcePropertyId ||
+                property.dataType !== contract.dataType)
+                fail('Native controller property changed; repair its original local contract first.');
+            await manager.update(devices_virtual_entity_1.VirtualChannelPropertyEntity, { id: propertyId }, { format: contract.format, step: contract.step });
+        }
+    }
+    async update(id, dto) {
+        await this.lock.runExclusive(async () => {
+            const unit = await this.capture(dto.sourceDevice, this.database.manager, true);
+            await this.graph.withStructuralWrite(async (manager) => {
+                const row = await manager.findOneByOrFail(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+                if (row.revision !== dto.expectedRevision)
+                    fail('Native thermostat revision changed.');
+                if (row.bindingState !== 'bound' || this.releaseOwners.has(id))
+                    fail('Native binding is not bound.');
+                await this.assertUnbound(manager, unit, id);
+                if (!!row.propertyIds.heating_setpoint !== !!unit.capabilities.heating ||
+                    !!row.propertyIds.cooling_setpoint !== !!unit.capabilities.cooling)
+                    fail('Changed heating/cooling topology requires a new controller.');
+                if (row.sourceDeviceId !== unit.deviceId || row.physicalIdentity !== unit.physicalIdentity)
+                    fail('Native binding identity is immutable; create another controller to use another physical unit.');
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => unit.isCurrent() && !this.releaseOwners.has(id));
+                await this.syncPropertyContracts(manager, row, unit);
+                await manager.update(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id, revision: row.revision }, {
+                    revision: row.revision + 1,
+                    fingerprint: unit.fingerprint,
+                    ownedPropertyIds: [...unit.ownedPropertyIds],
+                });
+                this.generations.set(id, (this.generations.get(id) ?? 0) + 1);
+            });
+            await this.reload();
+        });
+        return this.get(id);
+    }
+    async request(id, dto) {
+        dto = Object.freeze({
+            requestId: dto.requestId,
+            expectedRevision: dto.expectedRevision,
+            mode: dto.mode,
+            heatingSetpoint: dto.heatingSetpoint,
+            coolingSetpoint: dto.coolingSetpoint,
+        });
+        const intent = JSON.stringify({
+            mode: dto.mode,
+            heatingSetpoint: dto.heatingSetpoint,
+            coolingSetpoint: dto.coolingSetpoint,
+        });
+        const original = this.originalRequests.get(dto.requestId);
+        if (original) {
+            if (original.controller !== id || original.intent !== intent)
+                fail('Request id was already used for another intent.');
+            return original.result;
+        }
+        let settle;
+        const completion = new Promise((resolve) => {
+            settle = resolve;
+        });
+        const group = this.attempts.get(id) ?? new Set();
+        this.attempts.set(id, group);
+        group.add(completion);
+        this.work.add(completion);
+        const issued = (async () => {
+            try {
+                return await this.requestOwned(id, dto);
+            }
+            finally {
+                settle();
+                group.delete(completion);
+                this.work.delete(completion);
+                this.originalRequests.delete(dto.requestId);
+                if (!group.size && this.attempts.get(id) === group)
+                    this.attempts.delete(id);
+            }
+        })();
+        this.originalRequests.set(dto.requestId, { controller: id, intent, result: issued });
+        return issued;
+    }
+    async requestOwned(id, dto) {
+        if (!this.ready || this.destroyed)
+            fail('Native runtime is not ready.');
+        const pendingRelease = this.pendingReleaseAdmissions.get(id);
+        if (pendingRelease !== undefined) {
+            if (pendingRelease.isOriginalOwner?.())
+                fail('Native release admission is still being decided.');
+            await pendingRelease.decision;
+        }
+        if (!this.ready || this.destroyed)
+            fail('Native runtime is not ready.');
+        if (this.releaseOwners.has(id))
+            fail('Native binding is not bound.');
+        const request = Object.fromEntries(Object.entries({
+            mode: dto.mode,
+            heatingSetpoint: dto.heatingSetpoint,
+            coolingSetpoint: dto.coolingSetpoint,
+        }).filter(([, value]) => value !== undefined));
+        let execute;
+        let releaseAdmission;
+        await this.lock.runExclusive(async () => {
+            const pending = this.pendingReleaseAdmissions.get(id);
+            if (pending?.isOriginalOwner?.())
+                fail('Native release admission is still being decided.');
+            releaseAdmission = pending?.decision;
+            if (releaseAdmission !== undefined)
+                return;
+            const previous = await this.database.manager.findOneBy(native_thermostat_entity_1.NativeThermostatRequestEntity, { id: dto.requestId });
+            if (previous) {
+                if (previous.controllerId !== id || JSON.stringify(previous.request) !== JSON.stringify(request))
+                    fail('Request id was already used for another intent.');
+                return;
+            }
+            const row = await this.database.manager.findOneByOrFail(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+            if (row.bindingState !== 'bound' || this.releaseOwners.has(id))
+                fail('Native binding is not bound.');
+            const owner = await this.database.manager.findOneBy(devices_entity_1.DeviceEntity, { id });
+            if (!owner?.enabled)
+                fail('Native controller is disabled or missing.');
+            if (dto.expectedRevision !== row.revision)
+                fail('Native thermostat revision changed.');
+            const unit = await this.capture(row.sourceDeviceId);
+            if (unit.fingerprint !== row.fingerprint || unit.physicalIdentity !== row.physicalIdentity)
+                fail('Native binding changed; explicitly revalidate first.');
+            const prepared = unit.prepare(request);
+            if (!Object.keys(request).length || !prepared?.isCurrent())
+                fail('Unsupported native climate request or combination.');
+            const revision = row.revision + 1;
+            const generation = (this.generations.get(id) ?? 0) + 1;
+            await this.graph.withStructuralWrite(async (manager) => {
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => unit.isCurrent() && prepared.isCurrent() && !this.releaseOwners.has(id) && this.ready);
+                await manager.insert(native_thermostat_entity_1.NativeThermostatRequestEntity, {
+                    id: dto.requestId,
+                    controllerId: id,
+                    revision,
+                    request,
+                    operations: [],
+                    state: 'pending',
+                    createdAt: new Date(),
+                });
+                await manager.update(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id, revision: row.revision }, {
+                    revision,
+                    requested: { ...row.requested, ...request },
+                    latestRequestId: dto.requestId,
+                });
+            });
+            this.generations.set(id, generation);
+            await this.reload();
+            const current = () => this.ready &&
+                !this.releaseOwners.has(id) &&
+                this.generations.get(id) === generation &&
+                unit.isCurrent() &&
+                prepared.isCurrent();
+            execute = async () => {
+                const admitted = async () => this.lock.runShared(async () => {
+                    const liveOwner = await this.database.manager.findOneBy(devices_entity_1.DeviceEntity, { id });
+                    const live = await this.database.manager.findOneBy(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+                    return (!!liveOwner?.enabled &&
+                        live?.bindingState === 'bound' &&
+                        live.revision === revision &&
+                        live.latestRequestId === dto.requestId &&
+                        current());
+                });
+                let operations;
+                try {
+                    operations = (await admitted())
+                        ? await prepared.dispatch(current)
+                        : [
+                            {
+                                operation: 'request',
+                                outcome: 'refused',
+                                reason: 'request_superseded',
+                                confirmed: false,
+                            },
+                        ];
+                }
+                catch {
+                    operations = [
+                        { operation: 'request', outcome: 'unknown', reason: 'transport_error', confirmed: false },
+                    ];
+                }
+                await this.lock.runExclusive(() => this.graph.withStructuralWrite(async (manager) => {
+                    await manager.update(native_thermostat_entity_1.NativeThermostatRequestEntity, { id: dto.requestId, controllerId: id, revision, state: 'pending' }, { operations: [...operations], state: 'settled' });
+                }));
+            };
+        });
+        if (releaseAdmission !== undefined) {
+            await releaseAdmission;
+            return this.requestOwned(id, dto);
+        }
+        if (execute) {
+            const issued = execute();
+            this.work.add(issued);
+            try {
+                await issued;
+            }
+            finally {
+                this.work.delete(issued);
+            }
+        }
+        await this.refresh();
+        return this.get(id);
+    }
+    async release(id, dto) {
+        if (this.destroyed || !this.ready)
+            fail('Native runtime is stopped.');
+        if (this.releaseOwners.has(id) || this.pendingReleaseAdmissions.has(id))
+            fail('Native binding release is already in progress.');
+        const expectedRevision = dto.expectedRevision;
+        const token = Object.freeze({});
+        let decide;
+        const admission = new Promise((resolve) => {
+            decide = resolve;
+        });
+        const pending = { decision: admission };
+        this.pendingReleaseAdmissions.set(id, pending);
+        const completeAdmission = () => {
+            if (this.pendingReleaseAdmissions.get(id) === pending)
+                this.pendingReleaseAdmissions.delete(id);
+            decide();
+        };
+        const originalAttempts = [...(this.attempts.get(id) ?? [])];
+        let settle;
+        const completion = new Promise((resolve) => {
+            settle = resolve;
+        });
+        this.work.add(completion);
+        try {
+            const revision = await this.lock.runExclusive(() => {
+                pending.isOriginalOwner = this.lock.captureExclusiveOwner();
+                return this.graph.withStructuralWrite(async (manager) => {
+                    try {
+                        const row = await manager.findOneByOrFail(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+                        if (row.revision !== expectedRevision)
+                            fail('Native thermostat revision changed.');
+                        if (row.bindingState === 'released')
+                            return null;
+                        this.releaseOwners.set(id, token);
+                        const next = row.revision + 1;
+                        await manager.update(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id, revision: row.revision, bindingState: row.bindingState }, { bindingState: 'releasing', revision: next });
+                        return next;
+                    }
+                    finally {
+                        if (this.releaseOwners.get(id) !== token)
+                            completeAdmission();
+                    }
+                });
+            });
+            if (revision !== null) {
+                this.generations.set(id, (this.generations.get(id) ?? 0) + 1);
+                this.epoch++;
+            }
+            completeAdmission();
+            await Promise.allSettled(originalAttempts);
+            if (revision !== null)
+                await this.lock.runExclusive(async () => {
+                    await this.graph.withStructuralWrite(async (manager) => {
+                        const row = await manager.findOneByOrFail(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+                        if (this.releaseOwners.get(id) !== token || row.revision !== revision || row.bindingState !== 'releasing')
+                            fail('Native binding release owner changed.');
+                        await manager.update(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id, revision, bindingState: 'releasing' }, { bindingState: 'released', revision: revision + 1 });
+                    });
+                    for (const propertyId of Object.values(this.reservations.find((row) => row.controllerId === id)?.propertyIds ?? {})) {
+                        const lease = this.leases.get(propertyId);
+                        if (lease)
+                            this.producers.unregister(lease);
+                        this.leases.delete(propertyId);
+                    }
+                    await this.reload();
+                });
+            return this.get(id);
+        }
+        finally {
+            if (this.releaseOwners.get(id) === token)
+                this.releaseOwners.delete(id);
+            completeAdmission();
+            settle();
+            this.work.delete(completion);
+        }
+    }
+    async isRegisteredSetting(property, manager) {
+        if (property.valueOrigin !== devices_virtual_entity_1.VirtualValueOrigin.LOCAL || property.sourcePropertyId)
+            return false;
+        return (await manager.find(native_thermostat_entity_1.NativeThermostatEntity)).some((row) => ['mode', 'heating_setpoint', 'cooling_setpoint', 'heating_enabled', 'cooling_enabled'].some((key) => row.propertyIds[key] === property.id));
+    }
+    async ownsController(id) {
+        return this.database.manager.existsBy(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+    }
+    async command(updates) {
+        return this.commandSettings(updates.map((entry) => ({ deviceId: entry.device.id, propertyId: entry.property.id, value: entry.value })));
+    }
+    async commandSettings(input) {
+        const updates = input.map((entry) => Object.freeze({ deviceId: entry.deviceId, propertyId: entry.propertyId, value: entry.value }));
+        if (!updates.length)
+            return true;
+        const id = updates[0].deviceId;
+        const row = await this.database.manager.findOneBy(native_thermostat_entity_1.NativeThermostatEntity, { controllerId: id });
+        if (!row ||
+            row.bindingState !== 'bound' ||
+            this.releaseOwners.has(id) ||
+            updates.some((entry) => entry.deviceId !== id))
+            return false;
+        const request = new native_thermostat_dto_1.RequestNativeThermostatDto();
+        request.requestId = (0, uuid_1.v4)();
+        request.expectedRevision = row.revision;
+        const seen = new Set();
+        let modeControl = false;
+        for (const update of updates) {
+            const key = Object.keys(row.propertyIds).find((key) => row.propertyIds[key] === update.propertyId);
+            if (!key || seen.has(key))
+                return false;
+            seen.add(key);
+            if (key === 'mode') {
+                if (modeControl)
+                    return false;
+                modeControl = true;
+                request.mode = update.value;
+            }
+            else if (key === 'heating_enabled' || key === 'cooling_enabled') {
+                if (typeof update.value !== 'boolean' || modeControl)
+                    return false;
+                modeControl = true;
+                const branch = key === 'heating_enabled' ? 'heat' : 'cool';
+                const opposite = branch === 'heat' ? 'cool' : 'heat';
+                if (update.value)
+                    request.mode = branch;
+                else if (row.requested.mode === opposite)
+                    continue;
+                else
+                    request.mode = row.requested.mode === 'auto' ? opposite : 'off';
+            }
+            else if (key === 'heating_setpoint')
+                request.heatingSetpoint = update.value;
+            else if (key === 'cooling_setpoint')
+                request.coolingSetpoint = update.value;
+            else
+                return false;
+        }
+        if (request.mode === undefined && request.heatingSetpoint === undefined && request.coolingSetpoint === undefined)
+            return true;
+        try {
+            await this.request(id, request);
+            const original = await this.database.manager.findOneBy(native_thermostat_entity_1.NativeThermostatRequestEntity, { id: request.requestId });
+            return (original?.state === 'settled' &&
+                original.operations.length > 0 &&
+                original.operations.every((operation) => operation.outcome === 'accepted'));
+        }
+        catch (error) {
+            if (error instanceof devices_exceptions_1.DevicesValidationException)
+                return false;
+            throw error;
+        }
+    }
+    async refresh() {
+        const issued = this.refreshOwned();
+        this.work.add(issued);
+        try {
+            await issued;
+        }
+        finally {
+            this.work.delete(issued);
+        }
+    }
+    async refreshOwned() {
+        if (!this.ready || this.refreshing)
+            return;
+        this.refreshing = true;
+        try {
+            await this.lock.runShared(async () => {
+                for (const row of this.reservations) {
+                    if (row.bindingState !== 'bound' || this.releaseOwners.has(row.controllerId))
+                        continue;
+                    const generation = this.generations.get(row.controllerId) ?? 0;
+                    let unit = null;
+                    try {
+                        unit = await this.capture(row.sourceDeviceId);
+                    }
+                    catch {
+                    }
+                    const owner = await this.database.manager.findOneBy(devices_entity_1.DeviceEntity, { id: row.controllerId });
+                    const observed = unit?.observe() ?? {
+                        available: false,
+                        temperature: null,
+                        mode: null,
+                        heatingSetpoint: null,
+                        coolingSetpoint: null,
+                        activity: null,
+                        observedAt: null,
+                        reasons: ['native_source_unavailable'],
+                        isCurrent: () => false,
+                    };
+                    const feedbackCurrent = () => this.ready &&
+                        !!owner?.enabled &&
+                        !!unit?.isCurrent() &&
+                        observed?.isCurrent?.() === true &&
+                        unit.fingerprint === row.fingerprint &&
+                        unit.physicalIdentity === row.physicalIdentity &&
+                        (this.generations.get(row.controllerId) ?? 0) === generation;
+                    for (const [key, propertyId] of Object.entries(row.propertyIds)) {
+                        const property = await this.database.manager.findOneBy(devices_virtual_entity_1.VirtualChannelPropertyEntity, {
+                            id: propertyId,
+                            channel: { device: { id: row.controllerId } },
+                            valueOrigin: devices_virtual_entity_1.VirtualValueOrigin.LOCAL,
+                        });
+                        if (!property || property.sourcePropertyId) {
+                            const previous = this.leases.get(propertyId);
+                            if (previous)
+                                this.producers.unregister(previous);
+                            this.leases.delete(propertyId);
+                            this.observations.delete(propertyId);
+                            this.requestedPublications.delete(propertyId);
+                            continue;
+                        }
+                        if (key === 'mode' || key === 'locked' || key.endsWith('_setpoint') || key.endsWith('_enabled')) {
+                            const field = key === 'mode' ? 'mode' : key === 'heating_setpoint' ? 'heatingSetpoint' : 'coolingSetpoint';
+                            const value = key === 'locked'
+                                ? false
+                                : key.endsWith('_enabled')
+                                    ? row.requested.mode === undefined
+                                        ? undefined
+                                        : row.requested.mode === (key === 'heating_enabled' ? 'heat' : 'cool') ||
+                                            row.requested.mode === 'auto'
+                                    : row.requested[field];
+                            if (value !== undefined &&
+                                this.ready &&
+                                !!owner?.enabled &&
+                                !this.releaseOwners.has(row.controllerId) &&
+                                (this.generations.get(row.controllerId) ?? 0) === generation &&
+                                this.requestedPublications.get(propertyId) !== row.revision) {
+                                let written = false;
+                                try {
+                                    written = await this.values.write(property, value);
+                                }
+                                catch {
+                                }
+                                if (written &&
+                                    this.ready &&
+                                    !this.releaseOwners.has(row.controllerId) &&
+                                    (this.generations.get(row.controllerId) ?? 0) === generation)
+                                    this.requestedPublications.set(propertyId, row.revision);
+                            }
+                            continue;
+                        }
+                        let lease = this.leases.get(propertyId);
+                        if (!lease || lease.revision !== row.revision || !this.producers.isAvailable(lease)) {
+                            lease = this.producers.register(property, row.revision, {
+                                isCurrent: feedbackCurrent,
+                                reason: 'native_feedback_expired',
+                            });
+                            this.leases.set(propertyId, lease);
+                        }
+                        const value = key === 'temperature'
+                            ? observed.temperature
+                            : observed.activity === null
+                                ? null
+                                : observed.activity === (key === 'heating_activity' ? 'heating' : 'cooling');
+                        if (!feedbackCurrent() || !observed.available || !observed.observedAt || value === null) {
+                            this.producers.invalidate(lease, observed.reasons.length ? [...observed.reasons] : ['native_feedback_unavailable']);
+                            continue;
+                        }
+                        const sampledAt = new Date(observed.observedAt);
+                        const observationKey = JSON.stringify([row.revision, observed.observedAt, value]);
+                        if (this.observations.get(propertyId) === observationKey && this.producers.isAvailable(lease))
+                            continue;
+                        const publication = await this.values.publishDerived(property, lease, value, {
+                            quality: 'good',
+                            reasons: [],
+                            sampledAt,
+                            evaluatedAt: new Date(),
+                            expiresAt: new Date(sampledAt.getTime() + 30_000),
+                        });
+                        if (publication.state)
+                            this.observations.set(propertyId, observationKey);
+                    }
+                }
+            });
+        }
+        finally {
+            this.refreshing = false;
+        }
+    }
+};
+exports.NativeThermostatService = NativeThermostatService;
+__decorate([
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_UPDATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_DELETED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_PROPERTY_UPDATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_PROPERTY_DELETED),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], NativeThermostatService.prototype, "onCatalogChanged", null);
+exports.NativeThermostatService = NativeThermostatService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        device_structure_lock_service_1.DeviceStructureLockService,
+        virtual_dependency_graph_service_1.VirtualDependencyGraphService,
+        devices_service_1.DevicesService,
+        platform_registry_service_1.PlatformRegistryService,
+        property_command_admission_registry_service_1.PropertyCommandAdmissionRegistryService,
+        property_value_service_1.PropertyValueService,
+        property_producer_registry_service_1.PropertyProducerRegistryService])
+], NativeThermostatService);
+//# sourceMappingURL=native-thermostat.service.js.map