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

package/dist/modules/devices/services/climate-automation-ledger.service.js

@@ -0,0 +1,1061 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClimateAutomationLedgerService = exports.ClimateAutomationLedgerError = exports.ClimateAutomationDeletionCaptureChanged = exports.ClimateAutomationLedgerConflict = void 0;
+const class_transformer_1 = require("class-transformer");
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = require("node:crypto");
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
+const climate_automation_entity_1 = require("../entities/climate-automation.entity");
+const climate_automation_ledger_lifecycle_1 = require("./climate-automation-ledger-lifecycle");
+const climate_automation_ledger_utils_1 = require("./climate-automation-ledger.utils");
+const climate_automation_registry_service_1 = require("./climate-automation.registry.service");
+const creation_capture_1 = require("./creation-capture");
+const device_structure_lock_service_1 = require("./device-structure-lock.service");
+var climate_automation_ledger_utils_2 = require("./climate-automation-ledger.utils");
+Object.defineProperty(exports, "ClimateAutomationLedgerConflict", { enumerable: true, get: function () { return climate_automation_ledger_utils_2.ClimateAutomationLedgerConflict; } });
+const originalLeaseRead = device_structure_lock_service_1.DeviceStructureLockService.prototype.hasCurrentStructuralLease;
+const originalOwnerCapture = device_structure_lock_service_1.DeviceStructureLockService.prototype.captureExclusiveOwner;
+let PrivateLedgerSnapshot = class PrivateLedgerSnapshot {
+    toJSON() {
+        return {};
+    }
+};
+PrivateLedgerSnapshot = __decorate([
+    (0, class_transformer_1.Exclude)()
+], PrivateLedgerSnapshot);
+function privateSnapshot(fields) {
+    return Object.freeze(Object.assign(new PrivateLedgerSnapshot(), fields));
+}
+class ClimateAutomationDeletionCaptureChanged extends climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict {
+    constructor() {
+        super('stale');
+    }
+}
+exports.ClimateAutomationDeletionCaptureChanged = ClimateAutomationDeletionCaptureChanged;
+class ClimateAutomationLedgerError extends Error {
+    constructor(outcome, cause) {
+        super('Private climate ledger transaction failed', { cause });
+        this.outcome = outcome;
+    }
+}
+exports.ClimateAutomationLedgerError = ClimateAutomationLedgerError;
+let ClimateAutomationLedgerService = class ClimateAutomationLedgerService {
+    constructor(database, structure, registry) {
+        this.database = database;
+        this.structure = structure;
+        this.registry = registry;
+        this.context = new node_async_hooks_1.AsyncLocalStorage();
+        this.scopes = new WeakMap();
+        this.records = new WeakMap();
+    }
+    async inAdmittedManager(manager, receipt, work) {
+        const ambient = this.context.getStore();
+        if (ambient)
+            throw this.refuse(ambient.operation);
+        if (!(this.database instanceof sqlite_data_source_1.SqliteDataSource) ||
+            manager.connection !== this.database ||
+            !manager.queryRunner ||
+            receipt.outcome !== 'pending' ||
+            !(0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.database))
+            throw new Error('Borrowed climate ledger requires the original pending native owner');
+        const ownerCurrent = Reflect.apply(originalOwnerCapture, this.structure, []);
+        const operation = {
+            borrowed: true,
+            phase: 'OPEN',
+            scope: Object.freeze({}),
+            manager,
+            runner: manager.queryRunner,
+            receipt,
+            tail: Promise.resolve(),
+            children: new Set(),
+            guards: [{ current: ownerCurrent }],
+            latest: new Map(),
+            issued: new Set(),
+        };
+        (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => operation.phase === 'READY' &&
+            operation.manager === manager &&
+            manager.queryRunner === operation.runner &&
+            !operation.failure &&
+            operation.children.size === 0 &&
+            (0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.database) &&
+            operation.guards.every((pin) => pin.current()));
+        this.scopes.set(operation.scope, operation);
+        return this.context.run({ operation, internal: false }, async () => {
+            try {
+                let result;
+                try {
+                    result = await work(operation.scope);
+                }
+                catch (cause) {
+                    this.fail(operation, cause);
+                }
+                await this.drainAndValidate(operation, manager);
+                return result;
+            }
+            catch (cause) {
+                operation.phase = 'SETTLED';
+                throw cause;
+            }
+            finally {
+                this.scopes.delete(operation.scope);
+                for (const snapshot of operation.issued)
+                    this.records.delete(snapshot);
+                operation.issued.clear();
+                operation.latest.clear();
+            }
+        });
+    }
+    currentScope(manager) {
+        const operation = this.context.getStore()?.operation;
+        if (!operation)
+            throw new Error('No climate ledger owner');
+        this.admit(manager, operation.scope);
+        return operation.scope;
+    }
+    async sealAdmittedManager(manager) {
+        const operation = this.context.getStore()?.operation;
+        if (!operation?.borrowed)
+            throw new Error('Original borrowed climate owner required');
+        this.admit(manager, operation.scope);
+        await this.drainAndValidate(operation, manager);
+    }
+    async drainAndValidate(operation, manager) {
+        if (operation.phase === 'READY') {
+            this.healthy(operation);
+            return;
+        }
+        operation.phase = 'DRAINING';
+        await Promise.all(operation.children);
+        await operation.tail;
+        this.healthy(operation);
+        operation.phase = 'VALIDATING';
+        await this.context.run({ operation, internal: true }, async () => {
+            for (const record of operation.latest.values())
+                await record.validate?.();
+            for (const record of operation.latest.values())
+                await this.validateRow(manager, record);
+        });
+        this.healthy(operation);
+        operation.phase = 'READY';
+    }
+    async runReserved(work) {
+        const ambient = this.context.getStore();
+        if (ambient)
+            throw new ClimateAutomationLedgerError('not_started', this.refuse(ambient.operation));
+        if (!(this.database instanceof sqlite_data_source_1.SqliteDataSource) || (0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.database))
+            throw new ClimateAutomationLedgerError('not_started', new Error('Independent coordinated SQLite lease required'));
+        return this.structure
+            .runExclusiveReleased(async () => {
+            const operation = {
+                phase: 'OPENING',
+                scope: Object.freeze({}),
+                tail: Promise.resolve(),
+                children: new Set(),
+                guards: [],
+                latest: new Map(),
+                issued: new Set(),
+            };
+            this.scopes.set(operation.scope, operation);
+            return this.context.run({ operation, internal: false }, async () => {
+                try {
+                    await this.database.transaction(async (manager) => {
+                        operation.manager = manager;
+                        operation.runner = manager.queryRunner;
+                        operation.receipt = (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => operation.phase === 'READY' &&
+                            operation.manager === manager &&
+                            manager.queryRunner === operation.runner &&
+                            (0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.database) &&
+                            !operation.failure &&
+                            originalLeaseRead.call(this.structure) &&
+                            operation.children.size === 0 &&
+                            operation.guards.every((pin) => pin.current()));
+                        await manager.query(`UPDATE "${climate_automation_entity_1.CLIMATE_SOURCE_TABLE}" SET "revision"="revision" WHERE 0`);
+                        operation.phase = 'OPEN';
+                        try {
+                            await work(manager, operation.scope);
+                        }
+                        catch (cause) {
+                            this.fail(operation, cause);
+                        }
+                        await this.drainAndValidate(operation, manager);
+                    });
+                    if (operation.receipt?.outcome !== 'committed')
+                        throw new Error('Missing native ledger COMMIT receipt');
+                    return Object.freeze({ outcome: 'committed' });
+                }
+                catch (cause) {
+                    const outcome = operation.receipt?.outcome;
+                    throw new ClimateAutomationLedgerError(outcome && outcome !== 'pending' ? outcome : 'not_started', operation.failure ? operation.failure.cause : cause);
+                }
+                finally {
+                    operation.phase = 'SETTLED';
+                    this.scopes.delete(operation.scope);
+                    for (const snapshot of operation.issued)
+                        this.records.delete(snapshot);
+                    operation.issued.clear();
+                    operation.latest.clear();
+                    operation.guards.length = 0;
+                    operation.manager = undefined;
+                    operation.runner = undefined;
+                }
+            });
+        })
+            .catch((cause) => {
+            if (cause instanceof ClimateAutomationLedgerError)
+                throw cause;
+            throw new ClimateAutomationLedgerError('not_started', cause);
+        });
+    }
+    inReservedManager(manager, scope, work) {
+        const operation = this.admit(manager, scope);
+        const task = Promise.resolve().then(work);
+        const settled = task.then(() => {
+            operation.children.delete(settled);
+        }, (cause) => {
+            this.fail(operation, cause);
+            operation.children.delete(settled);
+        });
+        operation.children.add(settled);
+        return task;
+    }
+    readSource(manager, scope, producerKey, subjectId) {
+        const operation = this.admit(manager, scope);
+        this.requireKey(operation, producerKey);
+        this.requireKey(operation, subjectId);
+        return this.enqueue(operation, async () => this.sourceSnapshot(operation, producerKey, subjectId, await this.source(manager, producerKey, subjectId)));
+    }
+    readSlot(manager, scope, controllerId, withController = true, providerKey) {
+        const operation = this.admit(manager, scope);
+        this.requireKey(operation, controllerId);
+        return this.enqueue(operation, async () => {
+            const row = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId });
+            const facts = row ? Object.freeze({ ...row }) : null;
+            let controller = null;
+            let validate;
+            if (withController && (facts || providerKey)) {
+                if (facts && providerKey && facts.providerKey !== providerKey)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                const capture = this.registry.captureProvider(facts?.providerKey ?? providerKey);
+                const pin = this.pin(capture, 'readControllerInManager');
+                operation.guards.push(pin);
+                const read = async () => {
+                    this.requirePin(pin);
+                    const value = await Reflect.apply(pin.method, pin.receiver, [manager, controllerId]);
+                    this.requirePin(pin);
+                    return this.controllerFacts(value);
+                };
+                controller = await read();
+                if (!controller)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('unavailable');
+                const expected = (0, climate_automation_ledger_utils_1.canonical)(controller);
+                validate = async () => {
+                    if ((0, climate_automation_ledger_utils_1.canonical)(await read()) !== expected)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                };
+            }
+            const snapshot = privateSnapshot({ facts, controller });
+            this.issue(operation, snapshot, {
+                kind: 'slot',
+                operation,
+                controllerId,
+                providerKey: facts?.providerKey ?? providerKey,
+                snapshot,
+                validate,
+            });
+            return snapshot;
+        });
+    }
+    stageSource(manager, scope, request) {
+        const operation = this.admit(manager, scope);
+        try {
+            const { producerKey, pin, subjectId, expected, bytes } = this.context.run({ operation, internal: true }, () => {
+                const producerKey = request.producerKey;
+                const pin = this.pin(this.registry.captureProducer(producerKey), 'validateInManager');
+                operation.guards.push(pin);
+                const { subjectId, expected, evidence } = request;
+                if (typeof producerKey !== 'string' || typeof subjectId !== 'string' || !subjectId)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                const bytes = (0, climate_automation_ledger_utils_1.canonical)(evidence);
+                this.healthy(operation);
+                return { producerKey, pin, subjectId, expected, bytes };
+            });
+            return this.enqueue(operation, async () => {
+                const record = this.records.get(expected);
+                if (!record ||
+                    record.operation !== operation ||
+                    record.kind !== 'source' ||
+                    record.producerKey !== producerKey ||
+                    record.subjectId !== subjectId)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                await this.validateRow(manager, record);
+                const previous = record.snapshot.facts;
+                if (previous && !['REVOKED', 'DELETED', 'FINALIZED_INACTIVE'].includes(previous.state))
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                if (previous &&
+                    (await manager
+                        .createQueryBuilder(climate_automation_entity_1.ClimateAutomationSlotEntity, 'slot')
+                        .where('slot.generationId = :generation', { generation: previous.generationId })
+                        .andWhere('slot.state IN (:...states)', { states: ['PROVISIONAL', 'LIVE'] })
+                        .getCount()))
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const next = Object.freeze({
+                    generationId: (0, node_crypto_1.randomUUID)(),
+                    ownerId: previous && previous.state !== 'DELETED' ? previous.ownerId : (0, node_crypto_1.randomUUID)(),
+                    producerKey,
+                    subjectId,
+                    generationIndex: previous && previous.state !== 'DELETED' ? (0, climate_automation_ledger_utils_1.increment)(previous.generationIndex) : 1,
+                    revision: 1,
+                    isCurrent: true,
+                    state: 'PENDING',
+                    evidence: bytes,
+                    evidenceDigest: (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex'),
+                });
+                const validate = async () => {
+                    this.requirePin(pin);
+                    const actual = await Reflect.apply(pin.method, pin.receiver, [manager, next, 'prepare']);
+                    this.requirePin(pin);
+                    if (actual === null || (0, climate_automation_ledger_utils_1.canonical)(actual) !== bytes)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                };
+                await validate();
+                await this.validateRow(manager, record);
+                if (previous) {
+                    const query = manager
+                        .createQueryBuilder()
+                        .update(climate_automation_entity_1.ClimateAutomationSourceEntity)
+                        .set({ revision: (0, climate_automation_ledger_utils_1.increment)(previous.revision), isCurrent: false });
+                    for (const column of Object.keys(previous))
+                        query.andWhere(`"${column}" IS :expected_${column}`, { [`expected_${column}`]: previous[column] });
+                    query.andWhere(`NOT EXISTS (SELECT 1 FROM "${climate_automation_entity_1.CLIMATE_SLOT_TABLE}" slot WHERE slot."generationId" = :generation AND slot."state" IN ('PROVISIONAL','LIVE'))`, { generation: previous.generationId });
+                    if ((await query.execute()).affected !== 1)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                }
+                await manager.insert(climate_automation_entity_1.ClimateAutomationSourceEntity, next);
+                return this.sourceSnapshot(operation, producerKey, subjectId, next, validate);
+            });
+        }
+        catch (cause) {
+            this.fail(operation, cause);
+            throw cause;
+        }
+    }
+    async captureControllerDeletion(id) {
+        if ((0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.database))
+            throw new Error('Controller deletion requires entry before native ownership');
+        const providers = this.registry.captureProviders();
+        const row = await this.database.manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId: id });
+        if (!row) {
+            let finished = false;
+            const execute = async (manager, scope, remove) => {
+                if (finished)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const slot = await this.readSlot(manager, scope, id, false);
+                if (slot.facts)
+                    throw new ClimateAutomationDeletionCaptureChanged();
+                await this.inReservedManager(manager, scope, remove);
+            };
+            return Object.freeze(Object.assign(execute, {
+                finish: () => {
+                    finished = true;
+                    return Promise.resolve();
+                },
+            }));
+        }
+        const expected = Object.freeze({ ...row });
+        const capture = providers.get(expected.providerKey) ?? null;
+        const predecessor = this.pin(capture, 'beginControllerDeletion');
+        const deletion = this.pin(capture, 'readDeletedControllerInManager');
+        const absence = this.pin(capture, 'validateDeletedControllerInManager');
+        const controller = this.pin(capture, 'readControllerInManager');
+        const configuration = this.pin(capture, 'readDeletionConfigurationInManager');
+        const retirement = ['LIVE', 'PROVISIONAL'].includes(expected.state)
+            ? this.pin(capture, 'retireControllerInManager')
+            : null;
+        const completion = await Reflect.apply(predecessor.method, predecessor.receiver, [expected]);
+        const captured = completion ? (0, creation_capture_1.captureCreation)(completion, ['finish']) : undefined;
+        let finished = false;
+        const finish = async (outcome = 'unknown') => {
+            if (finished)
+                return;
+            finished = true;
+            if (captured && completion)
+                await (0, creation_capture_1.invokeCreation)(captured.values.finish, completion, outcome);
+        };
+        try {
+            this.requirePin(predecessor);
+        }
+        catch (cause) {
+            try {
+                await finish('unknown');
+            }
+            catch {
+            }
+            throw cause;
+        }
+        const execute = async (manager, scope, remove) => {
+            if (finished)
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+            const operation = this.admit(manager, scope);
+            operation.guards.push(predecessor, absence, controller, configuration, deletion);
+            if (retirement)
+                operation.guards.push(retirement);
+            const slot = await this.readSlot(manager, scope, id, false);
+            if ((0, climate_automation_ledger_utils_1.canonical)(slot.facts) !== (0, climate_automation_ledger_utils_1.canonical)(expected))
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+            this.requirePin(controller);
+            const original = this.controllerFacts(await Reflect.apply(controller.method, controller.receiver, [manager, id]));
+            if (!original)
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('unavailable');
+            const devices = await manager.query('SELECT * FROM "devices_module_devices" WHERE "id" = ?', [id]);
+            if (devices.length !== 1)
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+            const deviceEvidence = (0, climate_automation_ledger_utils_1.canonical)({ ...devices[0] });
+            if (retirement) {
+                this.requirePin(retirement);
+                await Reflect.apply(retirement.method, retirement.receiver, [manager, expected]);
+                this.requirePin(retirement);
+            }
+            const fenced = await this.fenceManual(manager, scope, slot, true);
+            const before = this.controllerFacts(await Reflect.apply(controller.method, controller.receiver, [manager, id]));
+            this.requirePin(controller);
+            if (!before)
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+            const configurationEvidence = (0, climate_automation_ledger_utils_1.canonical)(await Reflect.apply(configuration.method, configuration.receiver, [manager, id]));
+            this.requirePin(configuration);
+            const tombstone = {
+                deletionId: (0, node_crypto_1.randomUUID)(),
+                controllerId: id,
+                controllerIncarnation: fenced.facts.controllerIncarnation,
+                providerKey: fenced.facts.providerKey,
+                slotRevision: fenced.facts.slotRevision,
+                manualCounter: fenced.facts.manualCounter,
+                slotEvidence: (0, climate_automation_ledger_utils_1.canonical)(fenced.facts),
+                controllerEvidence: (0, climate_automation_ledger_utils_1.canonical)(before),
+                deviceEvidence,
+                configurationEvidence,
+                nativeDeviceEvidence: null,
+                nativeConfigurationEvidence: null,
+                consumedByIncarnation: null,
+                consumedSlotRevision: null,
+            };
+            await manager.insert(climate_automation_entity_1.ClimateAutomationDeletionEntity, tombstone);
+            await this.inReservedManager(manager, scope, remove);
+            await this.enqueue(operation, async () => {
+                this.requirePin(deletion);
+                const retained = (0, climate_automation_ledger_utils_1.ownedJson)(await Reflect.apply(deletion.method, deletion.receiver, [manager, id, before]));
+                this.requirePin(deletion);
+                const deleted = async () => {
+                    this.requirePin(absence);
+                    await Reflect.apply(absence.method, absence.receiver, [manager, id, retained]);
+                    this.requirePin(absence);
+                };
+                await deleted();
+                const record = this.records.get(fenced);
+                await this.validateRow(manager, record);
+                const proof = await manager.findOneByOrFail(climate_automation_entity_1.ClimateAutomationDeletionEntity, {
+                    deletionId: tombstone.deletionId,
+                });
+                if (!proof.nativeDeviceEvidence ||
+                    !proof.nativeConfigurationEvidence ||
+                    (0, climate_automation_ledger_utils_1.canonical)(JSON.parse(proof.nativeDeviceEvidence)) !== deviceEvidence ||
+                    (0, climate_automation_ledger_utils_1.canonical)(JSON.parse(proof.nativeConfigurationEvidence)) !== configurationEvidence)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const captured = {
+                    ...tombstone,
+                    nativeDeviceEvidence: proof.nativeDeviceEvidence,
+                    nativeConfigurationEvidence: proof.nativeConfigurationEvidence,
+                };
+                if ((0, climate_automation_ledger_utils_1.canonical)({ ...proof }) !== (0, climate_automation_ledger_utils_1.canonical)(captured))
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const intended = { ...captured, controllerEvidence: (0, climate_automation_ledger_utils_1.canonical)({ original, atDeletion: before, retained }) };
+                const finish = manager
+                    .createQueryBuilder()
+                    .update(climate_automation_entity_1.ClimateAutomationDeletionEntity)
+                    .set({ controllerEvidence: intended.controllerEvidence });
+                for (const [column, value] of Object.entries(captured))
+                    finish.andWhere(`"${column}" IS :old_${column}`, { [`old_${column}`]: value });
+                if ((await finish.execute()).affected !== 1)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const validate = async () => {
+                    await deleted();
+                    const actual = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationDeletionEntity, { deletionId: tombstone.deletionId });
+                    if (!actual || (0, climate_automation_ledger_utils_1.canonical)({ ...actual }) !== (0, climate_automation_ledger_utils_1.canonical)(intended))
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                };
+                await validate();
+                this.issue(operation, fenced, { ...record, validate }, true);
+            });
+        };
+        return Object.freeze(Object.assign(execute, { finish, hasControllerSlot: true }));
+    }
+    async captureControllerRecreation(manager, scope, id) {
+        const operation = this.admit(manager, scope);
+        const previous = await this.readSlot(manager, scope, id, false);
+        if (!previous.facts)
+            return null;
+        const provider = this.registry.captureProvider(previous.facts.providerKey);
+        const prepare = this.pin(provider, 'prepareControllerRecreationInManager');
+        const archivePin = this.pin(provider, 'captureControllerRecreationArchiveInManager');
+        const validation = this.pin(provider, 'validateControllerRecreationInManager');
+        operation.guards.push(prepare, archivePin, validation);
+        this.requirePin(prepare);
+        const found = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationDeletionEntity, {
+            controllerId: id,
+            controllerIncarnation: previous.facts.controllerIncarnation,
+            consumedByIncarnation: (0, typeorm_1.IsNull)(),
+        });
+        if (!found ||
+            !found.nativeDeviceEvidence ||
+            !found.nativeConfigurationEvidence ||
+            (0, climate_automation_ledger_utils_1.canonical)(JSON.parse(found.nativeDeviceEvidence)) !== found.deviceEvidence ||
+            (0, climate_automation_ledger_utils_1.canonical)(JSON.parse(found.nativeConfigurationEvidence)) !== found.configurationEvidence ||
+            found.slotEvidence !== (0, climate_automation_ledger_utils_1.canonical)(previous.facts) ||
+            found.providerKey !== previous.facts.providerKey ||
+            found.slotRevision !== previous.facts.slotRevision ||
+            found.manualCounter !== previous.facts.manualCounter)
+            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+        const originalTombstone = Object.freeze({ ...found });
+        const evidence = JSON.parse(originalTombstone.controllerEvidence);
+        this.requirePin(archivePin);
+        const archive = (0, climate_automation_ledger_utils_1.ownedJson)(await Reflect.apply(archivePin.method, archivePin.receiver, [manager, id, (0, climate_automation_ledger_utils_1.ownedJson)(evidence.retained)]));
+        this.requirePin(archivePin);
+        const tombstone = Object.freeze({
+            ...originalTombstone,
+            controllerEvidence: (0, climate_automation_ledger_utils_1.canonical)({
+                ...evidence,
+                priorControllerEvidence: originalTombstone.controllerEvidence,
+                recreationArchive: archive,
+            }),
+        });
+        const archiveWrite = manager
+            .createQueryBuilder()
+            .update(climate_automation_entity_1.ClimateAutomationDeletionEntity)
+            .set({ controllerEvidence: tombstone.controllerEvidence });
+        for (const [column, value] of Object.entries(originalTombstone))
+            archiveWrite.andWhere(`"${column}" IS :old_${column}`, { [`old_${column}`]: value });
+        if ((await archiveWrite.execute()).affected !== 1)
+            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+        const preparation = (0, climate_automation_ledger_utils_1.ownedJson)(await Reflect.apply(prepare.method, prepare.receiver, [manager, id, (0, climate_automation_ledger_utils_1.ownedJson)(evidence.retained), archive]));
+        this.requirePin(prepare);
+        const validatePreparation = async () => {
+            this.requirePin(validation);
+            await Reflect.apply(validation.method, validation.receiver, [manager, id, preparation]);
+            this.requirePin(validation);
+        };
+        let consumed = false;
+        const consume = async (current) => {
+            if (consumed ||
+                this.admit(manager, scope) !== operation ||
+                (0, climate_automation_ledger_utils_1.canonical)(current.facts) !== (0, climate_automation_ledger_utils_1.canonical)(previous.facts))
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+            consumed = true;
+            const record = this.records.get(current);
+            if (!record || record.operation !== operation || record.kind !== 'slot' || !current.controller)
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+            const devices = await manager.query('SELECT * FROM "devices_module_devices" WHERE "id" = ?', [id]);
+            const priorDevice = JSON.parse(tombstone.deviceEvidence);
+            if (devices.length !== 1 ||
+                !Number.isSafeInteger(devices[0].catalogBirth) ||
+                devices[0].catalogBirth < 1 ||
+                devices[0].catalogBirth === priorDevice.catalogBirth)
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+            const deviceEvidence = (0, climate_automation_ledger_utils_1.canonical)({ ...devices[0] });
+            const next = await this.lifecycleCommand(manager, scope, (lifecycle) => lifecycle.initializeSlot({
+                expected: current,
+                releaseManualHold: true,
+                explicitOptIn: true,
+                freshIncarnation: true,
+            }));
+            await this.enqueue(operation, async () => {
+                const intended = {
+                    ...tombstone,
+                    consumedByIncarnation: next.facts.controllerIncarnation,
+                    consumedSlotRevision: next.facts.slotRevision,
+                };
+                const query = manager.createQueryBuilder().update(climate_automation_entity_1.ClimateAutomationDeletionEntity).set({
+                    consumedByIncarnation: intended.consumedByIncarnation,
+                    consumedSlotRevision: intended.consumedSlotRevision,
+                });
+                for (const [column, value] of Object.entries(tombstone))
+                    query.andWhere(`"${column}" IS :old_${column}`, { [`old_${column}`]: value });
+                if ((await query.execute()).affected !== 1)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const nextRecord = this.records.get(next);
+                const validate = async () => {
+                    await nextRecord.validate?.();
+                    await validatePreparation();
+                    const actual = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationDeletionEntity, { deletionId: tombstone.deletionId });
+                    const owner = await manager.query('SELECT * FROM "devices_module_devices" WHERE "id" = ?', [id]);
+                    if (!actual ||
+                        (0, climate_automation_ledger_utils_1.canonical)({ ...actual }) !== (0, climate_automation_ledger_utils_1.canonical)(intended) ||
+                        owner.length !== 1 ||
+                        (0, climate_automation_ledger_utils_1.canonical)({ ...owner[0] }) !== deviceEvidence)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                };
+                await validate();
+                this.issue(operation, next, { ...nextRecord, validate }, true);
+            });
+            return next;
+        };
+        return Object.freeze({ preparation, consume });
+    }
+    initializeSlot(manager, scope, request) {
+        return this.lifecycleCommand(manager, scope, (lifecycle) => {
+            const { expected, releaseManualHold, explicitOptIn } = request;
+            return lifecycle.initializeSlot({ expected, releaseManualHold, explicitOptIn });
+        });
+    }
+    stageSlot(manager, scope, request) {
+        return this.lifecycleCommand(manager, scope, (lifecycle) => lifecycle.stageSlot(request));
+    }
+    retireSlot(manager, scope, expectedSlot, expectedSource) {
+        return this.lifecycleCommand(manager, scope, (lifecycle) => lifecycle.retireSlot(expectedSlot, expectedSource));
+    }
+    fenceManual(manager, scope, expected, manualHold, takeover = true) {
+        return this.lifecycleCommand(manager, scope, (lifecycle) => lifecycle.fenceManual(expected, manualHold, takeover));
+    }
+    installBundle(manager, scope, expectedSource, expectedSlots) {
+        const operation = this.admit(manager, scope);
+        try {
+            const { sourceRecord, source, producer, candidates } = this.context.run({ operation, internal: true }, () => {
+                const sourceRecord = this.records.get(expectedSource);
+                if (sourceRecord?.operation !== operation || sourceRecord.kind !== 'source')
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                const source = sourceRecord.snapshot.facts;
+                if (sourceRecord?.operation !== operation ||
+                    sourceRecord.kind !== 'source' ||
+                    !source?.isCurrent ||
+                    source.state !== 'PENDING' ||
+                    !expectedSlots.length)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                const producer = this.pin(this.registry.captureProducer(source.producerKey), 'validateInManager');
+                operation.guards.push(producer);
+                const candidates = expectedSlots.map((snapshot) => {
+                    const record = this.records.get(snapshot);
+                    if (record?.operation !== operation || record.kind !== 'slot')
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                    const facts = record.snapshot.facts;
+                    if (record?.operation !== operation ||
+                        record.kind !== 'slot' ||
+                        !record.validate ||
+                        !facts ||
+                        facts.state !== 'PROVISIONAL' ||
+                        facts.manualHold ||
+                        facts.ownerId !== source.ownerId ||
+                        facts.generationId !== source.generationId)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                    const registration = this.registry.captureProvider(facts.providerKey);
+                    const install = this.pin(registration, 'installControllerInManager');
+                    const read = this.pin(registration, 'readControllerInManager');
+                    operation.guards.push(install, read);
+                    return { snapshot, record, facts, install, read };
+                });
+                if (new Set(candidates.map(({ facts }) => facts.controllerId)).size !== candidates.length ||
+                    new Set(candidates.map(({ facts }) => facts.bundleId)).size !== 1)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                candidates.sort((a, b) => a.facts.controllerId.localeCompare(b.facts.controllerId));
+                this.healthy(operation);
+                return { sourceRecord, source, producer, candidates };
+            });
+            return this.enqueue(operation, async () => {
+                await this.validateRow(manager, sourceRecord);
+                for (const candidate of candidates) {
+                    await candidate.record.validate();
+                    await this.validateRow(manager, candidate.record);
+                }
+                const active = await manager.findBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { generationId: source.generationId });
+                if (active.length !== candidates.length ||
+                    active.some((row) => !candidates.some(({ facts }) => (0, climate_automation_ledger_utils_1.canonical)(facts) === (0, climate_automation_ledger_utils_1.canonical)({ ...row }))))
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const installed = [];
+                for (const { record, facts, install, read } of candidates) {
+                    this.requirePin(install);
+                    const result = this.controllerFacts(await Reflect.apply(install.method, install.receiver, [manager, facts]));
+                    this.requirePin(install);
+                    this.requirePin(read);
+                    const post = this.controllerFacts(await Reflect.apply(read.method, read.receiver, [manager, facts.controllerId]));
+                    if (!result || (0, climate_automation_ledger_utils_1.canonical)(result) !== (0, climate_automation_ledger_utils_1.canonical)(post))
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                    await this.validateRow(manager, record);
+                    const next = Object.freeze({
+                        ...facts,
+                        state: 'LIVE',
+                        slotRevision: (0, climate_automation_ledger_utils_1.increment)(facts.slotRevision),
+                        installEvidence: (0, climate_automation_ledger_utils_1.canonical)(result),
+                    });
+                    const query = manager.createQueryBuilder().update(climate_automation_entity_1.ClimateAutomationSlotEntity).set(next);
+                    for (const key of Object.keys(facts))
+                        query.andWhere(`"${key}" IS :old_${key}`, { [`old_${key}`]: facts[key] });
+                    if ((await query.execute()).affected !== 1)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                    const snapshot = privateSnapshot({ facts: next, controller: result });
+                    this.issue(operation, snapshot, {
+                        kind: 'slot',
+                        operation,
+                        controllerId: next.controllerId,
+                        providerKey: next.providerKey,
+                        snapshot,
+                        validate: async () => {
+                            this.requirePin(read);
+                            const actual = await Reflect.apply(read.method, read.receiver, [manager, facts.controllerId]);
+                            this.requirePin(read);
+                            if ((0, climate_automation_ledger_utils_1.canonical)(this.controllerFacts(actual)) !== (0, climate_automation_ledger_utils_1.canonical)(result))
+                                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                        },
+                    }, true);
+                    installed.push(snapshot);
+                }
+                await this.validateRow(manager, sourceRecord);
+                const nextSource = Object.freeze({
+                    ...source,
+                    state: 'FINALIZED_LIVE',
+                    revision: (0, climate_automation_ledger_utils_1.increment)(source.revision),
+                });
+                const query = manager.createQueryBuilder().update(climate_automation_entity_1.ClimateAutomationSourceEntity).set(nextSource);
+                for (const key of Object.keys(source))
+                    query.andWhere(`"${key}" IS :old_${key}`, { [`old_${key}`]: source[key] });
+                if ((await query.execute()).affected !== 1)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                this.sourceSnapshot(operation, source.producerKey, source.subjectId, nextSource, async () => {
+                    this.requirePin(producer);
+                    const evidence = await Reflect.apply(producer.method, producer.receiver, [manager, nextSource, 'prepare']);
+                    this.requirePin(producer);
+                    if (evidence === null || (0, climate_automation_ledger_utils_1.canonical)(evidence) !== source.evidence)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                    const membership = await manager.findBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { generationId: source.generationId });
+                    if (membership.length !== installed.length ||
+                        membership.some((row) => !installed.some(({ facts }) => (0, climate_automation_ledger_utils_1.canonical)(facts) === (0, climate_automation_ledger_utils_1.canonical)({ ...row }))))
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                });
+                return Object.freeze(installed);
+            });
+        }
+        catch (cause) {
+            this.fail(operation, cause);
+            throw cause;
+        }
+    }
+    refreshInstalledSlot(manager, scope, expected, kind = 'intent', preserveUnchangedGraph = false) {
+        const operation = this.admit(manager, scope);
+        try {
+            if (preserveUnchangedGraph && kind !== 'graph')
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+            const record = this.records.get(expected);
+            if (record?.operation !== operation || record.kind !== 'slot')
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+            const previous = record.snapshot.facts;
+            if (record?.operation !== operation ||
+                record.kind !== 'slot' ||
+                !record.snapshot.controller ||
+                previous?.state !== 'LIVE' ||
+                previous.manualHold)
+                throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+            const provider = this.registry.captureProvider(previous.providerKey);
+            if (kind === 'graph') {
+                const capability = provider && (0, creation_capture_1.captureCreation)(provider.implementation, ['graphRefreshVersion']);
+                if (capability?.values.graphRefreshVersion !== 1)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('unavailable');
+                (0, sqlite_data_source_1.registerSqliteCommitGuard)(manager, () => provider.isCurrent() && capability.current());
+            }
+            const refresh = this.pin(provider, 'refreshControllerInManager');
+            const read = this.pin(provider, 'readControllerInManager');
+            operation.guards.push(refresh, read);
+            return this.enqueue(operation, async () => {
+                await this.validateRow(manager, record);
+                const source = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, { generationId: previous.generationId });
+                if (!source?.isCurrent || source.state !== 'FINALIZED_LIVE' || source.ownerId !== previous.ownerId)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                const sourceBytes = (0, climate_automation_ledger_utils_1.canonical)({ ...source });
+                const producer = this.pin(this.registry.captureProducer(source.producerKey), 'validateInManager');
+                operation.guards.push(producer);
+                const validateSource = async () => {
+                    this.requirePin(producer);
+                    const evidence = await Reflect.apply(producer.method, producer.receiver, [manager, source, 'prepare']);
+                    this.requirePin(producer);
+                    const current = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, { generationId: source.generationId });
+                    if (evidence === null ||
+                        (0, climate_automation_ledger_utils_1.canonical)(evidence) !== source.evidence ||
+                        !current ||
+                        (0, climate_automation_ledger_utils_1.canonical)({ ...current }) !== sourceBytes)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                };
+                await validateSource();
+                this.requirePin(refresh);
+                const controller = this.controllerFacts(await Reflect.apply(refresh.method, refresh.receiver, [manager, previous, expected.controller, kind]));
+                this.requirePin(refresh);
+                if (!controller)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('unavailable');
+                const validate = async () => {
+                    await validateSource();
+                    this.requirePin(read);
+                    const actual = this.controllerFacts(await Reflect.apply(read.method, read.receiver, [manager, previous.controllerId]));
+                    this.requirePin(read);
+                    if ((0, climate_automation_ledger_utils_1.canonical)(actual) !== (0, climate_automation_ledger_utils_1.canonical)(controller))
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                };
+                await validate();
+                await this.validateRow(manager, record);
+                const next = preserveUnchangedGraph && (0, climate_automation_ledger_utils_1.canonical)(controller) === previous.installEvidence
+                    ? previous
+                    : Object.freeze({
+                        ...previous,
+                        slotRevision: (0, climate_automation_ledger_utils_1.increment)(previous.slotRevision),
+                        installEvidence: (0, climate_automation_ledger_utils_1.canonical)(controller),
+                    });
+                if (next !== previous) {
+                    const query = manager.createQueryBuilder().update(climate_automation_entity_1.ClimateAutomationSlotEntity).set(next);
+                    for (const key of Object.keys(previous))
+                        query.andWhere(`"${key}" IS :old_${key}`, { [`old_${key}`]: previous[key] });
+                    if ((await query.execute()).affected !== 1)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                }
+                const snapshot = privateSnapshot({ facts: next, controller });
+                this.issue(operation, snapshot, {
+                    kind: 'slot',
+                    operation,
+                    controllerId: next.controllerId,
+                    providerKey: next.providerKey,
+                    snapshot,
+                    validate,
+                }, true);
+                return snapshot;
+            });
+        }
+        catch (cause) {
+            this.fail(operation, cause);
+            throw cause;
+        }
+    }
+    revokeSource(manager, scope, expectedSource, slots, deleted = false) {
+        return this.lifecycleCommand(manager, scope, (lifecycle) => lifecycle.revokeSource(expectedSource, slots, deleted));
+    }
+    finalizeInactive(manager, scope, expected) {
+        return this.lifecycleCommand(manager, scope, (lifecycle) => lifecycle.finalizeInactive(expected));
+    }
+    lifecycleCommand(manager, scope, capture) {
+        const operation = this.admit(manager, scope);
+        try {
+            const record = (snapshot) => {
+                const value = this.records.get(snapshot);
+                if (!value || value.operation !== operation)
+                    throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                return value;
+            };
+            const access = {
+                manager,
+                source: (snapshot) => {
+                    const value = record(snapshot);
+                    if (value.kind !== 'source')
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                    if (!value.snapshot.facts)
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                    return value.snapshot.facts;
+                },
+                slot: (snapshot) => {
+                    const value = record(snapshot);
+                    if (value.kind !== 'slot')
+                        throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                    return {
+                        ...value.snapshot,
+                        controllerId: value.controllerId,
+                        providerKey: value.providerKey,
+                        validateController: value.validate,
+                    };
+                },
+                validate: (snapshot) => this.validateRow(manager, record(snapshot)),
+                producer: (key) => {
+                    const pin = this.pin(this.registry.captureProducer(key), 'validateInManager');
+                    operation.guards.push(pin);
+                    return async (source) => {
+                        this.requirePin(pin);
+                        const actual = await Reflect.apply(pin.method, pin.receiver, [manager, source, 'prepare']);
+                        this.requirePin(pin);
+                        if (actual === null || (0, climate_automation_ledger_utils_1.canonical)(actual) !== source.evidence)
+                            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+                    };
+                },
+                provider: (key) => {
+                    const pin = this.pin(this.registry.captureProvider(key), 'validateSelectionInManager');
+                    operation.guards.push(pin);
+                    return async (id, facts, selection) => {
+                        this.requirePin(pin);
+                        const accepted = await Reflect.apply(pin.method, pin.receiver, [manager, id, facts, selection]);
+                        this.requirePin(pin);
+                        if (accepted !== true)
+                            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+                    };
+                },
+                issueSource: (facts, validate) => this.sourceSnapshot(operation, facts.producerKey, facts.subjectId, facts, validate),
+                issueSlot: (facts, controller, validate) => {
+                    const snapshot = privateSnapshot({ facts, controller });
+                    this.issue(operation, snapshot, {
+                        kind: 'slot',
+                        operation,
+                        controllerId: facts.controllerId,
+                        providerKey: facts.providerKey,
+                        snapshot,
+                        validate,
+                    }, true);
+                    return snapshot;
+                },
+            };
+            const work = this.context.run({ operation, internal: true }, () => {
+                const captured = capture(new climate_automation_ledger_lifecycle_1.ClimateAutomationLedgerLifecycle(access));
+                this.healthy(operation);
+                return captured;
+            });
+            return this.enqueue(operation, work);
+        }
+        catch (cause) {
+            this.fail(operation, cause);
+            throw cause;
+        }
+    }
+    admit(manager, scope) {
+        const context = this.context.getStore();
+        const operation = this.scopes.get(scope);
+        if (!operation || context?.operation !== operation) {
+            if (context)
+                throw this.refuse(context.operation);
+            throw new Error('Invalid private climate ledger scope');
+        }
+        if (operation.phase !== 'OPEN' ||
+            context.internal ||
+            operation.failure ||
+            operation.manager !== manager ||
+            manager.queryRunner !== operation.runner ||
+            !(0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.database) ||
+            !originalLeaseRead.call(this.structure))
+            throw this.refuse(operation);
+        return operation;
+    }
+    requireKey(operation, key) {
+        if (typeof key !== 'string' || key.length === 0) {
+            const cause = new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+            this.fail(operation, cause);
+            throw cause;
+        }
+    }
+    enqueue(operation, work) {
+        const task = operation.tail.then(() => {
+            this.healthy(operation);
+            return this.context.run({ operation, internal: true }, work);
+        });
+        operation.tail = task.then(() => { }, (cause) => this.fail(operation, cause));
+        return task;
+    }
+    fail(operation, cause) {
+        operation.failure ??= { cause };
+    }
+    healthy(operation) {
+        if (operation.failure)
+            throw operation.failure.cause;
+    }
+    refuse(operation) {
+        const cause = new Error('Private climate ledger admission requires its open original scope and manager');
+        if (operation.phase !== 'SETTLED')
+            this.fail(operation, cause);
+        return cause;
+    }
+    sourceSnapshot(operation, producerKey, subjectId, facts, validate) {
+        const snapshot = privateSnapshot({ facts });
+        this.issue(operation, snapshot, { kind: 'source', operation, producerKey, subjectId, snapshot, validate }, !!validate);
+        return snapshot;
+    }
+    issue(operation, snapshot, record, write = false) {
+        this.records.set(snapshot, record);
+        operation.issued.add(snapshot);
+        const key = record.kind === 'source'
+            ? JSON.stringify(['source', record.producerKey, record.subjectId])
+            : JSON.stringify(['slot', record.controllerId]);
+        const previous = operation.latest.get(key);
+        const latest = previous?.written && !write ? previous : { ...record, written: write };
+        operation.latest.set(key, previous?.validate && !write
+            ? {
+                ...latest,
+                validate: record.validate
+                    ? async () => {
+                        await previous.validate();
+                        await record.validate();
+                    }
+                    : previous.validate,
+            }
+            : latest);
+    }
+    async source(manager, producerKey, subjectId) {
+        const row = await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSourceEntity, { producerKey, subjectId, isCurrent: true });
+        return row ? Object.freeze({ ...row }) : null;
+    }
+    async validateRow(manager, record) {
+        const actual = record.kind === 'source'
+            ? await this.source(manager, record.producerKey, record.subjectId)
+            : await manager.findOneBy(climate_automation_entity_1.ClimateAutomationSlotEntity, { controllerId: record.controllerId });
+        if ((0, climate_automation_ledger_utils_1.canonical)(actual ? { ...actual } : null) !== (0, climate_automation_ledger_utils_1.canonical)(record.snapshot.facts))
+            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('stale');
+    }
+    controllerFacts(value) {
+        if (value === null)
+            return null;
+        const { controllerRevision, graphRevision, evidence, legacyBaseline } = value;
+        if (!Number.isSafeInteger(controllerRevision) ||
+            controllerRevision < 1 ||
+            !Number.isSafeInteger(graphRevision) ||
+            graphRevision < 0)
+            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('invalid');
+        return Object.freeze({
+            controllerRevision,
+            graphRevision,
+            evidence: (0, climate_automation_ledger_utils_1.ownedJson)(evidence),
+            legacyBaseline: (0, climate_automation_ledger_utils_1.ownedJson)(legacyBaseline),
+        });
+    }
+    pin(capture, key) {
+        if (!capture)
+            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('unavailable');
+        const receiver = capture.implementation;
+        const method = dataMethod(receiver, key);
+        if (typeof method !== 'function')
+            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('unavailable');
+        return Object.freeze({
+            receiver,
+            method: method,
+            current: () => capture.isCurrent() && dataMethod(receiver, key) === method,
+        });
+    }
+    requirePin(pin) {
+        if (!pin.current())
+            throw new climate_automation_ledger_utils_1.ClimateAutomationLedgerConflict('unavailable');
+    }
+};
+exports.ClimateAutomationLedgerService = ClimateAutomationLedgerService;
+exports.ClimateAutomationLedgerService = ClimateAutomationLedgerService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectDataSource)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        device_structure_lock_service_1.DeviceStructureLockService,
+        climate_automation_registry_service_1.ClimateAutomationRegistryService])
+], ClimateAutomationLedgerService);
+function dataMethod(receiver, key) {
+    for (let item = receiver; item; item = Object.getPrototypeOf(item)) {
+        const descriptor = Object.getOwnPropertyDescriptor(item, key);
+        if (descriptor)
+            return 'value' in descriptor ? descriptor.value : undefined;
+    }
+    return undefined;
+}
+//# sourceMappingURL=climate-automation-ledger.service.js.map