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

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

@@ -0,0 +1,680 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThermostatRuntimeJournal = exports.ThermostatRuntimeOwnership = void 0;
+exports.readThermostatRecreationHistory = readThermostatRecreationHistory;
+exports.assertThermostatRecreationHistory = assertThermostatRecreationHistory;
+exports.resetThermostatRecreationRuntime = resetThermostatRecreationRuntime;
+const node_async_hooks_1 = require("node:async_hooks");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
+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 virtual_thermostat_runtime_entity_1 = require("../entities/virtual-thermostat-runtime.entity");
+class ThermostatRuntimeOwnership {
+    constructor() {
+        this.identities = new WeakMap();
+        this.pending = new Map();
+        this.current = new node_async_hooks_1.AsyncLocalStorage();
+    }
+    admit(controllerId) {
+        let resolve;
+        let reject;
+        const completion = new Promise((yes, no) => {
+            resolve = yes;
+            reject = no;
+        });
+        void completion.catch(() => undefined);
+        const decision = {
+            controllerId,
+            completion,
+            resolve,
+            reject,
+            commands: new Map(),
+            started: false,
+            accepting: false,
+        };
+        const identity = Object.freeze({});
+        this.identities.set(identity, decision);
+        const pending = this.pending.get(controllerId) ?? new Set();
+        pending.add(decision);
+        this.pending.set(controllerId, pending);
+        return identity;
+    }
+    completion(identity) {
+        const decision = this.identities.get(identity);
+        if (!decision || decision.started)
+            throw new Error('Original unstarted thermostat decision required');
+        return decision.completion;
+    }
+    async run(identity, evaluate) {
+        const decision = this.identities.get(identity);
+        if (!decision || decision.started)
+            throw new Error('Original thermostat decision required');
+        decision.started = true;
+        decision.accepting = true;
+        let failure;
+        try {
+            await this.current.run(decision, evaluate);
+        }
+        catch (cause) {
+            failure = { cause };
+            throw cause;
+        }
+        finally {
+            decision.accepting = false;
+            this.identities.delete(identity);
+            void Promise.allSettled([...decision.commands.values()].map((command) => command.completion)).then((results) => {
+                const rejected = results.find((result) => result.status === 'rejected');
+                if (failure)
+                    decision.reject(failure.cause);
+                else if (rejected)
+                    decision.reject(rejected.reason);
+                else if ([...decision.commands.values()].some((command) => !command.matchesIdentity()))
+                    decision.reject(new Error('Original thermostat command identity changed'));
+                else
+                    decision.resolve();
+                const pending = this.pending.get(decision.controllerId);
+                pending?.delete(decision);
+                if (!pending?.size)
+                    this.pending.delete(decision.controllerId);
+            });
+        }
+    }
+    enroll(command, completion) {
+        const decision = this.current.getStore();
+        if (!decision?.accepting || decision.controllerId !== command.controllerId || decision.commands.has(command.id))
+            throw new Error('Original accepting thermostat decision required');
+        const tuple = () => JSON.stringify([
+            command.id,
+            command.controllerId,
+            command.claimId,
+            command.claimRevision,
+            command.configurationRevision,
+            command.decisionRevision,
+            command.action,
+        ]);
+        const identity = tuple();
+        decision.commands.set(command.id, {
+            matchesIdentity: () => tuple() === identity,
+            completion,
+        });
+    }
+    capture(controllerId) {
+        const originals = [...(this.pending.get(controllerId) ?? [])].map((decision) => decision.completion);
+        let failure;
+        return Promise.all(originals.map((original) => original.catch((cause) => {
+            failure ??= { cause };
+        }))).then(() => {
+            if (failure)
+                throw failure.cause;
+        });
+    }
+}
+exports.ThermostatRuntimeOwnership = ThermostatRuntimeOwnership;
+const commandColumns = [
+    'id',
+    'controllerId',
+    'claimId',
+    'claimRevision',
+    'configurationRevision',
+    'decisionRevision',
+    'action',
+    'status',
+    'preparedAt',
+    'dispatchedAt',
+    'settledAt',
+    'proofId',
+    'fault',
+];
+const branchColumns = [
+    'claimId',
+    'activity',
+    'lastVerifiedOffAt',
+    'releaseProofId',
+    'releaseAttempts',
+    'nextReleaseAt',
+    'fault',
+    'floorLatched',
+];
+const stateColumns = [
+    'controllerId',
+    'decisionRevision',
+    'configurationRevision',
+    'floorLatched',
+    'heuristicHold',
+    'previousDemand',
+    'reasons',
+    'evaluatedAt',
+];
+const commandIdentity = [...commandColumns.slice(0, 7), 'preparedAt'];
+class ThermostatRuntimeJournal {
+    constructor(database, structure) {
+        this.database = database;
+        this.structure = structure;
+        this.originals = new WeakMap();
+        this.pendingImages = new WeakMap();
+        this.runtimeRows = new WeakMap();
+        this.scopes = new WeakMap();
+    }
+    refuse() {
+        throw new Error('Original thermostat command journal image required');
+    }
+    image(command) {
+        const metadata = this.database.getMetadata(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity);
+        return Object.freeze(Object.fromEntries(commandColumns.map((key) => {
+            if (command[key] === undefined)
+                this.refuse();
+            return [
+                key,
+                this.database.driver.preparePersistentValue((0, creation_capture_1.snapshotCreation)(command[key]), metadata.findColumnWithPropertyName(key)),
+            ];
+        })));
+    }
+    async read(manager, id) {
+        return manager
+            .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, 'command')
+            .select(commandColumns.map((key) => `command.${key} AS "${key}"`))
+            .where('command.id = :id', { id })
+            .callListeners(false)
+            .getRawOne();
+    }
+    equal(left, right) {
+        return !!left && commandColumns.every((key) => Object.is(left[key], right[key]));
+    }
+    rowShape(row) {
+        return row instanceof virtual_thermostat_runtime_entity_1.VirtualThermostatRuntimeEntity
+            ? { entity: virtual_thermostat_runtime_entity_1.VirtualThermostatRuntimeEntity, columns: stateColumns, key: 'controllerId', id: row.controllerId }
+            : { entity: virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity, columns: branchColumns, key: 'claimId', id: row.claimId };
+    }
+    async readRuntimeRow(manager, row) {
+        const shape = this.rowShape(row);
+        return ((await manager
+            .createQueryBuilder(shape.entity, 'owned')
+            .select(shape.columns.map((key) => `owned.${key} AS "${key}"`))
+            .where(`owned.${shape.key} = :id`, { id: shape.id })
+            .callListeners(false)
+            .getRawOne()) ?? null);
+    }
+    runtimeImage(row) {
+        const shape = this.rowShape(row), metadata = this.database.getMetadata(shape.entity);
+        return Object.freeze(Object.fromEntries(shape.columns.map((key) => {
+            const value = Reflect.get(row, key);
+            if (value === undefined)
+                this.refuse();
+            return [
+                key,
+                this.database.driver.preparePersistentValue((0, creation_capture_1.snapshotCreation)(value), metadata.findColumnWithPropertyName(key)),
+            ];
+        })));
+    }
+    async captureRuntimeRow(manager, row) {
+        const before = await this.readRuntimeRow(manager, row);
+        const image = this.runtimeImage(row);
+        if (before) {
+            const metadata = this.database.getMetadata(this.rowShape(row).entity);
+            for (const key of this.rowShape(row).columns) {
+                const column = metadata.findColumnWithPropertyName(key);
+                const hydrated = this.database.driver.prepareHydratedValue(before[key], column);
+                const normalized = this.database.driver.preparePersistentValue(hydrated, column);
+                if (JSON.stringify(normalized) !== JSON.stringify(image[key]))
+                    this.refuse();
+            }
+        }
+        this.runtimeRows.set(row, before && Object.freeze({ ...before }));
+    }
+    async writeRuntimeRows(manager, rows) {
+        const scope = this.scopes.get(manager);
+        if (!scope?.current())
+            this.refuse();
+        const plans = rows.map((row) => {
+            if (!this.runtimeRows.has(row))
+                this.refuse();
+            const before = this.runtimeRows.get(row), value = (0, creation_capture_1.snapshotCreation)(row), shape = this.rowShape(row);
+            const after = { ...this.runtimeImage(value) };
+            if (before) {
+                const metadata = this.database.getMetadata(shape.entity);
+                for (const key of shape.columns) {
+                    const column = metadata.findColumnWithPropertyName(key);
+                    const hydrated = this.database.driver.prepareHydratedValue(before[key], column);
+                    const normalized = this.database.driver.preparePersistentValue(hydrated, column);
+                    if (JSON.stringify(normalized) === JSON.stringify(after[key]))
+                        after[key] = before[key];
+                }
+            }
+            return { row, value, shape, before, after: Object.freeze(after) };
+        });
+        if (new Set(plans.map(({ shape }) => `${shape.key}:${shape.id}`)).size !== plans.length)
+            this.refuse();
+        for (const { row, value, shape, before, after } of plans) {
+            const actual = await this.readRuntimeRow(manager, row);
+            if (before ? !actual || shape.columns.some((key) => !Object.is(before[key], actual[key])) : actual)
+                this.refuse();
+            if (!before) {
+                await manager.insert(shape.entity, value);
+            }
+            else {
+                const changed = shape.columns.filter((key) => !Object.is(before[key], after[key]));
+                if (changed.length) {
+                    const query = manager
+                        .createQueryBuilder()
+                        .update(shape.entity)
+                        .set(Object.fromEntries(changed.map((key) => [key, Reflect.get(value, key)])));
+                    for (const key of shape.columns)
+                        query.andWhere(`"${key}" IS :old_${key}`, { [`old_${key}`]: before[key] });
+                    if ((await query.execute()).affected !== 1)
+                        this.refuse();
+                }
+            }
+        }
+        scope.verify.push(async () => {
+            for (const { row, shape, after } of plans) {
+                const actual = await this.readRuntimeRow(manager, row);
+                if (!actual || shape.columns.some((key) => !Object.is(after[key], actual[key])))
+                    this.refuse();
+            }
+        });
+        if (!scope.current())
+            this.refuse();
+        scope.accept.push(() => {
+            for (const { row, after } of plans)
+                this.runtimeRows.set(row, after);
+        });
+    }
+    async readPending(manager, controllerId, claimId) {
+        return manager
+            .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, 'command')
+            .select(commandColumns.map((key) => `command.${key} AS "${key}"`))
+            .where('command.controllerId = :controllerId AND command.claimId = :claimId', { controllerId, claimId })
+            .andWhere("command.status NOT IN ('confirmed', 'cancelled')")
+            .orderBy('command.id')
+            .callListeners(false)
+            .getRawMany();
+    }
+    async capturePending(manager, commands, controllerId, claimId) {
+        const rows = await this.readPending(manager, controllerId, claimId);
+        if (rows.length !== commands.length)
+            this.refuse();
+        const metadata = this.database.getMetadata(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity);
+        for (const row of rows) {
+            const command = commands.find((candidate) => candidate.id === row.id);
+            if (!command)
+                this.refuse();
+            const image = this.image(command);
+            for (const key of commandColumns) {
+                const column = metadata.findColumnWithPropertyName(key);
+                const hydrated = this.database.driver.prepareHydratedValue(row[key], column);
+                const normalized = this.database.driver.preparePersistentValue(hydrated, column);
+                if (!Object.is(normalized, image[key]))
+                    this.refuse();
+            }
+        }
+        this.pendingImages.set(commands, Object.freeze(rows.map((row) => Object.freeze({ ...row }))));
+    }
+    addNativeCheck(manager, verify, guard) {
+        const scope = this.scopes.get(manager);
+        if (!scope?.current())
+            this.refuse();
+        scope.verify.push(verify);
+        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, guard);
+    }
+    async confirmPending(manager, commands, controllerId, claimId, proofId, settledAt) {
+        const scope = this.scopes.get(manager), before = this.pendingImages.get(commands);
+        if (!scope?.current() || !before)
+            this.refuse();
+        const current = await this.readPending(manager, controllerId, claimId);
+        if (current.length !== before.length || current.some((row, index) => !this.equal(row, before[index])))
+            return false;
+        const storedAt = this.database.driver.preparePersistentValue(settledAt, this.database.getMetadata(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity).findColumnWithPropertyName('settledAt'));
+        for (let offset = 0; offset < before.length; offset += 32) {
+            const batch = before.slice(offset, offset + 32);
+            const query = manager
+                .createQueryBuilder()
+                .update(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity)
+                .set({ status: 'confirmed', proofId, settledAt });
+            for (const [index, row] of batch.entries()) {
+                const parameters = {};
+                query.orWhere(`(${commandColumns
+                    .map((key) => {
+                    parameters[`${index}_${key}`] = row[key];
+                    return `"${key}" IS :${index}_${key}`;
+                })
+                    .join(' AND ')})`, parameters);
+            }
+            if ((await query.execute()).affected !== batch.length)
+                this.refuse();
+        }
+        scope.verify.push(async () => {
+            if ((await this.readPending(manager, controllerId, claimId)).length)
+                this.refuse();
+            for (const row of before)
+                if (!this.equal(await this.read(manager, row.id), {
+                    ...row,
+                    status: 'confirmed',
+                    proofId,
+                    settledAt: storedAt,
+                }))
+                    this.refuse();
+        });
+        return true;
+    }
+    async persistRuntimeRows(rows) {
+        await this.runNative((manager) => this.writeRuntimeRows(manager, rows));
+    }
+    async runNative(work) {
+        const database = (0, creation_capture_1.captureCreation)(this.database, ['transaction', 'driver', 'manager']);
+        const driver = (0, creation_capture_1.captureCreation)(this.database.driver, ['connection', 'databaseConnection', 'createQueryRunner']);
+        const physical = driver.values.databaseConnection;
+        if (!physical || driver.values.connection !== this.database)
+            this.refuse();
+        const native = (0, creation_capture_1.captureCreation)(physical, ['all']);
+        return this.structure.runExclusive(async () => {
+            const owner = this.structure.captureExclusiveOwner();
+            let receipt;
+            const accepted = [];
+            const transaction = database.values.transaction;
+            const result = await transaction.call(this.database, async (manager) => {
+                receipt = (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager);
+                const selected = (0, creation_capture_1.captureCreation)(manager, [
+                    'connection',
+                    'queryRunner',
+                    'query',
+                    'createQueryBuilder',
+                    'insert',
+                ]);
+                const runner = manager.queryRunner;
+                if (!runner)
+                    this.refuse();
+                const runnerPin = (0, creation_capture_1.captureCreation)(runner, [
+                    'manager',
+                    'connection',
+                    'driver',
+                    'query',
+                    'connect',
+                    'commitTransaction',
+                    'release',
+                ]);
+                let ready = false;
+                const current = () => database.current() &&
+                    driver.current() &&
+                    native.current() &&
+                    selected.current() &&
+                    runnerPin.current() &&
+                    owner() &&
+                    manager.connection === this.database &&
+                    runner.manager === manager &&
+                    runner.connection === this.database &&
+                    runnerPin.values.driver === database.values.driver &&
+                    runner.isTransactionActive &&
+                    Reflect.get(runner, 'transactionDepth') === 1 &&
+                    Reflect.get(database.values.driver, 'databaseConnection') === physical;
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => ready && current());
+                if (!current())
+                    this.refuse();
+                await manager.query('UPDATE "devices_virtual_thermostat_command_journal" SET "status"="status" WHERE 0');
+                if (!current())
+                    this.refuse();
+                const scope = { current, verify: [], accept: accepted };
+                this.scopes.set(manager, scope);
+                try {
+                    const value = await work(manager, current);
+                    for (const verify of scope.verify)
+                        await verify();
+                    if (!current())
+                        this.refuse();
+                    ready = true;
+                    return value;
+                }
+                finally {
+                    this.scopes.delete(manager);
+                }
+            });
+            if (receipt?.outcome !== 'committed')
+                this.refuse();
+            for (const accept of accepted)
+                accept();
+            return result;
+        });
+    }
+    async restart(inFlight = []) {
+        for (const command of inFlight)
+            if (!this.originals.has(command))
+                this.refuse();
+        await this.runNative(async (manager, current) => {
+            const pending = await manager
+                .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, 'command')
+                .select(commandColumns.map((key) => `command.${key} AS "${key}"`))
+                .where("command.status IN ('prepared','dispatching')")
+                .orderBy('command.id')
+                .callListeners(false)
+                .getRawMany();
+            const branches = await manager
+                .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity, 'branch')
+                .select(branchColumns.map((key) => `branch.${key} AS "${key}"`))
+                .orderBy('branch.claimId')
+                .callListeners(false)
+                .getRawMany();
+            const retained = new Map();
+            for (const command of inFlight) {
+                const original = this.originals.get(command), value = this.image(command);
+                if (!original || commandIdentity.some((key) => !Object.is(original[key], value[key])))
+                    this.refuse();
+                const row = pending.find((candidate) => candidate.id === original.id);
+                if (!row)
+                    continue;
+                if (!this.equal(row, original))
+                    this.refuse();
+                retained.set(row.id, row);
+            }
+            const suspended = pending.filter((row) => !retained.has(row.id));
+            for (let offset = 0; offset < suspended.length; offset += 32) {
+                const batch = suspended.slice(offset, offset + 32);
+                const query = manager
+                    .createQueryBuilder()
+                    .update(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity)
+                    .set({ status: 'unknown', fault: 'restart_requires_release_reconciliation' });
+                for (const [index, row] of batch.entries()) {
+                    const parameters = {};
+                    const predicate = commandColumns
+                        .map((key) => {
+                        parameters[`${index}_${key}`] = row[key];
+                        return `"${key}" IS :${index}_${key}`;
+                    })
+                        .join(' AND ');
+                    query.orWhere(`(${predicate})`, parameters);
+                }
+                if ((await query.execute()).affected !== batch.length)
+                    this.refuse();
+            }
+            for (let offset = 0; offset < branches.length; offset += 32) {
+                const batch = branches.slice(offset, offset + 32);
+                const query = manager
+                    .createQueryBuilder()
+                    .update(virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity)
+                    .set({ activity: 'unknown', releaseAttempts: 0, nextReleaseAt: null });
+                for (const [index, row] of batch.entries()) {
+                    const parameters = {};
+                    const predicate = branchColumns
+                        .map((key) => {
+                        parameters[`${index}_${key}`] = row[key];
+                        return `"${key}" IS :${index}_${key}`;
+                    })
+                        .join(' AND ');
+                    query.orWhere(`(${predicate})`, parameters);
+                }
+                if ((await query.execute()).affected !== batch.length)
+                    this.refuse();
+            }
+            for (const row of pending) {
+                const expected = retained.has(row.id)
+                    ? row
+                    : {
+                        ...row,
+                        status: 'unknown',
+                        fault: 'restart_requires_release_reconciliation',
+                    };
+                if (!this.equal(await this.read(manager, row.id), expected))
+                    this.refuse();
+            }
+            const remaining = await manager
+                .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, 'command')
+                .where("command.status IN ('prepared','dispatching')")
+                .getCount();
+            const after = await manager
+                .createQueryBuilder(virtual_thermostat_runtime_entity_1.VirtualThermostatBranchRuntimeEntity, 'branch')
+                .select(branchColumns.map((key) => `branch.${key} AS "${key}"`))
+                .orderBy('branch.claimId')
+                .callListeners(false)
+                .getRawMany();
+            if (remaining !== retained.size || after.length !== branches.length || !current())
+                this.refuse();
+            for (const [index, row] of branches.entries()) {
+                const expected = { ...row, activity: 'unknown', releaseAttempts: 0, nextReleaseAt: null };
+                if (!branchColumns.every((key) => Object.is(expected[key], after[index][key])))
+                    this.refuse();
+            }
+        });
+    }
+    async insert(command, branch, validate) {
+        if (this.originals.has(command))
+            this.refuse();
+        const value = (0, creation_capture_1.snapshotCreation)(command), expected = this.image(value);
+        await this.runNative(async (manager, current) => {
+            if (validate) {
+                await validate(manager);
+                this.scopes.get(manager).verify.push(() => validate(manager));
+            }
+            if (await this.read(manager, value.id))
+                this.refuse();
+            await manager.insert(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity, value);
+            await this.writeRuntimeRows(manager, [branch]);
+            if (!current() ||
+                !this.equal(await this.read(manager, value.id), expected) ||
+                !this.equal(this.image(command), expected))
+                this.refuse();
+            this.scopes.get(manager).accept.push(() => this.originals.set(command, expected));
+        });
+    }
+    async write(command, validate) {
+        const before = this.originals.get(command);
+        if (!before)
+            this.refuse();
+        const value = (0, creation_capture_1.snapshotCreation)(command), expected = this.image(value);
+        if (commandIdentity.some((key) => !Object.is(before[key], expected[key])))
+            this.refuse();
+        await this.runNative(async (manager, current) => {
+            if (validate) {
+                await validate(manager);
+                this.scopes.get(manager).verify.push(() => validate(manager));
+            }
+            if (!this.equal(await this.read(manager, value.id), before))
+                this.refuse();
+            const query = manager.createQueryBuilder().update(virtual_thermostat_runtime_entity_1.VirtualThermostatCommandEntity).set({
+                status: value.status,
+                dispatchedAt: value.dispatchedAt,
+                settledAt: value.settledAt,
+                proofId: value.proofId,
+                fault: value.fault,
+            });
+            for (const key of commandColumns)
+                query.andWhere(`"${key}" IS :old_${key}`, { [`old_${key}`]: before[key] });
+            if ((await query.execute()).affected !== 1)
+                this.refuse();
+            if (!current() || !this.equal(await this.read(manager, value.id), expected))
+                this.refuse();
+            this.scopes.get(manager).accept.push(() => this.originals.set(command, expected));
+        });
+    }
+}
+exports.ThermostatRuntimeJournal = ThermostatRuntimeJournal;
+async function readThermostatRecreationHistory(manager, controllerId) {
+    const rows = async (sql) => Object.freeze((await manager.query(sql, [controllerId])).map((row) => Object.freeze({ ...row })));
+    return Object.freeze({
+        runtime: await rows('SELECT * FROM "devices_virtual_thermostat_runtime" WHERE "controllerId"=? ORDER BY "controllerId"'),
+        branches: await rows('SELECT * FROM "devices_virtual_thermostat_branch_runtime" WHERE "claimId" IN (SELECT "id" FROM "devices_virtual_thermostat_actuator_claims" WHERE "controllerId"=?) ORDER BY "claimId"'),
+        commands: await rows('SELECT * FROM "devices_virtual_thermostat_command_journal" WHERE "controllerId"=? ORDER BY "id"'),
+    });
+}
+async function assertThermostatRecreationHistory(manager, id, expected) {
+    if ((0, climate_automation_ledger_utils_1.canonical)(await readThermostatRecreationHistory(manager, id)) !== (0, climate_automation_ledger_utils_1.canonical)(expected))
+        throw new Error('Retained thermostat runtime history changed');
+}
+async function resetThermostatRecreationRuntime(manager, id, before, claims, configurationRevision) {
+    const refuse = () => {
+        throw new Error('Retained thermostat history is not eligible for fresh creation');
+    };
+    await assertThermostatRecreationHistory(manager, id, before);
+    if (before.runtime.length > 1 ||
+        (before.commands.length && before.runtime.length !== 1) ||
+        claims.some((claim) => claim.state !== 'released'))
+        refuse();
+    for (const command of before.commands) {
+        const claim = claims.find((row) => row.id === command.claimId);
+        if (!claim ||
+            !['confirmed', 'cancelled'].includes(command.status) ||
+            !Number.isSafeInteger(command.configurationRevision) ||
+            command.configurationRevision >= configurationRevision)
+            refuse();
+        if (command.action === 'on' && command.dispatchedAt !== null) {
+            const release = typeof claim.releaseEvidence === 'string'
+                ? JSON.parse(claim.releaseEvidence)
+                : null;
+            const branch = before.branches.find((row) => row.claimId === claim.id);
+            if (!claim.releasedAt ||
+                !release ||
+                release.outputConfirmedOff !== true ||
+                release.pendingOnDrained !== true ||
+                typeof release.evidenceId !== 'string' ||
+                !release.evidenceId ||
+                branch?.activity !== 'off' ||
+                branch.releaseProofId !== release.evidenceId ||
+                !branch.lastVerifiedOffAt)
+                refuse();
+        }
+    }
+    const previous = before.runtime[0];
+    if (!previous)
+        return before;
+    if (!Number.isSafeInteger(previous.decisionRevision) ||
+        previous.decisionRevision < 0 ||
+        previous.decisionRevision >= Number.MAX_SAFE_INTEGER ||
+        !Number.isSafeInteger(configurationRevision) ||
+        configurationRevision < 1)
+        refuse();
+    const decisionRevision = previous.decisionRevision === 0 ? 1 : (0, climate_automation_ledger_utils_1.increment)(previous.decisionRevision);
+    if (before.commands.some((command) => !Number.isSafeInteger(command.decisionRevision) || command.decisionRevision >= decisionRevision))
+        refuse();
+    const evaluatedAt = new Date();
+    const update = manager.createQueryBuilder().update(virtual_thermostat_runtime_entity_1.VirtualThermostatRuntimeEntity).set({
+        decisionRevision,
+        configurationRevision,
+        floorLatched: false,
+        heuristicHold: null,
+        previousDemand: 'off',
+        reasons: [],
+        evaluatedAt,
+    });
+    for (const [column, value] of Object.entries(previous))
+        update.andWhere(`"${column}" IS :old_${column}`, { [`old_${column}`]: value });
+    if ((await update.execute()).affected !== 1)
+        refuse();
+    const column = manager.connection
+        .getMetadata(virtual_thermostat_runtime_entity_1.VirtualThermostatRuntimeEntity)
+        .findColumnWithPropertyName('evaluatedAt');
+    const expected = {
+        ...before,
+        runtime: [
+            {
+                ...previous,
+                decisionRevision,
+                configurationRevision,
+                floorLatched: 0,
+                heuristicHold: null,
+                previousDemand: 'off',
+                reasons: '[]',
+                evaluatedAt: manager.connection.driver.preparePersistentValue(evaluatedAt, column),
+            },
+        ],
+    };
+    await assertThermostatRecreationHistory(manager, id, expected);
+    return expected;
+}
+//# sourceMappingURL=virtual-thermostat-runtime-ownership.js.map