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

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

@@ -0,0 +1,1617 @@
+"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); }
+};
+var VirtualThermostatRuntimeService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualThermostatRuntimeService = void 0;
+const node_crypto_1 = require("node:crypto");
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
+const config_utils_1 = require("../../../common/utils/config.utils");
+const devices_constants_1 = require("../../../modules/devices/devices.constants");
+const devices_entity_1 = require("../../../modules/devices/entities/devices.entity");
+const controller_publication_context_1 = require("../../../modules/devices/services/controller-publication-context");
+const creation_capture_1 = require("../../../modules/devices/services/creation-capture");
+const device_structure_lock_service_1 = require("../../../modules/devices/services/device-structure-lock.service");
+const property_producer_registry_service_1 = require("../../../modules/devices/services/property-producer.registry.service");
+const property_value_service_1 = require("../../../modules/devices/services/property-value.service");
+const devices_shelly_ng_entity_1 = require("../../devices-shelly-ng/entities/devices-shelly-ng.entity");
+const thermostat_actuation_contract_1 = require("../contracts/thermostat-actuation.contract");
+const devices_virtual_entity_1 = require("../entities/devices-virtual.entity");
+const virtual_thermostat_runtime_entity_1 = require("../entities/virtual-thermostat-runtime.entity");
+const virtual_thermostat_entity_1 = require("../entities/virtual-thermostat.entity");
+const thermostat_controller_mutation_1 = require("./thermostat-controller-mutation");
+const thermostat_cooling_dependency_service_1 = require("./thermostat-cooling-dependency.service");
+const thermostat_member_protection_service_1 = require("./thermostat-member-protection.service");
+const virtual_dependency_graph_service_1 = require("./virtual-dependency-graph.service");
+const virtual_thermostat_automation_service_1 = require("./virtual-thermostat-automation.service");
+const virtual_thermostat_branch_utils_1 = require("./virtual-thermostat-branch.utils");
+const virtual_thermostat_claims_service_1 = require("./virtual-thermostat-claims.service");
+const virtual_thermostat_comfort_service_1 = require("./virtual-thermostat-comfort.service");
+const virtual_thermostat_comfort_utils_1 = require("./virtual-thermostat-comfort.utils");
+const virtual_thermostat_config_service_1 = require("./virtual-thermostat-config.service");
+const virtual_thermostat_contract_utils_1 = require("./virtual-thermostat-contract.utils");
+const virtual_thermostat_inputs_service_1 = require("./virtual-thermostat-inputs.service");
+const virtual_thermostat_policy_utils_1 = require("./virtual-thermostat-policy.utils");
+const virtual_thermostat_runtime_ownership_1 = require("./virtual-thermostat-runtime-ownership");
+const virtual_thermostat_transport_service_1 = require("./virtual-thermostat-transport.service");
+const virtual_window_contact_utils_1 = require("./virtual-window-contact.utils");
+const virtual_window_trend_utils_1 = require("./virtual-window-trend.utils");
+const unresolved = (command) => !['confirmed', 'cancelled'].includes(command.status);
+const newestCommandFirst = (a, b) => b.preparedAt.getTime() - a.preparedAt.getTime() ||
+    b.decisionRevision - a.decisionRevision ||
+    (b.id > a.id ? 1 : b.id < a.id ? -1 : 0);
+class ThermostatDecisionRetiredError extends Error {
+}
+const retryDelaysMs = [1000, 2000, 4000, 8000, 16000];
+const copyBranchDiagnostic = (branch, unavailable = false) => ({
+    ...branch,
+    cooling_protection: branch.cooling_protection
+        ? {
+            ...branch.cooling_protection,
+            ready: !unavailable && branch.cooling_protection.ready,
+            reasons: [...branch.cooling_protection.reasons],
+            dew_point: unavailable ? null : branch.cooling_protection.dew_point,
+            surface: unavailable ? null : branch.cooling_protection.surface,
+        }
+        : null,
+    ...(unavailable
+        ? {
+            activity: 'unknown',
+            qualification_ready: null,
+            activity_sampled_at: null,
+            activity_expires_at: null,
+            release_proven: false,
+        }
+        : {}),
+    protection: branch.protection
+        ? {
+            ...branch.protection,
+            reasons: unavailable
+                ? ['graph_or_runtime_unavailable', ...branch.protection.reasons]
+                : [...branch.protection.reasons],
+            ...(unavailable
+                ? {
+                    ready: false,
+                    latched: true,
+                    temperature: null,
+                    status: 'unavailable',
+                    quality: 'unavailable',
+                }
+                : {}),
+        }
+        : null,
+});
+let VirtualThermostatRuntimeService = VirtualThermostatRuntimeService_1 = class VirtualThermostatRuntimeService {
+    get coolingDependencies() {
+        return (this.coolingService ??= new thermostat_cooling_dependency_service_1.ThermostatCoolingDependencyService(this.dataSource, this.values, this.claims));
+    }
+    isReconciled(claim) {
+        const proof = this.reconciled.get(`${claim.id}:${claim.revision}`);
+        const qualification = this.claims.qualification(claim, false);
+        return !!proof && !!qualification && proof.qualification === qualification && proof.sourceIsCurrent();
+    }
+    constructor(dataSource, structure, claims, inputs, transport, values, producers, events, graph, comfort, configService = new config_1.ConfigService(), memberProtection = new thermostat_member_protection_service_1.ThermostatMemberProtectionService(dataSource, values), automation) {
+        this.dataSource = dataSource;
+        this.structure = structure;
+        this.claims = claims;
+        this.inputs = inputs;
+        this.transport = transport;
+        this.values = values;
+        this.producers = producers;
+        this.events = events;
+        this.graph = graph;
+        this.comfort = comfort;
+        this.configService = configService;
+        this.memberProtection = memberProtection;
+        this.automation = automation;
+        this.ownership = new virtual_thermostat_runtime_ownership_1.ThermostatRuntimeOwnership();
+        this.logger = new common_1.Logger(VirtualThermostatRuntimeService_1.name);
+        this.active = false;
+        this.epoch = (0, node_crypto_1.randomUUID)();
+        this.sequence = 0;
+        this.queues = new Map();
+        this.retiredQueues = new Set();
+        this.epochs = new Map();
+        this.contexts = new Map();
+        this.diagnostics = new Map();
+        this.memberFaults = new Map();
+        this.reconciled = new Map();
+        this.diagnosticGuards = new Map();
+        this.contacts = new Map();
+        this.trends = new Map();
+        this.outputs = new Map();
+        this.inFlight = new Map();
+        this.inFlightCommands = new Map();
+        this.listener = (payload) => {
+            if (payload?.id && this.outputs.has(payload.id))
+                return;
+            const propertyId = payload?.propertyId ?? payload?.id;
+            for (const [id, context] of this.contexts)
+                if (!propertyId ||
+                    context.bindings.some((binding) => binding.property?.id === propertyId) ||
+                    context.memberBindings.some((entry) => entry.binding?.sourcePropertyId === propertyId || entry.binding?.physicalPropertyIdentity === propertyId) ||
+                    context.claims.some((claim) => claim.sourcePropertyId === propertyId)) {
+                    this.memberProtection.read(context.memberBindings, Date.now());
+                    void this.request(id);
+                }
+        };
+        this.reset = () => {
+            this.memberProtection.reset();
+            this.coolingService?.reset();
+            this.reconciled.clear();
+            this.contacts.clear();
+            for (const [id, trend] of this.trends)
+                this.trends.set(id, {
+                    ...(0, virtual_window_trend_utils_1.createVirtualWindowTrendState)(),
+                    pausedAt: trend.pausedAt,
+                    pausedUntil: trend.pausedUntil,
+                    cooldownUntil: trend.cooldownUntil,
+                });
+            this.listener();
+        };
+        this.journal = new virtual_thermostat_runtime_ownership_1.ThermostatRuntimeJournal(dataSource, structure);
+    }
+    onApplicationBootstrap() {
+        if (this.bootstrap)
+            return this.bootstrap.completion;
+        if (this.active)
+            return Promise.resolve();
+        try {
+            if ((0, config_utils_1.getEnvValue)(this.configService, 'FB_CLI', null) === 'on')
+                return Promise.resolve();
+        }
+        catch (cause) {
+            return Promise.resolve().then(() => {
+                throw cause;
+            });
+        }
+        const lifecycle = { stops: [] };
+        let resolve, reject;
+        const completion = new Promise((yes, no) => {
+            resolve = yes;
+            reject = no;
+        });
+        const attempt = { lifecycle, completion };
+        this.lifecycle = lifecycle;
+        this.active = true;
+        this.bootstrap = attempt;
+        void this.startLifecycle(lifecycle).then(() => {
+            if (this.bootstrap === attempt)
+                this.bootstrap = undefined;
+            resolve();
+        }, (cause) => {
+            if (this.lifecycle === lifecycle) {
+                try {
+                    this.onModuleDestroy();
+                }
+                catch (cleanup) {
+                    this.logger.error('Failed to retire original thermostat runtime', cleanup);
+                }
+            }
+            if (this.bootstrap === attempt)
+                this.bootstrap = undefined;
+            reject(cause);
+        });
+        return completion;
+    }
+    isCurrentLifecycle(lifecycle) {
+        return lifecycle !== undefined && this.active && this.lifecycle === lifecycle;
+    }
+    async startLifecycle(lifecycle) {
+        const assertCurrent = () => {
+            if (!this.isCurrentLifecycle(lifecycle))
+                throw new Error('Original runtime lifecycle ended');
+        };
+        const own = (stop) => {
+            if (stop === undefined)
+                return;
+            if (!this.isCurrentLifecycle(lifecycle)) {
+                stop();
+                assertCurrent();
+            }
+            lifecycle.stops.push(stop);
+        };
+        const hooks = (0, creation_capture_1.captureCreation)(this, ['capturePredecessors', 'requestInstalled']);
+        own(this.automation?.registerRuntime((id) => {
+            assertCurrent();
+            return hooks.values.capturePredecessors.call(hooks.receiver, id);
+        }, (id) => {
+            if (!this.isCurrentLifecycle(lifecycle) || !hooks.current())
+                return Promise.reject(new Error('Original thermostat runtime unavailable'));
+            return hooks.values.requestInstalled.call(hooks.receiver, id);
+        }));
+        own(this.transport.registerCoolingFrameReader?.((claim) => {
+            if (!this.isCurrentLifecycle(lifecycle))
+                return null;
+            const context = this.contexts.get(claim.controllerId), binding = context?.coolingBindings.find((b) => b.claimId === claim.id);
+            if (!context || !binding || !context.publishGuard())
+                return null;
+            const captured = this.coolingDependencies.capture(binding);
+            return captured
+                ? {
+                    ...captured,
+                    isCurrent: () => captured.isCurrent() &&
+                        context.publishGuard() &&
+                        this.contexts.get(claim.controllerId) === context &&
+                        context.config.revision === captured.controllerRevision &&
+                        context.claims.some((c) => c.id === claim.id && c.revision === claim.revision),
+                }
+                : null;
+        }));
+        own(this.claims.registerRuntimeAdmission((claim) => {
+            if (!this.isCurrentLifecycle(lifecycle))
+                return false;
+            const context = this.contexts.get(claim.controllerId);
+            return !!context && this.canSend(context, claim, 'on');
+        }));
+        const listener = (...args) => {
+            if (this.isCurrentLifecycle(lifecycle))
+                this.listener(...args);
+        };
+        const reset = () => {
+            if (this.isCurrentLifecycle(lifecycle))
+                this.reset();
+        };
+        const invalidated = (payload) => {
+            if (!this.isCurrentLifecycle(lifecycle))
+                return;
+            this.memberProtection.invalidateSource(payload.propertyId);
+            this.listener(payload);
+        };
+        this.events.on(devices_constants_1.EventType.CHANNEL_PROPERTY_SAMPLE_INVALIDATED, invalidated);
+        own(() => this.events.off(devices_constants_1.EventType.CHANNEL_PROPERTY_SAMPLE_INVALIDATED, invalidated));
+        for (const event of [devices_constants_1.EventType.CHANNEL_PROPERTY_SAMPLE_ACCEPTED, devices_constants_1.EventType.CHANNEL_PROPERTY_VALUE_STATE_CHANGED]) {
+            this.events.on(event, listener);
+            own(() => this.events.off(event, listener));
+        }
+        for (const event of [
+            devices_constants_1.EventType.DEVICE_CONNECTION_CHANGED,
+            devices_constants_1.EventType.CHANNEL_PROPERTY_UPDATED,
+            devices_constants_1.EventType.CHANNEL_PROPERTY_DELETED,
+            devices_constants_1.EventType.CHANNEL_UPDATED,
+            devices_constants_1.EventType.CHANNEL_DELETED,
+            devices_constants_1.EventType.DEVICE_UPDATED,
+            devices_constants_1.EventType.DEVICE_DELETED,
+        ]) {
+            this.events.on(event, reset);
+            own(() => this.events.off(event, reset));
+        }
+        const configured = (id) => {
+            if (!this.isCurrentLifecycle(lifecycle))
+                return;
+            this.memberProtection.reset();
+            this.coolingService?.reset();
+            void this.request(id);
+        };
+        this.events.on(virtual_thermostat_config_service_1.THERMOSTAT_CONFIG_CHANGED, configured);
+        own(() => this.events.off(virtual_thermostat_config_service_1.THERMOSTAT_CONFIG_CHANGED, configured));
+        await this.automation?.restoreCurrentInstallations();
+        assertCurrent();
+        await this.journal.restart([...this.inFlightCommands.values()]);
+        assertCurrent();
+        const configurations = await this.dataSource.manager.find(virtual_thermostat_entity_1.VirtualThermostatConfigEntity);
+        assertCurrent();
+        for (const config of configurations)
+            void this.request(config.controllerId);
+        await this.flush();
+        assertCurrent();
+        lifecycle.timer = setInterval(() => {
+            if (!this.isCurrentLifecycle(lifecycle))
+                return;
+            for (const id of this.contexts.keys())
+                void this.request(id, false);
+        }, 1000);
+        this.timer = lifecycle.timer;
+        lifecycle.timer.unref();
+    }
+    onModuleDestroy() {
+        const lifecycle = this.lifecycle, outputs = [...this.outputs.values()];
+        this.active = false;
+        this.lifecycle = undefined;
+        if (this.bootstrap?.lifecycle === lifecycle)
+            this.bootstrap = undefined;
+        this.timer = undefined;
+        if (lifecycle?.timer)
+            clearInterval(lifecycle.timer);
+        this.outputs.clear();
+        this.diagnosticGuards.clear();
+        this.contexts.clear();
+        for (const queue of this.queues.values()) {
+            this.retiredQueues.add(queue);
+            void queue.then(() => this.retiredQueues.delete(queue), () => this.retiredQueues.delete(queue));
+        }
+        this.queues.clear();
+        this.contacts.clear();
+        this.trends.clear();
+        this.reconciled.clear();
+        this.memberFaults.clear();
+        this.memberProtection.reset();
+        this.coolingService?.reset();
+        for (const id of this.epochs.keys())
+            this.epochs.set(id, (this.epochs.get(id) ?? 0) + 1);
+        const stops = lifecycle?.stops.splice(0) ?? [];
+        let failure;
+        for (const stop of [...stops, ...outputs.map((output) => () => this.producers.unregister(output.lease))]) {
+            try {
+                stop();
+            }
+            catch (cause) {
+                failure ??= { cause };
+            }
+        }
+        if (failure)
+            throw failure.cause;
+    }
+    readDiagnostics(controllerId) {
+        const result = this.diagnostics.get(controllerId);
+        const observedAt = new Date(), context = this.contexts.get(controllerId);
+        if (result && (!this.graph.isValidated() || this.diagnosticGuards.get(controllerId)?.() === false))
+            return {
+                ...result,
+                effective_comfort: { ...result.effective_comfort },
+                readiness: 'unavailable',
+                current_temperature: null,
+                floor_temperature: null,
+                comfort_demand: 'off',
+                reasons: ['graph_validation_pending'],
+                headline_reason: 'graph_validation_pending',
+                inputs: result.inputs.map((input) => ({
+                    ...input,
+                    status: 'unavailable',
+                    quality: 'unavailable',
+                    reasons: ['graph_validation_pending'],
+                })),
+                branches: result.branches.map((branch) => copyBranchDiagnostic(branch, true)),
+            };
+        return result
+            ? {
+                ...result,
+                effective_comfort: { ...result.effective_comfort },
+                inputs: result.inputs.map((input) => ({ ...input, reasons: [...input.reasons] })),
+                reasons: [...result.reasons],
+                branches: result.branches.map((branch) => ({
+                    ...copyBranchDiagnostic(branch),
+                    ...this.branchObservation(context?.config.revision === result.configuration_revision &&
+                        context.state.decisionRevision === result.decision_revision
+                        ? context
+                        : undefined, branch.claim, observedAt),
+                })),
+            }
+            : null;
+    }
+    async inspect(controllerId) {
+        if (!(await this.dataSource.manager.existsBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId })))
+            return null;
+        await this.request(controllerId, false);
+        return this.readDiagnostics(controllerId);
+    }
+    request(controllerId, revoke = true) {
+        return this.requestOperation(controllerId, revoke, false);
+    }
+    requestInstalled(controllerId) {
+        return this.requestOperation(controllerId, true, true);
+    }
+    requestOperation(controllerId, revoke, complete) {
+        const lifecycle = this.lifecycle;
+        if (!this.isCurrentLifecycle(lifecycle))
+            return complete ? Promise.reject(new Error('Original thermostat runtime unavailable')) : Promise.resolve();
+        const originalNativeEvent = (0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.dataSource);
+        const owned = this.ownership.admit(controllerId);
+        const original = this.ownership.completion(owned);
+        if (revoke)
+            this.epochs.set(controllerId, (this.epochs.get(controllerId) ?? 0) + 1);
+        const previous = this.queues.get(controllerId) ?? Promise.resolve();
+        const next = (0, sqlite_data_source_1.outsideSqliteTransaction)(this.dataSource, () => previous
+            .catch(() => undefined)
+            .then(() => controller_publication_context_1.ControllerPublicationContext.independent(() => this.ownership.run(owned, () => this.evaluate(controllerId, lifecycle))))
+            .catch(() => {
+            if (!this.isCurrentLifecycle(lifecycle))
+                return;
+            this.diagnostics.set(controllerId, {
+                epoch: this.epoch,
+                sequence: ++this.sequence,
+                configuration_revision: 0,
+                decision_revision: 0,
+                readiness: 'unavailable',
+                requested_mode: 'off',
+                effective_comfort: {
+                    source: 'manual',
+                    preset: null,
+                    override_id: null,
+                    expires_at: null,
+                    heating_setpoint: null,
+                    cooling_setpoint: null,
+                },
+                heating_setpoint: null,
+                cooling_setpoint: null,
+                current_temperature: null,
+                floor_temperature: null,
+                floor_latched: false,
+                comfort_demand: 'off',
+                reasons: ['runtime_error'],
+                headline_reason: 'runtime_error',
+                inputs: [],
+                branches: this.diagnostics.get(controllerId)?.branches.map((branch) => copyBranchDiagnostic(branch, true)) ?? [],
+            });
+        }));
+        this.queues.set(controllerId, next);
+        void next.finally(() => {
+            if (this.queues.get(controllerId) === next)
+                this.queues.delete(controllerId);
+        });
+        const completion = complete ? Promise.all([next, original]).then(() => undefined) : next;
+        return originalNativeEvent
+            ? controller_publication_context_1.ControllerPublicationContext.effect('thermostat.runtime-request', () => completion)
+            : completion;
+    }
+    capturePredecessors(controllerId) {
+        this.epochs.set(controllerId, (this.epochs.get(controllerId) ?? 0) + 1);
+        return this.ownership.capture(controllerId);
+    }
+    fenceMember(claimId) {
+        for (const [id, context] of this.contexts)
+            if (context.claims.some((claim) => claim.id === claimId))
+                void this.request(id);
+    }
+    async flush() {
+        const lifecycle = this.lifecycle;
+        if (lifecycle === undefined) {
+            await Promise.all([...this.retiredQueues]);
+            return;
+        }
+        while (this.isCurrentLifecycle(lifecycle) && this.queues.size)
+            await Promise.all([...this.queues.values()]);
+    }
+    async write(entity, validate) {
+        const publishOutcome = () => {
+            if (entity instanceof virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity) {
+                const current = this.contexts.get(entity.controllerId)?.commands.find((command) => command.id === entity.id);
+                if (current)
+                    Object.assign(current, entity);
+            }
+        };
+        if (entity instanceof virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity) {
+            await this.journal.write(entity, validate);
+        }
+        else {
+            await this.journal.persistRuntimeRows([entity]);
+        }
+        publishOutcome();
+    }
+    async readAutomationImage(manager, controllerId) {
+        const slots = await manager.query('SELECT * FROM devices_module_climate_automation_slots WHERE controllerId = ?', [controllerId]);
+        const sources = await manager.query(`SELECT * FROM devices_module_climate_automation_sources WHERE generationId IN
+			(SELECT generationId FROM devices_module_climate_automation_slots WHERE controllerId = ?) ORDER BY generationId`, [controllerId]);
+        return JSON.stringify({ slots, sources });
+    }
+    async validateNativeDecision(manager, context, claim, action, requireLiveDecision = true) {
+        if (!this.isCurrentLifecycle(context.lifecycle))
+            throw new ThermostatDecisionRetiredError('Original runtime lifecycle ended');
+        const current = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, { id: claim.id });
+        const identity = [
+            'id',
+            'controllerId',
+            'revision',
+            'sourcePropertyId',
+            'sourcePropertyIdentity',
+            'sourceDeviceId',
+            'sourceDeviceIdentity',
+            'physicalIdentity',
+            'contractFingerprint',
+            'qualificationGeneration',
+            'providerProfile',
+            'providerProfileVersion',
+        ];
+        if (!current || current.state === 'released' || identity.some((key) => !Object.is(current[key], claim[key])))
+            throw new Error('Original thermostat native claim required');
+        if (action === 'off')
+            return;
+        const original = context.onNative;
+        if (!original?.current())
+            throw new Error('Original thermostat native decision required');
+        if (requireLiveDecision && !this.canSend(context, claim, 'on'))
+            throw new ThermostatDecisionRetiredError('Original thermostat decision retired before native dispatch');
+        await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(manager, claim.controllerId, original.image);
+        await original.verifyBindings(manager);
+        if ((await this.readAutomationImage(manager, claim.controllerId)) !== original.automation)
+            throw new Error('Original thermostat native automation required');
+        const automation = await this.automation?.resolve(manager, context.config);
+        if (JSON.stringify(automation?.baseline ?? null) !== JSON.stringify(context.automation?.baseline ?? null) ||
+            (automation?.baseline && !automation.isCurrent()) ||
+            !original.current())
+            throw new Error('Original thermostat native automation required');
+        if (requireLiveDecision && !this.canSend(context, claim, 'on'))
+            throw new ThermostatDecisionRetiredError('Original thermostat decision retired before native dispatch');
+    }
+    async load(controllerId) {
+        const lifecycle = this.lifecycle;
+        await this.comfort.settle(controllerId);
+        return this.structure.runShared(async () => {
+            let image, automationImage;
+            try {
+                image = await (0, thermostat_controller_mutation_1.readControllerMutationImage)(this.dataSource.manager, controllerId);
+                automationImage = await this.readAutomationImage(this.dataSource.manager, controllerId);
+            }
+            catch {
+            }
+            const admission = this.claims.capture();
+            const publishGuard = this.graph.capturePublishGuard();
+            const config = await this.dataSource.manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, { controllerId });
+            if (!config)
+                return null;
+            const automation = await this.automation?.resolve(this.dataSource.manager, config);
+            const owner = config.ownerDeviceId
+                ? await this.dataSource.manager.findOneBy(devices_entity_1.DeviceEntity, { id: config.ownerDeviceId })
+                : null;
+            const claims = await this.dataSource.manager.findBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, {
+                controllerId,
+                state: (0, typeorm_1.Not)('released'),
+            });
+            const rows = await this.dataSource.manager.findBy(virtual_thermostat_entity_1.VirtualThermostatSourceEntity, { controllerId });
+            const bindings = await this.inputs.load(rows);
+            const memberBindings = await this.memberProtection.load(config, claims);
+            const coolingBindings = await this.coolingDependencies.load(config, claims);
+            const commands = await this.loadDecisionCommands(controllerId, claims);
+            const state = (await this.dataSource.manager.findOneBy(virtual_thermostat_runtime_entity_1.VirtualThermostatRuntimeEntity, { controllerId })) ??
+                this.dataSource.manager.create(virtual_thermostat_runtime_entity_1.VirtualThermostatRuntimeEntity, {
+                    controllerId,
+                    decisionRevision: 0,
+                    configurationRevision: config.revision,
+                    floorLatched: false,
+                    heuristicHold: null,
+                    previousDemand: 'off',
+                    reasons: [],
+                    evaluatedAt: new Date(),
+                });
+            await this.journal.captureRuntimeRow(this.dataSource.manager, state);
+            const branches = new Map(), targets = new Map();
+            for (const claim of claims) {
+                const branch = (await this.dataSource.manager.findOneBy(virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity, { claimId: claim.id })) ??
+                    this.dataSource.manager.create(virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity, {
+                        claimId: claim.id,
+                        activity: 'unknown',
+                        lastVerifiedOffAt: null,
+                        releaseProofId: null,
+                        releaseAttempts: 0,
+                        nextReleaseAt: null,
+                        fault: null,
+                        floorLatched: null,
+                    });
+                await this.journal.captureRuntimeRow(this.dataSource.manager, branch);
+                branches.set(claim.id, branch);
+                const property = claim.sourcePropertyId
+                    ? await this.dataSource.manager.findOne(devices_entity_1.ChannelPropertyEntity, {
+                        where: { id: claim.sourcePropertyId },
+                        relations: ['channel', 'channel.device'],
+                    })
+                    : null;
+                if (property) {
+                    const channel = property.channel;
+                    targets.set(claim.id, { property, channel, device: channel.device, value: false });
+                }
+            }
+            let onNative;
+            try {
+                if (image && automationImage !== undefined) {
+                    const edges = (0, creation_capture_1.captureCreation)(this.graph, ['edges']);
+                    const bindings = await (0, thermostat_controller_mutation_1.captureControllerBindings)(this.dataSource.manager, controllerId, image, [], (manager) => edges.values.edges.call(edges.receiver, manager));
+                    await (0, thermostat_controller_mutation_1.assertControllerMutationImage)(this.dataSource.manager, controllerId, image);
+                    if (automationImage === (await this.readAutomationImage(this.dataSource.manager, controllerId)))
+                        onNative = {
+                            image,
+                            automation: automationImage,
+                            verifyBindings: (manager) => bindings(undefined, manager),
+                            current: () => edges.current(),
+                        };
+                }
+            }
+            catch {
+            }
+            return {
+                lifecycle,
+                onNative,
+                admission,
+                publishGuard: () => this.isCurrentLifecycle(lifecycle) && publishGuard() && (!automation?.baseline || automation.isCurrent()),
+                automation,
+                config,
+                owner,
+                claims,
+                bindings,
+                memberBindings,
+                memberProtection: [],
+                coolingBindings,
+                coolingProtection: [],
+                commands,
+                state,
+                branches,
+                targets,
+                epoch: this.epochs.get(controllerId) ?? 0,
+                decision: {
+                    desiredHeating: false,
+                    desiredCooling: false,
+                    comfortDemand: 'off',
+                    floorOverheatLatched: state.floorLatched,
+                    reasons: [],
+                },
+            };
+        });
+    }
+    async loadDecisionCommands(controllerId, claims) {
+        const byId = new Map();
+        for (const claim of claims) {
+            const scoped = () => this.dataSource.manager
+                .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, 'command')
+                .where('command.controllerId = :controllerId', { controllerId })
+                .andWhere('command.claimId = :claimId', { claimId: claim.id });
+            const pending = () => scoped().andWhere("command.status NOT IN ('confirmed', 'cancelled')");
+            const witnesses = await Promise.all([
+                scoped()
+                    .andWhere("command.action = 'on' AND command.status <> 'cancelled'")
+                    .orderBy('command.preparedAt', 'DESC')
+                    .addOrderBy('command.decisionRevision', 'DESC')
+                    .addOrderBy('command.id', 'DESC')
+                    .limit(1)
+                    .getOne(),
+                pending().andWhere("command.action = 'on'").limit(1).getOne(),
+                pending().andWhere("command.action = 'off'").limit(1).getOne(),
+                pending().andWhere("command.action = 'on' AND command.status = 'unknown'").limit(1).getOne(),
+                pending()
+                    .andWhere("command.action = 'on' AND command.dispatchedAt IS NOT NULL")
+                    .orderBy('command.dispatchedAt', 'DESC')
+                    .addOrderBy('command.id', 'DESC')
+                    .limit(1)
+                    .getOne(),
+                pending().andWhere("command.fault IS NOT NULL AND command.fault <> ''").limit(1).getOne(),
+            ]);
+            for (const command of witnesses)
+                if (command && !byId.has(command.id))
+                    byId.set(command.id, command);
+        }
+        return [...byId.values()];
+    }
+    async loadUnresolvedCommands(controllerId, claimId, manager = this.dataSource.manager) {
+        return manager
+            .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, 'command')
+            .where('command.controllerId = :controllerId AND command.claimId = :claimId', { controllerId, claimId })
+            .andWhere("command.status NOT IN ('confirmed', 'cancelled')")
+            .getMany();
+    }
+    evidence(context, claim, now) {
+        const branch = context.branches.get(claim.id), target = context.targets.get(claim.id);
+        const feedback = target ? this.values.readQualifiedSample(target.property, 30_000, new Date(now)) : null;
+        branch.activity = typeof feedback?.value === 'boolean' ? (feedback.value ? 'on' : 'off') : 'unknown';
+        const latest = new Map(context.commands.map((command) => [command.id, command]));
+        for (const command of this.inFlightCommands.values())
+            if (command.claimId === claim.id)
+                latest.set(command.id, command);
+        const pending = [...latest.values()].filter((command) => command.claimId === claim.id && unresolved(command));
+        const qualification = this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims));
+        const parallel = context.claims.filter((member) => member.role === claim.role).length > 1;
+        const unobservedOn = parallel &&
+            pending.some((command) => command.action === 'on' &&
+                command.status === 'accepted' &&
+                (!feedback ||
+                    feedback.value !== true ||
+                    !command.dispatchedAt ||
+                    feedback.receivedAt.getTime() < command.dispatchedAt.getTime()));
+        let ownedReady = true;
+        if (context.automation?.baseline &&
+            context.owner?.enabled &&
+            claim.state === 'reserved' &&
+            target?.device.enabled &&
+            qualification) {
+            ownedReady = !!this.transport.captureReconcileReadiness(target, claim, qualification)?.isCurrent();
+            context.ownedReadinessRefusals ??= new Set();
+            if (ownedReady)
+                context.ownedReadinessRefusals.delete(claim.id);
+            else
+                context.ownedReadinessRefusals.add(claim.id);
+        }
+        return {
+            activity: branch.activity,
+            pendingOn: pending.some((command) => command.action === 'on'),
+            releaseProven: this.isReconciled(claim),
+            offSince: branch.lastVerifiedOffAt?.getTime() ?? null,
+            canEnergize: !!context.owner?.enabled &&
+                claim.state === 'reserved' &&
+                !!target?.device.enabled &&
+                !!qualification &&
+                ownedReady &&
+                !!this.transport.get(target, claim)?.canReconcile(target, qualification) &&
+                this.isReconciled(claim) &&
+                !branch.fault &&
+                !this.memberFaults.has(`${claim.id}:${claim.revision}`) &&
+                !unobservedOn &&
+                (branch.activity === 'on' ||
+                    (branch.lastVerifiedOffAt !== null &&
+                        now >= branch.lastVerifiedOffAt.getTime() + context.config.policy.minimumOffMs)) &&
+                !pending.some((command) => command.action === 'off'),
+        };
+    }
+    decide(context, frame, now, advance) {
+        const windows = frame.contacts.map((contact) => {
+            const state = (0, virtual_window_contact_utils_1.evaluateVirtualWindowContact)(this.contacts.get(contact.id) ?? (0, virtual_window_contact_utils_1.createVirtualWindowContactState)(), { openingMs: context.config.contactOpeningMs, closingMs: context.config.contactClosingMs }, {
+                now,
+                basis: (0, virtual_thermostat_contract_utils_1.thermostatFingerprint)({ contact: contact.basis, configRevision: context.config.revision }),
+                reported: contact.value,
+            });
+            if (advance)
+                this.contacts.set(contact.id, state);
+            return state.confirmed === 'unknown' ? null : state.confirmed;
+        });
+        let trend = this.trends.get(context.config.controllerId);
+        if (!trend) {
+            trend = (0, virtual_window_trend_utils_1.createVirtualWindowTrendState)();
+            if (context.state.heuristicHold)
+                Object.assign(trend, context.state.heuristicHold);
+        }
+        const previousDirection = context.state.previousDemand === 'heat'
+            ? 'heating'
+            : context.state.previousDemand === 'cool'
+                ? 'cooling'
+                : context.config.requestedMode === 'cool'
+                    ? 'cooling'
+                    : 'heating';
+        const heuristic = context.config.heuristic
+            ? (0, virtual_window_trend_utils_1.evaluateVirtualWindowTrend)(context.config.heuristic, trend, {
+                now,
+                enabled: true,
+                direction: context.config.requestedMode === 'off' ? 'off' : previousDirection,
+                frame: frame.ambientSample
+                    ? {
+                        temperature: frame.ambient,
+                        sampledAt: frame.ambientSample.sampledAt.getTime(),
+                        basis: (0, virtual_thermostat_contract_utils_1.thermostatFingerprint)({ input: frame.basis, configRevision: context.config.revision }),
+                        quality: frame.ambientSample.quality,
+                    }
+                    : null,
+            })
+            : null;
+        if (advance && heuristic)
+            this.trends.set(context.config.controllerId, heuristic.state);
+        const branchEvidence = (role) => (0, virtual_thermostat_branch_utils_1.thermostatBranchEvidence)(context.claims.filter((claim) => claim.role === role).map((claim) => this.evidence(context, claim, now)));
+        const effective = (0, virtual_thermostat_comfort_utils_1.effectiveThermostatComfort)(context.config.policy, context.config.comfort, context.automation);
+        const decision = (0, virtual_thermostat_policy_utils_1.evaluateVirtualThermostatPolicy)({
+            ...context.config.policy,
+            floor: context.memberBindings.length && !context.bindings.some((row) => row.binding.role === 'floor')
+                ? null
+                : context.config.policy.floor,
+            heatingSetpoint: effective.heating_setpoint,
+            coolingSetpoint: effective.cooling_setpoint,
+        }, {
+            now,
+            mode: context.owner?.enabled && effective.source !== 'user_off' ? context.config.requestedMode : 'off',
+            ambient: frame.ambient,
+            floor: frame.floor,
+            heating: branchEvidence('heating'),
+            cooling: branchEvidence('cooling'),
+            previousDemand: context.state.previousDemand,
+            floorOverheatLatched: context.state.floorLatched,
+            windows,
+            heuristicWindowPause: heuristic?.paused ?? false,
+            reconciled: context.claims.length > 0 && context.claims.every((claim) => this.isReconciled(claim)),
+        });
+        context.coolingProtection = this.coolingDependencies.read(context.coolingBindings, now);
+        if (context.config.policy.cooling &&
+            context.coolingBindings.length !== context.claims.filter((c) => c.role === 'cooling').length) {
+            decision.desiredCooling = false;
+            decision.reasons.push('cooling_mandatory_dependencies_missing');
+        }
+        for (const member of context.coolingProtection) {
+            if (!member.ready) {
+                decision.desiredCooling = false;
+                decision.reasons.push(...member.reasons.map((reason) => `${reason}:${member.claim}`));
+            }
+        }
+        context.memberProtection = this.memberProtection.read(context.memberBindings, now);
+        for (const member of context.memberProtection) {
+            const branch = context.branches.get(member.claim);
+            if (branch)
+                branch.floorLatched = member.latched;
+            if (!member.ready) {
+                decision.desiredHeating = false;
+                decision.reasons.push(...member.reasons.map((reason) => `${reason}:${member.claim}`));
+            }
+        }
+        for (const claim of context.claims)
+            if (context.commands.some((command) => command.claimId === claim.id && command.action === 'on' && command.status === 'unknown')) {
+                decision.reasons.push(claim.role + '_unresolved_on');
+                if (claim.role === 'heating')
+                    decision.desiredHeating = false;
+                else
+                    decision.desiredCooling = false;
+            }
+        if (!this.comfort.isCurrent(context.config) ||
+            (context.config.comfort && (0, virtual_thermostat_comfort_utils_1.validateThermostatComfort)(context.config.comfort, context.config.policy).length)) {
+            decision.desiredHeating = false;
+            decision.desiredCooling = false;
+            decision.reasons.push(context.config.comfort?.temporary_override?.status === 'clock_uncertain'
+                ? 'comfort_clock_uncertain'
+                : 'comfort_refresh_required');
+        }
+        if (!context.publishGuard()) {
+            decision.desiredHeating = false;
+            decision.desiredCooling = false;
+            decision.comfortDemand = 'off';
+            decision.reasons.push('graph_validation_pending');
+        }
+        return decision;
+    }
+    canSend(context, claim, action) {
+        const current = this.contexts.get(context.config.controllerId);
+        const liveClaim = current?.claims.find((candidate) => candidate.id === claim.id);
+        if (!this.isCurrentLifecycle(context.lifecycle) ||
+            !current ||
+            !context.admission.isCurrent() ||
+            !liveClaim ||
+            liveClaim.revision !== claim.revision ||
+            liveClaim.physicalIdentity !== claim.physicalIdentity ||
+            liveClaim.sourcePropertyId !== claim.sourcePropertyId)
+            return false;
+        if (action === 'off')
+            return true;
+        if (current !== context ||
+            !context.publishGuard() ||
+            current.config.revision !== context.config.revision ||
+            context.epoch !== this.epochs.get(context.config.controllerId))
+            return false;
+        const fresh = this.decide(current, this.inputs.read(current.bindings), Date.now(), false);
+        return claim.role === 'heating' ? fresh.desiredHeating : fresh.desiredCooling;
+    }
+    async evaluate(controllerId, lifecycle = this.lifecycle) {
+        if (!this.isCurrentLifecycle(lifecycle))
+            return;
+        const context = await this.load(controllerId);
+        if (!context || !this.isCurrentLifecycle(lifecycle))
+            return;
+        this.contexts.set(controllerId, context);
+        const now = Date.now(), frame = this.inputs.read(context.bindings, now);
+        context.decision = this.decide(context, frame, now, true);
+        this.acknowledgeMemberRelease(context);
+        this.acknowledgeCoolingRelease(context);
+        context.state.decisionRevision++;
+        context.state.configurationRevision = context.config.revision;
+        context.state.floorLatched = context.decision.floorOverheatLatched;
+        context.state.previousDemand = context.decision.comfortDemand;
+        context.state.reasons = context.decision.reasons;
+        context.state.evaluatedAt = new Date(now);
+        const trend = this.trends.get(controllerId);
+        context.state.heuristicHold =
+            trend?.pausedAt !== null && trend?.pausedUntil !== null && trend
+                ? { pausedAt: trend.pausedAt, pausedUntil: trend.pausedUntil, cooldownUntil: trend.cooldownUntil }
+                : null;
+        await this.journal.persistRuntimeRows([context.state, ...context.branches.values()]);
+        if (!this.isCurrentLifecycle(lifecycle))
+            return;
+        for (const claim of context.claims) {
+            const desired = claim.role === 'heating' ? context.decision.desiredHeating : context.decision.desiredCooling;
+            const branch = context.branches.get(claim.id);
+            const pending = context.commands.some((command) => command.claimId === claim.id && command.action === 'on' && unresolved(command));
+            if (!desired && (branch.activity !== 'off' || pending || !this.isReconciled(claim) || claim.state !== 'reserved'))
+                await this.prepare(context, claim, 'off');
+        }
+        for (const claim of context.claims) {
+            if (!this.isCurrentLifecycle(lifecycle))
+                return;
+            await this.reconcile(context, claim);
+        }
+        if (!this.isCurrentLifecycle(lifecycle))
+            return;
+        this.acknowledgeMemberRelease(context);
+        this.acknowledgeCoolingRelease(context);
+        for (const claim of context.claims) {
+            const desired = claim.role === 'heating' ? context.decision.desiredHeating : context.decision.desiredCooling;
+            const latest = context.commands
+                .filter((command) => command.claimId === claim.id && command.action === 'on' && command.status !== 'cancelled')
+                .sort(newestCommandFirst)[0];
+            if (desired &&
+                (!latest ||
+                    (latest.status === 'confirmed' && context.branches.get(claim.id).activity === 'off') ||
+                    (context.branches.get(claim.id).activity === 'on' &&
+                        now - latest.preparedAt.getTime() >= claim.leaseSeconds * 500)))
+                await this.prepare(context, claim, 'on');
+        }
+        await this.publish(context, frame);
+    }
+    releaseScope(context) {
+        return (0, virtual_thermostat_contract_utils_1.thermostatFingerprint)({
+            configuration: context.config.revision,
+            inputs: context.bindings
+                .map(({ binding, compatible, producerRevision }) => ({ binding, compatible, producerRevision }))
+                .sort((a, b) => a.binding.id.localeCompare(b.binding.id)),
+            claims: context.claims
+                .map((claim) => ({
+                id: claim.id,
+                revision: claim.revision,
+                generation: claim.qualificationGeneration,
+                role: claim.role,
+                state: claim.state,
+                leaseSeconds: claim.leaseSeconds,
+                providerProfile: claim.providerProfile,
+                providerProfileVersion: claim.providerProfileVersion,
+                device: claim.sourceDeviceId,
+                physicalIdentity: claim.physicalIdentity,
+                source: claim.sourcePropertyId,
+                contract: claim.contractFingerprint,
+            }))
+                .sort((a, b) => a.id.localeCompare(b.id)),
+            cooling: context.coolingBindings.map((entry) => ({ claim: entry.claimId, basis: entry.basis })),
+            members: context.memberBindings
+                .map((member) => ({ claim: member.claimId, basis: member.basis }))
+                .sort((a, b) => a.claim.localeCompare(b.claim)),
+        });
+    }
+    hasCurrentDrain(context, claim, requiredAfter) {
+        const proof = this.reconciled.get(`${claim.id}:${claim.revision}`);
+        const member = this.memberProtection.requiredReleaseAfter(context.memberBindings);
+        const cooling = claim.role === 'cooling' ? this.coolingDependencies.requiredReleaseAfter(context.coolingBindings) : null;
+        const after = requiredAfter ?? (member === null ? cooling : cooling === null ? member : Math.max(member, cooling));
+        const evidence = this.evidence(context, claim, Date.now());
+        const target = context.targets.get(claim.id);
+        return (!!proof &&
+            !!target &&
+            !!this.transport.get(target, claim)?.canReconcile(target, proof.qualification) &&
+            proof.scope === this.releaseScope(context) &&
+            proof.scopeIsCurrent() &&
+            (after === null || proof.observedAt > after) &&
+            evidence.activity === 'off' &&
+            !evidence.pendingOn &&
+            evidence.releaseProven &&
+            ![...this.inFlightCommands.values()].some((command) => command.claimId === claim.id));
+    }
+    acknowledgeMemberRelease(context) {
+        const after = this.memberProtection.requiredReleaseAfter(context.memberBindings);
+        if (after === null ||
+            !context.admission.isCurrent() ||
+            !context.publishGuard() ||
+            this.contexts.get(context.config.controllerId) !== context ||
+            context.epoch !== this.epochs.get(context.config.controllerId))
+            return;
+        const heating = context.claims.filter((claim) => claim.role === 'heating');
+        if (!heating.length || !heating.every((claim) => this.hasCurrentDrain(context, claim)))
+            return;
+        this.memberProtection.acknowledgeRelease(context.memberBindings, Date.now());
+    }
+    acknowledgeCoolingRelease(context) {
+        const after = this.coolingDependencies.requiredReleaseAfter(context.coolingBindings);
+        if (after === null ||
+            !context.admission.isCurrent() ||
+            !context.publishGuard() ||
+            this.contexts.get(context.config.controllerId) !== context ||
+            context.epoch !== this.epochs.get(context.config.controllerId))
+            return;
+        const cooling = context.claims.filter((claim) => claim.role === 'cooling');
+        if (!cooling.length || !cooling.every((claim) => this.hasCurrentDrain(context, claim, after)))
+            return;
+        this.coolingDependencies.acknowledgeRelease(context.coolingBindings);
+    }
+    async prepare(context, claim, action) {
+        const branch = context.branches.get(claim.id), now = Date.now();
+        if (action === 'off' &&
+            ((branch.nextReleaseAt && branch.nextReleaseAt.getTime() > now) ||
+                [...this.inFlightCommands.values()].some((command) => command.claimId === claim.id && command.action === 'off')))
+            return;
+        const target = context.targets.get(claim.id), qualification = this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims));
+        const readiness = target && action === 'on' && context.automation?.baseline
+            ? this.transport.captureReconcileReadiness(target, claim, qualification)
+            : undefined;
+        if (readiness === null || (readiness && !readiness.isCurrent())) {
+            (context.ownedReadinessRefusals ??= new Set()).add(claim.id);
+            return;
+        }
+        const adapter = target && this.transport.capture(target, claim, qualification);
+        if (!target || !adapter) {
+            branch.fault = 'actuator_missing_or_unsupported';
+            await this.write(branch);
+            return;
+        }
+        const command = this.dataSource.manager.create(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, {
+            id: (0, node_crypto_1.randomUUID)(),
+            controllerId: claim.controllerId,
+            claimId: claim.id,
+            claimRevision: claim.revision,
+            configurationRevision: context.config.revision,
+            decisionRevision: context.state.decisionRevision,
+            action,
+            status: 'prepared',
+            preparedAt: new Date(now),
+            dispatchedAt: null,
+            settledAt: null,
+            proofId: null,
+            fault: null,
+        });
+        if (action === 'off') {
+            branch.releaseAttempts++;
+            branch.nextReleaseAt = new Date(now + retryDelaysMs[Math.min(branch.releaseAttempts - 1, retryDelaysMs.length - 1)]);
+        }
+        await this.journal.insert(command, branch, (manager) => this.validateNativeDecision(manager, context, claim, action, false));
+        context.commands.push(command);
+        this.inFlightCommands.set(command.id, command);
+        const operation = this.dispatch(context, claim, target, command, adapter, qualification, readiness?.isCurrent).finally(() => {
+            this.inFlight.delete(command.id);
+            this.inFlightCommands.delete(command.id);
+        });
+        this.inFlight.set(command.id, operation);
+        this.ownership.enroll(command, operation);
+        void operation.catch(() => undefined);
+    }
+    recordMemberFault(context, claim, reason) {
+        if (!this.isCurrentLifecycle(context.lifecycle) ||
+            context.claims.filter((member) => member.role === claim.role).length < 2)
+            return null;
+        this.memberFaults.set(`${claim.id}:${claim.revision}`, reason);
+        const current = this.contexts.get(claim.controllerId);
+        if (current?.claims.find((member) => member.id === claim.id)?.revision !== claim.revision)
+            return null;
+        const branch = current.branches.get(claim.id);
+        branch.fault = reason;
+        context.branches.get(claim.id).fault = reason;
+        return branch;
+    }
+    async dispatch(context, claim, target, command, adapter, qualification, readinessCurrent) {
+        let enteredTransport = false;
+        let refusedOn = false;
+        let expiredTransport = false;
+        try {
+            expiredTransport = !adapter.isCurrent() || (readinessCurrent !== undefined && !readinessCurrent());
+            if (expiredTransport || !this.canSend(context, claim, command.action)) {
+                command.status = 'cancelled';
+                await this.write(command);
+                if (!expiredTransport)
+                    await this.retryOffImmediately(command, context);
+                return;
+            }
+            const authority = this.claims.mintAuthority(claim.id, command.action), update = { ...target, value: command.action === 'on' };
+            const guard = () => adapter.isCurrent() &&
+                (readinessCurrent === undefined || readinessCurrent()) &&
+                this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims)) === qualification &&
+                this.canSend(context, claim, command.action) &&
+                this.claims.isAuthorized(authority, update);
+            command.status = 'dispatching';
+            command.dispatchedAt = new Date();
+            await this.write(command, (manager) => this.validateNativeDecision(manager, context, claim, command.action));
+            if (!guard()) {
+                expiredTransport = !adapter.isCurrent() || (readinessCurrent !== undefined && !readinessCurrent());
+                command.status = 'cancelled';
+                await this.write(command);
+                if (!expiredTransport)
+                    await this.retryOffImmediately(command, context);
+                return;
+            }
+            enteredTransport = true;
+            const result = await adapter.send(update, claim, qualification, guard, {
+                commandId: command.id,
+            });
+            refusedOn = command.action === 'on' && result.outcome === 'refused';
+            command.status = refusedOn ? 'cancelled' : result.outcome === 'accepted' ? 'accepted' : 'unknown';
+            command.settledAt = new Date();
+            command.fault =
+                result.outcome === 'refused'
+                    ? result.reasons.join(',')
+                    : result.outcome === 'unknown'
+                        ? 'command_execution_unknown'
+                        : null;
+            if (command.action === 'on' && result.outcome !== 'accepted') {
+                const branch = this.recordMemberFault(context, claim, command.fault ?? 'mandatory_member_refused');
+                if (branch)
+                    await this.write(branch);
+            }
+            await this.write(command);
+        }
+        catch (error) {
+            command.status = enteredTransport && !refusedOn ? 'unknown' : 'cancelled';
+            const retiredBeforeSend = !enteredTransport && error instanceof ThermostatDecisionRetiredError;
+            command.fault = retiredBeforeSend ? null : error instanceof Error ? error.message : 'dispatch_error';
+            if (command.action === 'on' && !retiredBeforeSend)
+                this.recordMemberFault(context, claim, command.fault);
+            try {
+                await this.write(command);
+                if (!enteredTransport)
+                    await this.retryOffImmediately(command, context);
+            }
+            catch (cleanup) {
+                if (retiredBeforeSend)
+                    throw cleanup;
+                this.logger.error('Failed to persist original thermostat command failure', cleanup);
+            }
+            if (!retiredBeforeSend)
+                throw error;
+        }
+        finally {
+            if (this.isCurrentLifecycle(context.lifecycle) && !refusedOn && !expiredTransport)
+                void this.request(claim.controllerId, !context.claims.some((member) => context.claims.filter((other) => other.role === member.role).length > 1));
+        }
+    }
+    async retryOffImmediately(command, context) {
+        if (!this.isCurrentLifecycle(context.lifecycle))
+            return;
+        if (command.action !== 'off')
+            return;
+        await this.journal.runNative(async (manager) => {
+            const branch = await manager.findOneBy(virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity, { claimId: command.claimId });
+            if (!branch)
+                return;
+            await this.journal.captureRuntimeRow(manager, branch);
+            branch.releaseAttempts = Math.max(0, branch.releaseAttempts - 1);
+            branch.nextReleaseAt = null;
+            await this.journal.writeRuntimeRows(manager, [branch]);
+        });
+    }
+    async reconcile(context, claim) {
+        const target = context.targets.get(claim.id), qualification = this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims));
+        if (context.automation?.baseline && (!target || !qualification)) {
+            (context.ownedReadinessRefusals ??= new Set()).add(claim.id);
+            return;
+        }
+        const metadata = context.automation?.baseline && target && qualification
+            ? this.transport.captureOffMetadata(target, claim, qualification)
+            : undefined;
+        if (metadata === null || (metadata && !metadata.isCurrent())) {
+            (context.ownedReadinessRefusals ??= new Set()).add(claim.id);
+            return;
+        }
+        const readiness = context.automation?.baseline && target && qualification
+            ? this.transport.captureReconcileReadiness(target, claim, qualification)
+            : undefined;
+        if (readiness === null || (readiness && !readiness.isCurrent())) {
+            (context.ownedReadinessRefusals ??= new Set()).add(claim.id);
+            return;
+        }
+        const adapter = target && this.transport.capture(target, claim, qualification);
+        if (!target || !qualification || !adapter?.canReconcile(target, qualification))
+            return;
+        const off = this.values.readQualifiedSample(target.property, 30_000);
+        if (off?.value !== false)
+            return;
+        if ([...this.inFlightCommands.values()].some((command) => command.claimId === claim.id))
+            return;
+        const { pending, controllerImage } = await this.structure.runShared(async () => {
+            const pending = await this.loadUnresolvedCommands(claim.controllerId, claim.id);
+            await this.journal.capturePending(this.dataSource.manager, pending, claim.controllerId, claim.id);
+            return {
+                pending,
+                controllerImage: await (0, thermostat_controller_mutation_1.readControllerMutationImage)(this.dataSource.manager, claim.controllerId),
+            };
+        });
+        if (pending.some((command) => this.inFlight.has(command.id)))
+            return;
+        if (!pending.length && this.hasCurrentDrain(context, claim))
+            return;
+        if (!pending.length && !context.publishGuard() && this.isReconciled(claim))
+            return;
+        const startedAt = new Date();
+        if (!adapter.isCurrent())
+            return;
+        const proof = await adapter.reconcile(target, pending.map((command) => command.id), off, () => adapter.isCurrent() && this.canSend(context, claim, 'off'), {
+            controllerId: context.config.controllerId,
+            controllerRevision: context.config.revision,
+            claimId: claim.id,
+            claimRevision: claim.revision,
+            contractFingerprint: claim.contractFingerprint,
+            qualification,
+        });
+        let retireConfirmedCommandIds;
+        try {
+            retireConfirmedCommandIds = proof?.retireConfirmedCommandIds;
+        }
+        catch {
+        }
+        const acceptedOff = this.values.readQualifiedSample(target.property, 30_000);
+        const endedAt = new Date();
+        const covered = new Set(proof?.coveredCommandIds ?? []);
+        if (!proof ||
+            (metadata !== undefined && !metadata.isCurrent()) ||
+            (readiness !== undefined && !readiness.isCurrent()) ||
+            !adapter.isCurrent() ||
+            !acceptedOff ||
+            acceptedOff.value !== false ||
+            acceptedOff.provenance !== 'live' ||
+            acceptedOff.quality !== 'good' ||
+            !proof.isCurrent?.() ||
+            !proof.sourceIsCurrent?.() ||
+            this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims)) !== qualification ||
+            proof.scope?.controllerId !== context.config.controllerId ||
+            proof.scope.controllerRevision !== context.config.revision ||
+            proof.scope.claimId !== claim.id ||
+            proof.scope.claimRevision !== claim.revision ||
+            proof.scope.contractFingerprint !== claim.contractFingerprint ||
+            !Number.isFinite(proof.observedAt?.getTime()) ||
+            proof.observedAt.getTime() < startedAt.getTime() ||
+            proof.observedAt.getTime() > endedAt.getTime() ||
+            !this.canSend(context, claim, 'off') ||
+            !proof.proofId ||
+            !proof.connectionIdentity ||
+            proof.physicalIdentity !== claim.physicalIdentity ||
+            !proof.externalWriterBarrier ||
+            pending.some((command) => !covered.has(command.id)) ||
+            proof.offSample.propertyId !== target.property.id ||
+            proof.offSample.value !== false ||
+            proof.offSample.provenance !== 'live' ||
+            proof.offSample.quality !== 'good' ||
+            proof.offSample.sampledAt.getTime() < proof.observedAt.getTime() ||
+            proof.offSample.receivedAt.getTime() > endedAt.getTime() ||
+            proof.offSample.sampledAt.getTime() !== acceptedOff.sampledAt.getTime() ||
+            proof.offSample.receivedAt.getTime() !== acceptedOff.receivedAt.getTime() ||
+            proof.offSample.revision !== acceptedOff.revision)
+            return;
+        const isProofCurrent = () => {
+            const currentOff = this.values.readQualifiedSample(target.property, 30_000);
+            return (adapter.isCurrent() &&
+                (metadata === undefined || metadata.isCurrent()) &&
+                (readiness === undefined || readiness.isCurrent()) &&
+                this.canSend(context, claim, 'off') &&
+                proof.isCurrent() &&
+                proof.sourceIsCurrent() &&
+                this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims)) === qualification &&
+                this.contexts.get(claim.controllerId)?.config.revision === proof.scope.controllerRevision &&
+                !!currentOff &&
+                currentOff.value === false &&
+                currentOff.provenance === 'live' &&
+                currentOff.quality === 'good' &&
+                currentOff.sampledAt.getTime() === proof.offSample.sampledAt.getTime() &&
+                currentOff.receivedAt.getTime() === proof.offSample.receivedAt.getTime() &&
+                currentOff.revision === proof.offSample.revision &&
+                adapter.canReconcile(target, qualification));
+        };
+        const branch = context.branches.get(claim.id);
+        const staleProof = new Error('Qualified release proof expired during journal settlement');
+        const settled = await this.journal
+            .runNative(async (manager) => {
+            const current = await this.loadUnresolvedCommands(claim.controllerId, claim.id, manager);
+            const currentConfig = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, {
+                controllerId: claim.controllerId,
+            });
+            const currentClaim = await manager.findOneBy(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, { id: claim.id });
+            const currentQualification = this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims));
+            const currentOff = this.values.readQualifiedSample(target.property, 30_000);
+            if (!this.canSend(context, claim, 'off') ||
+                !proof.isCurrent?.() ||
+                !proof.sourceIsCurrent?.() ||
+                currentConfig?.revision !== proof.scope.controllerRevision ||
+                !currentClaim ||
+                currentClaim.state === 'released' ||
+                currentClaim.revision !== proof.scope.claimRevision ||
+                currentClaim.contractFingerprint !== proof.scope.contractFingerprint ||
+                currentClaim.sourcePropertyId !== target.property.id ||
+                currentClaim.physicalIdentity !== proof.physicalIdentity ||
+                currentQualification !== qualification ||
+                !currentOff ||
+                currentOff.value !== false ||
+                currentOff.provenance !== 'live' ||
+                currentOff.quality !== 'good' ||
+                currentOff.sampledAt.getTime() !== proof.offSample.sampledAt.getTime() ||
+                currentOff.receivedAt.getTime() !== proof.offSample.receivedAt.getTime() ||
+                currentOff.revision !== proof.offSample.revision ||
+                !adapter.isCurrent() ||
+                !adapter.canReconcile(target, currentQualification) ||
+                current.some((command) => this.inFlight.has(command.id) || !covered.has(command.id)))
+                return null;
+            const settledBranch = await manager.findOneBy(virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity, { claimId: claim.id });
+            if (!settledBranch)
+                throw staleProof;
+            await this.journal.captureRuntimeRow(manager, settledBranch);
+            Object.assign(settledBranch, {
+                releaseProofId: proof.proofId,
+                activity: 'off',
+                lastVerifiedOffAt: !branch.lastVerifiedOffAt || current.some((command) => command.action === 'on')
+                    ? proof.offSample.receivedAt
+                    : branch.lastVerifiedOffAt,
+                releaseAttempts: 0,
+                nextReleaseAt: null,
+                fault: null,
+            });
+            const settledAt = new Date();
+            if (!(await this.journal.confirmPending(manager, pending, claim.controllerId, claim.id, proof.proofId, settledAt)))
+                return null;
+            const verifyController = async () => {
+                if (JSON.stringify(await (0, thermostat_controller_mutation_1.readControllerMutationImage)(manager, claim.controllerId)) !==
+                    JSON.stringify(controllerImage) ||
+                    !isProofCurrent())
+                    throw staleProof;
+            };
+            await verifyController();
+            this.journal.addNativeCheck(manager, verifyController, isProofCurrent);
+            await this.journal.writeRuntimeRows(manager, [settledBranch]);
+            if (!isProofCurrent())
+                throw staleProof;
+            return { branch: settledBranch, currentIds: new Set(current.map((command) => command.id)), settledAt };
+        })
+            .catch((error) => {
+            if (error === staleProof)
+                return null;
+            throw error;
+        });
+        if (!settled)
+            return;
+        try {
+            if (retireConfirmedCommandIds != null)
+                (0, creation_capture_1.invokeCreation)(retireConfirmedCommandIds, proof, [...settled.currentIds]);
+        }
+        catch {
+        }
+        context.branches.set(claim.id, settled.branch);
+        for (const command of context.commands)
+            if (settled.currentIds.has(command.id) && unresolved(command)) {
+                command.status = 'confirmed';
+                command.proofId = proof.proofId;
+                command.settledAt = settled.settledAt;
+            }
+        if (!isProofCurrent())
+            return;
+        this.memberFaults.delete(`${claim.id}:${claim.revision}`);
+        if (claim.state === 'releasing') {
+            const authority = this.claims.mintAuthority(claim.id, 'off');
+            await this.claims.completeRelease(this.claims.recordQualifiedRelease(authority, {
+                outputConfirmedOff: true,
+                pendingOnDrained: true,
+                evidenceId: proof.proofId,
+                qualification,
+                isCurrent: isProofCurrent,
+                controllerRevision: proof.scope.controllerRevision,
+            }));
+        }
+        this.reconciled.set(`${claim.id}:${claim.revision}`, {
+            qualification,
+            sourceIsCurrent: proof.sourceIsCurrent,
+            observedAt: proof.offSample.receivedAt.getTime(),
+            scope: this.releaseScope(context),
+            scopeIsCurrent: () => context.admission.isCurrent() &&
+                context.publishGuard() &&
+                (metadata === undefined || metadata.isCurrent()) &&
+                (readiness === undefined || readiness.isCurrent()),
+        });
+    }
+    branchObservation(context, claimId, now) {
+        const unavailable = {
+            qualification_ready: null,
+            activity: 'unknown',
+            activity_sampled_at: null,
+            activity_expires_at: null,
+        };
+        if (!this.active ||
+            !context ||
+            !context.admission.isCurrent() ||
+            !context.publishGuard() ||
+            context.epoch !== (this.epochs.get(context.config.controllerId) ?? 0))
+            return unavailable;
+        const claim = context.claims.find((member) => member.id === claimId), target = context.targets.get(claimId);
+        if (!claim ||
+            !target?.device.enabled ||
+            !(target.property instanceof devices_shelly_ng_entity_1.ShellyNgChannelPropertyEntity) ||
+            target.property.id !== claim.sourcePropertyId ||
+            (0, virtual_thermostat_contract_utils_1.thermostatActuatorIdentity)(target.property, target.channel, target.device) !== claim.physicalIdentity ||
+            !this.values.captureSampleSourceGuard(target.property)())
+            return unavailable;
+        const qualificationReady = this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims))
+            ? true
+            : null;
+        const sample = this.values.readQualifiedSampleSnapshot(target.property, 30_000, now);
+        if (!sample ||
+            sample.propertyId !== target.property.id ||
+            sample.provenance !== 'live' ||
+            sample.quality !== 'good' ||
+            typeof sample.value !== 'boolean')
+            return { ...unavailable, qualification_ready: qualificationReady };
+        const sampledAt = sample.sampledAt.getTime(), receivedAt = sample.receivedAt.getTime(), expiresAt = new Date(sampledAt + 30_000);
+        if (!Number.isFinite(sampledAt) ||
+            !Number.isFinite(receivedAt) ||
+            !Number.isFinite(expiresAt.getTime()) ||
+            sampledAt > now.getTime() ||
+            receivedAt > now.getTime() ||
+            now.getTime() >= expiresAt.getTime())
+            return { ...unavailable, qualification_ready: qualificationReady };
+        const commands = new Map(context.commands.map((command) => [command.id, command]));
+        for (const command of this.inFlightCommands.values())
+            if (command.claimId === claim.id)
+                commands.set(command.id, command);
+        if ([...commands.values()].some((command) => command.claimId === claim.id &&
+            unresolved(command) &&
+            command.action === 'on' &&
+            command.dispatchedAt &&
+            receivedAt < command.dispatchedAt.getTime()))
+            return { ...unavailable, qualification_ready: qualificationReady };
+        return {
+            qualification_ready: qualificationReady,
+            activity: sample.value ? 'on' : 'off',
+            activity_sampled_at: sample.sampledAt.toISOString(),
+            activity_expires_at: expiresAt.toISOString(),
+        };
+    }
+    async publish(context, frame) {
+        if (!context.publishGuard())
+            return;
+        const observedAt = new Date();
+        const branches = context.claims.map((claim) => {
+            const branch = context.branches.get(claim.id), commands = context.commands.filter((command) => command.claimId === claim.id && unresolved(command));
+            const target = context.targets.get(claim.id);
+            const readinessFault = !target
+                ? 'actuator_missing'
+                : !this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims))
+                    ? 'hardware_qualification_missing'
+                    : !this.values.readQualifiedSample(target.property, 30_000)
+                        ? 'feedback_unavailable'
+                        : claim.state !== 'reserved'
+                            ? `actuator_${claim.state}`
+                            : null;
+            return {
+                protection: context.memberProtection.find((entry) => entry.claim === claim.id) ?? null,
+                cooling_protection: context.coolingProtection.find((entry) => entry.claim === claim.id) ?? null,
+                claim: claim.id,
+                group_identity: (0, thermostat_actuation_contract_1.thermostatBranchGroupIdentity)(claim.controllerId, claim.role),
+                physical_identity: claim.physicalIdentity,
+                claim_state: claim.state,
+                last_verified_off_at: branch.lastVerifiedOffAt?.toISOString() ?? null,
+                release_evidence: claim.releaseEvidence,
+                role: claim.role,
+                activity: commands.some((command) => command.action === 'on' &&
+                    command.dispatchedAt &&
+                    ((target ? this.values.readQualifiedSample(target.property, 30_000)?.receivedAt.getTime() : null) ?? 0) <
+                        command.dispatchedAt.getTime())
+                    ? 'unknown'
+                    : branch.activity,
+                pending_on: commands.some((command) => command.action === 'on'),
+                release_pending: commands.some((command) => command.action === 'off'),
+                release_attempts: branch.releaseAttempts,
+                next_release_at: branch.nextReleaseAt?.toISOString() ?? null,
+                release_proven: branch.activity === 'off' && !commands.some((command) => command.action === 'on') && this.isReconciled(claim),
+                fault: this.memberFaults.get(`${claim.id}:${claim.revision}`) ??
+                    branch.fault ??
+                    commands.find((command) => command.fault)?.fault ??
+                    readinessFault,
+            };
+        });
+        const reasons = [...context.decision.reasons];
+        if (context.claims.some((claim) => !this.claims.qualification(claim, (0, thermostat_actuation_contract_1.thermostatHasOpposedBranches)(context.claims))))
+            reasons.push('hardware_qualification_missing');
+        if (context.claims.some((claim) => !this.isReconciled(claim)))
+            reasons.push('release_ordering_unreconciled');
+        if (context.automation?.baseline && context.ownedReadinessRefusals?.size)
+            reasons.push('owned_transport_not_ready');
+        const priority = [
+            'release_ordering_unreconciled',
+            'ambient_unavailable',
+            'floor_unavailable',
+            'contact_unknown',
+            'user_off',
+            'floor_overheat',
+            'window_open',
+            'suspected_window_open',
+        ];
+        const runtime = {
+            epoch: this.epoch,
+            sequence: ++this.sequence,
+            configuration_revision: context.config.revision,
+            decision_revision: context.state.decisionRevision,
+            readiness: reasons.some((reason) => [
+                'hardware_qualification_missing',
+                'release_ordering_unreconciled',
+                'startup_unreconciled',
+                'owned_transport_not_ready',
+            ].includes(reason) || reason.startsWith('member_'))
+                ? 'suspended'
+                : 'ready',
+            inputs: frame.inputs,
+            requested_mode: context.config.requestedMode,
+            effective_comfort: (0, virtual_thermostat_comfort_utils_1.effectiveThermostatComfort)(context.config.policy, context.config.comfort, context.automation),
+            heating_setpoint: context.config.policy.heatingSetpoint,
+            cooling_setpoint: context.config.policy.coolingSetpoint,
+            current_temperature: frame.ambient,
+            floor_temperature: context.config.displayFloorClaimId
+                ? (context.memberProtection.find((row) => row.claim === context.config.displayFloorClaimId)?.temperature ??
+                    null)
+                : frame.floor,
+            floor_latched: context.state.floorLatched,
+            comfort_demand: context.decision.comfortDemand,
+            reasons: [...new Set(reasons)],
+            headline_reason: priority.find((reason) => reasons.includes(reason)) ?? reasons[0] ?? null,
+            branches: branches.map((branch) => ({ ...branch, ...this.branchObservation(context, branch.claim, observedAt) })),
+        };
+        if (!context.publishGuard())
+            return;
+        this.diagnostics.set(context.config.controllerId, runtime);
+        this.diagnosticGuards.set(context.config.controllerId, context.publishGuard);
+        this.events.emit('DevicesVirtualPlugin.Thermostat.RuntimeChanged', {
+            controller: context.config.controllerId,
+            configuration_revision: context.config.revision,
+            decision_revision: context.state.decisionRevision,
+            epoch: this.epoch,
+            sequence: runtime.sequence,
+            runtime,
+        });
+        if (!context.publishGuard())
+            return;
+        const properties = await this.dataSource.manager.find(devices_virtual_entity_1.VirtualChannelPropertyEntity, {
+            where: { channel: { device: { id: context.config.controllerId } } },
+            relations: ['channel'],
+        });
+        if (!context.publishGuard())
+            return;
+        for (const property of properties) {
+            if (!context.publishGuard())
+                return;
+            if (property.valueOrigin !== devices_virtual_entity_1.VirtualValueOrigin.LOCAL ||
+                property.permissions.some((permission) => permission === devices_constants_1.PermissionType.READ_WRITE || permission === devices_constants_1.PermissionType.WRITE_ONLY))
+                continue;
+            const channel = property.channel;
+            let value, sample = frame.ambientSample;
+            if (channel.category === devices_constants_1.ChannelCategory.TEMPERATURE && property.category === devices_constants_1.PropertyCategory.TEMPERATURE)
+                value = frame.ambient;
+            else if (channel.category === devices_constants_1.ChannelCategory.THERMOSTAT &&
+                property.category === devices_constants_1.PropertyCategory.FLOOR_TEMPERATURE) {
+                const selected = context.config.displayFloorClaimId &&
+                    context.memberBindings.find((entry) => entry.claimId === context.config.displayFloorClaimId);
+                sample = selected
+                    ? selected.source &&
+                        this.values.readQualifiedSample(selected.source.property, selected.binding.maximumAgeSeconds * 1000)
+                    : frame.floorSample;
+                value = sample && typeof sample.value === 'number' ? sample.value : null;
+            }
+            else if (property.category === devices_constants_1.PropertyCategory.STATUS &&
+                [devices_constants_1.ChannelCategory.HEATER, devices_constants_1.ChannelCategory.COOLER].includes(channel.category)) {
+                const activity = (0, virtual_thermostat_branch_utils_1.thermostatBranchActivity)(branches.filter((branch) => branch.role === (channel.category === devices_constants_1.ChannelCategory.HEATER ? 'heating' : 'cooling')));
+                value = activity === 'unknown' ? null : activity === 'on';
+                sample = null;
+            }
+            else
+                continue;
+            let output = this.outputs.get(property.id);
+            if (!output || output.lease.revision !== context.config.revision || !this.producers.isAvailable(output.lease)) {
+                output = {
+                    property,
+                    lease: this.producers.register(property, context.config.revision, {
+                        isCurrent: context.publishGuard,
+                        reason: 'graph_validation_pending',
+                    }),
+                };
+                this.outputs.set(property.id, output);
+            }
+            if (value === null) {
+                this.producers.invalidate(output.lease, ['input_or_feedback_unavailable']);
+                continue;
+            }
+            const sampledAt = sample?.sampledAt ?? new Date();
+            await this.values.publishDerived(property, output.lease, value, {
+                quality: 'good',
+                reasons: [],
+                sampledAt,
+                evaluatedAt: new Date(),
+                expiresAt: new Date(Math.min(sampledAt.getTime() + 30000, Date.now() + 1000)),
+            });
+        }
+    }
+};
+exports.VirtualThermostatRuntimeService = VirtualThermostatRuntimeService;
+exports.VirtualThermostatRuntimeService = VirtualThermostatRuntimeService = VirtualThermostatRuntimeService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(10, (0, common_1.Optional)()),
+    __param(11, (0, common_1.Optional)()),
+    __param(12, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        device_structure_lock_service_1.DeviceStructureLockService,
+        virtual_thermostat_claims_service_1.VirtualThermostatClaimsService,
+        virtual_thermostat_inputs_service_1.VirtualThermostatInputsService,
+        virtual_thermostat_transport_service_1.VirtualThermostatTransportService,
+        property_value_service_1.PropertyValueService,
+        property_producer_registry_service_1.PropertyProducerRegistryService,
+        event_emitter_1.EventEmitter2,
+        virtual_dependency_graph_service_1.VirtualDependencyGraphService,
+        virtual_thermostat_comfort_service_1.VirtualThermostatComfortService,
+        config_1.ConfigService,
+        thermostat_member_protection_service_1.ThermostatMemberProtectionService,
+        virtual_thermostat_automation_service_1.VirtualThermostatAutomationService])
+], VirtualThermostatRuntimeService);
+//# sourceMappingURL=virtual-thermostat-runtime.service.js.map