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

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

@@ -0,0 +1,1189 @@
+"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.VirtualThermostatAutomationService = exports.THERMOSTAT_AUTOMATION_PROVIDER = void 0;
+const class_validator_1 = require("class-validator");
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+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 climate_automation_entity_1 = require("../../../modules/devices/entities/climate-automation.entity");
+const climate_automation_ledger_service_1 = require("../../../modules/devices/services/climate-automation-ledger.service");
+const climate_automation_ledger_utils_1 = require("../../../modules/devices/services/climate-automation-ledger.utils");
+const climate_automation_registry_service_1 = require("../../../modules/devices/services/climate-automation.registry.service");
+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 devices_virtual_entity_1 = require("../entities/devices-virtual.entity");
+const virtual_thermostat_entity_1 = require("../entities/virtual-thermostat.entity");
+const thermostat_controller_mutation_1 = require("./thermostat-controller-mutation");
+const virtual_dependency_graph_service_1 = require("./virtual-dependency-graph.service");
+const virtual_thermostat_comfort_utils_1 = require("./virtual-thermostat-comfort.utils");
+const virtual_thermostat_ownership_sql_1 = require("./virtual-thermostat-ownership.sql");
+const virtual_thermostat_runtime_ownership_1 = require("./virtual-thermostat-runtime-ownership");
+exports.THERMOSTAT_AUTOMATION_PROVIDER = 'virtual-thermostat:v1';
+const asJson = (value) => JSON.parse(JSON.stringify(value));
+const fail = () => {
+    throw new devices_exceptions_1.DevicesValidationException('Thermostat automation provenance or selection is unavailable.');
+};
+let VirtualThermostatAutomationService = class VirtualThermostatAutomationService {
+    constructor(database, registry, ledger, graph, structure) {
+        this.database = database;
+        this.registry = registry;
+        this.ledger = ledger;
+        this.graph = graph;
+        this.structure = structure;
+        this.graphRenewals = new WeakMap();
+        this.mutationVacancies = new Map();
+        this.mutationCohorts = new Map();
+        this.installations = new Map();
+        this.localAdmissions = new Map();
+        this.removedPredecessors = new WeakMap();
+        this.generationAdmissions = new Map();
+        this.retiringGenerations = new Map();
+        this.destroyed = false;
+        this.provider = {
+            beginControllerDeletion: (expected) => {
+                const installed = this.installations.get(expected.controllerId);
+                if (installed && installed.slot !== (0, climate_automation_ledger_utils_1.canonical)(expected))
+                    fail();
+                const original = installed ?? this.mutationCohorts.get(expected.generationId)?.group.get(expected.controllerId);
+                if (!original)
+                    return this.beginMutation(expected.controllerId);
+                if (original.slot !== (0, climate_automation_ledger_utils_1.canonical)(expected))
+                    fail();
+                const source = JSON.parse(original.source);
+                return this.beginSourceMutation(source.producerKey, source.subjectId, source.generationId);
+            },
+            readDeletionConfigurationInManager: async (manager, id) => {
+                await this.assertDeletionSchema(manager);
+                const rows = await manager.query('SELECT * FROM "devices_virtual_thermostat_configs" WHERE "controllerId" = ?', [id]);
+                if (rows.length !== 1)
+                    fail();
+                return { ...rows[0] };
+            },
+            readDeletedControllerInManager: async (manager, id, before) => {
+                await this.assertDeletionSchema(manager);
+                const original = before.evidence.image;
+                const retained = {
+                    ...original,
+                    configuration: original.configuration.map((row) => ({ ...row, ownerDeviceId: null })),
+                    settings: [],
+                    properties: [],
+                };
+                await this.validateDeletedController(manager, id, asJson(retained));
+                return asJson(retained);
+            },
+            validateDeletedControllerInManager: (manager, id, retained) => this.validateDeletedController(manager, id, retained),
+            captureControllerRecreationArchiveInManager: async (manager, id, retained) => {
+                await this.validateDeletedController(manager, id, retained);
+                return asJson({ controller: retained, history: await (0, virtual_thermostat_runtime_ownership_1.readThermostatRecreationHistory)(manager, id) });
+            },
+            prepareControllerRecreationInManager: async (manager, id, retained, archive) => {
+                await this.validateDeletedController(manager, id, retained);
+                const original = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, id);
+                if ((0, climate_automation_ledger_utils_1.canonical)(original) !== (0, climate_automation_ledger_utils_1.canonical)(retained))
+                    fail();
+                const captured = archive;
+                if ((0, climate_automation_ledger_utils_1.canonical)(captured.controller) !== (0, climate_automation_ledger_utils_1.canonical)(original))
+                    fail();
+                const row = await manager.findOneByOrFail(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: id });
+                const nextRevision = (0, climate_automation_ledger_utils_1.increment)(row.revision);
+                row.revision = nextRevision;
+                const history = await (0, virtual_thermostat_runtime_ownership_1.resetThermostatRecreationRuntime)(manager, id, captured.history, original.claims, nextRevision);
+                row.comfort = null;
+                row.locked = false;
+                row.releaseRequestedAt = null;
+                const configuration = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'configuration', original.configuration, [row]);
+                const sources = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'sources', original.sources, []);
+                const image = { ...original, configuration, sources };
+                if ((0, climate_automation_ledger_utils_1.canonical)(await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, id)) !== (0, climate_automation_ledger_utils_1.canonical)(image))
+                    fail();
+                return asJson({ revision: row.revision, image, history });
+            },
+            validateControllerRecreationInManager: (manager, id, preparation) => (0, virtual_thermostat_runtime_ownership_1.assertThermostatRecreationHistory)(manager, id, preparation.history),
+            withAutomationWrite: (work) => this.withAutomationWrite(work),
+            resolveActionInManager: (manager, id, action) => this.resolveAction(manager, id, action),
+            retireControllerInManager: (manager, slot) => this.retireController(manager, slot),
+            beginSourceMutation: (producerKey, subjectId, generationId) => this.beginSourceMutation(producerKey, subjectId, generationId),
+            graphRefreshVersion: 1,
+            ownedSettlementVersion: 1,
+            settleInstalled: (slots, producer, owned) => this.settleInstalled(slots, producer, owned),
+            readControllerInManager: (manager, id) => this.readController(manager, id),
+            validateSelectionInManager: async (manager, id, _facts, value) => {
+                const row = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: id });
+                const owner = await manager.findOneBy(devices_virtual_entity_1.VirtualDeviceEntity, { id });
+                return owner?.enabled === true && !!row && this.selection(row, value) !== null;
+            },
+            installControllerInManager: (manager, slot) => this.installController(manager, slot),
+            refreshControllerInManager: (manager, slot, before, kind) => this.refreshController(manager, slot, before, kind),
+        };
+    }
+    onModuleInit() {
+        if (process.env.FB_CLI === 'on')
+            return;
+        if (this.destroyed || this.registration)
+            fail();
+        this.registration = this.registry.registerProviderOwned(exports.THERMOSTAT_AUTOMATION_PROVIDER, this.provider) ?? undefined;
+        if (!this.registration)
+            fail();
+        this.removeCompletion = this.graph.observeCompletion((revision, current) => this.renewCompletedGraph(revision, current));
+    }
+    async onApplicationBootstrap() {
+        if (process.env.FB_CLI === 'on')
+            return;
+        const provider = this.registry.captureProvider(exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        if (!this.structure || this.destroyed || provider?.implementation !== this.provider)
+            fail();
+        await this.structure.runExclusive(async () => {
+            const owner = this.structure.captureExclusiveOwner();
+            let receipt;
+            const sql = await this.database.transaction(async (manager) => {
+                receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => owner() && !this.destroyed && provider.isCurrent());
+                await manager.query('UPDATE "devices_virtual_graph_revision" SET "revision"="revision" WHERE 0');
+                const expected = await (0, virtual_thermostat_ownership_sql_1.climateDeletionCaptureSql)(manager);
+                const read = () => manager.query('SELECT "sql" FROM sqlite_master WHERE "name" = ?', [
+                    'virtual_thermostat_capture_admitted_deletion',
+                ]);
+                const before = await read();
+                if (!before.length && this.database.options.synchronize === true)
+                    await manager.query(expected);
+                const after = await read();
+                if (after.length !== 1 || after[0].sql !== expected)
+                    fail();
+                return expected;
+            });
+            if (receipt?.outcome !== 'committed' || !owner() || this.destroyed || !provider.isCurrent())
+                fail();
+            this.deletionSchema = sql;
+        });
+    }
+    async assertDeletionSchema(manager) {
+        if (this.destroyed || !this.deletionSchema)
+            fail();
+        const rows = await manager.query('SELECT "sql" FROM sqlite_master WHERE "name" = ?', [
+            'virtual_thermostat_capture_admitted_deletion',
+        ]);
+        if (rows.length !== 1 || rows[0].sql !== this.deletionSchema)
+            fail();
+    }
+    async validateDeletedController(manager, id, retained) {
+        await this.assertDeletionSchema(manager);
+        if ((await manager.query('SELECT "id" FROM "devices_module_devices" WHERE "id" = ?', [id])).length)
+            fail();
+        if ((0, climate_automation_ledger_utils_1.canonical)(await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, id)) !== (0, climate_automation_ledger_utils_1.canonical)(retained))
+            fail();
+    }
+    async captureCreationPredecessor(id) {
+        const provider = this.registry.captureProvider(exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        const runtime = this.runtime;
+        const current = () => !this.destroyed &&
+            !!provider &&
+            provider.isCurrent() &&
+            provider.implementation === this.provider &&
+            this.runtime === runtime;
+        if (!current())
+            fail();
+        const slot = id ? await this.database.manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId: id }) : null;
+        const proof = slot
+            ? await this.database.manager.findOneBy(climate_automation_entity_1.ClimateAutomationDeletionEntity, {
+                controllerId: id,
+                controllerIncarnation: slot.controllerIncarnation,
+                consumedByIncarnation: (0, typeorm_1.IsNull)(),
+            })
+            : null;
+        const expectedSlot = slot && (0, climate_automation_ledger_utils_1.canonical)({ ...slot });
+        const expectedProof = proof && (0, climate_automation_ledger_utils_1.canonical)({ ...proof });
+        if (!current())
+            fail();
+        if (proof) {
+            this.revoke(id);
+            await (runtime?.capture(id) ?? Promise.resolve());
+            if (!current())
+                fail();
+        }
+        return async (manager) => {
+            if (!current())
+                fail();
+            (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, current);
+            if (proof) {
+                const actualSlot = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId: id });
+                const actualProof = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationDeletionEntity, { deletionId: proof.deletionId });
+                if (!actualSlot ||
+                    !actualProof ||
+                    (0, climate_automation_ledger_utils_1.canonical)({ ...actualSlot }) !== expectedSlot ||
+                    (0, climate_automation_ledger_utils_1.canonical)({ ...actualProof }) !== expectedProof)
+                    fail();
+            }
+        };
+    }
+    async captureCreation(manager, id, predecessor) {
+        if (predecessor)
+            await predecessor(manager);
+        const provider = this.registry.captureProvider(exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        if (!provider || provider.implementation !== this.provider || this.destroyed)
+            fail();
+        const current = () => !this.destroyed && provider.isCurrent() && provider.implementation === this.provider;
+        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, current);
+        const scope = this.ledger.currentScope(manager);
+        const recreate = await this.ledger.captureControllerRecreation(manager, scope, id);
+        if (!current())
+            fail();
+        const finish = async () => {
+            if (!current())
+                fail();
+            if (!recreate)
+                return this.initializeCreated(manager, id);
+            const slot = await this.ledger.readSlot(manager, scope, id, true, exports.THERMOSTAT_AUTOMATION_PROVIDER);
+            await recreate.consume(slot);
+        };
+        if (!recreate)
+            return Object.freeze({ finish });
+        const prepared = recreate.preparation;
+        return Object.freeze({
+            expectedRevision: prepared.revision,
+            finish,
+            beforePersist: async () => {
+                if (!current())
+                    fail();
+                const image = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, id);
+                if ((0, climate_automation_ledger_utils_1.canonical)({ ...image, properties: [] }) !== (0, climate_automation_ledger_utils_1.canonical)(prepared.image))
+                    fail();
+                await (0, virtual_thermostat_runtime_ownership_1.assertThermostatRecreationHistory)(manager, id, prepared.history);
+                return image;
+            },
+        });
+    }
+    onModuleDestroy() {
+        this.destroyed = true;
+        this.removeCompletion?.();
+        this.removeCompletion = undefined;
+        this.runtime = undefined;
+        this.publication = undefined;
+        this.localAdmissions.clear();
+        this.mutationVacancies.clear();
+        for (const cohort of this.mutationCohorts.values())
+            cohort.valid = false;
+        this.mutationCohorts.clear();
+        this.registration?.dispose();
+        this.registration = undefined;
+    }
+    revoke(id) {
+        this.mutationVacancies.delete(id);
+        this.localAdmissions.delete(id);
+        this.installations.delete(id);
+    }
+    removeOriginalInstallation(id, original) {
+        if (this.installations.get(id) !== original)
+            return;
+        const pending = this.localAdmissions.get(id);
+        if (original.attempt && pending?.attempt && pending.attempt !== original.attempt && pending.prior === original)
+            this.removedPredecessors.set(pending, original);
+        this.installations.delete(id);
+    }
+    registerRuntime(capture, request) {
+        if (this.destroyed || this.runtime)
+            fail();
+        const registration = Object.freeze({ capture, request });
+        this.runtime = registration;
+        return () => {
+            if (this.runtime === registration) {
+                this.runtime = undefined;
+                this.localAdmissions.clear();
+            }
+        };
+    }
+    async restoreCurrentInstallations() {
+        const runtime = this.runtime, provider = this.registry.captureProvider(exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        if (!runtime ||
+            this.restoredRuntime === runtime ||
+            this.destroyed ||
+            provider?.implementation !== this.provider ||
+            !this.structure)
+            return;
+        this.restoredRuntime = runtime;
+        const rows = await this.database.manager.findBy(climate_automation_entity_1.ClimateAutomationSlotEntity, {
+            providerKey: exports.THERMOSTAT_AUTOMATION_PROVIDER,
+            state: 'LIVE',
+        });
+        const groups = new Map();
+        for (const row of rows)
+            groups.set(row.generationId, [...(groups.get(row.generationId) ?? []), { ...row }]);
+        for (const slots of groups.values()) {
+            await Promise.all(slots.map((slot) => this.beginMutation(slot.controllerId)));
+            const admitted = new Map();
+            let complete = false;
+            try {
+                complete = await this.structure.runShared(() => this.database.transaction(async (manager) => {
+                    if (this.runtime !== runtime || !provider.isCurrent())
+                        return false;
+                    const source = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, {
+                        generationId: slots[0].generationId,
+                    });
+                    const producer = source && this.registry.captureProducer(source.producerKey);
+                    if (!source?.isCurrent || source.state !== 'FINALIZED_LIVE' || !producer)
+                        return false;
+                    for (const slot of slots.sort((a, b) => a.controllerId.localeCompare(b.controllerId))) {
+                        if (!(await this.activateLocal(manager, slot, producer, true)))
+                            return false;
+                        const original = this.installations.get(slot.controllerId);
+                        if (!original)
+                            return false;
+                        admitted.set(slot.controllerId, original);
+                    }
+                    return (this.runtime === runtime &&
+                        provider.isCurrent() &&
+                        producer.isCurrent() &&
+                        [...admitted].every(([id, original]) => this.installations.get(id) === original && original.providerCurrent() && original.graphCurrent()));
+                }));
+                complete = complete && [...admitted].every(([id, original]) => this.installations.get(id) === original);
+                if (complete) {
+                    const admission = {};
+                    this.generationAdmissions.set(slots[0].generationId, admission);
+                    for (const [id, original] of admitted)
+                        this.installations.set(id, { ...original, settled: true, admission });
+                }
+            }
+            finally {
+                if (!complete)
+                    for (const [id, original] of admitted)
+                        if (this.installations.get(id) === original)
+                            this.revoke(id);
+            }
+        }
+    }
+    beginMutation(id) {
+        const runtime = this.installations.get(id)?.runtime ?? this.localAdmissions.get(id)?.runtime ?? this.runtime;
+        this.revoke(id);
+        return runtime?.capture(id) ?? Promise.resolve();
+    }
+    registerPublication(run) {
+        if (this.destroyed || this.publication)
+            fail();
+        const publication = Object.freeze({ run });
+        this.publication = publication;
+        return () => {
+            if (this.publication === publication)
+                this.publication = undefined;
+        };
+    }
+    async beginSourceMutation(producerKey, subjectId, generationId) {
+        let cohort = this.mutationCohorts.get(generationId);
+        if (cohort?.closing) {
+            cohort.valid = false;
+            cohort = undefined;
+        }
+        if (!cohort) {
+            const group = new Map();
+            for (const [id, original] of this.installations) {
+                const source = JSON.parse(original.source);
+                if (source.producerKey === producerKey &&
+                    source.subjectId === subjectId &&
+                    source.generationId === generationId)
+                    group.set(id, original);
+            }
+            cohort = {
+                producerKey,
+                subjectId,
+                generationId,
+                group,
+                admission: this.generationAdmissions.get(generationId),
+                owners: new Set(),
+                token: {},
+                valid: true,
+                closing: false,
+            };
+            this.mutationCohorts.set(generationId, cohort);
+        }
+        if (cohort.producerKey !== producerKey || cohort.subjectId !== subjectId)
+            fail();
+        const originalCohort = cohort;
+        const token = {};
+        cohort.owners.add(token);
+        const ids = new Set([
+            ...cohort.group.keys(),
+            ...[...this.localAdmissions].filter(([, pending]) => pending.generationId === generationId).map(([id]) => id),
+        ]);
+        const jobs = [...ids].map(async (id) => {
+            const original = originalCohort.group.get(id);
+            const runtime = original?.runtime ?? this.localAdmissions.get(id)?.runtime ?? this.runtime;
+            if (original) {
+                if (this.installations.get(id) === original) {
+                    this.revoke(id);
+                    this.mutationVacancies.set(id, { original, token: originalCohort.token });
+                }
+                else if (this.installations.has(id) ||
+                    this.localAdmissions.has(id) ||
+                    this.mutationVacancies.get(id)?.token !== originalCohort.token) {
+                    originalCohort.valid = false;
+                    return;
+                }
+            }
+            else
+                this.revoke(id);
+            await runtime?.capture(id);
+        });
+        const results = await Promise.allSettled(jobs);
+        const failure = results.find((result) => result.status === 'rejected');
+        let consumed = false;
+        const completion = Object.freeze({
+            finish: async (outcome = 'unknown') => {
+                if (consumed)
+                    return;
+                consumed = true;
+                if (outcome !== 'rolled_back' && outcome !== 'not_started')
+                    originalCohort.valid = false;
+                originalCohort.owners.delete(token);
+                if (originalCohort.owners.size)
+                    return;
+                originalCohort.closing = true;
+                const current = () => !this.destroyed &&
+                    originalCohort.valid &&
+                    this.mutationCohorts.get(generationId) === originalCohort &&
+                    this.generationAdmissions.get(generationId) === originalCohort.admission &&
+                    [...originalCohort.group].every(([id, original]) => this.mutationVacancies.get(id)?.token === originalCohort.token &&
+                        this.mutationVacancies.get(id)?.original === original &&
+                        original.custodyCurrent());
+                try {
+                    if (!current())
+                        return;
+                    const graphCurrent = this.graph.capturePublishGuard();
+                    const sourceGuards = new Map([...originalCohort.group].map(([id, original]) => [id, original.captureSourceCurrent()]));
+                    const revision = await this.graph.revision();
+                    if (current())
+                        await this.renewGroup(originalCohort.group, revision, graphCurrent, { current, sourceGuards });
+                }
+                finally {
+                    for (const id of originalCohort.group.keys())
+                        if (this.mutationVacancies.get(id)?.token === originalCohort.token)
+                            this.mutationVacancies.delete(id);
+                    if (this.mutationCohorts.get(generationId) === originalCohort)
+                        this.mutationCohorts.delete(generationId);
+                }
+            },
+        });
+        if (failure?.status === 'rejected') {
+            await completion.finish('unknown');
+            throw failure.reason;
+        }
+        return completion;
+    }
+    async withAutomationWrite(work) {
+        const provider = this.registry.captureProvider(exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        if (!this.structure || this.destroyed || provider?.implementation !== this.provider)
+            fail();
+        return this.structure.runExclusive(async () => {
+            const owner = this.structure.captureExclusiveOwner();
+            let receipt;
+            return this.graph.withControllerMutationWrite(work, undefined, (manager) => {
+                receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => owner() && provider.isCurrent());
+            }, () => {
+                if (receipt?.outcome !== 'committed')
+                    fail();
+            });
+        });
+    }
+    async resolveAction(manager, id, action) {
+        if (!action || typeof action !== 'object' || Array.isArray(action))
+            return null;
+        const input = action;
+        const row = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: id });
+        const owner = await manager.findOneBy(devices_virtual_entity_1.VirtualDeviceEntity, { id });
+        if (!owner?.enabled ||
+            owner.category !== devices_constants_1.DeviceCategory.THERMOSTAT ||
+            owner.mode !== devices_virtual_entity_1.VirtualDeviceMode.CLIMATE_CONTROLLER ||
+            !row?.comfort?.automation_enabled ||
+            row.locked)
+            return null;
+        if (input.thermostat_preset === undefined && input.mode !== 'heat' && input.mode !== 'cool')
+            return null;
+        let selection;
+        if (input.thermostat_preset !== undefined)
+            selection = { preset: input.thermostat_preset, setpoints: null };
+        else {
+            if ((input.setpoint === undefined) === (input.setpoint_delta === undefined))
+                return null;
+            const manual = row.comfort.presets.find((preset) => preset.preset === row.comfort.selected_preset)?.setpoints;
+            const values = {
+                heating_setpoint: manual ? manual.heating_setpoint : row.policy.heatingSetpoint,
+                cooling_setpoint: manual ? manual.cooling_setpoint : row.policy.coolingSetpoint,
+            };
+            for (const key of [input.mode === 'heat' ? 'heating_setpoint' : 'cooling_setpoint']) {
+                const range = key === 'heating_setpoint' ? row.comfort.heating_range : row.comfort.cooling_range;
+                if (!range)
+                    return null;
+                if (input.setpoint !== undefined)
+                    values[key] = input.setpoint;
+                else if (typeof values[key] === 'number')
+                    values[key] += input.setpoint_delta;
+                else
+                    return null;
+            }
+            selection = { preset: null, setpoints: values };
+        }
+        return this.selection(row, asJson(selection)) ? asJson(selection) : null;
+    }
+    async retireController(manager, slot, attempt) {
+        if (attempt) {
+            if (this.retiringGenerations.get(attempt.generation) !== attempt ||
+                this.generationAdmissions.get(attempt.generation) !== attempt)
+                fail();
+        }
+        else {
+            const vacancy = this.mutationVacancies.get(slot.controllerId);
+            if (!vacancy ||
+                vacancy.original.slot !== (0, climate_automation_ledger_utils_1.canonical)(slot) ||
+                this.installations.has(slot.controllerId) ||
+                this.localAdmissions.has(slot.controllerId))
+                this.revoke(slot.controllerId);
+        }
+        if (!['LIVE', 'PROVISIONAL'].includes(slot.state) || !slot.baselineId || !slot.selection)
+            fail();
+        const actual = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId: slot.controllerId });
+        const source = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, { generationId: slot.generationId });
+        if (!actual ||
+            (0, climate_automation_ledger_utils_1.canonical)({ ...actual }) !== (0, climate_automation_ledger_utils_1.canonical)(slot) ||
+            !source ||
+            source.ownerId !== slot.ownerId ||
+            !source.isCurrent)
+            fail();
+        const row = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: slot.controllerId });
+        if (!row?.comfort?.automation_baseline)
+            return;
+        const mirror = row.comfort.automation_baseline;
+        const selection = JSON.parse(slot.selection);
+        if (mirror.actor_id !== slot.baselineId ||
+            (0, climate_automation_ledger_utils_1.canonical)({ preset: mirror.preset, setpoints: mirror.setpoints }) !== (0, climate_automation_ledger_utils_1.canonical)(selection))
+            return;
+        const before = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, slot.controllerId);
+        if (!Number.isSafeInteger(row.revision) || row.revision >= Number.MAX_SAFE_INTEGER)
+            fail();
+        row.revision++;
+        row.comfort.automation_baseline = null;
+        const configuration = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'configuration', before.configuration, [row]);
+        await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, slot.controllerId, { ...before, configuration });
+    }
+    ownSettlement(slots, owned) {
+        const originals = slots.map((slot) => Object.freeze({ ...slot }));
+        const generation = originals[0]?.generationId;
+        if (!generation || originals.some((slot) => slot.generationId !== generation))
+            fail();
+        const runtime = this.runtime, publication = this.publication;
+        const retire = this.retireController.bind(this);
+        const read = this.readController.bind(this);
+        let active = true, finished = false;
+        let permit;
+        const isSettled = owned.isSettled;
+        const attempt = Object.freeze({
+            generation,
+            current: () => active && owned.isCurrent(),
+            settled: () => isSettled?.call(owned) === true,
+        });
+        const eligible = !this.retiringGenerations.has(generation);
+        if (eligible)
+            this.generationAdmissions.set(generation, attempt);
+        const same = () => eligible &&
+            !this.destroyed &&
+            this.runtime === runtime &&
+            this.publication === publication &&
+            this.generationAdmissions.get(generation) === attempt &&
+            owned.isCurrent();
+        const invalidateOriginal = () => {
+            active = false;
+            for (const slot of originals) {
+                const original = this.installations.get(slot.controllerId);
+                if (original?.attempt === attempt)
+                    this.removeOriginalInstallation(slot.controllerId, original);
+                if (this.localAdmissions.get(slot.controllerId)?.attempt === attempt)
+                    this.localAdmissions.delete(slot.controllerId);
+            }
+        };
+        owned.accept(Object.freeze({
+            isCurrent: () => active && same(),
+            invalidateOriginal,
+            beginRetirement: () => {
+                invalidateOriginal();
+                if (permit)
+                    return permit;
+                if (!same() || this.retiringGenerations.has(generation))
+                    return null;
+                this.retiringGenerations.set(generation, attempt);
+                const jobs = originals.map((slot) => {
+                    try {
+                        return runtime?.capture(slot.controllerId) ?? Promise.resolve();
+                    }
+                    catch (cause) {
+                        return Promise.reject(cause);
+                    }
+                });
+                const predecessors = Promise.allSettled(jobs).then((results) => {
+                    const failure = results.find((result) => result.status === 'rejected');
+                    if (failure?.status === 'rejected')
+                        throw failure.reason;
+                });
+                void predecessors.catch(() => undefined);
+                permit = Object.freeze({
+                    predecessors,
+                    isCurrent: () => !finished && same() && this.retiringGenerations.get(generation) === attempt,
+                    finish: () => {
+                        finished = true;
+                        if (this.generationAdmissions.get(generation) === attempt)
+                            this.generationAdmissions.delete(generation);
+                        if (this.retiringGenerations.get(generation) === attempt)
+                            this.retiringGenerations.delete(generation);
+                    },
+                });
+                return permit;
+            },
+            retireInManager: async (manager) => {
+                if (!permit?.isCurrent())
+                    fail();
+                for (const slot of originals) {
+                    if ((0, climate_automation_ledger_utils_1.canonical)(await read(manager, slot.controllerId)) !== slot.installEvidence)
+                        fail();
+                    await retire(manager, slot, attempt);
+                }
+            },
+        }));
+        return attempt;
+    }
+    async settleInstalled(slots, producer, owned) {
+        const attempt = owned ? this.ownSettlement(slots, owned) : undefined;
+        const publication = this.publication, runtime = this.runtime;
+        if (!publication || this.destroyed)
+            return false;
+        await controller_publication_context_1.ControllerPublicationContext.complete(async () => {
+            for (const slot of slots)
+                await publication.run(slot.controllerId);
+        });
+        if (this.publication !== publication || this.runtime !== runtime || this.destroyed)
+            return false;
+        const admitted = new Map();
+        const retireOriginals = () => {
+            for (const [id, original] of admitted)
+                this.removeOriginalInstallation(id, original);
+            return false;
+        };
+        try {
+            for (const slot of slots) {
+                if (!(await this.activateLocal(this.database.manager, slot, producer, false, attempt)))
+                    return retireOriginals();
+                const original = this.installations.get(slot.controllerId);
+                if (!original)
+                    return retireOriginals();
+                admitted.set(slot.controllerId, original);
+            }
+        }
+        catch (cause) {
+            retireOriginals();
+            throw cause;
+        }
+        if (runtime?.request) {
+            const results = await Promise.allSettled([...admitted.keys()].map((id) => Promise.resolve().then(() => runtime.request(id))));
+            if (results.some((result) => result.status === 'rejected'))
+                return retireOriginals();
+        }
+        if (this.runtime !== runtime ||
+            this.publication !== publication ||
+            this.destroyed ||
+            [...admitted].some(([id, original]) => this.installations.get(id) !== original || !original.providerCurrent() || !original.graphCurrent()))
+            return retireOriginals();
+        for (const original of admitted.values())
+            original.settled = true;
+        return true;
+    }
+    selection(row, value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value) || !row.comfort?.automation_enabled || row.locked)
+            return null;
+        const selection = value;
+        if ((selection.preset === null) === (selection.setpoints === null))
+            return null;
+        const setpoints = selection.preset
+            ? row.comfort.presets.find((entry) => entry.preset === selection.preset)?.setpoints
+            : selection.setpoints;
+        if (!setpoints || (0, virtual_thermostat_comfort_utils_1.validateThermostatSetpoints)(setpoints, row.comfort, row.policy).length)
+            return null;
+        return { preset: selection.preset, setpoints: selection.setpoints };
+    }
+    async readController(manager, id) {
+        const owner = await manager.findOneBy(devices_virtual_entity_1.VirtualDeviceEntity, { id });
+        const row = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: id });
+        if (!owner ||
+            owner.category !== devices_constants_1.DeviceCategory.THERMOSTAT ||
+            owner.mode !== devices_virtual_entity_1.VirtualDeviceMode.CLIMATE_CONTROLLER ||
+            row?.ownerDeviceId !== id)
+            return null;
+        return {
+            controllerRevision: row.revision,
+            graphRevision: await this.graph.revision(manager),
+            evidence: asJson({
+                owner: { id: owner.id, type: owner.type, enabled: owner.enabled, mode: owner.mode },
+                image: await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, id),
+            }),
+            legacyBaseline: asJson(row.comfort?.automation_baseline ?? null),
+        };
+    }
+    async installController(manager, slot) {
+        const before = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, slot.controllerId);
+        const row = await manager.findOneByOrFail(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: slot.controllerId });
+        const current = await this.readController(manager, slot.controllerId);
+        const owner = await manager.findOneBy(devices_virtual_entity_1.VirtualDeviceEntity, { id: slot.controllerId });
+        if (!owner?.enabled ||
+            !current ||
+            (0, climate_automation_ledger_utils_1.canonical)(current) !== slot.installEvidence ||
+            slot.manualHold ||
+            slot.state !== 'PROVISIONAL')
+            fail();
+        const selection = this.selection(row, JSON.parse(slot.selection));
+        if (!selection || (row.comfort.automation_baseline !== null && row.comfort.automation_baseline !== undefined))
+            fail();
+        if (!Number.isSafeInteger(row.revision) || row.revision >= Number.MAX_SAFE_INTEGER)
+            fail();
+        row.revision++;
+        row.comfort.automation_baseline = { ...selection, actor_id: slot.baselineId, revision: row.revision };
+        const configuration = await (0, thermostat_controller_mutation_1.writeControllerPartition)(manager, 'configuration', before.configuration, [row]);
+        await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, slot.controllerId, { ...before, configuration });
+        return this.readController(manager, slot.controllerId);
+    }
+    async withEvidenceWrite(work) {
+        const owner = this.structure.captureExclusiveOwner();
+        return this.database.transaction(async (manager) => {
+            const receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+            const window = (0, sqlite_data_source_1.captureSqliteNoMutationWindow)(manager, owner);
+            await window.reserveZeroRows('devices_module_climate_automation_slots', 'slotRevision');
+            const result = await this.ledger.inAdmittedManager(manager, receipt, async () => {
+                const value = await work(manager);
+                window.beginFinalValidation();
+                return value;
+            });
+            window.applied();
+            return result;
+        });
+    }
+    async withRenewalWrite(work) {
+        const owner = this.structure.captureExclusiveOwner();
+        return this.database.transaction(async (manager) => {
+            const receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+            const window = (0, sqlite_data_source_1.captureSqliteNoMutationWindow)(manager, owner);
+            await window.reserveZeroRows('devices_module_climate_automation_slots', 'slotRevision');
+            const checkpoint = window.beginReads();
+            const renewed = await this.ledger.inAdmittedManager(manager, receipt, async () => {
+                const result = await work(manager);
+                if (result === true)
+                    window.beginFinalValidation();
+                else if (result !== false)
+                    fail();
+                return result;
+            });
+            if (renewed)
+                window.applied();
+            else
+                window.armUnchanged(checkpoint);
+            return renewed;
+        });
+    }
+    async renewCompletedGraph(revision, current) {
+        const groups = new Map();
+        for (const [id, original] of this.installations) {
+            const slot = JSON.parse(original.slot);
+            const group = groups.get(slot.generationId) ?? new Map();
+            group.set(id, original);
+            groups.set(slot.generationId, group);
+        }
+        for (const group of groups.values())
+            await this.renewGroup(group, revision, current);
+    }
+    async renewGroup(group, revision, graphCurrent, recovery) {
+        const first = group.values().next().value;
+        if (!first || !this.structure)
+            return;
+        const generation = JSON.parse(first.slot).generationId;
+        const originalAdmission = this.generationAdmissions.get(generation);
+        const sourceGuard = (id, original) => recovery?.sourceGuards.get(id) ?? original.sourceCurrent;
+        const eligible = () => !this.destroyed &&
+            graphCurrent() &&
+            this.graph.isRevisionCurrent(revision) &&
+            this.generationAdmissions.get(generation) === originalAdmission &&
+            !this.retiringGenerations.has(generation) &&
+            (!recovery || recovery.current()) &&
+            [...group].every(([id, original]) => original.settled &&
+                original.admission === originalAdmission &&
+                (!original.attempt || original.attempt.settled()) &&
+                original.custodyCurrent() &&
+                sourceGuard(id, original)() &&
+                (recovery ? !this.installations.has(id) : this.installations.get(id) === original) &&
+                !this.localAdmissions.has(id));
+        if (!eligible())
+            return;
+        if ((0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.database))
+            fail();
+        const renew = async () => {
+            const owner = this.structure.captureExclusiveOwner();
+            const current = () => owner() && eligible();
+            if (!current())
+                return;
+            let receipt;
+            const next = new Map();
+            const renewed = await this.withRenewalWrite(async (manager) => {
+                receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+                const scope = this.ledger.currentScope(manager);
+                const members = await manager.findBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { generationId: generation, state: 'LIVE' });
+                if (!current() || members.length !== group.size || members.some((slot) => !group.has(slot.controllerId)))
+                    return false;
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, current);
+                this.graphRenewals.set(manager, {
+                    revision,
+                    current,
+                    slots: new Map([...group].map(([id, original]) => [id, original.slot])),
+                });
+                try {
+                    for (const [id, original] of group) {
+                        if (!current())
+                            fail();
+                        const slot = await this.ledger.readSlot(manager, scope, id, true, exports.THERMOSTAT_AUTOMATION_PROVIDER);
+                        const source = slot.facts && (await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, { generationId: generation }));
+                        if (!current() ||
+                            !slot.facts ||
+                            (0, climate_automation_ledger_utils_1.canonical)(slot.facts) !== original.slot ||
+                            !source?.isCurrent ||
+                            source.state !== 'FINALIZED_LIVE' ||
+                            (0, climate_automation_ledger_utils_1.canonical)({ ...source }) !== original.source ||
+                            slot.controller?.graphRevision !== revision)
+                            fail();
+                        const refreshed = await this.ledger.refreshInstalledSlot(manager, scope, slot, 'graph', !!recovery);
+                        if (!current())
+                            fail();
+                        next.set(id, refreshed.facts);
+                    }
+                }
+                finally {
+                    this.graphRenewals.delete(manager);
+                }
+                return true;
+            });
+            if (!renewed)
+                return;
+            if (receipt?.outcome !== 'committed' || next.size !== group.size)
+                fail();
+            if (!owner() || !graphCurrent() || !this.graph.isRevisionCurrent(revision))
+                fail();
+            if (!eligible())
+                return;
+            const admission = {};
+            this.generationAdmissions.set(generation, admission);
+            for (const [id, original] of group) {
+                const sourceCurrent = sourceGuard(id, original);
+                this.installations.set(id, {
+                    ...original,
+                    admission,
+                    attempt: undefined,
+                    slot: (0, climate_automation_ledger_utils_1.canonical)(next.get(id)),
+                    graphCurrent,
+                    sourceCurrent,
+                    providerCurrent: () => original.custodyCurrent() && sourceCurrent() && this.generationAdmissions.get(generation) === admission,
+                });
+            }
+        };
+        if (this.structure.hasCurrentStructuralLease())
+            await renew();
+        else
+            await this.structure.runExclusive(renew);
+    }
+    async captureInstalledIntent(manager, id) {
+        const scope = this.ledger.currentScope(manager);
+        const slot = await this.ledger.readSlot(manager, scope, id, false);
+        return slot.facts?.state === 'LIVE' && !slot.facts.manualHold
+            ? this.ledger.readSlot(manager, scope, id, true, exports.THERMOSTAT_AUTOMATION_PROVIDER)
+            : null;
+    }
+    async captureManualBaseline(manager, id, graphDelta = 1) {
+        const owned = await this.captureInstalledIntent(manager, id);
+        if (!owned)
+            return null;
+        const slot = owned.facts, controller = owned.controller;
+        if (!slot?.installEvidence || !controller)
+            fail();
+        const installed = JSON.parse(slot.installEvidence);
+        if (controller.graphRevision !== installed.graphRevision + graphDelta ||
+            (0, climate_automation_ledger_utils_1.canonical)({ ...controller, graphRevision: installed.graphRevision }) !== slot.installEvidence)
+            fail();
+        return owned;
+    }
+    captureManualSlot(manager, id) {
+        return this.ledger.readSlot(manager, this.ledger.currentScope(manager), id, false);
+    }
+    async captureAppliedAuthority(manager, id, expected) {
+        const scope = this.ledger.currentScope(manager);
+        await this.ledger.readSlot(manager, scope, id, true, exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, id, expected);
+    }
+    async captureUnchangedAuthority(manager, id) {
+        const scope = this.ledger.currentScope(manager);
+        const slot = await this.ledger.readSlot(manager, scope, id, true, exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        if (slot.facts &&
+            (![slot.facts.slotRevision, slot.facts.manualCounter].every((value) => Number.isSafeInteger(value) && value >= 1) ||
+                ![slot.facts.controllerIncarnation, slot.facts.manualGeneration].every((value) => (0, class_validator_1.isUUID)(value))))
+            fail();
+        if (slot.facts?.generationId) {
+            const source = await manager.findOneByOrFail(climate_automation_entity_1.ClimateAutomationSourceEntity, {
+                generationId: slot.facts.generationId,
+            });
+            await this.ledger.readSource(manager, scope, source.producerKey, source.subjectId);
+        }
+    }
+    async refreshIntent(manager, before, kind = 'intent', qualifyResult) {
+        if (!before)
+            return null;
+        const scope = this.ledger.currentScope(manager);
+        const refreshed = await this.ledger.refreshInstalledSlot(manager, scope, before, kind);
+        let open = true;
+        try {
+            qualifyResult?.(this.selectionView(refreshed.facts, refreshed.controller.controllerRevision, () => open && this.ledger.currentScope(manager) === scope));
+        }
+        finally {
+            open = false;
+        }
+        return refreshed.facts;
+    }
+    selectionView(slot, revision, isCurrent) {
+        if (slot.state !== 'LIVE' || slot.manualHold || !slot.baselineId || !slot.selection)
+            fail();
+        const selection = JSON.parse(slot.selection);
+        return {
+            baseline: { ...selection, actor_id: slot.baselineId, revision },
+            manualHold: false,
+            isCurrent,
+        };
+    }
+    async refreshController(manager, slot, before, kind) {
+        const installed = JSON.parse(slot.installEvidence);
+        if (kind === 'graph') {
+            const original = this.graphRenewals.get(manager);
+            if (!original?.current() ||
+                original.slots.get(slot.controllerId) !== (0, climate_automation_ledger_utils_1.canonical)(slot) ||
+                before.graphRevision !== original.revision)
+                fail();
+            const after = await this.readController(manager, slot.controllerId);
+            if (!after ||
+                !Number.isSafeInteger(after.graphRevision) ||
+                after.graphRevision < installed.graphRevision ||
+                !original.current() ||
+                (0, climate_automation_ledger_utils_1.canonical)(after) !== (0, climate_automation_ledger_utils_1.canonical)(before) ||
+                (0, climate_automation_ledger_utils_1.canonical)({ ...after, graphRevision: installed.graphRevision }) !== slot.installEvidence)
+                fail();
+            return after;
+        }
+        if (kind !== 'intent' && kind !== 'watermark')
+            fail();
+        if ((before.graphRevision !== installed.graphRevision &&
+            !(kind === 'intent' && before.graphRevision === installed.graphRevision + 1)) ||
+            (0, climate_automation_ledger_utils_1.canonical)({ ...before, graphRevision: installed.graphRevision }) !== (0, climate_automation_ledger_utils_1.canonical)(installed))
+            fail();
+        const after = await this.readController(manager, slot.controllerId);
+        const row = await manager.findOneByOrFail(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: slot.controllerId });
+        if (!after ||
+            after.controllerRevision !== before.controllerRevision + (kind === 'intent' ? 1 : 0) ||
+            after.graphRevision !== installed.graphRevision + (kind === 'intent' ? 1 : 0) ||
+            (0, climate_automation_ledger_utils_1.canonical)(after.legacyBaseline) !== (0, climate_automation_ledger_utils_1.canonical)(before.legacyBaseline) ||
+            !this.selection(row, JSON.parse(slot.selection)))
+            fail();
+        const beforeEvidence = before.evidence;
+        const afterEvidence = after.evidence;
+        const oldConfig = beforeEvidence.image.configuration[0];
+        const newConfig = afterEvidence.image.configuration[0];
+        if (kind === 'watermark') {
+            const oldComfort = JSON.parse(oldConfig.comfort);
+            const newComfort = JSON.parse(newConfig.comfort);
+            const oldOverride = oldComfort.temporary_override;
+            const newOverride = newComfort.temporary_override;
+            if (!oldOverride ||
+                !newOverride ||
+                newOverride.id !== oldOverride.id ||
+                !Number.isFinite(newOverride.wall_watermark_ms) ||
+                newOverride.wall_watermark_ms < oldOverride.wall_watermark_ms ||
+                (0, climate_automation_ledger_utils_1.canonical)({
+                    ...newComfort,
+                    temporary_override: { ...newOverride, wall_watermark_ms: oldOverride.wall_watermark_ms },
+                }) !== (0, climate_automation_ledger_utils_1.canonical)(oldComfort))
+                fail();
+        }
+        if ((0, climate_automation_ledger_utils_1.canonical)({
+            ...afterEvidence,
+            image: {
+                ...afterEvidence.image,
+                configuration: [{ ...newConfig, comfort: oldConfig.comfort, revision: oldConfig.revision }],
+            },
+        }) !== (0, climate_automation_ledger_utils_1.canonical)(beforeEvidence))
+            fail();
+        return after;
+    }
+    async manualFence(manager, id, hold, expected, takeover = true) {
+        this.revoke(id);
+        const scope = this.ledger.currentScope(manager);
+        const slot = expected ?? (await this.ledger.readSlot(manager, scope, id, false));
+        if (slot.facts && slot.facts.controllerId !== id)
+            fail();
+        if (slot.facts)
+            await this.ledger.fenceManual(manager, scope, slot, hold ?? slot.facts.manualHold, takeover);
+    }
+    async initializeCreated(manager, id) {
+        const scope = this.ledger.currentScope(manager);
+        const expected = await this.ledger.readSlot(manager, scope, id, true, exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        if (expected.facts)
+            fail();
+        await this.ledger.initializeSlot(manager, scope, { expected, releaseManualHold: true });
+    }
+    async explicitOptIn(manager, id) {
+        this.revoke(id);
+        const scope = this.ledger.currentScope(manager);
+        const row = await manager.findOneByOrFail(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId: id });
+        if (!row.comfort?.automation_enabled || row.comfort.automation_baseline != null)
+            return;
+        const slot = await this.ledger.readSlot(manager, scope, id, true, exports.THERMOSTAT_AUTOMATION_PROVIDER);
+        await this.ledger.initializeSlot(manager, scope, { expected: slot, releaseManualHold: true, explicitOptIn: true });
+    }
+    async activateLocal(manager, expected, expectedProducer, restoring = false, attempt) {
+        const runtime = this.runtime;
+        if (this.retiringGenerations.has(expected.generationId) ||
+            (attempt && (!attempt.current() || this.generationAdmissions.get(expected.generationId) !== attempt)))
+            return false;
+        const prior = this.installations.get(expected.controllerId);
+        const admission = Object.freeze({ generationId: expected.generationId, runtime, attempt, prior });
+        if (!attempt)
+            this.generationAdmissions.set(expected.generationId, admission);
+        this.localAdmissions.set(expected.controllerId, admission);
+        try {
+            const provider = this.registry.captureProvider(exports.THERMOSTAT_AUTOMATION_PROVIDER);
+            if (this.destroyed || !provider || provider.implementation !== this.provider)
+                return false;
+            const slot = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId: expected.controllerId });
+            const source = slot?.generationId
+                ? await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, { generationId: slot.generationId })
+                : null;
+            if (!slot ||
+                (0, climate_automation_ledger_utils_1.canonical)({ ...slot }) !== (0, climate_automation_ledger_utils_1.canonical)(expected) ||
+                slot.state !== 'LIVE' ||
+                slot.manualHold ||
+                !source?.isCurrent ||
+                source.state !== 'FINALIZED_LIVE')
+                return false;
+            const producer = this.registry.captureProducer(source.producerKey);
+            if (!producer ||
+                (expectedProducer &&
+                    (!expectedProducer.isCurrent() || producer.implementation !== expectedProducer.implementation)))
+                return false;
+            const methods = (0, creation_capture_1.captureCreation)(producer.implementation, ['validateInManager', 'captureCurrent']);
+            const sourceCurrent = (methods.values.captureCurrent == null
+                ? undefined
+                : (0, creation_capture_1.invokeCreation)(methods.values.captureCurrent, producer.implementation, source)) ?? (() => true);
+            if ((0, climate_automation_ledger_utils_1.canonical)(await (0, creation_capture_1.invokeCreation)(methods.values.validateInManager, producer.implementation, manager, source, restoring ? 'restore' : 'prepare', provider)) !== source.evidence)
+                return false;
+            const controller = await this.readController(manager, slot.controllerId);
+            if (this.runtime !== runtime ||
+                this.retiringGenerations.has(expected.generationId) ||
+                (attempt && (!attempt.current() || this.generationAdmissions.get(expected.generationId) !== attempt)) ||
+                this.localAdmissions.get(expected.controllerId) !== admission ||
+                (this.installations.get(expected.controllerId) !== prior &&
+                    !(prior &&
+                        this.installations.get(expected.controllerId) === undefined &&
+                        this.removedPredecessors.get(admission) === prior)) ||
+                !controller ||
+                (0, climate_automation_ledger_utils_1.canonical)(controller) !== slot.installEvidence ||
+                !provider.isCurrent() ||
+                !producer.isCurrent() ||
+                !sourceCurrent() ||
+                !methods.current() ||
+                (expectedProducer && !expectedProducer.isCurrent()) ||
+                !this.graph.isRevisionCurrent(controller.graphRevision))
+                return false;
+            const custodyCurrent = () => !this.destroyed &&
+                this.runtime === runtime &&
+                provider.isCurrent() &&
+                producer.isCurrent() &&
+                methods.current() &&
+                (!expectedProducer || expectedProducer.isCurrent());
+            this.installations.set(slot.controllerId, {
+                settled: !attempt && !restoring,
+                admission: attempt ?? admission,
+                custodyCurrent,
+                sourceCurrent,
+                captureSourceCurrent: () => (methods.values.captureCurrent == null
+                    ? undefined
+                    : (0, creation_capture_1.invokeCreation)(methods.values.captureCurrent, producer.implementation, source)) ?? (() => true),
+                attempt,
+                runtime,
+                slot: (0, climate_automation_ledger_utils_1.canonical)({ ...slot }),
+                source: (0, climate_automation_ledger_utils_1.canonical)({ ...source }),
+                graphCurrent: this.graph.capturePublishGuard(),
+                providerCurrent: () => (!attempt || (attempt.current() && this.generationAdmissions.get(attempt.generation) === attempt)) &&
+                    this.runtime === runtime &&
+                    provider.isCurrent() &&
+                    producer.isCurrent() &&
+                    sourceCurrent() &&
+                    methods.current() &&
+                    (!expectedProducer || expectedProducer.isCurrent()),
+            });
+            return true;
+        }
+        finally {
+            if (this.localAdmissions.get(expected.controllerId) === admission)
+                this.localAdmissions.delete(expected.controllerId);
+        }
+    }
+    async resolve(manager, row) {
+        const slot = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId: row.controllerId });
+        const installation = this.installations.get(row.controllerId);
+        const absent = (manualHold = slot?.manualHold ?? false) => ({
+            baseline: null,
+            manualHold,
+            isCurrent: () => false,
+        });
+        if (!slot ||
+            !installation ||
+            slot.state !== 'LIVE' ||
+            slot.manualHold ||
+            (0, climate_automation_ledger_utils_1.canonical)({ ...slot }) !== installation.slot)
+            return absent();
+        const source = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, { generationId: slot.generationId });
+        const controller = await this.readController(manager, row.controllerId);
+        if (!source?.isCurrent ||
+            source.state !== 'FINALIZED_LIVE' ||
+            (0, climate_automation_ledger_utils_1.canonical)({ ...source }) !== installation.source ||
+            !controller ||
+            (0, climate_automation_ledger_utils_1.canonical)(controller) !== slot.installEvidence ||
+            controller.controllerRevision !== row.revision)
+            return absent();
+        const isCurrent = () => !this.destroyed &&
+            this.installations.get(row.controllerId) === installation &&
+            installation.graphCurrent() &&
+            installation.providerCurrent();
+        if (!isCurrent())
+            return absent();
+        return this.selectionView(slot, row.revision, isCurrent);
+    }
+};
+exports.VirtualThermostatAutomationService = VirtualThermostatAutomationService;
+exports.VirtualThermostatAutomationService = VirtualThermostatAutomationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(4, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        climate_automation_registry_service_1.ClimateAutomationRegistryService,
+        climate_automation_ledger_service_1.ClimateAutomationLedgerService,
+        virtual_dependency_graph_service_1.VirtualDependencyGraphService,
+        device_structure_lock_service_1.DeviceStructureLockService])
+], VirtualThermostatAutomationService);
+//# sourceMappingURL=virtual-thermostat-automation.service.js.map