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

package/dist/plugins/spaces-home-control/services/space-climate-automation.service.js

@@ -0,0 +1,722 @@
+"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.SpaceClimateAutomationService = exports.SPACE_ACTIVITY_CLIMATE_PRODUCER = void 0;
+const node_crypto_1 = require("node:crypto");
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
+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 creation_capture_1 = require("../../../modules/devices/services/creation-capture");
+const device_structure_lock_service_1 = require("../../../modules/devices/services/device-structure-lock.service");
+const space_entity_1 = require("../../../modules/spaces/entities/space.entity");
+const space_lifecycle_registry_service_1 = require("../../../modules/spaces/services/space-lifecycle-registry.service");
+const spaces_constants_1 = require("../../../modules/spaces/spaces.constants");
+const activity_result_utils_1 = require("../activity/activity-result.utils");
+const space_activity_constants_1 = require("../activity/space-activity.constants");
+const space_activity_config_entity_1 = require("../entities/space-activity-config.entity");
+const space_activity_state_entity_1 = require("../entities/space-activity-state.entity");
+const spaces_home_control_constants_1 = require("../spaces-home-control.constants");
+const climate_intent_service_1 = require("./climate-intent.service");
+class UnsupportedThermostatSelection extends Error {
+}
+class SupersededCompletion extends Error {
+}
+exports.SPACE_ACTIVITY_CLIMATE_PRODUCER = 'space-activity:v1';
+let SpaceClimateAutomationService = class SpaceClimateAutomationService {
+    constructor(database, registry, ledger, structure, lifecycle, intents) {
+        this.database = database;
+        this.registry = registry;
+        this.ledger = ledger;
+        this.structure = structure;
+        this.lifecycle = lifecycle;
+        this.intents = intents;
+        this.completions = new WeakMap();
+        this.participants = new Map();
+        this.destroyed = false;
+        this.epochs = new Map();
+        this.mutations = new Map();
+        this.completionCohorts = new Map();
+        this.activeLifetimes = new Map();
+        this.admissionEpoch = {};
+        this.producer = {
+            captureCurrent: (source) => {
+                const evidence = JSON.parse(source.evidence);
+                const configurationKey = `${source.subjectId}/${evidence.configId}`;
+                const activationKey = `${source.subjectId}/activation/${evidence.activationId}`;
+                const blocked = () => this.destroyed ||
+                    this.mutations.has(source.subjectId) ||
+                    this.mutations.has(configurationKey) ||
+                    this.mutations.has(activationKey);
+                if (blocked())
+                    return () => false;
+                let lifetime = this.activeLifetimes.get(source.subjectId);
+                if (lifetime && lifetime.evidence !== source.evidence)
+                    return () => false;
+                const admissionEpoch = this.admissionEpoch;
+                return () => {
+                    if (!lifetime) {
+                        if (this.admissionEpoch !== admissionEpoch || blocked())
+                            return false;
+                        const qualified = this.activeLifetimes.get(source.subjectId);
+                        if (!qualified)
+                            return true;
+                        if (qualified.evidence !== source.evidence)
+                            return false;
+                        lifetime = qualified;
+                    }
+                    return this.lifetimeCurrent(lifetime);
+                };
+            },
+            validateInManager: (manager, source, purpose, provider) => this.validateSource(manager, source, purpose, provider),
+        };
+    }
+    onModuleInit() {
+        if (process.env.FB_CLI === 'on')
+            return;
+        if (this.destroyed || this.registration)
+            throw new Error('Activity climate participant unavailable');
+        this.registration =
+            this.registry.registerProducerOwned(exports.SPACE_ACTIVITY_CLIMATE_PRODUCER, this.producer) ?? undefined;
+        if (!this.registration)
+            throw new Error('Activity climate producer already registered');
+        this.removeLifecycle = this.lifecycle.register({
+            reconcile: async () => { },
+            beforeAdmission: async (id) => {
+                const release = this.blockAdmission(id, id);
+                try {
+                    const finish = await this.capturePredecessors(id);
+                    return async (outcome) => {
+                        await release(outcome ?? 'unknown', finish);
+                    };
+                }
+                catch (cause) {
+                    await release('unknown');
+                    throw cause;
+                }
+            },
+            beforeMutation: (id, kind, manager) => this.retireInManager(manager, id, undefined, kind === 'delete'),
+        });
+    }
+    onModuleDestroy() {
+        this.destroyed = true;
+        this.removeLifecycle?.();
+        this.removeLifecycle = undefined;
+        this.registration?.dispose();
+        this.registration = undefined;
+        this.epochs.clear();
+        this.activeLifetimes.clear();
+        this.mutations.clear();
+        this.completionCohorts.clear();
+    }
+    async readEvidence(manager, spaceId, activationId, installed, restoring = false) {
+        if (manager === this.database.manager)
+            return this.database.transaction((original) => this.readEvidence(original, spaceId, activationId, installed, restoring));
+        if (!manager.queryRunner?.isTransactionActive || manager.connection !== this.database)
+            throw new Error('Original activity read manager unavailable');
+        const space = await manager.findOneBy(space_entity_1.SpaceEntity, { id: spaceId });
+        if (!space || ![spaces_constants_1.SpaceType.ROOM, spaces_constants_1.SpaceType.ZONE].includes(space.type))
+            return null;
+        const state = await manager.findOneBy(space_activity_state_entity_1.SpaceActivityStateEntity, { spaceId, activationId });
+        if (!state?.selectedActivityMode)
+            return null;
+        const activating = !restoring && state.activityStatus === space_activity_constants_1.ActivityActivationStatus.ACTIVATING;
+        const completed = installed &&
+            [space_activity_constants_1.ActivityActivationStatus.ACTIVE, space_activity_constants_1.ActivityActivationStatus.PARTIAL].includes(state.activityStatus) &&
+            state.activityResults?.some((result) => result.domain === space_activity_constants_1.ActivityDomain.CLIMATE && result.status === space_activity_constants_1.ActivityDomainStatus.SUCCEEDED);
+        if (!activating && !completed)
+            return null;
+        const config = await manager.findOneBy(space_activity_config_entity_1.SpaceActivityConfigEntity, {
+            spaceId,
+            activityMode: state.selectedActivityMode,
+            activityRevision: state.selectedActivityRevision,
+            activityEnabled: true,
+        });
+        if (!config?.activityConfiguration.climate.enabled)
+            return null;
+        const rows = await manager.query('SELECT "activityConfiguration" FROM "spaces_module_space_roles" WHERE "id"=? AND "type"=\'activity_config\'', [config.id]);
+        if (rows.length !== 1 || typeof rows[0].activityConfiguration !== 'string')
+            return null;
+        return {
+            spaceId,
+            spaceType: space.type,
+            activationId,
+            configId: config.id,
+            configurationRevision: config.activityRevision,
+            mode: config.activityMode,
+            configuration: rows[0].activityConfiguration,
+            targets: this.intents
+                ? (await this.intents.planAutomationTargets(spaceId, manager))
+                    .map(({ device, role }) => ({ id: device.id, role }))
+                    .sort((a, b) => a.id.localeCompare(b.id))
+                : [],
+        };
+    }
+    async validateSource(manager, source, purpose, restoredProvider) {
+        if (this.destroyed ||
+            source.producerKey !== exports.SPACE_ACTIVITY_CLIMATE_PRODUCER ||
+            purpose === 'retire' ||
+            (purpose === 'restore' && source.state !== 'FINALIZED_LIVE'))
+            return null;
+        if (purpose === 'restore' && (!restoredProvider || !restoredProvider.isCurrent()))
+            return null;
+        const originalProvider = purpose === 'restore' ? this.provider(restoredProvider) : undefined;
+        let expected;
+        try {
+            expected = JSON.parse(source.evidence);
+        }
+        catch {
+            return null;
+        }
+        if (!expected || expected.spaceId !== source.subjectId || typeof expected.activationId !== 'string')
+            return null;
+        const actual = await this.readEvidence(manager, source.subjectId, expected.activationId, source.state === 'FINALIZED_LIVE', purpose === 'restore');
+        if (!actual || (0, climate_automation_ledger_utils_1.canonical)(actual) !== source.evidence || (originalProvider && !originalProvider.isCurrent()))
+            return null;
+        this.qualifyLifetime(actual);
+        return actual;
+    }
+    lifetimeCurrent(lifetime) {
+        return (!this.destroyed &&
+            this.activeLifetimes.get(lifetime.subjectId) === lifetime &&
+            this.epochs.get(lifetime.subjectId) === lifetime.subjectEpoch &&
+            this.epochs.get(lifetime.configurationKey) === lifetime.configurationEpoch &&
+            !this.mutations.has(lifetime.subjectId) &&
+            !this.mutations.has(lifetime.configurationKey) &&
+            !this.mutations.has(lifetime.activationKey));
+    }
+    qualifyLifetime(evidence) {
+        const configurationKey = `${evidence.spaceId}/${evidence.configId}`;
+        const activationKey = `${evidence.spaceId}/activation/${evidence.activationId}`;
+        if (this.destroyed ||
+            this.mutations.has(evidence.spaceId) ||
+            this.mutations.has(configurationKey) ||
+            this.mutations.has(activationKey))
+            throw new SupersededCompletion();
+        const value = (0, climate_automation_ledger_utils_1.canonical)(evidence);
+        const existing = this.activeLifetimes.get(evidence.spaceId);
+        if (existing?.evidence === value && this.lifetimeCurrent(existing))
+            return existing;
+        const lifetime = Object.freeze({
+            subjectId: evidence.spaceId,
+            configurationKey,
+            activationKey,
+            evidence: value,
+            subjectEpoch: this.captureEpoch(evidence.spaceId),
+            configurationEpoch: this.captureEpoch(configurationKey),
+        });
+        this.activeLifetimes.set(evidence.spaceId, lifetime);
+        return lifetime;
+    }
+    captureEpoch(key) {
+        let epoch = this.epochs.get(key);
+        if (!epoch) {
+            epoch = {};
+            this.epochs.set(key, epoch);
+        }
+        return epoch;
+    }
+    blockAdmission(key, subject) {
+        this.admissionEpoch = {};
+        const lifetime = this.activeLifetimes.get(subject);
+        if (lifetime && (key === subject || key === lifetime.configurationKey || key === lifetime.activationKey))
+            this.activeLifetimes.delete(subject);
+        this.epochs.set(key, {});
+        const token = {};
+        const owners = this.mutations.get(key) ?? new Set();
+        owners.add(token);
+        this.mutations.set(key, owners);
+        const cohort = this.completionCohorts.get(subject) ?? {
+            owners: new Set(),
+            results: [],
+        };
+        cohort.owners.add(token);
+        this.completionCohorts.set(subject, cohort);
+        let consumed = false;
+        return async (outcome, finish) => {
+            if (consumed)
+                return;
+            consumed = true;
+            owners.delete(token);
+            if (!owners.size && this.mutations.get(key) === owners) {
+                this.mutations.delete(key);
+                this.epochs.delete(key);
+            }
+            cohort.results.push({ outcome, finish });
+            cohort.owners.delete(token);
+            if (cohort.owners.size)
+                return;
+            if (this.completionCohorts.get(subject) === cohort)
+                this.completionCohorts.delete(subject);
+            if (!this.activeLifetimes.has(subject))
+                for (const key of this.epochs.keys())
+                    if ((key === subject || key.startsWith(subject + '/')) && !this.mutations.has(key))
+                        this.epochs.delete(key);
+            const eligible = !this.destroyed &&
+                cohort.results.every(({ outcome }) => outcome === 'rolled_back' || outcome === 'not_started');
+            const results = await Promise.allSettled(cohort.results.map(({ outcome, finish }) => Promise.resolve().then(() => finish?.(eligible ? outcome : 'unknown'))));
+            const failure = results.find((result) => result.status === 'rejected');
+            if (failure?.status === 'rejected')
+                throw failure.reason;
+        };
+    }
+    async capturePredecessors(spaceId, activationId, configId) {
+        const source = await this.database.manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, {
+            producerKey: exports.SPACE_ACTIVITY_CLIMATE_PRODUCER,
+            subjectId: spaceId,
+            isCurrent: true,
+        });
+        if (!source)
+            return () => Promise.resolve();
+        const evidence = JSON.parse(source.evidence);
+        if ((activationId !== undefined && evidence.activationId !== activationId) ||
+            (configId !== undefined && evidence.configId !== configId))
+            return () => Promise.resolve();
+        const jobs = [...this.participants.values()].map(({ implementation, methods }) => {
+            try {
+                return methods.beginSourceMutation === undefined || methods.beginSourceMutation === null
+                    ? undefined
+                    : (0, creation_capture_1.invokeCreation)(methods.beginSourceMutation, implementation, exports.SPACE_ACTIVITY_CLIMATE_PRODUCER, spaceId, source.generationId);
+            }
+            catch (cause) {
+                return Promise.reject(cause);
+            }
+        });
+        const results = await Promise.allSettled(jobs);
+        const failure = results.find((result) => result.status === 'rejected');
+        let completed = false;
+        const finish = async (outcome) => {
+            if (completed)
+                return;
+            completed = true;
+            for (const result of results)
+                if (result.status === 'fulfilled' && result.value) {
+                    try {
+                        await result.value.finish(outcome);
+                    }
+                    catch {
+                    }
+                }
+        };
+        if (failure?.status === 'rejected') {
+            await finish('unknown');
+            throw failure.reason;
+        }
+        return finish;
+    }
+    virtual(target) {
+        return target.device.type === 'virtual' && Reflect.get(target.device, 'mode') === 'climate_controller';
+    }
+    provider(original) {
+        const provider = original ?? this.registry.captureProvider('virtual-thermostat:v1');
+        if (!provider?.isCurrent() ||
+            !provider.implementation.withAutomationWrite ||
+            !provider.implementation.resolveActionInManager ||
+            !provider.implementation.settleInstalled)
+            throw new Error('Trusted thermostat provider unavailable');
+        let participant = this.participants.get(provider.implementation);
+        if (!participant) {
+            const capture = (0, creation_capture_1.captureCreation)(provider.implementation, [
+                'withAutomationWrite',
+                'resolveActionInManager',
+                'settleInstalled',
+                'ownedSettlementVersion',
+                'beginSourceMutation',
+                'retireControllerInManager',
+            ]);
+            participant = {
+                implementation: provider.implementation,
+                methods: capture.values,
+                isCurrent: () => provider.isCurrent() && capture.current(),
+            };
+            this.participants.set(provider.implementation, participant);
+        }
+        if (!participant.isCurrent())
+            throw new Error('Original thermostat participant changed');
+        return participant;
+    }
+    async preview(spaceId, selection) {
+        if (!this.intents)
+            return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.UNSUPPORTED, 'climate_intent_unavailable');
+        const targets = await this.database.transaction((manager) => this.intents.planAutomationTargets(spaceId, manager));
+        if (!targets.length)
+            return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.NO_TARGETS, 'no_compatible_climate_targets');
+        const virtual = targets.filter((target) => this.virtual(target));
+        let provider = null;
+        if (virtual.length) {
+            try {
+                provider = this.provider();
+            }
+            catch {
+                return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.UNSUPPORTED, 'thermostat_provider_unavailable');
+            }
+        }
+        for (const target of virtual)
+            if (!(await (0, creation_capture_1.invokeCreation)(provider.methods.resolveActionInManager, provider.implementation, this.database.manager, target.device.id, selection)))
+                return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.UNSUPPORTED, 'thermostat_selection_or_opt_in_unavailable');
+        if (selection.thermostat_preset && virtual.length !== targets.length)
+            return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.UNSUPPORTED, 'physical_target_preset_unsupported');
+        if (provider && !provider.isCurrent())
+            return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.UNSUPPORTED, 'thermostat_provider_expired');
+        return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.READY, 'explicit_operator_climate_selection');
+    }
+    async apply(identity, selection) {
+        const attempt = {};
+        const completion = this.completions.get(identity);
+        if (completion && !completion.attempt)
+            completion.attempt = attempt;
+        if (!this.intents)
+            throw new Error('Climate intent unavailable');
+        const initial = await this.database.transaction(async (manager) => ({
+            evidence: await this.readEvidence(manager, identity.spaceId, identity.activationId, false),
+            targets: await this.intents.planAutomationTargets(identity.spaceId, manager),
+        }));
+        if (!initial.evidence ||
+            initial.evidence.configurationRevision !== identity.configurationRevision ||
+            (0, climate_automation_ledger_utils_1.canonical)(JSON.parse(initial.evidence.configuration).climate) !==
+                (0, climate_automation_ledger_utils_1.canonical)(selection))
+            throw new Error('Activity source changed');
+        const lifetime = this.qualifyLifetime(initial.evidence);
+        const targets = initial.targets;
+        const physicalIds = new Set(targets.filter((target) => !this.virtual(target)).map((target) => target.device.id));
+        if (selection.thermostat_preset && physicalIds.size)
+            return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.UNSUPPORTED, 'physical_target_preset_unsupported');
+        if (physicalIds.size) {
+            const physical = (await this.intents.planAutomationTargets(identity.spaceId)).filter((target) => physicalIds.has(target.device.id));
+            if (physical.length !== physicalIds.size)
+                throw new Error('Activity physical target plan changed');
+            for (const target of physical)
+                targets[targets.findIndex((candidate) => candidate.device.id === target.device.id)] = target;
+        }
+        const virtual = targets.filter((target) => this.virtual(target));
+        if (!targets.length)
+            return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.NO_TARGETS, 'no_compatible_climate_targets');
+        const provider = virtual.length ? this.provider() : null;
+        if (provider && provider.methods.ownedSettlementVersion !== 1)
+            throw new Error('Owned thermostat settlement unavailable');
+        attempt.provider = provider;
+        const originalProducer = this.registry.captureProducer(exports.SPACE_ACTIVITY_CLIMATE_PRODUCER);
+        if (originalProducer?.implementation !== this.producer)
+            throw new Error('Original activity producer unavailable');
+        let admitted = true;
+        const authorityCurrent = () => originalProducer.isCurrent() && this.lifetimeCurrent(lifetime) && (!provider || provider.isCurrent());
+        const current = () => admitted && authorityCurrent();
+        const owned = {
+            isSettled: () => attempt.completed === true,
+            isCurrent: authorityCurrent,
+            accept: (receipt) => {
+                if (attempt.receipt)
+                    throw new Error('Original settlement already captured');
+                attempt.receipt = receipt;
+            },
+        };
+        const install = async () => {
+            if (!current() || !(await identity.isCurrent()))
+                throw new Error('Activity superseded');
+            const repeated = await this.database.transaction(async (manager) => {
+                const source = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, {
+                    producerKey: exports.SPACE_ACTIVITY_CLIMATE_PRODUCER,
+                    subjectId: identity.spaceId,
+                    isCurrent: true,
+                });
+                if (!source || JSON.parse(source.evidence).activationId !== identity.activationId)
+                    return null;
+                const evidence = await this.readEvidence(manager, identity.spaceId, identity.activationId, true);
+                if (source.state !== 'FINALIZED_LIVE' || (0, climate_automation_ledger_utils_1.canonical)(evidence) !== source.evidence)
+                    throw new Error('Original activity installation cannot be replayed');
+                const slots = await manager.findBy(climate_automation_entity_1.ClimateAutomationSlotEntity, {
+                    generationId: source.generationId,
+                    ownerId: source.ownerId,
+                });
+                if (slots.some((slot) => slot.state !== 'LIVE' || slot.manualHold) ||
+                    (0, climate_automation_ledger_utils_1.canonical)(slots.map((slot) => slot.controllerId).sort()) !==
+                        (0, climate_automation_ledger_utils_1.canonical)(virtual.map((target) => target.device.id).sort()))
+                    throw new Error('Original activity candidate retired or changed');
+                attempt.source = { ...source };
+                return slots.map((slot) => ({ ...slot }));
+            });
+            if (repeated) {
+                attempt.slots = repeated;
+                if (!(await (0, creation_capture_1.invokeCreation)(provider.methods.settleInstalled, provider.implementation, repeated, originalProducer, owned)) ||
+                    !current() ||
+                    !attempt.receipt)
+                    throw new Error('Original installation is no longer eligible');
+                return repeated.length;
+            }
+            let installed = [];
+            await (0, creation_capture_1.invokeCreation)(provider.methods.withAutomationWrite, provider.implementation, async (manager) => {
+                const evidence = await this.readEvidence(manager, identity.spaceId, identity.activationId, false);
+                if (!current() ||
+                    !evidence ||
+                    evidence.configurationRevision !== identity.configurationRevision ||
+                    (0, climate_automation_ledger_utils_1.canonical)(JSON.parse(evidence.configuration).climate) !==
+                        (0, climate_automation_ledger_utils_1.canonical)(selection))
+                    throw new Error('Activity source changed');
+                const actualTargets = await this.intents.planAutomationTargets(identity.spaceId, manager);
+                if ((0, climate_automation_ledger_utils_1.canonical)(actualTargets.map((target) => target.device.id).sort()) !==
+                    (0, climate_automation_ledger_utils_1.canonical)(targets.map((target) => target.device.id).sort()))
+                    throw new Error('Activity target plan changed');
+                const scope = this.ledger.currentScope(manager);
+                const prior = await this.ledger.readSource(manager, scope, exports.SPACE_ACTIVITY_CLIMATE_PRODUCER, identity.spaceId);
+                if (prior.facts && ['PENDING', 'FINALIZED_LIVE'].includes(prior.facts.state))
+                    await this.retireInManager(manager, identity.spaceId);
+                const expected = await this.ledger.readSource(manager, scope, exports.SPACE_ACTIVITY_CLIMATE_PRODUCER, identity.spaceId);
+                const source = await this.ledger.stageSource(manager, scope, {
+                    producerKey: exports.SPACE_ACTIVITY_CLIMATE_PRODUCER,
+                    subjectId: identity.spaceId,
+                    expected,
+                    evidence: evidence,
+                });
+                const candidates = [];
+                const bundleId = (0, node_crypto_1.randomUUID)();
+                for (const target of virtual.sort((a, b) => a.device.id.localeCompare(b.device.id))) {
+                    const action = await (0, creation_capture_1.invokeCreation)(provider.methods.resolveActionInManager, provider.implementation, manager, target.device.id, selection);
+                    if (action === null)
+                        throw new UnsupportedThermostatSelection('Unsupported thermostat selection');
+                    let slot = await this.ledger.readSlot(manager, scope, target.device.id, true, 'virtual-thermostat:v1');
+                    if (!slot.facts)
+                        slot = await this.ledger.initializeSlot(manager, scope, { expected: slot, releaseManualHold: true });
+                    candidates.push(await this.ledger.stageSlot(manager, scope, {
+                        expectedSlot: slot,
+                        expectedSource: source,
+                        selection: action,
+                        bundleId,
+                    }));
+                }
+                installed = (await this.ledger.installBundle(manager, scope, source, candidates)).map((slot) => slot.facts);
+                attempt.source = (await this.ledger.readSource(manager, scope, exports.SPACE_ACTIVITY_CLIMATE_PRODUCER, identity.spaceId)).facts;
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, current);
+            });
+            attempt.slots = installed;
+            if (!(await (0, creation_capture_1.invokeCreation)(provider.methods.settleInstalled, provider.implementation, installed, originalProducer, owned)) ||
+                !current() ||
+                !attempt.receipt)
+                throw new Error('Committed climate installation remains inhibited');
+            return installed.length;
+        };
+        const intent = selection.setpoint_delta !== undefined
+            ? {
+                type: spaces_home_control_constants_1.ClimateIntentType.SETPOINT_DELTA,
+                delta: spaces_home_control_constants_1.SetpointDelta.SMALL,
+                increase: selection.setpoint_delta >= 0,
+            }
+            : selection.setpoint !== undefined
+                ? {
+                    type: spaces_home_control_constants_1.ClimateIntentType.CLIMATE_SET,
+                    mode: selection.mode,
+                    ...(selection.mode === spaces_home_control_constants_1.ClimateMode.COOL
+                        ? { coolingSetpoint: selection.setpoint }
+                        : { heatingSetpoint: selection.setpoint }),
+                }
+                : { type: spaces_home_control_constants_1.ClimateIntentType.SET_MODE, mode: selection.mode };
+        try {
+            if (!(await identity.isCurrent()))
+                throw new Error('Activity superseded');
+            const result = await this.intents.executeClimateIntent(identity.spaceId, intent, {
+                targets,
+                virtualTargetIds: virtual.map((target) => target.device.id),
+                installVirtual: provider ? install : undefined,
+                isCurrent: current,
+                numericDelta: selection.setpoint_delta === undefined ? undefined : Math.abs(selection.setpoint_delta),
+                numericDeltaMode: selection.setpoint_delta === undefined
+                    ? undefined
+                    : selection.mode === spaces_home_control_constants_1.ClimateMode.HEAT
+                        ? spaces_home_control_constants_1.ClimateMode.HEAT
+                        : selection.mode === spaces_home_control_constants_1.ClimateMode.COOL
+                            ? spaces_home_control_constants_1.ClimateMode.COOL
+                            : undefined,
+            });
+            const outcome = (0, activity_result_utils_1.intentDomainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, result);
+            if (outcome.status !== space_activity_constants_1.ActivityDomainStatus.SUCCEEDED)
+                attempt.receipt?.invalidateOriginal();
+            return outcome;
+        }
+        catch (cause) {
+            attempt.failure = { cause };
+            attempt.receipt?.invalidateOriginal();
+            if (cause instanceof UnsupportedThermostatSelection && current())
+                return (0, activity_result_utils_1.domainResult)(space_activity_constants_1.ActivityDomain.CLIMATE, space_activity_constants_1.ActivityDomainStatus.UNSUPPORTED, 'thermostat_selection_or_opt_in_unavailable');
+            throw cause;
+        }
+        finally {
+            admitted = false;
+        }
+    }
+    captureCompletion(identity) {
+        if (this.completions.has(identity))
+            throw new Error('Activity completion already captured');
+        const original = {};
+        this.completions.set(identity, original);
+        return async (results, write) => {
+            const attempt = original.attempt;
+            if (!attempt?.source)
+                return write(this.database.manager);
+            const receipt = attempt.receipt, provider = attempt.provider;
+            if (!receipt || !provider)
+                throw new Error('Original installed completion unavailable');
+            const failed = results.find((result) => result.domain === space_activity_constants_1.ActivityDomain.CLIMATE)?.status !== space_activity_constants_1.ActivityDomainStatus.SUCCEEDED;
+            const permit = failed ? receipt.beginRetirement() : undefined;
+            if (failed ? !permit : !receipt.isCurrent())
+                return false;
+            const current = () => !this.destroyed && provider.isCurrent() && (permit ? permit.isCurrent() : receipt.isCurrent());
+            try {
+                await permit?.predecessors;
+                return await this.structure.runExclusive(async () => {
+                    const owner = this.structure.captureExclusiveOwner();
+                    let native;
+                    const result = await this.database.transaction(async (manager) => {
+                        native = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+                        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => owner() && current());
+                        await manager.query('UPDATE "spaces_module_space_roles" SET "id"="id" WHERE 0');
+                        return this.ledger.inAdmittedManager(manager, native, async (scope) => {
+                            if (!current())
+                                throw new SupersededCompletion();
+                            const source = await this.ledger.readSource(manager, scope, exports.SPACE_ACTIVITY_CLIMATE_PRODUCER, identity.spaceId);
+                            if ((0, climate_automation_ledger_utils_1.canonical)(source.facts) !== (0, climate_automation_ledger_utils_1.canonical)(attempt.source))
+                                throw new SupersededCompletion();
+                            const slots = [];
+                            for (const expected of attempt.slots) {
+                                const slot = await this.ledger.readSlot(manager, scope, expected.controllerId, false);
+                                if ((0, climate_automation_ledger_utils_1.canonical)(slot.facts) !== (0, climate_automation_ledger_utils_1.canonical)(expected))
+                                    throw new SupersededCompletion();
+                                slots.push(slot);
+                            }
+                            if (failed) {
+                                await receipt.retireInManager(manager);
+                                await this.ledger.revokeSource(manager, scope, source, slots);
+                            }
+                            if (!(await write(manager)))
+                                throw new SupersededCompletion();
+                            return true;
+                        });
+                    });
+                    if (native?.outcome !== 'committed')
+                        throw new Error('Activity completion acknowledgement unavailable');
+                    if (!failed && current() && result)
+                        attempt.completed = true;
+                    return result;
+                });
+            }
+            catch (cause) {
+                if (cause instanceof SupersededCompletion)
+                    return false;
+                attempt.cleanupFailure = { cause };
+                if (attempt.failure)
+                    throw attempt.failure.cause;
+                throw cause;
+            }
+            finally {
+                permit?.finish();
+            }
+        };
+    }
+    withdraw(identity) {
+        return this.mutate(identity.spaceId, identity.activationId, async () => { });
+    }
+    async retireInManager(manager, spaceId, activationId, deleted = false, configId) {
+        const scope = this.ledger.currentScope(manager);
+        const source = await this.ledger.readSource(manager, scope, exports.SPACE_ACTIVITY_CLIMATE_PRODUCER, spaceId);
+        if (!source.facts)
+            return;
+        if (activationId !== undefined || configId !== undefined) {
+            const evidence = JSON.parse(source.facts.evidence);
+            if (activationId !== undefined && evidence.activationId !== activationId)
+                return;
+            if (configId !== undefined && evidence.configId !== configId)
+                return;
+        }
+        const rows = await manager.findBy(climate_automation_entity_1.ClimateAutomationSlotEntity, {
+            generationId: source.facts.generationId,
+            ownerId: source.facts.ownerId,
+        });
+        const slots = [];
+        for (const row of rows.sort((a, b) => a.controllerId.localeCompare(b.controllerId)))
+            if (row.state === 'LIVE' || row.state === 'PROVISIONAL') {
+                const slot = await this.ledger.readSlot(manager, scope, row.controllerId, false);
+                const captured = this.registry.captureProvider(row.providerKey);
+                const original = captured ? this.participants.get(captured.implementation) : undefined;
+                if (original?.isCurrent() &&
+                    original.methods.retireControllerInManager !== undefined &&
+                    original.methods.retireControllerInManager !== null)
+                    await (0, creation_capture_1.invokeCreation)(original.methods.retireControllerInManager, original.implementation, manager, slot.facts);
+                slots.push(slot);
+            }
+        await this.ledger.revokeSource(manager, scope, source, slots, deleted);
+    }
+    async mutate(spaceId, activationId, work, configId, prepareFinalValidation) {
+        const release = this.blockAdmission(configId !== undefined
+            ? `${spaceId}/${configId}`
+            : activationId !== undefined
+                ? `${spaceId}/activation/${activationId}`
+                : spaceId, spaceId);
+        let native;
+        let finish;
+        let callbackEntered = false;
+        let result;
+        let failure;
+        try {
+            const producer = this.registry.captureProducer(exports.SPACE_ACTIVITY_CLIMATE_PRODUCER);
+            if (this.destroyed || producer?.implementation !== this.producer)
+                throw new Error('Activity climate producer unavailable');
+            finish = await this.capturePredecessors(spaceId, activationId, configId);
+            result = await this.structure.runExclusive(async () => {
+                const owner = this.structure.captureExclusiveOwner();
+                return this.database.transaction(async (manager) => {
+                    callbackEntered = true;
+                    const receipt = (native = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager));
+                    (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => owner() && producer.isCurrent());
+                    const validate = prepareFinalValidation?.(manager);
+                    await manager.query('UPDATE "spaces_module_space_roles" SET "id"="id" WHERE 0');
+                    const value = await this.ledger.inAdmittedManager(manager, receipt, async () => {
+                        await this.retireInManager(manager, spaceId, activationId, false, configId);
+                        return work(manager);
+                    });
+                    await validate?.();
+                    return value;
+                });
+            });
+        }
+        catch (cause) {
+            failure = { cause };
+        }
+        try {
+            await release(native?.outcome === 'rolled_back' || native?.outcome === 'committed'
+                ? native.outcome
+                : callbackEntered
+                    ? 'unknown'
+                    : 'not_started', finish);
+        }
+        catch (cause) {
+            failure ??= { cause };
+        }
+        if (failure)
+            throw failure.cause;
+        return result;
+    }
+};
+exports.SpaceClimateAutomationService = SpaceClimateAutomationService;
+exports.SpaceClimateAutomationService = SpaceClimateAutomationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(5, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        climate_automation_registry_service_1.ClimateAutomationRegistryService,
+        climate_automation_ledger_service_1.ClimateAutomationLedgerService,
+        device_structure_lock_service_1.DeviceStructureLockService,
+        space_lifecycle_registry_service_1.SpaceLifecycleRegistryService,
+        climate_intent_service_1.ClimateIntentService])
+], SpaceClimateAutomationService);
+//# sourceMappingURL=space-climate-automation.service.js.map