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

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

@@ -0,0 +1,1171 @@
+"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.VirtualThermostatConfigService = exports.THERMOSTAT_CONFIG_CHANGED = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+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 controller_publication_context_1 = require("../../../modules/devices/services/controller-publication-context");
+const creation_capture_1 = require("../../../modules/devices/services/creation-capture");
+const device_structure_lock_service_1 = require("../../../modules/devices/services/device-structure-lock.service");
+const property_value_service_1 = require("../../../modules/devices/services/property-value.service");
+const property_permissions_utils_1 = require("../../../modules/devices/utils/property-permissions.utils");
+const devices_shelly_ng_entity_1 = require("../../devices-shelly-ng/entities/devices-shelly-ng.entity");
+const remote_dew_point_lease_contract_1 = require("../../devices-shelly-ng/services/remote-dew-point-lease.contract");
+const thermostat_actuation_contract_1 = require("../contracts/thermostat-actuation.contract");
+const devices_virtual_entity_1 = require("../entities/devices-virtual.entity");
+const native_thermostat_entity_1 = require("../entities/native-thermostat.entity");
+const thermostat_cooling_dependency_entity_1 = require("../entities/thermostat-cooling-dependency.entity");
+const thermostat_member_protection_entity_1 = require("../entities/thermostat-member-protection.entity");
+const virtual_thermostat_entity_1 = require("../entities/virtual-thermostat.entity");
+const virtual_transform_entity_1 = require("../entities/virtual-transform.entity");
+const virtual_thermostat_ownership_subscriber_1 = require("../subscribers/virtual-thermostat-ownership.subscriber");
+const native_thermostat_service_1 = require("./native-thermostat.service");
+const thermostat_comfort_selection_1 = require("./thermostat-comfort-selection");
+const thermostat_controller_mutation_1 = require("./thermostat-controller-mutation");
+const thermostat_cooling_dependency_service_1 = require("./thermostat-cooling-dependency.service");
+const thermostat_protection_source_utils_1 = require("./thermostat-protection-source.utils");
+const virtual_dependency_graph_service_1 = require("./virtual-dependency-graph.service");
+const virtual_numeric_transform_utils_1 = require("./virtual-numeric-transform.utils");
+const virtual_source_eligibility_utils_1 = require("./virtual-source-eligibility.utils");
+const virtual_thermostat_automation_service_1 = require("./virtual-thermostat-automation.service");
+const virtual_thermostat_claims_service_1 = require("./virtual-thermostat-claims.service");
+const virtual_thermostat_comfort_utils_1 = require("./virtual-thermostat-comfort.utils");
+const virtual_thermostat_contract_utils_1 = require("./virtual-thermostat-contract.utils");
+const virtual_thermostat_policy_utils_1 = require("./virtual-thermostat-policy.utils");
+const virtual_transform_contract_utils_1 = require("./virtual-transform-contract.utils");
+const virtual_transform_resolver_1 = require("./virtual-transform-resolver");
+const virtual_window_trend_utils_1 = require("./virtual-window-trend.utils");
+exports.THERMOSTAT_CONFIG_CHANGED = 'devices-virtual.thermostat.config.changed';
+const fail = (message) => {
+    throw new devices_exceptions_1.DevicesValidationException(message);
+};
+let VirtualThermostatConfigService = class VirtualThermostatConfigService {
+    constructor(dataSource, structureLock, graph, claims, events, values, resolver = new virtual_transform_resolver_1.VirtualTransformResolver(), automation, native) {
+        this.dataSource = dataSource;
+        this.structureLock = structureLock;
+        this.graph = graph;
+        this.claims = claims;
+        this.events = events;
+        this.values = values;
+        this.resolver = resolver;
+        this.automation = automation;
+        this.native = native;
+    }
+    onModuleInit() {
+        if (process.env.FB_CLI === 'on')
+            return;
+        const publication = (0, creation_capture_1.captureCreation)(this, ['afterCommit']);
+        this.stopAutomationPublication = this.automation?.registerPublication((id) => publication.values.afterCommit.call(publication.receiver, id));
+    }
+    onModuleDestroy() {
+        this.stopAutomationPublication?.();
+        this.stopAutomationPublication = undefined;
+    }
+    coolingDependencies() {
+        return new thermostat_cooling_dependency_service_1.ThermostatCoolingDependencyService(this.dataSource, this.values, this.claims);
+    }
+    async configure(controllerId, dto) {
+        return controller_publication_context_1.ControllerPublicationContext.complete(async () => {
+            const release = this.claims.holdRecoveryFence();
+            this.claims.revokeAllQualifications();
+            this.events.emit(exports.THERMOSTAT_CONFIG_CHANGED, controllerId);
+            let input;
+            let predecessors;
+            let captureFailure;
+            let ownerCurrent = () => false;
+            let noop;
+            try {
+                noop = virtual_thermostat_ownership_subscriber_1.VirtualThermostatOwnershipSubscriber.captureNoopFence(this.dataSource, () => ownerCurrent());
+                predecessors = this.automation?.beginMutation(controllerId);
+                void predecessors?.catch(() => undefined);
+                input = (0, creation_capture_1.snapshotCreation)(dto);
+            }
+            catch (cause) {
+                captureFailure = { cause };
+            }
+            try {
+                try {
+                    if (predecessors !== undefined)
+                        await predecessors;
+                }
+                catch (cause) {
+                    captureFailure ??= { cause };
+                }
+                return await this.structureLock.runExclusive(controller_publication_context_1.ControllerPublicationContext.captureCallback(async () => {
+                    if (captureFailure)
+                        throw captureFailure.cause;
+                    ownerCurrent = this.structureLock.captureExclusiveOwner();
+                    let receipt;
+                    let ready = false;
+                    let unchanged = false;
+                    const write = async (manager, advanceGraph) => {
+                        const slot = await this.automation?.captureManualSlot(manager, controllerId);
+                        const owned = await this.automation?.captureManualBaseline(manager, controllerId, 0);
+                        const before = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, controllerId);
+                        const edges = (0, creation_capture_1.captureCreation)(this.graph, ['edges']);
+                        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => edges.current());
+                        const bindings = await (0, thermostat_controller_mutation_1.captureControllerBindings)(manager, controllerId, before, [
+                            ...(Array.isArray(input.sources) ? input.sources.map((source) => source?.sourcePropertyId) : []),
+                            ...(Array.isArray(input.settings) ? input.settings.map((setting) => setting?.propertyId) : []),
+                            ...(Array.isArray(input.actuators)
+                                ? input.actuators.flatMap((actuator) => [
+                                    actuator?.sourcePropertyId,
+                                    actuator?.protection?.sourcePropertyId,
+                                    actuator?.coolingProtection?.dewPointPropertyId,
+                                    actuator?.coolingProtection?.surfacePropertyId,
+                                ])
+                                : []),
+                        ], () => edges.values.edges.call(edges.receiver, manager));
+                        const prepared = (0, creation_capture_1.snapshotCreation)(await this.prepare(manager, controllerId, input));
+                        if (owned && prepared.config.comfort)
+                            prepared.config.comfort.automation_baseline = null;
+                        await bindings();
+                        await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, controllerId, before);
+                        unchanged =
+                            (!slot?.facts || (!['LIVE', 'PROVISIONAL'].includes(slot.facts.state) && slot.facts.manualHold)) &&
+                                (0, thermostat_controller_mutation_1.controllerConfigurationUnchanged)(manager, before, prepared, input.sources.map((source) => source.id));
+                        if (unchanged) {
+                            await this.automation?.captureUnchangedAuthority(manager, controllerId);
+                            await this.graph.sealControllerLedger(manager);
+                            noop.arm();
+                            ready = true;
+                            return;
+                        }
+                        for (const row of [
+                            prepared.config,
+                            ...prepared.actuators,
+                            ...prepared.protections,
+                            ...prepared.coolingDependencies,
+                        ])
+                            if (!Number.isSafeInteger(row.revision) || row.revision < 1)
+                                fail('Thermostat configuration counter overflow.');
+                        const graphRevision = await advanceGraph();
+                        const expected = await this.persist(manager, controllerId, prepared, before);
+                        await bindings(expected.properties, manager, graphRevision);
+                        await this.automation?.manualFence(manager, controllerId, true, slot);
+                        await this.graph.sealControllerLedger(manager);
+                        noop.applied();
+                        ready = true;
+                    };
+                    await this.graph.withControllerMutationWrite(write, input.expectedGraphRevision, (manager) => {
+                        receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+                        noop.admit(manager);
+                        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => ready && ownerCurrent());
+                    }, () => {
+                        if (receipt.outcome !== 'committed')
+                            fail('Missing original native configuration acknowledgement.');
+                    }, write, noop);
+                    return unchanged ? this.get(controllerId) : this.afterCommit(controllerId);
+                }));
+            }
+            finally {
+                noop?.close();
+                release();
+                await this.claims.refresh().catch(() => undefined);
+            }
+        });
+    }
+    prepare(manager, controllerId, dto, draft) {
+        return this.validate(manager, controllerId, dto, draft);
+    }
+    async captureCreationPredecessor(controllerId) {
+        return this.automation ? this.automation.captureCreationPredecessor(controllerId) : () => Promise.resolve();
+    }
+    async captureCreation(manager, controllerId, predecessor) {
+        return this.automation
+            ? this.automation.captureCreation(manager, controllerId, predecessor)
+            : { finish: () => Promise.resolve() };
+    }
+    async persist(manager, controllerId, prepared, before, creation) {
+        if (before && creation)
+            for (const claim of prepared.actuators)
+                claim.qualificationGeneration = (0, uuid_1.v4)();
+        const expected = before ? { ...before } : undefined;
+        if (expected) {
+            expected.configuration = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'configuration', before.configuration, [
+                prepared.config,
+            ]);
+            expected.sources = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'sources', before.sources, prepared.sources);
+        }
+        else {
+            await manager.save(prepared.config);
+            await manager.delete(virtual_thermostat_entity_1.VirtualThermostatSourceEntity, { controllerId });
+            await manager.save(prepared.sources);
+        }
+        if (expected) {
+            expected.properties = await (0, thermostat_controller_mutation_1.writeControllerSettingPermissions)(manager, before, prepared.settings);
+        }
+        else {
+            const oldSettings = await manager.findBy(virtual_thermostat_entity_1.VirtualThermostatSettingEntity, { controllerId });
+            for (const setting of oldSettings)
+                if (!prepared.settings.some((row) => row.propertyId === setting.propertyId))
+                    await manager.update(devices_virtual_entity_1.VirtualChannelPropertyEntity, { id: setting.propertyId }, { permissions: [devices_constants_1.PermissionType.READ_ONLY] });
+            for (const setting of prepared.settings)
+                await manager.update(devices_virtual_entity_1.VirtualChannelPropertyEntity, { id: setting.propertyId }, { permissions: [devices_constants_1.PermissionType.READ_WRITE] });
+        }
+        if (expected) {
+            expected.settings = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'settings', before.settings, prepared.settings);
+            expected.claims = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'claims', before.claims, prepared.actuators, true);
+            expected.protections = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'protections', before.protections, prepared.protections, true);
+            expected.cooling = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'cooling', before.cooling, prepared.coolingDependencies, true);
+            await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, controllerId, expected);
+        }
+        else {
+            await manager.delete(virtual_thermostat_entity_1.VirtualThermostatSettingEntity, { controllerId });
+            await manager.save(prepared.settings);
+            await manager.save(prepared.actuators);
+            await manager.save(thermostat_member_protection_entity_1.ThermostatMemberProtectionEntity, prepared.protections);
+            if (prepared.coolingDependencies.length)
+                await manager.save(thermostat_cooling_dependency_entity_1.ThermostatCoolingDependencyEntity, prepared.coolingDependencies);
+            if (!creation)
+                await this.automation?.initializeCreated(manager, controllerId);
+        }
+        if (creation)
+            await creation();
+        return expected;
+    }
+    async describe(prepared) {
+        return this.model(prepared.config, prepared.sources, prepared.actuators, prepared.settings, undefined, prepared.protections, prepared.coolingDependencies);
+    }
+    async snapshot(manager, controllerId) {
+        const config = await manager.findOneByOrFail(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId });
+        const [sources, actuators, settings] = await Promise.all([
+            manager.findBy(virtual_thermostat_entity_1.VirtualThermostatSourceEntity, { controllerId }),
+            manager.findBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, { controllerId, state: (0, typeorm_1.Not)('released') }),
+            manager.findBy(virtual_thermostat_entity_1.VirtualThermostatSettingEntity, { controllerId }),
+        ]);
+        return this.model(config, sources, actuators, settings, manager);
+    }
+    async afterCommit(controllerId) {
+        const own = (0, creation_capture_1.captureCreation)(this, ['get', 'property']);
+        const get = Reflect.get(own.values, 'get');
+        const property = Reflect.get(own.values, 'property');
+        const manager = this.dataSource.manager;
+        const claims = (0, creation_capture_1.captureCreation)(this.claims, ['invalidate', 'refresh']);
+        const values = (0, creation_capture_1.captureCreation)(this.values, ['write', 'readLatest']);
+        const events = (0, creation_capture_1.captureCreation)(this.events, ['emit']);
+        const graphCurrent = this.graph.capturePublishGuard();
+        const publication = new controller_publication_context_1.ControllerPublicationContext(() => graphCurrent() && own.current() && claims.current() && values.current() && events.current());
+        return publication.run(async () => {
+            claims.values.invalidate.call(claims.receiver);
+            const current = await (0, creation_capture_1.invokeCreation)(get, this, controllerId);
+            for (const setting of current.settings) {
+                const target = await (0, creation_capture_1.invokeCreation)(property, this, manager, setting.property);
+                const value = setting.setting === 'heating_setpoint'
+                    ? current.policy.heatingSetpoint
+                    : setting.setting === 'cooling_setpoint'
+                        ? current.policy.coolingSetpoint
+                        : setting.setting === 'locked'
+                            ? current.locked
+                            : setting.setting === 'heating_enabled'
+                                ? ['heat', 'auto'].includes(current.requested_mode)
+                                : ['cool', 'auto'].includes(current.requested_mode);
+                await values.values.write.call(values.receiver, target.property, value);
+                target.property.value = await values.values.readLatest.call(values.receiver, target.property);
+                events.values.emit.call(events.receiver, devices_constants_1.EventType.CHANNEL_PROPERTY_UPDATED, target.property);
+            }
+            await claims.values.refresh.call(claims.receiver).catch(() => undefined);
+            events.values.emit.call(events.receiver, exports.THERMOSTAT_CONFIG_CHANGED, controllerId);
+            return current;
+        });
+    }
+    async preview(controllerId, dto) {
+        return this.structureLock.runExclusive(async () => {
+            if (dto.expectedGraphRevision !== undefined && dto.expectedGraphRevision !== (await this.graph.revision()))
+                fail('Virtual graph revision changed.');
+            const prepared = await this.prepare(this.dataSource.manager, controllerId, dto);
+            return this.describe(prepared);
+        });
+    }
+    async get(controllerId) {
+        return this.structureLock.runShared(async () => {
+            const manager = this.dataSource.manager;
+            const config = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId });
+            if (!config)
+                throw new common_1.NotFoundException('Thermostat configuration does not exist.');
+            const [sources, actuators, settings] = await Promise.all([
+                manager.findBy(virtual_thermostat_entity_1.VirtualThermostatSourceEntity, { controllerId }),
+                manager.findBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, { controllerId, state: (0, typeorm_1.Not)('released') }),
+                manager.findBy(virtual_thermostat_entity_1.VirtualThermostatSettingEntity, { controllerId }),
+            ]);
+            return this.model(config, sources, actuators, settings);
+        });
+    }
+    async requestRelease(controllerId, expectedRevision) {
+        const entryClaims = (0, creation_capture_1.captureCreation)(this.claims, ['holdRecoveryFence', 'revokeAllQualifications', 'refresh']);
+        const events = (0, creation_capture_1.captureCreation)(this.events, ['emit']);
+        const exclusiveLock = (0, creation_capture_1.captureCreation)(this.structureLock, ['runExclusive']);
+        const exclusive = exclusiveLock.values.runExclusive;
+        const read = (0, creation_capture_1.captureCreation)(this, ['get']);
+        const get = Reflect.get(read.values, 'get'), configChanged = exports.THERMOSTAT_CONFIG_CHANGED;
+        let ownerCurrent = () => false;
+        const captured = (() => {
+            try {
+                const lock = (0, creation_capture_1.captureCreation)(exclusiveLock.receiver, [
+                    'runShared',
+                    'hasCurrentStructuralLease',
+                    'context',
+                ]);
+                const own = (0, creation_capture_1.captureCreation)(this, [
+                    'requestRelease',
+                    'dataSource',
+                    'structureLock',
+                    'graph',
+                    'claims',
+                    'events',
+                    'get',
+                ]);
+                const claims = (0, creation_capture_1.captureCreation)(entryClaims.receiver, ['invalidate']);
+                const graph = (0, creation_capture_1.captureCreation)(this.graph, [
+                    'withComfortSelectionWrite',
+                    'sealControllerLedger',
+                    'structuralWrite',
+                    'refreshValidation',
+                    'dataSource',
+                    'revision',
+                ]);
+                const helper = (0, creation_capture_1.captureCreation)(thermostat_comfort_selection_1.thermostatComfortSelection, ['pin']);
+                const selection = helper.values.pin(this.dataSource, 'release-request');
+                const input = selection.releaseInput(controllerId, expectedRevision);
+                const pins = [own, entryClaims, claims, events, exclusiveLock, lock, graph, helper, selection];
+                const current = () => pins.every((pin) => pin.current());
+                const check = () => {
+                    if (!current())
+                        fail('Original thermostat release dispatch expired.');
+                };
+                const operation = selection.operation(input, () => ownerCurrent(), current, true);
+                return { value: { lock, graph, claims, input, operation, check } };
+            }
+            catch (cause) {
+                return { failure: Object.freeze({ cause }) };
+            }
+        })();
+        const release = entryClaims.values.holdRecoveryFence.call(entryClaims.receiver);
+        entryClaims.values.revokeAllQualifications.call(entryClaims.receiver);
+        events.values.emit.call(events.receiver, configChanged, controllerId);
+        try {
+            const predecessors = !captured.failure ? this.automation?.beginMutation(controllerId) : undefined;
+            if (predecessors !== undefined)
+                await predecessors;
+            return await (0, creation_capture_1.invokeCreation)(exclusive, exclusiveLock.receiver, async () => {
+                if (captured.failure)
+                    throw captured.failure.cause;
+                const { lock, graph, claims, input, operation, check } = captured.value;
+                check();
+                ownerCurrent = node_async_hooks_1.AsyncLocalStorage.bind(() => lock.values.hasCurrentStructuralLease.call(lock.receiver));
+                try {
+                    await graph.values.withComfortSelectionWrite.call(graph.receiver, async (manager) => {
+                        const slot = await this.automation?.captureManualSlot(manager, controllerId);
+                        const owned = await this.automation?.captureInstalledIntent(manager, controllerId);
+                        const result = await operation.write(manager, owned ?? undefined);
+                        await this.automation?.manualFence(manager, controllerId, true, slot);
+                        await graph.values.sealControllerLedger.call(graph.receiver, manager);
+                        operation.markReady();
+                        return result;
+                    }, undefined, operation.admit, operation.accepted, 'release-request');
+                    operation.accepted();
+                }
+                catch (cause) {
+                    operation.settlement.transactionFailure = Object.freeze({ cause });
+                    throw cause;
+                }
+                let stage = 'claims.invalidate';
+                try {
+                    claims.values.invalidate.call(claims.receiver);
+                    stage = 'claims.refresh';
+                    await entryClaims.values.refresh.call(entryClaims.receiver);
+                    stage = 'configChanged';
+                    events.values.emit.call(events.receiver, configChanged, input.id);
+                    stage = 'get';
+                    return await (0, creation_capture_1.invokeCreation)(get, read.receiver, input.id);
+                }
+                catch (cause) {
+                    operation.settlement.maintenanceFailure = Object.freeze({ stage, cause });
+                    throw cause;
+                }
+            });
+        }
+        catch (cause) {
+            if (captured.value)
+                captured.value.operation.settlement.structuralFailure = Object.freeze({ cause });
+            throw cause;
+        }
+        finally {
+            release();
+            await entryClaims.values.refresh.call(entryClaims.receiver).catch(() => undefined);
+        }
+    }
+    async restoreActuator(controllerId, claimId, dto, actorId) {
+        return controller_publication_context_1.ControllerPublicationContext.complete(async () => {
+            if (!actorId ||
+                dto.disconnectionAcknowledged !== true ||
+                typeof dto.reason !== 'string' ||
+                dto.reason.trim().length < 10)
+                fail('An identified operator, disconnection acknowledgement and meaningful reason are required.');
+            const releaseFence = this.claims.holdRecoveryFence();
+            let ownedInput;
+            let predecessors;
+            let captureFailure;
+            try {
+                predecessors = this.automation?.beginMutation(controllerId);
+                void predecessors?.catch(() => undefined);
+                ownedInput = (0, creation_capture_1.snapshotCreation)(dto);
+            }
+            catch (cause) {
+                captureFailure = { cause };
+            }
+            try {
+                try {
+                    if (predecessors !== undefined)
+                        await predecessors;
+                }
+                catch (cause) {
+                    captureFailure ??= { cause };
+                }
+                return await this.structureLock.runExclusive(controller_publication_context_1.ControllerPublicationContext.captureCallback(async () => {
+                    if (captureFailure)
+                        throw captureFailure.cause;
+                    const dto = ownedInput;
+                    const ownerCurrent = this.structureLock.captureExclusiveOwner();
+                    let receipt;
+                    let ready = false;
+                    await this.graph.withControllerMutationWrite(async (manager) => {
+                        const slot = await this.automation?.captureManualSlot(manager, controllerId);
+                        const owned = await this.automation?.captureManualBaseline(manager, controllerId);
+                        const before = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, controllerId);
+                        const config = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId });
+                        const edges = (0, creation_capture_1.captureCreation)(this.graph, ['edges']);
+                        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => edges.current());
+                        const bindings = await (0, thermostat_controller_mutation_1.captureControllerBindings)(manager, controllerId, before, [dto.sourcePropertyId], () => edges.values.edges.call(edges.receiver, manager));
+                        const claim = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, {
+                            id: claimId,
+                            controllerId,
+                        });
+                        if (!config ||
+                            !claim ||
+                            config.revision !== dto.expectedRevision ||
+                            claim.revision !== dto.expectedClaimRevision)
+                            fail('Thermostat or claim revision changed; reload the retained reservation.');
+                        if (![config.revision, claim.revision].every((value) => Number.isSafeInteger(value) && value >= 1 && value < Number.MAX_SAFE_INTEGER))
+                            fail('Thermostat or claim revision overflowed; the retained reservation cannot be restored.');
+                        if (claim.state === 'released' || claim.physicalIdentity !== dto.physicalIdentity)
+                            fail('Only this exact retained canonical claim can be restored.');
+                        if (claim.sourcePropertyId) {
+                            if (claim.sourcePropertyId !== dto.sourcePropertyId)
+                                fail('The old endpoint still exists; replacing its property requires a retained alias reservation.');
+                            const previous = await this.property(manager, claim.sourcePropertyId);
+                            if ((0, virtual_thermostat_contract_utils_1.thermostatActuatorIdentity)(previous.property, previous.channel, previous.device) !==
+                                claim.physicalIdentity)
+                                fail('Existing endpoint no longer matches the reserved canonical hardware.');
+                        }
+                        const target = await this.property(manager, dto.sourcePropertyId);
+                        const identity = (0, virtual_thermostat_contract_utils_1.thermostatActuatorIdentity)(target.property, target.channel, target.device);
+                        if (identity !== claim.physicalIdentity ||
+                            !(target.channel instanceof devices_shelly_ng_entity_1.ShellyNgChannelEntity) ||
+                            !(target.property instanceof devices_shelly_ng_entity_1.ShellyNgChannelPropertyEntity) ||
+                            target.property.identifier !== 'output')
+                            fail('Restored property must be the same canonical readable and writable Shelly output.');
+                        const conflict = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, {
+                            physicalIdentity: identity,
+                            state: (0, typeorm_1.Not)('released'),
+                        });
+                        if (conflict?.id !== claim.id)
+                            fail('Canonical physical actuator is reserved by another claim.');
+                        const priorProperty = claim.sourcePropertyIdentity;
+                        const releaseRequestedAt = claim.releaseRequestedAt ?? config.releaseRequestedAt;
+                        const releaseRequested = claim.state === 'releasing' || releaseRequestedAt !== null;
+                        if (owned && config.comfort)
+                            config.comfort.automation_baseline = null;
+                        config.revision++;
+                        config.requestedMode = 'off';
+                        claim.revision++;
+                        claim.qualificationGeneration = (0, uuid_1.v4)();
+                        claim.state = releaseRequested ? 'releasing' : 'reserved';
+                        claim.sourcePropertyId = target.property.id;
+                        claim.sourcePropertyIdentity = target.property.id;
+                        claim.sourceDeviceId = target.device.id;
+                        claim.sourceDeviceIdentity = target.device.id;
+                        claim.contractFingerprint = (0, virtual_thermostat_contract_utils_1.thermostatPropertyContract)(target.property, target.channel, target.device);
+                        claim.reason = releaseRequested ? claim.reason : 'operator_restored_same_physical_actuator';
+                        claim.releaseRequestedAt = releaseRequestedAt;
+                        claim.releasedAt = null;
+                        claim.releaseEvidence = null;
+                        await bindings();
+                        await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, controllerId, before);
+                        const configuration = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'configuration', before.configuration, [
+                            config,
+                        ]);
+                        const claims = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'claims', before.claims, [claim], true);
+                        const audit = manager.create(virtual_thermostat_entity_1.VirtualThermostatRecoveryEntity, {
+                            id: (0, uuid_1.v4)(),
+                            controllerId,
+                            claimId: claim.id,
+                            physicalIdentity: identity,
+                            previousPropertyIdentity: priorProperty,
+                            restoredPropertyId: target.property.id,
+                            actorId,
+                            reason: dto.reason.trim(),
+                            disconnectionAcknowledged: true,
+                            configurationRevision: config.revision,
+                            claimRevision: claim.revision,
+                            createdAt: new Date(),
+                        });
+                        const recoveries = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'recoveries', before.recoveries, [audit], true);
+                        await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, controllerId, {
+                            ...before,
+                            configuration,
+                            claims,
+                            recoveries,
+                        });
+                        await bindings();
+                        await this.automation?.manualFence(manager, controllerId, true, slot);
+                        await this.graph.sealControllerLedger(manager);
+                        ready = true;
+                    }, undefined, (manager) => {
+                        receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+                        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => ready && ownerCurrent());
+                    }, () => {
+                        if (receipt.outcome !== 'committed')
+                            fail('Missing original native restore acknowledgement.');
+                    });
+                    this.claims.revokeQualification(dto.physicalIdentity);
+                    return this.afterCommit(controllerId);
+                }));
+            }
+            finally {
+                releaseFence();
+                await this.claims.refresh().catch(() => undefined);
+            }
+        });
+    }
+    async recoveryEvents(controllerId) {
+        await this.get(controllerId);
+        return this.dataSource.manager.find(virtual_thermostat_entity_1.VirtualThermostatRecoveryEntity, {
+            where: { controllerId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async command(updates) {
+        return controller_publication_context_1.ControllerPublicationContext.complete(async () => {
+            const own = (0, creation_capture_1.captureCreation)(this, [
+                'command',
+                'dataSource',
+                'structureLock',
+                'graph',
+                'claims',
+                'events',
+                'values',
+            ]);
+            const lock = (0, creation_capture_1.captureCreation)(this.structureLock, [
+                'runExclusive',
+                'runShared',
+                'hasCurrentStructuralLease',
+                'context',
+            ]);
+            const graph = (0, creation_capture_1.captureCreation)(this.graph, [
+                'withComfortSelectionWrite',
+                'sealControllerLedger',
+                'structuralWrite',
+                'refreshValidation',
+                'dataSource',
+                'revision',
+            ]);
+            const claims = (0, creation_capture_1.captureCreation)(this.claims, ['invalidate', 'refresh']);
+            const values = (0, creation_capture_1.captureCreation)(this.values, ['write', 'readLatest']);
+            const events = (0, creation_capture_1.captureCreation)(this.events, ['emit']);
+            const helper = (0, creation_capture_1.captureCreation)(thermostat_comfort_selection_1.thermostatComfortSelection, ['pin']);
+            const valueSet = devices_constants_1.EventType.CHANNEL_PROPERTY_VALUE_SET, configChanged = exports.THERMOSTAT_CONFIG_CHANGED;
+            const selection = helper.values.pin(this.dataSource, 'registered-settings');
+            const { input, destinations } = selection.registeredInput(updates);
+            if (input === null)
+                return true;
+            if (this.native && (await this.native.ownsController(input.id)))
+                return this.native.commandSettings(input.commands);
+            const pins = [own, lock, graph, claims, values, events, helper, selection];
+            const current = () => pins.every((pin) => pin.current());
+            const check = () => {
+                if (!current())
+                    fail('Original thermostat settings dispatch expired.');
+            };
+            check();
+            let ownerCurrent = () => false;
+            const operation = selection.operation(input, () => ownerCurrent(), current, true);
+            const noop = virtual_thermostat_ownership_subscriber_1.VirtualThermostatOwnershipSubscriber.captureNoopFence(this.dataSource, () => ownerCurrent());
+            try {
+                const predecessors = this.automation?.beginMutation(input.id);
+                if (predecessors !== undefined)
+                    await predecessors;
+                await lock.values.runExclusive.call(lock.receiver, controller_publication_context_1.ControllerPublicationContext.captureCallback(async () => {
+                    check();
+                    ownerCurrent = node_async_hooks_1.AsyncLocalStorage.bind(() => lock.values.hasCurrentStructuralLease.call(lock.receiver));
+                    try {
+                        const write = async (manager, advanceGraph) => {
+                            const slot = await this.automation?.captureManualSlot(manager, input.id);
+                            const owned = await this.automation?.captureInstalledIntent(manager, input.id);
+                            const before = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, input.id);
+                            const result = await operation.write(manager, owned ?? undefined, {
+                                advanceGraph,
+                                canRemainUnchanged: (takeover) => !slot?.facts ||
+                                    (!['LIVE', 'PROVISIONAL'].includes(slot.facts.state) && (!takeover || slot.facts.manualHold)),
+                                verifyUnchanged: async () => {
+                                    await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, input.id, before);
+                                    await this.automation?.captureUnchangedAuthority(manager, input.id);
+                                },
+                            });
+                            if (this.automation && operation.changed()) {
+                                const takeover = operation.takesManualHold();
+                                await this.automation.manualFence(manager, input.id, takeover ? true : undefined, slot, takeover);
+                            }
+                            await graph.values.sealControllerLedger.call(graph.receiver, manager);
+                            if (operation.changed())
+                                noop.applied();
+                            else
+                                noop.arm();
+                            operation.markReady();
+                            return result;
+                        };
+                        await graph.values.withComfortSelectionWrite.call(graph.receiver, write, undefined, (manager) => {
+                            operation.admit(manager);
+                            noop.admit(manager);
+                        }, operation.accepted, 'registered-settings', write, noop);
+                        operation.accepted();
+                    }
+                    catch (cause) {
+                        operation.settlement.transactionFailure = Object.freeze({ cause });
+                        throw cause;
+                    }
+                    const publication = new controller_publication_context_1.ControllerPublicationContext(this.graph.capturePublishGuard());
+                    return publication.run(async () => {
+                        let stage = 'claims.invalidate';
+                        let index;
+                        try {
+                            claims.values.invalidate.call(claims.receiver);
+                            stage = 'claims.refresh';
+                            await claims.values.refresh.call(claims.receiver);
+                            for (index = 0; index < destinations.length; index++) {
+                                const property = destinations[index], value = input.commands[index].value;
+                                stage = 'values.write';
+                                await (0, creation_capture_1.invokeCreation)(values.values.write, values.receiver, property, value);
+                                stage = 'values.readLatest';
+                                const latest = await (0, creation_capture_1.invokeCreation)(values.values.readLatest, values.receiver, property);
+                                stage = 'property.value';
+                                property.value = latest;
+                                stage = 'VALUE_SET';
+                                events.values.emit.call(events.receiver, valueSet, property);
+                            }
+                            index = undefined;
+                            stage = 'configChanged';
+                            events.values.emit.call(events.receiver, configChanged, input.id);
+                            return true;
+                        }
+                        catch (cause) {
+                            operation.settlement.maintenanceFailure = Object.freeze({ stage, index, cause });
+                            throw cause;
+                        }
+                    });
+                }));
+                return true;
+            }
+            catch (cause) {
+                operation.settlement.structuralFailure = Object.freeze({ cause });
+                throw cause;
+            }
+            finally {
+                noop.close();
+            }
+        });
+    }
+    async isRegisteredSetting(property, manager = this.dataSource.manager) {
+        if (await this.native?.isRegisteredSetting(property, manager))
+            return true;
+        const setting = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatSettingEntity, { propertyId: property.id });
+        if (!setting)
+            return false;
+        const target = await this.property(manager, property.id);
+        return (property.valueOrigin === devices_virtual_entity_1.VirtualValueOrigin.LOCAL &&
+            !property.sourcePropertyId &&
+            setting.contractFingerprint === (0, virtual_thermostat_contract_utils_1.thermostatPropertyContract)(property, target.channel, target.device));
+    }
+    async property(manager, id, previewOnly = false) {
+        const property = previewOnly
+            ? await manager
+                .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'property')
+                .leftJoinAndSelect('property.channel', 'channel')
+                .leftJoinAndSelect('channel.device', 'device')
+                .where('property.id = :id', { id })
+                .callListeners(false)
+                .getOne()
+            : await manager.findOne(devices_entity_1.ChannelPropertyEntity, {
+                where: { id },
+                relations: ['channel', 'channel.device'],
+            });
+        if (!property)
+            fail('Thermostat source or setting property does not exist.');
+        const channel = property.channel;
+        return { property, channel, device: channel.device };
+    }
+    validatePolicy(policy, mode) {
+        const errors = (0, virtual_thermostat_policy_utils_1.validateVirtualThermostatPolicy)(policy);
+        if (errors.length ||
+            !['off', 'heat', 'cool', 'auto'].includes(mode) ||
+            ((mode === 'heat' || mode === 'auto') && policy.heatingSetpoint === null) ||
+            ((mode === 'cool' || mode === 'auto') && policy.coolingSetpoint === null))
+            fail(`Invalid thermostat mode/policy: ${errors.join(', ')}.`);
+    }
+    async validate(manager, controllerId, dto, draft) {
+        const owner = draft ?? (await manager.findOneBy(devices_virtual_entity_1.VirtualDeviceEntity, { id: controllerId }));
+        if (!owner || owner.mode !== devices_virtual_entity_1.VirtualDeviceMode.CLIMATE_CONTROLLER || owner.category !== devices_constants_1.DeviceCategory.THERMOSTAT)
+            fail('Thermostat configuration requires a climate-controller thermostat device.');
+        const previous = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId });
+        if (!previous &&
+            this.dataSource.hasMetadata(native_thermostat_entity_1.NativeThermostatEntity) &&
+            (await manager.existsBy(native_thermostat_entity_1.NativeThermostatEntity, { controllerId })))
+            fail('Guarded branches and native units are mutually exclusive.');
+        if (dto.schemaVersion !== 1 || dto.expectedRevision !== (previous?.revision ?? 0))
+            fail('Thermostat configuration revision changed.');
+        if (dto.controlStrategy !== undefined && dto.controlStrategy !== 'guarded_branches')
+            fail('Use the native thermostat API to configure the native_unit strategy.');
+        this.validatePolicy(dto.policy, dto.requestedMode);
+        const comfort = dto.comfort
+            ? {
+                ...dto.comfort,
+                selected_preset: previous?.comfort?.selected_preset ?? null,
+                user_off: dto.requestedMode === 'off',
+                automation_enabled: dto.comfort.automation_enabled ?? previous?.comfort?.automation_enabled ?? false,
+                automation_baseline: dto.comfort.automation_enabled === false ? null : (previous?.comfort?.automation_baseline ?? null),
+                temporary_override: previous?.comfort?.temporary_override ?? null,
+            }
+            : previous?.comfort
+                ? { ...previous.comfort, user_off: dto.requestedMode === 'off' }
+                : null;
+        if (comfort) {
+            const errors = (0, virtual_thermostat_comfort_utils_1.validateThermostatComfort)(comfort, dto.policy);
+            if (errors.length)
+                fail(`Reconfigure comfort before changing branches/ranges: ${errors.join(', ')}`);
+        }
+        if (dto.heuristic && !(0, virtual_window_trend_utils_1.validateVirtualWindowTrendPolicy)(dto.heuristic))
+            fail('Invalid independent window trend policy.');
+        if (![dto.contactOpeningMs, dto.contactClosingMs].every((value) => Number.isSafeInteger(value) && value >= 0 && value <= 86400000))
+            fail('Invalid contact debounce policy.');
+        const heatingInputs = Array.isArray(dto.actuators)
+            ? dto.actuators.filter((member) => member.role === 'heating')
+            : [];
+        if (!Array.isArray(dto.sources) ||
+            dto.sources.length > 18 ||
+            dto.sources.filter((source) => source.role === 'ambient').length !== 1 ||
+            dto.sources.filter((source) => source.role === 'floor').length > (dto.policy.floor ? 1 : 0) ||
+            (dto.policy.floor &&
+                !dto.sources.some((source) => source.role === 'floor') &&
+                !(heatingInputs.length > 0 && heatingInputs.every((member) => !!member.protection))))
+            fail('One ambient and one independently configured floor source are required for their enabled roles.');
+        const oldSources = await manager.findBy(virtual_thermostat_entity_1.VirtualThermostatSourceEntity, { controllerId });
+        const sources = [];
+        for (const input of dto.sources) {
+            if (!['ambient', 'floor', 'contact'].includes(input.role) ||
+                !Number.isInteger(input.maximumAgeSeconds) ||
+                input.maximumAgeSeconds < 1 ||
+                input.maximumAgeSeconds > 86400)
+                fail('Invalid thermostat source role or freshness bound.');
+            const old = input.id ? oldSources.find((row) => row.id === input.id && row.role === input.role) : null;
+            if (input.id && !old)
+                fail('Source binding identity is not owned by this role/controller.');
+            if (!input.sourcePropertyId) {
+                if (!old || old.sourcePropertyId !== null)
+                    fail('Only an existing missing source may retain a null binding.');
+                sources.push(manager.create(virtual_thermostat_entity_1.VirtualThermostatSourceEntity, { ...old, maximumAgeSeconds: input.maximumAgeSeconds }));
+                continue;
+            }
+            const target = await this.property(manager, input.sourcePropertyId, !!draft);
+            if (input.role === 'contact') {
+                const primitive = (value) => ['string', 'number', 'boolean'].includes(typeof value) &&
+                    (typeof value !== 'number' || Number.isFinite(value));
+                if (target.device.type === 'virtual' ||
+                    target.channel.category !== devices_constants_1.ChannelCategory.CONTACT ||
+                    target.property.category !== devices_constants_1.PropertyCategory.DETECTED ||
+                    !(0, property_permissions_utils_1.permissionSatisfied)(devices_constants_1.PermissionType.READ_ONLY, new Set(target.property.permissions)) ||
+                    !primitive(input.openValue) ||
+                    !primitive(input.closedValue) ||
+                    input.openValue === input.closedValue)
+                    fail('Contacts require physical readable detected properties and distinct explicit open/closed mappings.');
+            }
+            else if (!(0, virtual_thermostat_contract_utils_1.isThermostatTemperature)(target.property, target.channel) ||
+                (target.device.type === 'virtual' &&
+                    !(0, virtual_source_eligibility_utils_1.isEligibleVirtualTransformedTemperature)(target.property, target.channel, target.device) &&
+                    (input.role !== 'ambient' || !(0, virtual_source_eligibility_utils_1.isEligibleVirtualMeasurement)(target.property, target.channel, target.device))))
+                fail('Temperature roles require readable Celsius physical inputs or a materialized ambient producer.');
+            let physicalIdentity = target.device.type === 'virtual' ? null : `property:${target.property.id}`;
+            let contractFingerprint = (0, virtual_thermostat_contract_utils_1.thermostatPropertyContract)(target.property, target.channel, target.device);
+            if (target.device.mode === devices_virtual_entity_1.VirtualDeviceMode.SENSOR_TRANSFORM) {
+                const transform = await manager.findOneBy(virtual_transform_entity_1.VirtualTransformConfigEntity, {
+                    outputPropertyId: target.property.id,
+                });
+                const binding = await manager.findOneBy(virtual_transform_entity_1.VirtualTransformSourceEntity, { outputPropertyId: target.property.id });
+                const physical = binding?.sourcePropertyId
+                    ? (await this.property(manager, binding.sourcePropertyId, !!draft)).property
+                    : null;
+                if (!transform ||
+                    (input.role === 'floor' && transform.policy?.operator === virtual_numeric_transform_utils_1.VirtualNumericTransformOperator.EXTENSION) ||
+                    !binding ||
+                    transform.quantity !== String(devices_constants_1.PropertyCategory.TEMPERATURE) ||
+                    transform.unit !== '°C' ||
+                    (0, virtual_transform_contract_utils_1.transformContractErrors)(transform, target.property, physical, binding, this.resolver).length)
+                    fail('Transformed thermostat temperatures require a configured Celsius single-physical-input producer contract.');
+                physicalIdentity = `property:${binding.sourcePropertyIdentity}`;
+                contractFingerprint = (0, virtual_thermostat_contract_utils_1.thermostatFingerprint)({
+                    output: contractFingerprint,
+                    transformRevision: transform.revision,
+                    transformPolicy: transform.policy,
+                    physicalIdentity,
+                    sourceQuantity: binding.quantity,
+                    sourceUnit: binding.unit,
+                });
+            }
+            sources.push(manager.create(virtual_thermostat_entity_1.VirtualThermostatSourceEntity, {
+                id: old?.id ?? (0, uuid_1.v4)(),
+                controllerId,
+                role: input.role,
+                sourcePropertyId: target.property.id,
+                sourcePropertyIdentity: target.property.id,
+                physicalIdentity,
+                contractFingerprint,
+                maximumAgeSeconds: input.maximumAgeSeconds,
+                openValue: input.openValue ?? null,
+                closedValue: input.closedValue ?? null,
+            }));
+        }
+        if (new Set(sources.map((source) => source.role + ':' + source.sourcePropertyIdentity)).size !== sources.length)
+            fail('Duplicate source binding.');
+        if (!Array.isArray(dto.actuators) ||
+            dto.actuators.length < 1 ||
+            dto.actuators.length > thermostat_actuation_contract_1.MAX_THERMOSTAT_ACTUATOR_MEMBERS ||
+            dto.actuators.some((actuator) => !['heating', 'cooling'].includes(actuator.role)) ||
+            !!dto.actuators.find((actuator) => actuator.role === 'heating') !== (dto.policy.heatingSetpoint !== null) ||
+            !!dto.actuators.find((actuator) => actuator.role === 'cooling') !== (dto.policy.coolingSetpoint !== null))
+            fail('Physical actuator branches must match configured comfort setpoints.');
+        const oldClaims = await manager.findBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, {
+            controllerId,
+            state: (0, typeorm_1.Not)('released'),
+        });
+        const actuators = [];
+        for (const input of dto.actuators) {
+            const old = oldClaims.find((claim) => claim.role === input.role && claim.sourcePropertyIdentity === input.sourcePropertyId);
+            if (old && old.sourcePropertyId !== input.sourcePropertyId)
+                fail('Request and prove release before actuator repair, remap or detach.');
+            const target = await this.property(manager, input.sourcePropertyId, !!draft);
+            const identity = (0, virtual_thermostat_contract_utils_1.thermostatActuatorIdentity)(target.property, target.channel, target.device);
+            if (!identity ||
+                !(target.channel instanceof devices_shelly_ng_entity_1.ShellyNgChannelEntity) ||
+                !(target.property instanceof devices_shelly_ng_entity_1.ShellyNgChannelPropertyEntity) ||
+                target.property.identifier !== 'output' ||
+                !Number.isFinite(input.leaseSeconds) ||
+                input.leaseSeconds <= 0)
+                fail('Actuator requires a supported physical guarded boolean leaf and explicit finite ON lease.');
+            const fingerprint = (0, virtual_thermostat_contract_utils_1.thermostatPropertyContract)(target.property, target.channel, target.device);
+            if (old && (old.physicalIdentity !== identity || old.contractFingerprint !== fingerprint))
+                fail('Actuator identity/contract changed; explicit release and repair required.');
+            const conflict = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, {
+                physicalIdentity: identity,
+                state: (0, typeorm_1.Not)('released'),
+            });
+            if (conflict && conflict.id !== old?.id)
+                fail('Canonical physical actuator is already reserved; qualified release is required before repair or remap.');
+            actuators.push(manager.create(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, {
+                id: old?.id ?? (0, uuid_1.v4)(),
+                controllerId,
+                role: input.role,
+                physicalIdentity: identity,
+                providerProfile: input.role === 'cooling' && dto.policy.cooling
+                    ? remote_dew_point_lease_contract_1.REMOTE_DEW_POINT_PROFILE
+                    : (old?.providerProfile ?? thermostat_actuation_contract_1.SHELLY_GUARDED_PROFILE),
+                providerProfileVersion: old?.providerProfileVersion ?? thermostat_actuation_contract_1.SHELLY_GUARDED_PROFILE_VERSION,
+                sourcePropertyId: target.property.id,
+                sourcePropertyIdentity: target.property.id,
+                sourceDeviceId: target.device.id,
+                sourceDeviceIdentity: target.device.id,
+                contractFingerprint: fingerprint,
+                revision: (old?.revision ?? 0) + 1,
+                qualificationGeneration: old?.qualificationGeneration ?? null,
+                state: old?.state ?? 'reserved',
+                leaseSeconds: input.leaseSeconds,
+                reason: old?.reason ?? null,
+                releaseRequestedAt: old?.releaseRequestedAt ?? null,
+                releasedAt: null,
+                releaseEvidence: null,
+            }));
+        }
+        if (oldClaims.some((old) => !actuators.some((claim) => claim.id === old.id)))
+            fail('Unresolved actuator reservation cannot be detached.');
+        if (new Set(actuators.map((claim) => claim.physicalIdentity)).size !== actuators.length)
+            fail('Branch members cannot own the same physical actuator more than once.');
+        const coolingDependencies = [];
+        for (const claim of actuators) {
+            const input = dto.actuators.find((member) => member.sourcePropertyId === claim.sourcePropertyIdentity);
+            if (input.coolingProtection || (dto.policy.cooling && claim.role === 'cooling')) {
+                if (!dto.policy.cooling)
+                    fail('Cooling dependency requires the separate cooling policy.');
+                const dependency = await this.coolingDependencies().prepare(manager, claim, input.coolingProtection);
+                if (sources.some((source) => source.role === 'ambient' &&
+                    (source.sourcePropertyId === dependency.surfacePropertyId ||
+                        source.physicalIdentity === `property:${dependency.physicalSurfaceIdentity}`)))
+                    fail('Ambient temperature cannot substitute for a cooled-surface probe.');
+                coolingDependencies.push(dependency);
+                claim.qualificationGeneration = (0, uuid_1.v4)();
+            }
+        }
+        const protections = [];
+        const heating = actuators.filter((claim) => claim.role === 'heating');
+        for (const claim of actuators) {
+            const input = dto.actuators.find((member) => member.sourcePropertyId === claim.sourcePropertyIdentity);
+            const old = await manager.findOneBy(thermostat_member_protection_entity_1.ThermostatMemberProtectionEntity, { claimId: claim.id });
+            if (input.protection === undefined) {
+                if (old || (claim.role === 'heating' && heating.length > 1))
+                    fail('Every parallel or previously explicit heating member requires an explicit retained protection binding.');
+                continue;
+            }
+            const protection = input.protection;
+            if (!protection ||
+                claim.role !== 'heating' ||
+                protection.schemaVersion !== 1 ||
+                protection.kind !== 'local_floor' ||
+                !dto.policy.floor ||
+                !Number.isInteger(protection.maximumAgeSeconds) ||
+                protection.maximumAgeSeconds < 1 ||
+                protection.maximumAgeSeconds > 86400)
+                fail('Invalid explicit local floor protection.');
+            if (!protection.sourcePropertyId) {
+                if (!old || old.sourcePropertyId !== null)
+                    fail('Null cannot remove protection; only retain an already missing source.');
+                protections.push(manager.create(thermostat_member_protection_entity_1.ThermostatMemberProtectionEntity, {
+                    ...old,
+                    revision: old.revision + 1,
+                    maximumAgeSeconds: protection.maximumAgeSeconds,
+                }));
+            }
+            else {
+                const source = await (0, thermostat_protection_source_utils_1.resolveThermostatProtectionSource)(manager, protection.sourcePropertyId, claim.physicalIdentity);
+                protections.push(manager.create(thermostat_member_protection_entity_1.ThermostatMemberProtectionEntity, {
+                    claimId: claim.id,
+                    schemaVersion: 1,
+                    kind: 'local_floor',
+                    revision: (old?.revision ?? 0) + 1,
+                    sourcePropertyId: source.property.id,
+                    sourcePropertyIdentity: source.property.id,
+                    physicalPropertyIdentity: source.leaf.id,
+                    contractFingerprint: source.fingerprint,
+                    maximumAgeSeconds: protection.maximumAgeSeconds,
+                }));
+            }
+            claim.qualificationGeneration = (0, uuid_1.v4)();
+        }
+        if (dto.displayFloorClaimId && !protections.some((row) => row.claimId === dto.displayFloorClaimId))
+            fail('Display floor must select an explicitly protected active member.');
+        const otherConsumers = await manager
+            .createQueryBuilder(thermostat_member_protection_entity_1.ThermostatMemberProtectionEntity, 'protection')
+            .innerJoin('protection.claim', 'claim')
+            .where('claim.controllerId <> :controllerId AND claim.state <> :released', { controllerId, released: 'released' })
+            .getMany();
+        (0, thermostat_protection_source_utils_1.validateProtectionConsumerIndex)([...otherConsumers, ...protections]);
+        this.graph.validate(await this.graph.edges(manager));
+        if (!Array.isArray(dto.settings) ||
+            dto.settings.length > 5 ||
+            new Set(dto.settings.map((input) => input.setting)).size !== dto.settings.length ||
+            new Set(dto.settings.map((input) => input.propertyId)).size !== dto.settings.length)
+            fail('Invalid or duplicate local setting registration.');
+        const settings = [];
+        for (const input of dto.settings) {
+            const draftProperty = draft?.channels
+                ?.flatMap((channel) => channel.properties ?? [])
+                .find((property) => property.id === input.propertyId);
+            const target = draftProperty
+                ? { property: draftProperty, channel: draftProperty.channel, device: draft }
+                : await this.property(manager, input.propertyId);
+            const expected = this.settingContract(input.setting);
+            const property = target.property;
+            if (target.device.id !== controllerId ||
+                property.valueOrigin !== devices_virtual_entity_1.VirtualValueOrigin.LOCAL ||
+                property.sourcePropertyId ||
+                !expected ||
+                target.channel.category !== expected.channel ||
+                property.category !== expected.property ||
+                (expected.numeric
+                    ? ![devices_constants_1.DataTypeType.FLOAT, devices_constants_1.DataTypeType.INT].includes(property.dataType)
+                    : property.dataType !== devices_constants_1.DataTypeType.BOOL) ||
+                !property.permissions.some((permission) => [devices_constants_1.PermissionType.READ_ONLY, devices_constants_1.PermissionType.READ_WRITE].includes(permission)) ||
+                (input.setting.startsWith('heating') && dto.policy.heatingSetpoint === null) ||
+                (input.setting.startsWith('cooling') && dto.policy.coolingSetpoint === null))
+                fail('Setting must be an owned writable property matching its thermostat role.');
+            property.permissions = [devices_constants_1.PermissionType.READ_WRITE];
+            settings.push(manager.create(virtual_thermostat_entity_1.VirtualThermostatSettingEntity, {
+                propertyId: input.propertyId,
+                controllerId,
+                setting: input.setting,
+                contractFingerprint: (0, virtual_thermostat_contract_utils_1.thermostatPropertyContract)(property, target.channel, target.device),
+            }));
+        }
+        const config = manager.create(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, {
+            controlStrategy: 'guarded_branches',
+            displayFloorClaimId: dto.displayFloorClaimId ?? null,
+            controllerId,
+            ownerDeviceId: controllerId,
+            schemaVersion: 1,
+            revision: (previous?.revision ?? 0) + 1,
+            requestedMode: dto.requestedMode,
+            comfort,
+            locked: previous?.locked ?? false,
+            policy: { ...dto.policy, floor: dto.policy.floor ?? null },
+            heuristic: dto.heuristic ?? null,
+            contactOpeningMs: dto.contactOpeningMs,
+            contactClosingMs: dto.contactClosingMs,
+            configuredAt: new Date(),
+            releaseRequestedAt: previous?.releaseRequestedAt ?? null,
+        });
+        return { config, sources, actuators, settings, protections, coolingDependencies };
+    }
+    settingContract(setting) {
+        if (setting === 'locked')
+            return { channel: devices_constants_1.ChannelCategory.THERMOSTAT, property: devices_constants_1.PropertyCategory.LOCKED, numeric: false };
+        if (!['heating_setpoint', 'cooling_setpoint', 'heating_enabled', 'cooling_enabled'].includes(setting))
+            return null;
+        return {
+            channel: setting.startsWith('heating') ? devices_constants_1.ChannelCategory.HEATER : devices_constants_1.ChannelCategory.COOLER,
+            property: setting.endsWith('setpoint') ? devices_constants_1.PropertyCategory.TEMPERATURE : devices_constants_1.PropertyCategory.ON,
+            numeric: setting.endsWith('setpoint'),
+        };
+    }
+    async model(config, sources, actuators, settings, manager, preparedProtections, preparedCoolingDependencies) {
+        const protections = preparedProtections ?? (await (manager ?? this.dataSource.manager).find(thermostat_member_protection_entity_1.ThermostatMemberProtectionEntity));
+        const coolingDependencies = preparedCoolingDependencies ??
+            (this.dataSource.hasMetadata?.(thermostat_cooling_dependency_entity_1.ThermostatCoolingDependencyEntity)
+                ? await (manager ?? this.dataSource.manager).find(thermostat_cooling_dependency_entity_1.ThermostatCoolingDependencyEntity)
+                : []);
+        const coolingService = this.coolingDependencies();
+        const coolingDiagnostics = this.dataSource.hasMetadata?.(thermostat_cooling_dependency_entity_1.ThermostatCoolingDependencyEntity)
+            ? coolingService.read(await coolingService.load(config, actuators, coolingDependencies), Date.now())
+            : [];
+        const reasons = ['controller_runtime_unavailable'];
+        if (config.policy.cooling &&
+            coolingDiagnostics.some((d) => d.reasons.includes('cooling_remote_profile_installation_unqualified')))
+            reasons.push('cooling_remote_profile_installation_unqualified');
+        for (const claim of actuators) {
+            if (!claim.sourcePropertyId || !claim.sourceDeviceId)
+                reasons.push(claim.role + '_actuator_missing');
+            if (!this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(actuators)))
+                reasons.push(claim.role + '_hardware_qualification_missing');
+            if (claim.state !== 'reserved')
+                reasons.push(claim.role + '_' + claim.state);
+        }
+        for (const source of sources)
+            if (!source.sourcePropertyId)
+                reasons.push(source.role + '_source_missing');
+        const modelClaim = (claim) => ({
+            cooling_diagnostics: coolingDiagnostics.find((entry) => entry.claim === claim.id) ?? null,
+            cooling_protection: coolingDependencies
+                .filter((row) => row.claimId === claim.id)
+                .map((row) => ({
+                schema_version: row.schemaVersion,
+                revision: row.revision,
+                purpose: row.purpose,
+                dew_point_property: row.dewPointPropertyId,
+                dew_point_identity: row.dewPointIdentity,
+                surface_property: row.surfacePropertyId,
+                surface_identity: row.surfaceIdentity,
+                maximum_age_seconds: row.maximumAgeSeconds,
+            }))[0] ?? null,
+            protection: protections
+                .filter((row) => row.claimId === claim.id)
+                .map((row) => ({
+                schema_version: row.schemaVersion,
+                kind: row.kind,
+                revision: row.revision,
+                source_property: row.sourcePropertyId,
+                source_identity: row.sourcePropertyIdentity,
+                physical_property: row.physicalPropertyIdentity,
+                maximum_age_seconds: row.maximumAgeSeconds,
+            }))[0] ?? null,
+            id: claim.id,
+            group_identity: (0, thermostat_actuation_contract_1.thermostatBranchGroupIdentity)(config.controllerId, claim.role),
+            provider_profile: claim.providerProfile ?? thermostat_actuation_contract_1.SHELLY_GUARDED_PROFILE,
+            provider_profile_version: claim.providerProfileVersion ?? thermostat_actuation_contract_1.SHELLY_GUARDED_PROFILE_VERSION,
+            role: claim.role,
+            source_property: claim.sourcePropertyId,
+            source_identity: claim.sourcePropertyIdentity,
+            physical_identity: claim.physicalIdentity,
+            revision: claim.revision,
+            qualification_generation: claim.qualificationGeneration,
+            state: claim.state,
+            lease_seconds: claim.leaseSeconds,
+            reason: claim.reason,
+            release_requested_at: claim.releaseRequestedAt?.toISOString() ?? null,
+            released_at: claim.releasedAt?.toISOString() ?? null,
+            release_evidence: claim.releaseEvidence,
+        });
+        return {
+            display_floor_claim: config.displayFloorClaimId ?? null,
+            controller: config.controllerId,
+            schema_version: 1,
+            control_strategy: config.controlStrategy ?? 'guarded_branches',
+            revision: config.revision,
+            graph_revision: await this.graph.revision(manager),
+            requested_mode: config.requestedMode,
+            locked: config.locked,
+            policy: config.policy,
+            heuristic: config.heuristic,
+            contact_opening_ms: config.contactOpeningMs,
+            contact_closing_ms: config.contactClosingMs,
+            readiness: 'draft',
+            reasons,
+            sources: sources.map((source) => ({
+                id: source.id,
+                role: source.role,
+                source_property: source.sourcePropertyId,
+                source_identity: source.sourcePropertyIdentity,
+                physical_identity: source.physicalIdentity,
+                contract_fingerprint: source.contractFingerprint,
+                maximum_age_seconds: source.maximumAgeSeconds,
+                open_value: source.openValue,
+                closed_value: source.closedValue,
+            })),
+            actuators: actuators.map(modelClaim),
+            released_actuators: (await (manager ?? this.dataSource.manager).findBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, {
+                controllerId: config.controllerId,
+                state: 'released',
+            })).map(modelClaim),
+            settings: settings.map((setting) => ({ property: setting.propertyId, setting: setting.setting })),
+        };
+    }
+};
+exports.VirtualThermostatConfigService = VirtualThermostatConfigService;
+exports.VirtualThermostatConfigService = VirtualThermostatConfigService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(6, (0, common_1.Optional)()),
+    __param(7, (0, common_1.Optional)()),
+    __param(8, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        device_structure_lock_service_1.DeviceStructureLockService,
+        virtual_dependency_graph_service_1.VirtualDependencyGraphService,
+        virtual_thermostat_claims_service_1.VirtualThermostatClaimsService,
+        event_emitter_1.EventEmitter2,
+        property_value_service_1.PropertyValueService,
+        virtual_transform_resolver_1.VirtualTransformResolver,
+        virtual_thermostat_automation_service_1.VirtualThermostatAutomationService,
+        native_thermostat_service_1.NativeThermostatService])
+], VirtualThermostatConfigService);
+//# sourceMappingURL=virtual-thermostat-config.service.js.map