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

package/dist/plugins/devices-virtual/services/virtual-dependency-graph.service.js

@@ -0,0 +1,667 @@
+"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.VirtualDependencyGraphService = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
+const extension_logger_service_1 = require("../../../common/logger/extension-logger.service");
+const config_utils_1 = require("../../../common/utils/config.utils");
+const devices_exceptions_1 = require("../../../modules/devices/devices.exceptions");
+const devices_entity_1 = require("../../../modules/devices/entities/devices.entity");
+const property_read_policy_model_1 = require("../../../modules/devices/models/property-read-policy.model");
+const climate_automation_ledger_service_1 = require("../../../modules/devices/services/climate-automation-ledger.service");
+const creation_capture_1 = require("../../../modules/devices/services/creation-capture");
+const devices_virtual_constants_1 = require("../devices-virtual.constants");
+const devices_virtual_entity_1 = require("../entities/devices-virtual.entity");
+const virtual_dew_point_entity_1 = require("../entities/virtual-dew-point.entity");
+const virtual_producer_entity_1 = require("../entities/virtual-producer.entity");
+const virtual_transform_entity_1 = require("../entities/virtual-transform.entity");
+const virtual_numeric_profile_utils_1 = require("./virtual-numeric-profile.utils");
+function ownGraphView(value) {
+    const owned = (0, creation_capture_1.snapshotCreation)(value), seen = new Set();
+    const freeze = (item) => {
+        if (!item || typeof item !== 'object' || seen.has(item))
+            return;
+        seen.add(item);
+        for (const key of Object.keys(item))
+            freeze(Reflect.get(item, key));
+        Object.freeze(item);
+    };
+    freeze(owned);
+    return owned;
+}
+let VirtualDependencyGraphService = class VirtualDependencyGraphService {
+    observeCompletion(complete) {
+        const record = Object.freeze({ complete });
+        this.completionObservers.add(record);
+        return () => {
+            this.completionObservers.delete(record);
+        };
+    }
+    observeStatePublication(participant) {
+        const registration = { participant, active: true };
+        this.stateParticipants.add(registration);
+        return () => {
+            registration.active = false;
+            this.stateParticipants.delete(registration);
+        };
+    }
+    capturePublication(configuration) {
+        const listeners = [...this.validationListeners.values()];
+        const completions = [...this.completionObservers].map((record) => ({
+            record,
+            pin: (0, creation_capture_1.captureCreation)(record, ['complete']),
+        }));
+        const participants = [...this.stateParticipants].map((record) => ({
+            record,
+            pin: (0, creation_capture_1.captureCreation)(record.participant, ['prepare']),
+        }));
+        const own = (0, creation_capture_1.captureCreation)(this, [
+            'observeStatePublication',
+            'observeValidation',
+            'observeCompletion',
+            'readPublicationSnapshot',
+            'capturePublishGuard',
+            'isValidated',
+            'isRevisionCurrent',
+        ]);
+        let resolve, reject;
+        const view = new Promise((yes, no) => {
+            resolve = yes;
+            reject = no;
+        });
+        void view.catch(() => undefined);
+        const admission = {
+            active: true,
+            resolved: false,
+            listeners,
+            completions,
+            current: () => admission.active &&
+                own.current() &&
+                completions.every(({ record, pin }) => this.completionObservers.has(record) && pin.current()) &&
+                participants.every(({ record, pin }) => record.active && this.stateParticipants.has(record) && pin.current()) &&
+                listeners.every((record) => record.active && this.validationListeners.get(record.listener) === record && record.optionsCurrent()) &&
+                (admission.generation === undefined || admission.generation === this.validationGeneration),
+            tasks: [],
+            resolve: (value) => resolve(value),
+            reject: (cause) => reject(cause),
+        };
+        Object.assign(admission, {
+            tasks: participants.map(({ pin }) => {
+                try {
+                    const input = view.then((value) => ownGraphView(value));
+                    void input.catch(() => undefined);
+                    const task = (0, creation_capture_1.invokeCreation)(pin.values.prepare, pin.receiver, input, {
+                        configuration,
+                        current: () => admission.current(),
+                        ready: () => admission.current() && admission.generation !== undefined && !this.validationPending,
+                    });
+                    const captured = task.then((stage) => (0, creation_capture_1.captureCreation)(stage, ['validate', 'install', 'publish', 'close']));
+                    void captured.catch(() => undefined);
+                    return captured;
+                }
+                catch (cause) {
+                    const task = Promise.resolve().then(() => {
+                        throw cause;
+                    });
+                    void task.catch(() => undefined);
+                    return task;
+                }
+            }),
+        });
+        return admission;
+    }
+    async closePublication(admission) {
+        if (!admission.active)
+            return;
+        admission.active = false;
+        if (!admission.resolved)
+            admission.reject(new Error('Original graph publication closed'));
+        const results = await Promise.allSettled(admission.tasks);
+        for (const result of results)
+            if (result.status === 'fulfilled') {
+                try {
+                    (0, creation_capture_1.invokeCreation)(result.value.values.close, result.value.receiver);
+                }
+                catch {
+                }
+            }
+    }
+    constructor(dataSource, configService = new config_1.ConfigService(), climateLedger) {
+        this.dataSource = dataSource;
+        this.configService = configService;
+        this.climateLedger = climateLedger;
+        this.quarantined = new Set();
+        this.liveValueProperties = new Set();
+        this.knownProperties = new Set();
+        this.valueSources = new Map();
+        this.validationListeners = new Map();
+        this.completionObservers = new Set();
+        this.stateParticipants = new Set();
+        this.quarantineRevision = -1;
+        this.validationPending = true;
+        this.validationGeneration = 0;
+        this.logger = (0, extension_logger_service_1.createExtensionLogger)(devices_virtual_constants_1.DEVICES_VIRTUAL_PLUGIN_NAME, 'VirtualDependencyGraphService');
+    }
+    invalidateValidation() {
+        this.validationGeneration++;
+        this.validationPending = true;
+    }
+    async withStructuralWrite(operation, expectedGraphRevision) {
+        return this.structuralWrite(operation, expectedGraphRevision);
+    }
+    withProducerConfigurationWrite(operation, expectedGraphRevision, handoff) {
+        const original = (0, creation_capture_1.captureCreation)(handoff, ['token', 'admit', 'validate', 'outcome', 'settled']);
+        return this.structuralWrite(async (manager) => {
+            const result = await operation(manager);
+            await original.values.validate.call(original.receiver, manager);
+            if (!original.current())
+                throw new Error('Original producer configuration handoff changed');
+            return result;
+        }, expectedGraphRevision, (manager) => original.values.admit.call(original.receiver, manager), undefined, undefined, false, original.values.token, () => original.values.outcome.call(original.receiver)).finally(() => original.values.settled.call(original.receiver));
+    }
+    withCreationWrite(operation, expectedGraphRevision, admit) {
+        return this.structuralWrite(operation, expectedGraphRevision, admit, undefined, undefined, true);
+    }
+    withControllerMutationWrite(operation, expectedGraphRevision, admit, accepted, deferredOperation, readWindow) {
+        return this.structuralWrite(deferredOperation ?? operation, expectedGraphRevision, admit, accepted, undefined, true, undefined, undefined, deferredOperation !== undefined, readWindow);
+    }
+    withComfortSelectionWrite(operation, expectedGraphRevision, admit, accepted, kind, deferredOperation, readWindow) {
+        const refresh = this.refreshValidation.bind(this);
+        return this.structuralWrite(deferredOperation ?? operation, expectedGraphRevision, (manager) => {
+            admit(manager);
+            if (!((kind === 'registered-settings' || kind === 'release-request') && expectedGraphRevision === undefined) &&
+                (!Number.isSafeInteger(expectedGraphRevision) ||
+                    expectedGraphRevision === undefined ||
+                    expectedGraphRevision < 0))
+                throw new devices_exceptions_1.DevicesValidationException('Invalid virtual dependency graph revision.');
+        }, accepted, (publication) => refresh(false, publication), true, undefined, undefined, deferredOperation !== undefined, readWindow);
+    }
+    async sealControllerLedger(manager) {
+        if (this.climateLedger)
+            await this.climateLedger.sealAdmittedManager(manager);
+    }
+    async structuralWrite(operation, expectedGraphRevision, admit, accepted, settleValidation, borrowClimateLedger = false, configuration, configurationOutcome, deferMutation = false, readWindow) {
+        const publication = this.capturePublication(configuration);
+        let applied = !deferMutation;
+        try {
+            const result = await this.dataSource.transaction(async (manager) => {
+                const receipt = borrowClimateLedger && this.climateLedger ? (0, sqlite_data_source_1.observeSqliteOuterOutcome)(manager) : undefined;
+                admit?.(manager);
+                if (readWindow)
+                    await readWindow.reserveZeroRows('devices_virtual_graph_revision', 'revision');
+                else if (deferMutation)
+                    await manager.query('UPDATE "devices_virtual_graph_revision" SET "revision"="revision" WHERE 0');
+                else
+                    await manager.query('INSERT OR IGNORE INTO "devices_virtual_graph_revision" ("id", "revision") VALUES (1, 0)');
+                readWindow?.beginReads();
+                const current = await manager.findOneBy(virtual_producer_entity_1.VirtualGraphRevisionEntity, { id: 1 });
+                const initialRevision = current?.revision ?? 0;
+                if (expectedGraphRevision !== undefined && initialRevision !== expectedGraphRevision) {
+                    throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph revision changed; reload and retry.');
+                }
+                if (admit &&
+                    (!Number.isSafeInteger(initialRevision) || (!deferMutation && initialRevision >= Number.MAX_SAFE_INTEGER)))
+                    throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph revision overflow.');
+                if (accepted && initialRevision < 0)
+                    throw new devices_exceptions_1.DevicesValidationException('Invalid virtual dependency graph revision.');
+                let advanced = false;
+                const advance = async () => {
+                    if (advanced)
+                        throw new devices_exceptions_1.DevicesValidationException('Graph mutation was already admitted.');
+                    if (!Number.isSafeInteger(initialRevision) || initialRevision >= Number.MAX_SAFE_INTEGER)
+                        throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph revision overflow.');
+                    if (current) {
+                        const update = await manager
+                            .createQueryBuilder()
+                            .update(virtual_producer_entity_1.VirtualGraphRevisionEntity)
+                            .set({ revision: initialRevision + 1 })
+                            .where({ id: 1, revision: initialRevision })
+                            .execute();
+                        if (update.affected !== 1)
+                            throw new devices_exceptions_1.DevicesValidationException('Original graph revision changed.');
+                    }
+                    else
+                        await manager.insert(virtual_producer_entity_1.VirtualGraphRevisionEntity, { id: 1, revision: 1 });
+                    advanced = true;
+                    applied = true;
+                    publication.expectedRevision = initialRevision + 1;
+                    return initialRevision + 1;
+                };
+                if (!deferMutation) {
+                    await manager.increment(virtual_producer_entity_1.VirtualGraphRevisionEntity, { id: 1 }, 'revision', 1);
+                    publication.expectedRevision = initialRevision + 1;
+                }
+                const work = () => operation(manager, deferMutation ? advance : undefined);
+                const value = receipt ? await this.climateLedger.inAdmittedManager(manager, receipt, work) : await work();
+                if (deferMutation && !advanced) {
+                    if (!current)
+                        throw new devices_exceptions_1.DevicesValidationException('Missing unchanged graph identity.');
+                    const final = await manager.findOneByOrFail(virtual_producer_entity_1.VirtualGraphRevisionEntity, { id: 1 });
+                    if (final.revision !== initialRevision)
+                        throw new devices_exceptions_1.DevicesValidationException('Original unchanged graph drifted.');
+                }
+                return value;
+            });
+            accepted?.();
+            if (!applied) {
+                await this.closePublication(publication);
+                return result;
+            }
+            try {
+                if (settleValidation)
+                    await settleValidation(publication);
+                else
+                    await this.refreshValidation(false, publication);
+            }
+            catch (error) {
+                await this.closePublication(publication);
+                this.logger.error('Virtual structural write committed, but graph validation failed; live authority remains unavailable until validation succeeds.', error instanceof Error ? error : new Error('Post-commit graph validation rejected', { cause: error }));
+            }
+            return result;
+        }
+        catch (cause) {
+            const outcome = configurationOutcome?.();
+            if ((outcome === 'committed' || outcome === 'unknown') && !publication.resolved) {
+                this.validationGeneration++;
+                this.validationPending = true;
+                try {
+                    if (outcome === 'committed')
+                        await this.refreshValidation(false, publication, false);
+                    else
+                        await this.closePublication(publication);
+                }
+                catch {
+                    await this.closePublication(publication);
+                }
+            }
+            else
+                await this.closePublication(publication);
+            throw cause;
+        }
+    }
+    isRevisionCurrent(revision) {
+        return !this.validationPending && this.quarantineRevision === revision;
+    }
+    isValidated() {
+        return !this.validationPending && this.quarantineRevision >= 0;
+    }
+    propertyRequiresLiveValue(propertyId) {
+        return this.isValidated() && this.knownProperties.has(propertyId) ? this.liveValueProperties.has(propertyId) : null;
+    }
+    matchesValueSource(property) {
+        const source = this.valueSources.get(property.id);
+        return (this.isValidated() &&
+            !!source &&
+            source.valueOrigin === (property.valueOrigin ?? devices_virtual_entity_1.VirtualValueOrigin.SOURCE) &&
+            source.sourcePropertyId === (property.sourcePropertyId ?? null));
+    }
+    capturePublishGuard() {
+        const generation = this.validationGeneration;
+        return () => this.isValidated() && generation === this.validationGeneration;
+    }
+    captureReadPolicyObservation() {
+        return (0, property_read_policy_model_1.observePropertyReadPolicy)(this, [
+            'validationGeneration',
+            'validationPending',
+            'quarantineRevision',
+            'quarantined',
+            'knownProperties',
+            'liveValueProperties',
+            'valueSources',
+            'isValidated',
+            'isQuarantined',
+            'matchesValueSource',
+            'propertyRequiresLiveValue',
+            'captureReadPolicyObservation',
+        ]);
+    }
+    async revision(manager = this.dataSource.manager) {
+        return (await manager.findOneBy(virtual_producer_entity_1.VirtualGraphRevisionEntity, { id: 1 }))?.revision ?? 0;
+    }
+    async edges(manager) {
+        const projections = await manager
+            .createQueryBuilder(devices_virtual_entity_1.VirtualChannelPropertyEntity, 'property')
+            .select(['property.id', 'property.sourcePropertyId', 'property.valueOrigin'])
+            .where('property.sourcePropertyId IS NOT NULL')
+            .callListeners(false)
+            .getMany();
+        const dewPoints = await manager.find(virtual_dew_point_entity_1.VirtualDewPointSourceEntity, { where: { sourcePropertyId: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) } });
+        const transforms = await manager.find(virtual_transform_entity_1.VirtualTransformSourceEntity, { where: { sourcePropertyId: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) } });
+        const inputs = await manager.find(virtual_producer_entity_1.VirtualAggregateInputEntity, { where: { sourcePropertyId: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) } });
+        const bindings = await manager.find(virtual_producer_entity_1.VirtualLightGroupBindingEntity, { where: { sourcePropertyId: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) } });
+        return [
+            ...dewPoints.map((input) => ({
+                outputPropertyId: input.outputPropertyId,
+                sourcePropertyId: input.sourcePropertyId,
+            })),
+            ...transforms.map((input) => ({
+                outputPropertyId: input.outputPropertyId,
+                sourcePropertyId: input.sourcePropertyId,
+            })),
+            ...projections
+                .filter((property) => property.isProjecting)
+                .map((property) => ({ outputPropertyId: property.id, sourcePropertyId: property.sourcePropertyId })),
+            ...inputs.map((input) => ({
+                outputPropertyId: input.outputPropertyId,
+                sourcePropertyId: input.sourcePropertyId,
+            })),
+            ...bindings.map((binding) => ({
+                outputPropertyId: binding.outputPropertyId,
+                sourcePropertyId: binding.sourcePropertyId,
+            })),
+        ];
+    }
+    async validateReplacement(manager, outputIds, replacements) {
+        const replacing = new Set(outputIds);
+        this.validate([
+            ...(await this.edges(manager)).filter((edge) => !replacing.has(edge.outputPropertyId)),
+            ...replacements,
+        ]);
+    }
+    async validateProperty(manager, property) {
+        if (property.valueOrigin === devices_virtual_entity_1.VirtualValueOrigin.DERIVED) {
+            this.validate(await this.edges(manager));
+            return;
+        }
+        const producerInputs = await manager.count(virtual_producer_entity_1.VirtualAggregateInputEntity, {
+            where: { outputPropertyId: property.id },
+        });
+        const groupBindings = await manager.count(virtual_producer_entity_1.VirtualLightGroupBindingEntity, {
+            where: { outputPropertyId: property.id },
+        });
+        const transformInputs = await manager.count(virtual_transform_entity_1.VirtualTransformSourceEntity, {
+            where: { outputPropertyId: property.id },
+        });
+        const dewPointInputs = await manager.count(virtual_dew_point_entity_1.VirtualDewPointSourceEntity, {
+            where: { outputPropertyId: property.id },
+        });
+        if (producerInputs || groupBindings || transformInputs || dewPointInputs)
+            throw new devices_exceptions_1.DevicesValidationException('A configured producer output must retain derived origin; edit or remove its producer configuration first.');
+        await this.validateReplacement(manager, [property.id], property.isLinked && property.sourcePropertyId
+            ? [{ outputPropertyId: property.id, sourcePropertyId: property.sourcePropertyId }]
+            : []);
+    }
+    validate(edges) {
+        if (edges.length > 8192)
+            throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph exceeds the edge limit.');
+        const graph = new Map();
+        const fanOut = new Map();
+        const nodes = new Set();
+        for (const edge of edges) {
+            nodes.add(edge.outputPropertyId);
+            nodes.add(edge.sourcePropertyId);
+            const inputs = graph.get(edge.outputPropertyId) ?? new Set();
+            inputs.add(edge.sourcePropertyId);
+            graph.set(edge.outputPropertyId, inputs);
+            const outputs = fanOut.get(edge.sourcePropertyId) ?? new Set();
+            outputs.add(edge.outputPropertyId);
+            fanOut.set(edge.sourcePropertyId, outputs);
+            if (outputs.size > 256)
+                throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph exceeds the fan-out limit.');
+        }
+        if (nodes.size > 4096)
+            throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph exceeds the node limit.');
+        const depths = new Map();
+        const visiting = new Set();
+        const depth = (node) => {
+            if (visiting.size > 16)
+                throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph exceeds the depth limit.');
+            if (visiting.has(node))
+                throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph contains a cycle or self-reference.');
+            if (depths.has(node))
+                return depths.get(node);
+            visiting.add(node);
+            let result = 0;
+            for (const input of graph.get(node) ?? []) {
+                result = Math.max(result, depth(input) + 1);
+                if (result > 16)
+                    throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph exceeds the depth limit.');
+            }
+            visiting.delete(node);
+            depths.set(node, result);
+            return result;
+        };
+        for (const node of nodes)
+            depth(node);
+    }
+    isQuarantined(propertyId) {
+        return this.quarantined.has(propertyId);
+    }
+    observeValidation(listener, options = {}) {
+        const original = (0, creation_capture_1.captureCreation)(options, ['requiresActivation']);
+        const previous = this.validationListeners.get(listener);
+        if (previous)
+            previous.active = false;
+        const record = {
+            listener,
+            options,
+            optionsCurrent: original.current,
+            requiresActivation: original.values.requiresActivation === true,
+            active: true,
+        };
+        this.validationListeners.set(listener, record);
+        return () => {
+            record.active = false;
+            if (this.validationListeners.get(listener) === record)
+                this.validationListeners.delete(listener);
+        };
+    }
+    async onApplicationBootstrap() {
+        if ((0, config_utils_1.getEnvValue)(this.configService, 'FB_CLI', null) === 'on')
+            return;
+        await this.refreshQuarantine();
+    }
+    async refreshQuarantine() {
+        await this.refreshValidation(true);
+    }
+    async readProjectionSources(manager) {
+        const sources = manager
+            .createQueryBuilder(devices_virtual_entity_1.VirtualChannelPropertyEntity, 'projection')
+            .select('projection.sourcePropertyId')
+            .where('projection.valueOrigin = :projectionOrigin', { projectionOrigin: devices_virtual_entity_1.VirtualValueOrigin.SOURCE })
+            .andWhere('projection.sourcePropertyId IS NOT NULL');
+        const sourceQuery = sources.getQuery();
+        return manager
+            .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'property')
+            .select(['property.id'])
+            .where(`property.id IN (${sourceQuery})`)
+            .setParameters(sources.getParameters())
+            .callListeners(false)
+            .getMany();
+    }
+    async readPublicationSnapshot() {
+        return this.dataSource.transaction(async (manager) => ({
+            edges: await this.edges(manager),
+            aggregates: await manager.find(virtual_producer_entity_1.VirtualAggregateConfigEntity),
+            transforms: await manager.find(virtual_transform_entity_1.VirtualTransformConfigEntity),
+            groups: await manager.find(virtual_producer_entity_1.VirtualLightGroupConfigEntity),
+            aggregateInputs: await manager.find(virtual_producer_entity_1.VirtualAggregateInputEntity, { order: { id: 'ASC' } }),
+            transformSources: await manager.find(virtual_transform_entity_1.VirtualTransformSourceEntity, { order: { id: 'ASC' } }),
+            groupMembers: await manager.find(virtual_producer_entity_1.VirtualLightGroupMemberEntity, { order: { id: 'ASC' } }),
+            groupBindings: await manager.find(virtual_producer_entity_1.VirtualLightGroupBindingEntity, { order: { id: 'ASC' } }),
+            sourceCatalog: await manager
+                .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'source')
+                .leftJoinAndSelect('source.channel', 'channel')
+                .leftJoinAndSelect('channel.device', 'device')
+                .callListeners(false)
+                .orderBy('source.id', 'ASC')
+                .getMany(),
+            knownProperties: await this.readProjectionSources(manager),
+            properties: await manager
+                .createQueryBuilder(devices_virtual_entity_1.VirtualChannelPropertyEntity, 'property')
+                .leftJoinAndSelect('property.channel', 'channel')
+                .leftJoinAndSelect('channel.device', 'device')
+                .callListeners(false)
+                .getMany(),
+            revision: await this.revision(manager),
+        }));
+    }
+    async refreshValidation(activated, admission = this.capturePublication(), invokeOrdinary = true) {
+        const generation = ++this.validationGeneration;
+        admission.generation = generation;
+        this.validationPending = true;
+        const read = (0, creation_capture_1.captureCreation)(this, ['readPublicationSnapshot']);
+        try {
+            const snapshot = ownGraphView(await read.values.readPublicationSnapshot.call(read.receiver));
+            const snapshotBytes = JSON.stringify(snapshot);
+            const verify = async () => {
+                if (!read.current() || !admission.current())
+                    throw new Error('Original graph publication expired');
+                const latest = await read.values.readPublicationSnapshot.call(read.receiver);
+                if (!read.current() || !admission.current() || JSON.stringify(latest) !== snapshotBytes)
+                    throw new Error('Original durable graph publication changed');
+            };
+            const initialEligibilityFailure = !admission.current() ||
+                (admission.expectedRevision !== undefined && snapshot.revision !== admission.expectedRevision)
+                ? { cause: new Error('Original graph revision changed') }
+                : undefined;
+            if (snapshot.revision < this.quarantineRevision)
+                throw new Error('Graph validation snapshot is older than the applied revision');
+            const quarantined = new Set();
+            const neighbors = new Map();
+            for (const edge of snapshot.edges) {
+                for (const [node, neighbor] of [
+                    [edge.outputPropertyId, edge.sourcePropertyId],
+                    [edge.sourcePropertyId, edge.outputPropertyId],
+                ]) {
+                    const adjacent = neighbors.get(node) ?? new Set();
+                    adjacent.add(neighbor);
+                    neighbors.set(node, adjacent);
+                }
+            }
+            const visited = new Set();
+            for (const root of neighbors.keys()) {
+                if (visited.has(root))
+                    continue;
+                const component = new Set();
+                const queue = [root];
+                for (let index = 0; index < queue.length; index++) {
+                    const node = queue[index];
+                    if (component.has(node))
+                        continue;
+                    component.add(node);
+                    visited.add(node);
+                    queue.push(...(neighbors.get(node) ?? []));
+                }
+                try {
+                    this.validate(snapshot.edges.filter((edge) => component.has(edge.outputPropertyId)));
+                }
+                catch (error) {
+                    if (!(error instanceof devices_exceptions_1.DevicesValidationException))
+                        throw error;
+                    for (const node of component)
+                        quarantined.add(node);
+                }
+            }
+            if (snapshot.edges.length > 8192 || neighbors.size > 4096)
+                for (const node of neighbors.keys())
+                    quarantined.add(node);
+            for (const config of snapshot.aggregates) {
+                const property = snapshot.properties.find((candidate) => candidate.id === config.outputPropertyId);
+                const channel = property?.channel;
+                if (!property ||
+                    !channel?.device ||
+                    !(0, virtual_numeric_profile_utils_1.isEligibleAggregateOutput)(property, channel, channel.device) ||
+                    (0, virtual_numeric_profile_utils_1.aggregateProfile)(property, channel)?.id !== config.profile)
+                    quarantined.add(config.outputPropertyId);
+            }
+            admission.resolved = true;
+            admission.resolve(ownGraphView({ ...snapshot, quarantined: [...quarantined].sort() }));
+            const prepared = await Promise.allSettled(admission.tasks);
+            const rejected = prepared.find((result) => result.status === 'rejected');
+            let eligibilityFailure = initialEligibilityFailure ??
+                (rejected?.status === 'rejected' ? { cause: rejected.reason } : undefined);
+            const stages = prepared.flatMap((result) => (result.status === 'fulfilled' ? [result.value] : []));
+            try {
+                await verify();
+                if (!stages.every((stage) => stage.current() && (0, creation_capture_1.invokeCreation)(stage.values.validate, stage.receiver)))
+                    throw new Error('Original producer state slot changed');
+            }
+            catch (cause) {
+                eligibilityFailure ??= { cause };
+            }
+            if (!eligibilityFailure) {
+                this.quarantined = quarantined;
+                this.knownProperties = new Set(snapshot.knownProperties.map((property) => property.id));
+                this.valueSources = new Map(snapshot.properties.map((property) => [
+                    property.id,
+                    { valueOrigin: property.valueOrigin, sourcePropertyId: property.sourcePropertyId ?? null },
+                ]));
+                this.liveValueProperties = new Set(snapshot.properties.filter((property) => property.requiresLiveValue).map((property) => property.id));
+            }
+            for (const record of admission.listeners)
+                if (invokeOrdinary && !record.requiresActivation)
+                    await Reflect.apply(record.listener, undefined, [snapshot.revision, new Set(quarantined)]);
+            if (eligibilityFailure)
+                throw eligibilityFailure.cause;
+            await verify();
+            for (const stage of stages)
+                if (!stage.current() || !(0, creation_capture_1.invokeCreation)(stage.values.validate, stage.receiver))
+                    throw new Error('Producer state preparation expired');
+            for (const stage of stages)
+                if (!(0, creation_capture_1.invokeCreation)(stage.values.install, stage.receiver))
+                    throw new Error('Producer state installation refused');
+            let publicationFailure;
+            for (const stage of stages) {
+                try {
+                    await (0, creation_capture_1.invokeCreation)(stage.values.publish, stage.receiver);
+                }
+                catch (cause) {
+                    publicationFailure ??= { cause };
+                }
+            }
+            if (publicationFailure)
+                throw publicationFailure.cause;
+            await verify();
+            if (!stages.every((stage) => stage.current() && (0, creation_capture_1.invokeCreation)(stage.values.validate, stage.receiver)))
+                throw new Error('Original producer state publication expired');
+            this.quarantineRevision = snapshot.revision;
+            this.validationPending = false;
+            if (activated) {
+                for (const record of admission.listeners)
+                    if (record.requiresActivation)
+                        await Reflect.apply(record.listener, undefined, [snapshot.revision, new Set(quarantined)]);
+                await verify();
+            }
+            const published = this.capturePublishGuard();
+            const current = () => admission.current() && published() && this.isRevisionCurrent(snapshot.revision);
+            for (const { pin } of invokeOrdinary ? admission.completions : []) {
+                if (!current())
+                    throw new devices_exceptions_1.DevicesValidationException('Original completed graph expired.');
+                await (0, creation_capture_1.invokeCreation)(pin.values.complete, pin.receiver, snapshot.revision, current);
+            }
+            if (invokeOrdinary && admission.completions.length)
+                await verify();
+        }
+        catch (error) {
+            if (generation === this.validationGeneration)
+                this.validationPending = true;
+            await this.closePublication(admission);
+            throw error;
+        }
+    }
+};
+exports.VirtualDependencyGraphService = VirtualDependencyGraphService;
+exports.VirtualDependencyGraphService = VirtualDependencyGraphService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        config_1.ConfigService,
+        climate_automation_ledger_service_1.ClimateAutomationLedgerService])
+], VirtualDependencyGraphService);
+//# sourceMappingURL=virtual-dependency-graph.service.js.map