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

package/dist/plugins/devices-virtual/services/thermostat-comfort-selection.js

@@ -0,0 +1,1064 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thermostatComfortSelection = exports.ThermostatSelectionSettlement = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
+const devices_exceptions_1 = require("../../../modules/devices/devices.exceptions");
+const devices_entity_1 = require("../../../modules/devices/entities/devices.entity");
+const climate_automation_ledger_utils_1 = require("../../../modules/devices/services/climate-automation-ledger.utils");
+const creation_capture_1 = require("../../../modules/devices/services/creation-capture");
+const devices_virtual_entity_1 = require("../entities/devices-virtual.entity");
+const virtual_producer_entity_1 = require("../entities/virtual-producer.entity");
+const virtual_thermostat_entity_1 = require("../entities/virtual-thermostat.entity");
+const virtual_thermostat_comfort_utils_1 = require("./virtual-thermostat-comfort.utils");
+const virtual_thermostat_contract_utils_1 = require("./virtual-thermostat-contract.utils");
+const virtual_thermostat_policy_utils_1 = require("./virtual-thermostat-policy.utils");
+function claimImage(row, milliseconds) {
+    return {
+        id: row.id,
+        controllerId: row.controllerId,
+        role: row.role,
+        physicalIdentity: row.physicalIdentity,
+        providerProfile: row.providerProfile,
+        providerProfileVersion: row.providerProfileVersion,
+        sourcePropertyId: row.sourcePropertyId,
+        sourcePropertyIdentity: row.sourcePropertyIdentity,
+        sourceDeviceId: row.sourceDeviceId,
+        sourceDeviceIdentity: row.sourceDeviceIdentity,
+        contractFingerprint: row.contractFingerprint,
+        revision: row.revision,
+        qualificationGeneration: row.qualificationGeneration,
+        state: row.state,
+        leaseSeconds: row.leaseSeconds,
+        reason: row.reason,
+        releaseRequestedAt: milliseconds(row.releaseRequestedAt),
+        releasedAt: milliseconds(row.releasedAt),
+        releaseEvidence: row.releaseEvidence,
+    };
+}
+function configImage(row, milliseconds = (date) => (date === null ? null : date.getTime())) {
+    return {
+        controllerId: row.controllerId,
+        displayFloorClaimId: row.displayFloorClaimId,
+        ownerDeviceId: row.ownerDeviceId,
+        schemaVersion: row.schemaVersion,
+        revision: row.revision,
+        requestedMode: row.requestedMode,
+        controlStrategy: row.controlStrategy,
+        locked: row.locked,
+        comfort: row.comfort,
+        policy: row.policy,
+        heuristic: row.heuristic,
+        contactOpeningMs: row.contactOpeningMs,
+        contactClosingMs: row.contactClosingMs,
+        configuredAt: milliseconds(row.configuredAt),
+        releaseRequestedAt: milliseconds(row.releaseRequestedAt),
+    };
+}
+function refuse(message = 'Original thermostat selection admission expired') {
+    throw new devices_exceptions_1.DevicesValidationException(message);
+}
+function revision(value, minimum, capacity = false) {
+    return Number.isSafeInteger(value) && value >= minimum && (!capacity || value < Number.MAX_SAFE_INTEGER);
+}
+class ThermostatSelectionSettlement {
+    get outcome() {
+        return this.receipt?.outcome ?? 'not_started';
+    }
+}
+exports.ThermostatSelectionSettlement = ThermostatSelectionSettlement;
+function pin(database, kind = 'selection', leases) {
+    const serialize = climate_automation_ledger_utils_1.canonical;
+    const detach = climate_automation_ledger_utils_1.ownedJson;
+    const validate = virtual_thermostat_comfort_utils_1.validateThermostatComfort;
+    const validateSetpoints = virtual_thermostat_comfort_utils_1.validateThermostatSetpoints;
+    const effective = virtual_thermostat_comfort_utils_1.effectiveThermostatComfort;
+    const contract = virtual_thermostat_contract_utils_1.thermostatPropertyContract;
+    const validatePolicy = virtual_thermostat_policy_utils_1.validateVirtualThermostatPolicy;
+    const observe = sqlite_data_source_1.observeSqliteOuterOutcome;
+    const guard = sqlite_data_source_1.registerSqliteCommitGuard;
+    const manual = kind === 'registered-settings';
+    if (!manual && (!(database instanceof sqlite_data_source_1.SqliteDataSource) || !database.isInitialized))
+        refuse();
+    const source = (0, creation_capture_1.captureCreation)(database, ['manager', 'driver', 'transaction', 'isInitialized', 'createQueryRunner']);
+    const root = (0, creation_capture_1.captureCreation)(source.values.manager, ['connection', 'queryRunner', 'query', 'createQueryBuilder']);
+    const driver = (0, creation_capture_1.captureCreation)(source.values.driver, [
+        'connection',
+        'databaseConnection',
+        'createQueryRunner',
+    ]);
+    const physical = driver.values.databaseConnection;
+    if (!manual &&
+        (!physical ||
+            typeof physical !== 'object' ||
+            root.values.connection !== database ||
+            root.values.queryRunner !== undefined ||
+            driver.values.connection !== database))
+        refuse();
+    const native = physical ? (0, creation_capture_1.captureCreation)(physical, ['all']) : undefined;
+    const releaseDateGlobal = kind === 'release-request' ? (0, creation_capture_1.captureCreation)(globalThis, ['Date']) : undefined;
+    const releaseDate = releaseDateGlobal
+        ? (0, creation_capture_1.captureCreation)(releaseDateGlobal.values.Date, ['prototype'])
+        : undefined;
+    const releaseScalar = releaseDate ? (0, creation_capture_1.captureCreation)(releaseDate.values.prototype, ['getTime']) : undefined;
+    if (releaseDateGlobal &&
+        (typeof releaseDateGlobal.values.Date !== 'function' || typeof releaseScalar.values.getTime !== 'function'))
+        refuse();
+    const dated = kind === 'override' || kind === 'cancel';
+    const dateGlobal = dated ? (0, creation_capture_1.captureCreation)(globalThis, ['Date']) : undefined;
+    const date = dated
+        ? (0, creation_capture_1.captureCreation)(dateGlobal.values.Date, kind === 'override' ? ['now', 'parse', 'prototype'] : ['prototype'])
+        : undefined;
+    const iso = dated ? (0, creation_capture_1.captureCreation)(date.values.prototype, ['toISOString']) : undefined;
+    const monotonic = kind === 'override' ? (0, creation_capture_1.captureCreation)(node_perf_hooks_1.performance, ['now']) : undefined;
+    const uuid = kind === 'override' ? (0, creation_capture_1.captureCreation)(node_crypto_1.default, ['randomUUID']) : undefined;
+    const local = dated && leases instanceof Map
+        ? (0, creation_capture_1.captureCreation)(leases, kind === 'override' ? ['get', 'set'] : ['get', 'delete'])
+        : undefined;
+    if (dated &&
+        (!local ||
+            typeof local.values.get !== 'function' ||
+            (kind === 'override' ? typeof local.values.set !== 'function' : typeof local.values.delete !== 'function') ||
+            typeof dateGlobal.values.Date !== 'function' ||
+            typeof iso.values.toISOString !== 'function' ||
+            (kind === 'override' &&
+                (typeof date.values.now !== 'function' ||
+                    typeof date.values.parse !== 'function' ||
+                    typeof monotonic.values.now !== 'function' ||
+                    typeof uuid.values.randomUUID !== 'function'))))
+        refuse();
+    const lifetimePins = [
+        dateGlobal,
+        date,
+        iso,
+        monotonic,
+        uuid,
+        local,
+        releaseDateGlobal,
+        releaseDate,
+        releaseScalar,
+    ].filter((pin) => pin !== undefined);
+    const current = () => source.current() &&
+        root.current() &&
+        driver.current() &&
+        native?.current() === true &&
+        database instanceof sqlite_data_source_1.SqliteDataSource &&
+        root.values.connection === database &&
+        root.values.queryRunner === undefined &&
+        driver.values.connection === database &&
+        database.isInitialized &&
+        lifetimePins.every((pin) => pin.current());
+    const check = () => {
+        if (!current())
+            refuse();
+    };
+    const reader = () => {
+        const cache = new Map();
+        return (object, field) => {
+            if (!object || typeof object !== 'object')
+                refuse('Invalid thermostat definition structure.');
+            let fields = cache.get(object);
+            if (!fields)
+                cache.set(object, (fields = new Map()));
+            if (!fields.has(field))
+                fields.set(field, Reflect.get(object, field));
+            return fields.get(field);
+        };
+    };
+    const record = (value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            refuse('Invalid thermostat definition structure.');
+        return value;
+    };
+    const fences = (id, fence, read) => {
+        record(fence);
+        const expected_revision = read(fence, 'expected_revision');
+        const expected_graph_revision = read(fence, 'expected_graph_revision');
+        if (typeof id !== 'string' ||
+            !id ||
+            typeof expected_revision !== 'number' ||
+            !revision(expected_revision, 1) ||
+            typeof expected_graph_revision !== 'number' ||
+            !revision(expected_graph_revision, 0))
+            refuse('Invalid thermostat selection or revision fences.');
+        return { expected_revision, expected_graph_revision };
+    };
+    return Object.freeze({
+        current,
+        releaseInput(id, expectedRevision) {
+            if (kind !== 'release-request' || typeof id !== 'string' || !id || !revision(expectedRevision, 1))
+                refuse('Invalid thermostat release or revision fence.');
+            check();
+            return Object.freeze({ kind: 'release-request', id, expectedRevision });
+        },
+        registeredInput(updates) {
+            if (!manual)
+                refuse('Invalid thermostat settings intent kind.');
+            const read = reader();
+            const array = (value) => {
+                if (!Array.isArray(value))
+                    refuse('Invalid thermostat settings array.');
+                return value;
+            };
+            const length = (value) => {
+                const size = read(value, 'length');
+                if (typeof size !== 'number' || !Number.isSafeInteger(size) || size < 0)
+                    refuse('Invalid thermostat settings array.');
+                return size;
+            };
+            const scalar = (value) => {
+                if (value === null ||
+                    value === undefined ||
+                    typeof value === 'string' ||
+                    typeof value === 'boolean' ||
+                    (typeof value === 'number' && Number.isFinite(value)))
+                    return value;
+                refuse('Invalid thermostat settings metadata.');
+            };
+            const primitives = (value) => {
+                const input = array(value), size = length(input), output = [];
+                for (let index = 0; index < size; index++) {
+                    if (!Object.hasOwn(input, index))
+                        refuse('Invalid thermostat settings metadata entry.');
+                    output.push(scalar(read(input, String(index))));
+                }
+                return output;
+            };
+            const id = (value) => {
+                if (typeof value !== 'string' || !value)
+                    refuse('Invalid thermostat setting identity.');
+                return value;
+            };
+            const entries = array(updates), size = length(entries);
+            if (size === 0)
+                return { input: null, destinations: [] };
+            check();
+            const commands = [];
+            const destinations = [];
+            for (let index = 0; index < size; index++) {
+                if (!Object.hasOwn(entries, index))
+                    refuse('Invalid thermostat settings entry.');
+                const entry = record(read(entries, String(index)));
+                const property = record(read(entry, 'property'));
+                const channel = record(read(entry, 'channel')), device = record(read(entry, 'device'));
+                const propertyChannel = read(property, 'channel');
+                const unitChannel = propertyChannel === null || propertyChannel === undefined || typeof propertyChannel === 'string'
+                    ? propertyChannel
+                    : {
+                        category: scalar(read(record(propertyChannel), 'category')),
+                        identifier: scalar(read(propertyChannel, 'identifier')),
+                    };
+                const permissions = read(property, 'permissions'), format = read(property, 'format');
+                const ownedProperty = {
+                    id: id(read(property, 'id')),
+                    identifier: scalar(read(property, 'identifier')),
+                    category: scalar(read(property, 'category')),
+                    dataType: scalar(read(property, 'dataType')),
+                    permissions: permissions == null ? [] : primitives(permissions),
+                    format: format == null ? null : Array.isArray(format) ? primitives(format) : scalar(format),
+                    channel: unitChannel,
+                };
+                const ownedChannel = {
+                    id: id(read(channel, 'id')),
+                    identifier: scalar(read(channel, 'identifier')),
+                    category: scalar(read(channel, 'category')),
+                };
+                const ownedDevice = { id: id(read(device, 'id')), type: scalar(read(device, 'type')) };
+                const value = read(entry, 'value');
+                if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean')
+                    refuse('Invalid thermostat setting scalar.');
+                commands.push(Object.freeze({
+                    propertyId: ownedProperty.id,
+                    channelId: ownedChannel.id,
+                    deviceId: ownedDevice.id,
+                    contract: contract(ownedProperty, ownedChannel, ownedDevice),
+                    value,
+                }));
+                destinations.push(property);
+            }
+            check();
+            const input = Object.freeze({
+                kind: 'registered-settings',
+                id: commands[0].deviceId,
+                commands: Object.freeze(commands),
+            });
+            return { input, destinations };
+        },
+        input(id, fence, preset, clearUserOff) {
+            const input = Object.freeze({
+                kind: 'selection',
+                id,
+                ...fences(id, fence, reader()),
+                preset,
+                clearUserOff,
+            });
+            check();
+            if ((preset !== null && !['comfort', 'eco', 'away'].includes(preset)) || typeof clearUserOff !== 'boolean')
+                refuse('Invalid thermostat selection or revision fences.');
+            return input;
+        },
+        definitionInput(id, fence, definition) {
+            record(definition);
+            const read = reader();
+            const capturedFence = fences(id, fence, read);
+            const number = (value) => {
+                if (typeof value !== 'number' || !Number.isFinite(value))
+                    refuse('Invalid thermostat definition number.');
+                return value;
+            };
+            const range = (value) => value === null
+                ? null
+                : {
+                    minimum: number(read(record(value), 'minimum')),
+                    maximum: number(read(value, 'maximum')),
+                };
+            const heating_range = range(read(definition, 'heating_range'));
+            const cooling_range = range(read(definition, 'cooling_range'));
+            const entries = read(definition, 'presets');
+            if (!Array.isArray(entries))
+                refuse('Invalid thermostat definition presets.');
+            const length = read(entries, 'length');
+            if (typeof length !== 'number' || !Number.isInteger(length) || length < 0 || length > 3)
+                refuse('Invalid thermostat definition presets.');
+            const presets = [];
+            for (let index = 0; index < length; index++) {
+                if (!Object.hasOwn(entries, index))
+                    refuse('Invalid thermostat definition preset entry.');
+                const entry = record(read(entries, String(index)));
+                const preset = read(entry, 'preset');
+                if (preset !== 'comfort' && preset !== 'eco' && preset !== 'away')
+                    refuse('Invalid thermostat definition preset.');
+                const setpoints = record(read(entry, 'setpoints'));
+                const heating = read(setpoints, 'heating_setpoint');
+                const cooling = read(setpoints, 'cooling_setpoint');
+                presets.push({
+                    preset,
+                    setpoints: {
+                        heating_setpoint: heating === null ? null : number(heating),
+                        cooling_setpoint: cooling === null ? null : number(cooling),
+                    },
+                });
+            }
+            const enabled = read(definition, 'automation_enabled');
+            if (enabled !== undefined && enabled !== null && typeof enabled !== 'boolean')
+                refuse('Invalid thermostat automation flag.');
+            const automation = enabled === true ? 'enable' : enabled === false ? 'disable' : 'preserve';
+            const payload = detach({
+                heating_range,
+                cooling_range,
+                presets,
+                automation,
+            });
+            check();
+            return Object.freeze({ kind: 'definition', id, ...capturedFence, definition: payload });
+        },
+        overrideInput(id, fence, input, actorId, source) {
+            const read = reader();
+            const capturedFence = fences(id, fence, read);
+            record(input);
+            const preset = read(input, 'preset');
+            const supplied = read(input, 'setpoints');
+            const expires_at = read(input, 'expires_at');
+            if ((preset !== null && preset !== 'comfort' && preset !== 'eco' && preset !== 'away') ||
+                typeof expires_at !== 'string' ||
+                typeof actorId !== 'string' ||
+                !actorId ||
+                (source !== 'user' && source !== 'panel'))
+                refuse('Override needs an identified actor and a future expiry within seven days.');
+            let setpoints = null;
+            if (supplied !== null) {
+                record(supplied);
+                const heating = read(supplied, 'heating_setpoint'), cooling = read(supplied, 'cooling_setpoint');
+                if ((heating !== null && (typeof heating !== 'number' || !Number.isFinite(heating))) ||
+                    (cooling !== null && (typeof cooling !== 'number' || !Number.isFinite(cooling))))
+                    refuse('unsupported_branch_or_setpoint_range');
+                setpoints = { heating_setpoint: heating, cooling_setpoint: cooling };
+            }
+            const payload = detach({ preset, setpoints, expires_at });
+            check();
+            return Object.freeze({ kind: 'override', id, ...capturedFence, override: payload, actorId, source });
+        },
+        cancelInput(id, fence, overrideId) {
+            const capturedFence = fences(id, fence, reader());
+            if (typeof overrideId !== 'string' || !overrideId)
+                refuse('Override identity/state changed; reload before cancelling.');
+            check();
+            return Object.freeze({ kind: 'cancel', id, ...capturedFence, overrideId });
+        },
+        operation(input, ownerCurrent, dispatchCurrent, deferReady = false) {
+            if (!['selection', 'definition', 'override', 'cancel', 'registered-settings', 'release-request'].includes(input.kind) ||
+                (input.kind === 'registered-settings' && !manual) ||
+                (input.kind === 'release-request' && kind !== 'release-request') ||
+                ((input.kind === 'override' || input.kind === 'cancel') && (input.kind !== kind || !local)))
+                refuse('Invalid thermostat comfort intent kind.');
+            const settlement = new ThermostatSelectionSettlement();
+            let ready = false;
+            let imageComplete = false;
+            let manualTakeover;
+            let changed = true;
+            let resultPolicy;
+            const completeImage = () => {
+                imageComplete = true;
+                if (!deferReady)
+                    ready = true;
+            };
+            let slot;
+            let plan;
+            let original;
+            let scopedCurrent;
+            const valid = () => current() && dispatchCurrent() && scopedCurrent?.() === true && ownerCurrent();
+            const assert = () => {
+                if (!valid())
+                    refuse();
+            };
+            const validateOwned = (row, id, owned, graphDelta = 1) => {
+                if (!owned)
+                    return;
+                const slot = owned.facts;
+                const controller = owned.controller;
+                if (!slot ||
+                    !controller ||
+                    slot.state !== 'LIVE' ||
+                    slot.manualHold ||
+                    slot.controllerId !== id ||
+                    !slot.installEvidence)
+                    refuse('Missing original installed thermostat selection.');
+                const installed = JSON.parse(slot.installEvidence);
+                if (controller.controllerRevision !== row.revision ||
+                    controller.graphRevision !== installed.graphRevision + graphDelta ||
+                    serialize({ ...controller, graphRevision: installed.graphRevision }) !== slot.installEvidence ||
+                    serialize(controller.legacyBaseline) !== serialize(row.comfort?.automation_baseline ?? null))
+                    refuse('Installed thermostat mirror no longer matches its native controller.');
+            };
+            const writeRelease = async (manager, input, owned) => {
+                const readConfig = () => manager
+                    .createQueryBuilder(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, 'config')
+                    .where('config.controllerId = :id', { id: input.id })
+                    .callListeners(false)
+                    .getOneOrFail();
+                const readClaims = () => manager
+                    .createQueryBuilder(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity, 'claim')
+                    .where('claim.controllerId = :id AND claim.state != :released', { id: input.id, released: 'released' })
+                    .orderBy('claim.id', 'ASC')
+                    .callListeners(false)
+                    .getMany();
+                const readGraph = () => manager
+                    .createQueryBuilder(virtual_producer_entity_1.VirtualGraphRevisionEntity, 'graph')
+                    .where('graph.id = 1')
+                    .callListeners(false)
+                    .getOneOrFail();
+                const milliseconds = (date) => date === null ? null : releaseScalar.values.getTime.call(date);
+                const configuration = (row) => Object.freeze({
+                    ...configImage(row, milliseconds),
+                    comfort: detach(row.comfort),
+                    policy: detach(row.policy),
+                    heuristic: detach(row.heuristic),
+                });
+                const image = (row) => Object.freeze({
+                    ...claimImage(row, milliseconds),
+                    releaseEvidence: detach(row.releaseEvidence),
+                });
+                const sameConfig = (actual, intended) => Object.keys(intended).every((key) => key === 'comfort' || key === 'policy' || key === 'heuristic'
+                    ? serialize(actual[key]) === serialize(intended[key])
+                    : Object.is(actual[key], intended[key]));
+                const sameClaim = (actual, intended) => Object.keys(intended).every((key) => key === 'releaseEvidence'
+                    ? serialize(actual[key]) === serialize(intended[key])
+                    : Object.is(actual[key], intended[key]));
+                const row = await readConfig();
+                assert();
+                if (row.revision !== input.expectedRevision || !revision(row.revision, 1, true))
+                    refuse('Thermostat revision changed or overflowed.');
+                validateOwned(row, input.id, owned);
+                const DateConstructor = releaseDateGlobal.values.Date;
+                const instant = new DateConstructor();
+                const timestamp = releaseScalar.values.getTime.call(instant);
+                const intended = Object.freeze({
+                    ...configuration(row),
+                    ...(owned && row.comfort ? { comfort: { ...configuration(row).comfort, automation_baseline: null } } : {}),
+                    requestedMode: 'off',
+                    revision: row.revision + 1,
+                    releaseRequestedAt: timestamp,
+                });
+                const graph = await readGraph(), selected = await readClaims();
+                assert();
+                if (!revision(graph.revision, 1))
+                    refuse('Invalid virtual dependency graph revision.');
+                const graphRevision = graph.revision;
+                const starting = selected.map(image);
+                const claims = Object.freeze(starting.map((claim) => {
+                    if (!revision(claim.revision, 1, true))
+                        refuse('Thermostat claim revision overflow.');
+                    return Object.freeze({
+                        ...claim,
+                        state: claim.sourcePropertyId ? 'releasing' : 'missing',
+                        revision: claim.revision + 1,
+                        releaseRequestedAt: timestamp,
+                        reason: 'explicit_release_requested',
+                    });
+                }));
+                const updated = await manager
+                    .createQueryBuilder()
+                    .update(virtual_thermostat_entity_1.VirtualThermostatConfigEntity)
+                    .set({
+                    requestedMode: 'off',
+                    releaseRequestedAt: instant,
+                    revision: intended.revision,
+                    ...(owned ? { comfort: intended.comfort } : {}),
+                })
+                    .where({
+                    controllerId: input.id,
+                    revision: row.revision,
+                    ownerDeviceId: row.ownerDeviceId === null ? (0, typeorm_1.IsNull)() : row.ownerDeviceId,
+                })
+                    .execute();
+                assert();
+                if (updated.affected !== 1)
+                    refuse('Thermostat release lost its conditional configuration update.');
+                for (const [index, claim] of starting.entries()) {
+                    const changed = await manager
+                        .createQueryBuilder()
+                        .update(virtual_thermostat_entity_1.VirtualThermostatActuatorClaimEntity)
+                        .set({
+                        state: claims[index].state,
+                        revision: claims[index].revision,
+                        releaseRequestedAt: instant,
+                        reason: 'explicit_release_requested',
+                    })
+                        .where({
+                        id: claim.id,
+                        controllerId: input.id,
+                        revision: claim.revision,
+                        state: claim.state,
+                        role: claim.role,
+                        physicalIdentity: claim.physicalIdentity,
+                        providerProfile: claim.providerProfile,
+                        providerProfileVersion: claim.providerProfileVersion,
+                        sourcePropertyId: claim.sourcePropertyId === null ? (0, typeorm_1.IsNull)() : claim.sourcePropertyId,
+                        sourcePropertyIdentity: claim.sourcePropertyIdentity,
+                        sourceDeviceId: claim.sourceDeviceId === null ? (0, typeorm_1.IsNull)() : claim.sourceDeviceId,
+                        sourceDeviceIdentity: claim.sourceDeviceIdentity,
+                        contractFingerprint: claim.contractFingerprint,
+                        qualificationGeneration: claim.qualificationGeneration === null ? (0, typeorm_1.IsNull)() : claim.qualificationGeneration,
+                    })
+                        .execute();
+                    assert();
+                    if (changed.affected !== 1)
+                        refuse('Thermostat release lost a conditional claim update.');
+                }
+                const postimage = await readConfig(), members = await readClaims(), postGraph = await readGraph();
+                assert();
+                if (!sameConfig(configuration(postimage), intended) ||
+                    members.length !== claims.length ||
+                    members.some((member, index) => !sameClaim(image(member), claims[index])) ||
+                    postGraph.revision !== graphRevision)
+                    refuse('Thermostat release persisted an unexpected complete postimage.');
+                const value = Object.freeze({
+                    input,
+                    configuration: intended,
+                    claims,
+                    claimIds: Object.freeze(claims.map((claim) => claim.id)),
+                    graph_revision: graphRevision,
+                    timestamp,
+                });
+                settlement.releaseResult = Object.freeze({ value });
+                completeImage();
+                return value;
+            };
+            const writeRegistered = async (manager, input, owned, semantic) => {
+                const readGraph = () => manager
+                    .createQueryBuilder(virtual_producer_entity_1.VirtualGraphRevisionEntity, 'graph')
+                    .where('graph.id = 1')
+                    .callListeners(false)
+                    .getOneOrFail();
+                const readConfig = () => manager
+                    .createQueryBuilder(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, 'config')
+                    .where('config.controllerId = :id', { id: input.id })
+                    .callListeners(false)
+                    .getOneOrFail();
+                const readOwner = () => manager
+                    .createQueryBuilder(devices_virtual_entity_1.VirtualDeviceEntity, 'owner')
+                    .select(['owner.id', 'owner.enabled', 'owner.type'])
+                    .where('owner.id = :id', { id: input.id })
+                    .callListeners(false)
+                    .getOne();
+                const graph = await readGraph();
+                assert();
+                if (!revision(graph.revision, semantic ? 0 : 1))
+                    refuse('Invalid virtual dependency graph revision.');
+                let graphRevision = graph.revision;
+                const rows = [];
+                for (const command of input.commands) {
+                    const setting = await manager
+                        .createQueryBuilder(virtual_thermostat_entity_1.VirtualThermostatSettingEntity, 'setting')
+                        .where('setting.propertyId = :id', { id: command.propertyId })
+                        .callListeners(false)
+                        .getOne();
+                    const property = await manager
+                        .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'property')
+                        .leftJoinAndSelect('property.channel', 'channel')
+                        .leftJoinAndSelect('channel.device', 'device')
+                        .where('property.id = :id', { id: command.propertyId })
+                        .callListeners(false)
+                        .getOne();
+                    assert();
+                    const channel = property?.channel;
+                    const device = channel?.device;
+                    if (!setting ||
+                        !property ||
+                        !channel ||
+                        !device ||
+                        setting.controllerId !== input.id ||
+                        !['heating_setpoint', 'cooling_setpoint', 'heating_enabled', 'cooling_enabled', 'locked'].includes(setting.setting) ||
+                        !(property instanceof devices_virtual_entity_1.VirtualChannelPropertyEntity) ||
+                        property.valueOrigin !== devices_virtual_entity_1.VirtualValueOrigin.LOCAL ||
+                        property.sourcePropertyId ||
+                        property.id !== command.propertyId ||
+                        channel.id !== command.channelId ||
+                        device.id !== command.deviceId ||
+                        device.id !== input.id ||
+                        setting.contractFingerprint !== command.contract ||
+                        setting.contractFingerprint !== contract(property, channel, device))
+                        refuse('Only registered unchanged local thermostat settings accept commands.');
+                    rows.push(setting.setting);
+                }
+                const row = await readConfig(), owner = await readOwner();
+                assert();
+                if (!owner?.enabled ||
+                    owner.id !== input.id ||
+                    row.ownerDeviceId !== owner.id ||
+                    (row.locked && rows.some((role) => role !== 'locked')))
+                    refuse('Thermostat is disabled or locked.');
+                if (!revision(row.revision, 1))
+                    refuse('Invalid thermostat revision.');
+                validateOwned(row, input.id, owned, semantic ? 0 : 1);
+                const starting = detach(configImage(row));
+                const intended = JSON.parse(serialize(starting));
+                let heat = ['heat', 'auto'].includes(starting.requestedMode), cool = ['cool', 'auto'].includes(starting.requestedMode);
+                for (const [index, role] of rows.entries()) {
+                    const value = input.commands[index].value;
+                    if (role === 'heating_setpoint' || role === 'cooling_setpoint') {
+                        if (typeof value !== 'number' || !Number.isFinite(value))
+                            refuse('Setpoint must be finite.');
+                        if (role === 'heating_setpoint')
+                            intended.policy.heatingSetpoint = value;
+                        else
+                            intended.policy.coolingSetpoint = value;
+                    }
+                    else {
+                        if (typeof value !== 'boolean')
+                            refuse('Thermostat enable and lock settings must be boolean.');
+                        if (role === 'heating_enabled')
+                            heat = value;
+                        else if (role === 'cooling_enabled')
+                            cool = value;
+                        else
+                            intended.locked = value;
+                    }
+                }
+                if (intended.comfort) {
+                    if (owned)
+                        intended.comfort.automation_baseline = null;
+                    if (rows.some((role) => role.endsWith('setpoint')))
+                        intended.comfort.selected_preset = null;
+                    if (rows.some((role) => role.endsWith('enabled')))
+                        intended.comfort.user_off = !heat && !cool;
+                    const errors = validate(intended.comfort, intended.policy);
+                    if (errors.length)
+                        refuse(errors.join(', '));
+                }
+                intended.requestedMode = heat ? (cool ? 'auto' : 'heat') : cool ? 'cool' : 'off';
+                const errors = validatePolicy(intended.policy), mode = intended.requestedMode;
+                if (errors.length ||
+                    !['off', 'heat', 'cool', 'auto'].includes(mode) ||
+                    ((mode === 'heat' || mode === 'auto') && intended.policy.heatingSetpoint === null) ||
+                    ((mode === 'cool' || mode === 'auto') && intended.policy.coolingSetpoint === null))
+                    refuse(`Invalid thermostat mode/policy: ${errors.join(', ')}.`);
+                manualTakeover = rows.some((role) => role !== 'locked');
+                changed = !(semantic &&
+                    serialize(intended) === serialize(starting) &&
+                    semantic.canRemainUnchanged(manualTakeover));
+                if (changed) {
+                    if (!revision(row.revision, 1, true))
+                        refuse('Thermostat is missing, detached, locked or its revision changed/overflowed.');
+                    if (semantic)
+                        graphRevision = await semantic.advanceGraph();
+                    intended.revision = starting.revision + 1;
+                }
+                const intendedJson = serialize(intended);
+                if (changed) {
+                    const updated = await manager
+                        .createQueryBuilder()
+                        .update(virtual_thermostat_entity_1.VirtualThermostatConfigEntity)
+                        .set({
+                        policy: intended.policy,
+                        comfort: intended.comfort,
+                        requestedMode: intended.requestedMode,
+                        locked: intended.locked,
+                        revision: intended.revision,
+                    })
+                        .where({
+                        controllerId: input.id,
+                        ownerDeviceId: owner.id,
+                        revision: starting.revision,
+                        locked: starting.locked,
+                    })
+                        .execute();
+                    assert();
+                    if (updated.affected !== 1)
+                        refuse('Thermostat settings lost their conditional update.');
+                }
+                else
+                    await semantic.verifyUnchanged();
+                const postimage = await readConfig(), postOwner = await readOwner(), postGraph = await readGraph();
+                assert();
+                if (serialize(configImage(postimage)) !== intendedJson ||
+                    !postOwner?.enabled ||
+                    postOwner.id !== owner.id ||
+                    postOwner.type !== owner.type ||
+                    postimage.ownerDeviceId !== postOwner.id ||
+                    postGraph.revision !== graphRevision)
+                    refuse('Thermostat settings persisted an unexpected postimage.');
+                manualTakeover = rows.some((role) => role !== 'locked');
+                const value = detach({
+                    configuration: intended,
+                    owner: { id: owner.id, enabled: owner.enabled, type: owner.type },
+                    graph_revision: graphRevision,
+                    commands: input.commands,
+                });
+                settlement.manualResult = Object.freeze({ value });
+                completeImage();
+                return value;
+            };
+            return Object.freeze({
+                settlement,
+                changed() {
+                    if (!imageComplete)
+                        refuse();
+                    return changed;
+                },
+                takesManualHold() {
+                    assert();
+                    if (input.kind !== 'registered-settings' || !imageComplete || manualTakeover === undefined)
+                        refuse();
+                    return manualTakeover;
+                },
+                qualifyAutomation(intent) {
+                    assert();
+                    if (!deferReady ||
+                        ready ||
+                        !imageComplete ||
+                        !resultPolicy ||
+                        !settlement.result ||
+                        settlement.receipt?.outcome !== 'pending' ||
+                        !intent?.isCurrent())
+                        refuse();
+                    const value = settlement.result.value;
+                    settlement.result = Object.freeze({
+                        value: detach({
+                            ...value,
+                            effective: effective(resultPolicy, value.configuration, intent),
+                        }),
+                    });
+                },
+                markReady() {
+                    assert();
+                    if (!deferReady || !imageComplete || settlement.receipt?.outcome !== 'pending')
+                        refuse();
+                    ready = true;
+                },
+                captureSlot() {
+                    if (input.kind !== 'override' && input.kind !== 'cancel')
+                        return;
+                    const reference = local.values.get.call(local.receiver, input.id);
+                    slot = Object.freeze({ reference, id: reference?.id, revision: reference?.revision });
+                },
+                localAction() {
+                    if (input.kind !== 'override' && input.kind !== 'cancel')
+                        return;
+                    try {
+                        settlement.localAction = Object.freeze({ stage: 'checking' });
+                        if (!slot || settlement.outcome !== 'committed' || !settlement.result)
+                            refuse();
+                        const current = local.values.get.call(local.receiver, input.id);
+                        if (current !== slot.reference || current?.id !== slot.id || current?.revision !== slot.revision) {
+                            settlement.localAction = Object.freeze({ stage: 'superseded' });
+                        }
+                        else if (input.kind === 'override') {
+                            if (!plan)
+                                refuse();
+                            settlement.localAction = Object.freeze({ stage: 'installing' });
+                            local.values.set.call(local.receiver, plan.controller, {
+                                id: plan.id,
+                                revision: plan.revision,
+                                deadline: plan.deadline,
+                                watermark: plan.watermark,
+                                status: null,
+                            });
+                            settlement.localAction = Object.freeze({ stage: 'installed' });
+                        }
+                        else if (current && slot.id === input.overrideId) {
+                            settlement.localAction = Object.freeze({ stage: 'deleting' });
+                            local.values.delete.call(local.receiver, input.id);
+                            settlement.localAction = Object.freeze({ stage: 'deleted' });
+                        }
+                        else
+                            settlement.localAction = Object.freeze({ stage: 'no-target' });
+                    }
+                    catch (cause) {
+                        settlement.localFailure = Object.freeze({ cause });
+                        throw cause;
+                    }
+                },
+                admit(manager) {
+                    const receipt = observe(manager);
+                    if (original)
+                        refuse();
+                    settlement.receipt = receipt;
+                    original = manager;
+                    const selected = (0, creation_capture_1.captureCreation)(manager, ['connection', 'queryRunner', 'createQueryBuilder', 'query']);
+                    const runner = manager.queryRunner;
+                    if (!runner)
+                        refuse();
+                    const runnerPin = (0, creation_capture_1.captureCreation)(runner, [
+                        'manager',
+                        'connection',
+                        'driver',
+                        'query',
+                        'connect',
+                        'commitTransaction',
+                        'release',
+                    ]);
+                    scopedCurrent = () => selected.current() &&
+                        runnerPin.current() &&
+                        selected.values.connection === database &&
+                        selected.values.queryRunner === runner &&
+                        runnerPin.values.driver === driver.receiver &&
+                        runner.manager === manager &&
+                        runner.connection === database &&
+                        runner.isTransactionActive &&
+                        Reflect.get(runner, 'transactionDepth') === 1 &&
+                        driver.receiver.databaseConnection === physical;
+                    guard(manager, () => ready &&
+                        (input.kind === 'registered-settings'
+                            ? !!settlement.manualResult
+                            : input.kind === 'release-request'
+                                ? !!settlement.releaseResult
+                                : !!settlement.result && (input.kind !== 'override' || !!plan)) &&
+                        valid());
+                    assert();
+                },
+                async write(manager, owned, semantic) {
+                    assert();
+                    if (manager !== original)
+                        refuse();
+                    if (input.kind === 'registered-settings')
+                        return writeRegistered(manager, input, owned, semantic);
+                    if (input.kind === 'release-request')
+                        return writeRelease(manager, input, owned);
+                    const row = await manager
+                        .createQueryBuilder(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, 'config')
+                        .where('config.controllerId = :id', { id: input.id })
+                        .callListeners(false)
+                        .getOne();
+                    assert();
+                    if (!row)
+                        throw new common_1.NotFoundException('Thermostat configuration does not exist.');
+                    const owner = await manager
+                        .createQueryBuilder(devices_virtual_entity_1.VirtualDeviceEntity, 'owner')
+                        .select(['owner.id'])
+                        .where('owner.id = :id', { id: input.id })
+                        .callListeners(false)
+                        .getOne();
+                    assert();
+                    if (!owner ||
+                        owner.id !== input.id ||
+                        row.ownerDeviceId !== owner.id ||
+                        row.locked ||
+                        row.revision !== input.expected_revision ||
+                        !revision(row.revision, 1, !semantic))
+                        refuse('Thermostat is missing, detached, locked or its revision changed/overflowed.');
+                    validateOwned(row, input.id, owned, semantic ? 0 : 1);
+                    let intended;
+                    let birth;
+                    if (input.kind === 'selection') {
+                        if (!row.comfort)
+                            refuse('Configure explicit comfort ranges and presets first.');
+                        intended = JSON.parse(serialize(row.comfort));
+                        intended.selected_preset = input.preset;
+                        if (owned)
+                            intended.automation_baseline = null;
+                        if (input.clearUserOff)
+                            intended.user_off = false;
+                    }
+                    else if (input.kind === 'definition') {
+                        const definition = input.definition;
+                        const old = row.comfort;
+                        intended = {
+                            heating_range: definition.heating_range,
+                            cooling_range: definition.cooling_range,
+                            presets: definition.presets,
+                            selected_preset: old?.selected_preset ?? null,
+                            user_off: old?.user_off ?? row.requestedMode === 'off',
+                            automation_enabled: definition.automation === 'preserve'
+                                ? (old?.automation_enabled ?? false)
+                                : definition.automation === 'enable',
+                            automation_baseline: definition.automation === 'disable' ? null : (old?.automation_baseline ?? null),
+                            temporary_override: old?.temporary_override ?? null,
+                        };
+                        if (owned && intended.automation_baseline) {
+                            const baseline = intended.automation_baseline;
+                            const target = baseline.preset
+                                ? intended.presets.find((entry) => entry.preset === baseline.preset)?.setpoints
+                                : baseline.setpoints;
+                            if (!target || validateSetpoints(target, intended, row.policy).length)
+                                intended.automation_baseline = null;
+                        }
+                    }
+                    else {
+                        if (!row.comfort)
+                            refuse(input.kind === 'override'
+                                ? 'Configure explicit comfort ranges and presets first.'
+                                : 'Override identity/state changed; reload before cancelling.');
+                        intended = JSON.parse(serialize(row.comfort));
+                        const DateConstructor = dateGlobal.values.Date;
+                        const utc = (value) => iso.values.toISOString.call(value);
+                        if (input.kind === 'override') {
+                            const now = date.values.now.call(date.receiver);
+                            const duration = date.values.parse.call(date.receiver, input.override.expires_at) - now;
+                            if (!/T.*(?:Z|[+-]\d{2}:\d{2})$/i.test(input.override.expires_at) ||
+                                !Number.isFinite(duration) ||
+                                duration <= 0 ||
+                                duration > 7 * 86400000)
+                                refuse('Override needs an identified actor and a future expiry within seven days.');
+                            const resolved = input.override.preset
+                                ? intended.presets.find((entry) => entry.preset === input.override.preset)?.setpoints
+                                : input.override.setpoints;
+                            if (!resolved)
+                                refuse('Override preset or setpoints are missing.');
+                            const identity = uuid.values.randomUUID.call(uuid.receiver);
+                            const initial = monotonic.values.now.call(monotonic.receiver);
+                            const deadline = initial + duration;
+                            if (!Number.isFinite(initial) || !Number.isFinite(deadline))
+                                refuse('Override initial clock is not finite.');
+                            birth = Object.freeze({
+                                controller: input.id,
+                                id: identity,
+                                revision: row.revision + 1,
+                                deadline,
+                                watermark: now,
+                            });
+                            intended.temporary_override = {
+                                preset: input.override.preset,
+                                setpoints: input.override.setpoints,
+                                id: identity,
+                                source: input.source,
+                                actor_id: input.actorId,
+                                revision: row.revision + 1,
+                                original_duration_ms: duration,
+                                wall_watermark_ms: now,
+                                created_at: utc(new DateConstructor(now)),
+                                expires_at: utc(new DateConstructor(now + duration)),
+                                resolved_setpoints: { ...resolved },
+                                status: 'active',
+                                terminated_at: null,
+                            };
+                        }
+                        else {
+                            const override = intended.temporary_override;
+                            if (override?.id !== input.overrideId || !['active', 'clock_uncertain'].includes(override.status))
+                                refuse('Override identity/state changed; reload before cancelling.');
+                            override.status = 'cancelled';
+                            override.terminated_at = utc(new DateConstructor());
+                        }
+                    }
+                    const errors = validate(intended, row.policy);
+                    if (errors.length)
+                        refuse(errors.join(', '));
+                    const intendedJson = serialize(intended);
+                    changed = !(semantic &&
+                        (input.kind === 'selection' || input.kind === 'definition') &&
+                        serialize(row.comfort) === intendedJson &&
+                        semantic.canRemainUnchanged(true));
+                    if (changed) {
+                        if (!revision(row.revision, 1, true))
+                            refuse('Thermostat is missing, detached, locked or its revision changed/overflowed.');
+                        if (semantic)
+                            await semantic.advanceGraph();
+                        if (semantic) {
+                            if (!semantic.writeAppliedConfiguration)
+                                refuse('Original complete comfort image writer required.');
+                            await semantic.writeAppliedConfiguration(row, intended);
+                            assert();
+                        }
+                        else {
+                            const updated = await manager
+                                .createQueryBuilder()
+                                .update(virtual_thermostat_entity_1.VirtualThermostatConfigEntity)
+                                .set({ comfort: intended, revision: row.revision + 1 })
+                                .where({ controllerId: input.id, ownerDeviceId: owner.id, revision: row.revision, locked: false })
+                                .execute();
+                            assert();
+                            if (updated.affected !== 1)
+                                refuse('Thermostat selection lost its conditional update.');
+                        }
+                    }
+                    else
+                        await semantic.verifyUnchanged();
+                    const postimage = await manager
+                        .createQueryBuilder(virtual_thermostat_entity_1.VirtualThermostatConfigEntity, 'config')
+                        .where('config.controllerId = :id', { id: input.id })
+                        .callListeners(false)
+                        .getOneOrFail();
+                    const graph = await manager
+                        .createQueryBuilder(virtual_producer_entity_1.VirtualGraphRevisionEntity, 'graph')
+                        .where('graph.id = 1')
+                        .callListeners(false)
+                        .getOneOrFail();
+                    assert();
+                    if (postimage.controllerId !== input.id ||
+                        postimage.ownerDeviceId !== owner.id ||
+                        postimage.revision !== row.revision + (changed ? 1 : 0) ||
+                        serialize(postimage.comfort) !== intendedJson ||
+                        !revision(graph.revision, changed ? 1 : 0) ||
+                        graph.revision !== input.expected_graph_revision + (changed ? 1 : 0))
+                        refuse('Thermostat selection persisted an unexpected postimage.');
+                    resultPolicy = detach(postimage.policy);
+                    const value = detach({
+                        controller: postimage.controllerId,
+                        revision: postimage.revision,
+                        graph_revision: graph.revision,
+                        configuration: postimage.comfort,
+                        effective: effective(postimage.policy, postimage.comfort),
+                        clock_policy: 'bounded_absolute_recovery_with_uncertainty_inhibit',
+                    });
+                    plan = birth;
+                    settlement.result = Object.freeze({ value });
+                    completeImage();
+                    return value;
+                },
+                accepted() {
+                    if (settlement.outcome !== 'committed' ||
+                        (input.kind === 'registered-settings'
+                            ? !settlement.manualResult
+                            : input.kind === 'release-request'
+                                ? !settlement.releaseResult
+                                : !settlement.result))
+                        throw new Error('Missing original native thermostat selection ACK/result');
+                },
+                copy() {
+                    if (settlement.outcome !== 'committed' || !settlement.result)
+                        refuse();
+                    return JSON.parse(serialize(settlement.result.value));
+                },
+            });
+        },
+    });
+}
+exports.thermostatComfortSelection = Object.freeze({ pin });
+//# sourceMappingURL=thermostat-comfort-selection.js.map