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

package/dist/plugins/devices-virtual/services/virtual-producer-config.service.js

@@ -0,0 +1,694 @@
+"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.VirtualProducerConfigService = void 0;
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const devices_constants_1 = require("../../../modules/devices/devices.constants");
+const devices_exceptions_1 = require("../../../modules/devices/devices.exceptions");
+const devices_entity_1 = require("../../../modules/devices/entities/devices.entity");
+const creation_capture_1 = require("../../../modules/devices/services/creation-capture");
+const device_structure_lock_service_1 = require("../../../modules/devices/services/device-structure-lock.service");
+const platform_registry_service_1 = require("../../../modules/devices/services/platform.registry.service");
+const property_metadata_utils_1 = require("../../../modules/devices/utils/property-metadata.utils");
+const devices_virtual_entity_1 = require("../entities/devices-virtual.entity");
+const virtual_producer_entity_1 = require("../entities/virtual-producer.entity");
+const producer_response_model_1 = require("../models/producer-response.model");
+const virtual_aggregate_evaluator_1 = require("./virtual-aggregate-evaluator");
+const virtual_aggregate_policy_utils_1 = require("./virtual-aggregate-policy.utils");
+const virtual_aggregate_runtime_service_1 = require("./virtual-aggregate-runtime.service");
+const virtual_cover_contract_utils_1 = require("./virtual-cover-contract.utils");
+const virtual_cover_readiness_utils_1 = require("./virtual-cover-readiness.utils");
+const virtual_dependency_graph_service_1 = require("./virtual-dependency-graph.service");
+const virtual_group_contract_utils_1 = require("./virtual-group-contract.utils");
+const virtual_group_profile_1 = require("./virtual-group-profile");
+const virtual_light_group_state_service_1 = require("./virtual-light-group-state.service");
+const virtual_measurement_metadata_utils_1 = require("./virtual-measurement-metadata.utils");
+const virtual_numeric_profile_utils_1 = require("./virtual-numeric-profile.utils");
+const virtual_producer_state_service_1 = require("./virtual-producer-state.service");
+const virtual_typed_group_utils_1 = require("./virtual-typed-group.utils");
+let VirtualProducerConfigService = class VirtualProducerConfigService {
+    constructor(dataSource, structureLock, graph, eventEmitter, producerState, lightGroups, aggregateRuntime, platforms) {
+        this.dataSource = dataSource;
+        this.structureLock = structureLock;
+        this.graph = graph;
+        this.eventEmitter = eventEmitter;
+        this.producerState = producerState;
+        this.lightGroups = lightGroups;
+        this.aggregateRuntime = aggregateRuntime;
+        this.platforms = platforms;
+    }
+    listAggregateProfiles() {
+        return virtual_numeric_profile_utils_1.aggregateProfiles.map((profile) => Object.assign(new producer_response_model_1.VirtualAggregateProfileModel(), {
+            profile: profile.id,
+            channel: profile.channel,
+            quantity: profile.quantity,
+            unit: profile.unit,
+            data_types: [...profile.dataTypes],
+            operators: Object.values(virtual_producer_entity_1.VirtualAggregateOperator).filter((operator) => (0, virtual_numeric_profile_utils_1.aggregateOperatorAllowed)(profile, operator)),
+            numeric_policy: !profile.binary,
+            output_step: profile.outputStep,
+        }));
+    }
+    async listAggregateSources(profileId) {
+        const profile = virtual_numeric_profile_utils_1.aggregateProfiles.find((candidate) => candidate.id === profileId);
+        if (!profile)
+            return [];
+        const properties = await this.dataSource.manager
+            .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'property')
+            .leftJoinAndSelect('property.channel', 'channel')
+            .leftJoinAndSelect('channel.device', 'device')
+            .where('channel.category = :channelCategory', { channelCategory: profile.channel })
+            .andWhere('property.category = :quantity', { quantity: profile.quantity })
+            .callListeners(false)
+            .getMany();
+        for (const property of properties)
+            await (0, virtual_measurement_metadata_utils_1.hydrateMeasurementContract)(this.dataSource.manager, property);
+        return properties
+            .filter((property) => {
+            const channel = property.channel;
+            return (!this.graph.isQuarantined(property.id) &&
+                (0, virtual_numeric_profile_utils_1.aggregateProfile)(property, channel)?.id === profileId &&
+                (0, virtual_numeric_profile_utils_1.isEligibleAggregateSource)(property, channel, channel.device));
+        })
+            .map((property) => Object.assign(new producer_response_model_1.VirtualAggregateSourceModel(), {
+            property: property.id,
+            channel: property.channel.id,
+            device: property.channel.device.id,
+        }));
+    }
+    async configureAggregate(outputPropertyId, dto) {
+        const state = (0, creation_capture_1.captureCreation)(this.producerState, [
+            'captureConfigurationHandoff',
+            'withConfigurationWrite',
+            'recordConfiguration',
+            'installUnavailable',
+        ]);
+        const handoff = state.values.captureConfigurationHandoff.call(state.receiver);
+        return this.structureLock.runExclusive(async () => {
+            let committedOutput;
+            let committedRevision;
+            await state.values.withConfigurationWrite.call(state.receiver, handoff, async (manager) => {
+                const { config, inputs, output } = await this.prepareAggregate(manager, outputPropertyId, dto);
+                await state.values.recordConfiguration.call(state.receiver, manager, handoff, {
+                    kind: 'aggregate',
+                    config,
+                    inputs,
+                    outputs: [output],
+                });
+                await this.persistAggregate(manager, { config, inputs });
+                committedOutput = output;
+                committedRevision = config.revision;
+            }, dto.expectedGraphRevision, this.structureLock.captureExclusiveOwner());
+            state.values.installUnavailable.call(state.receiver, committedOutput, committedRevision);
+            await this.announceOutputs([outputPropertyId]);
+            return this.getAggregate(outputPropertyId);
+        });
+    }
+    async persistAggregate(manager, prepared) {
+        await manager.save(prepared.config);
+        await manager.delete(virtual_producer_entity_1.VirtualAggregateInputEntity, { outputPropertyId: prepared.config.outputPropertyId });
+        await manager.save(prepared.inputs);
+    }
+    describeAggregate(prepared, graphRevision) {
+        return this.aggregateModel(prepared.config, prepared.inputs, graphRevision, prepared.output?.step, false);
+    }
+    async previewPreparedAggregate(prepared, graphRevision, graphCurrent) {
+        const { config, inputs, output } = prepared;
+        const readEvidence = await this.aggregateRuntime?.snapshotEvidence(config, inputs, output);
+        const saved = await this.dataSource.manager.findOneBy(virtual_producer_entity_1.VirtualAggregateConfigEntity, {
+            outputPropertyId: output.id,
+        });
+        const revision = await this.graph.revision();
+        const now = new Date();
+        const profile = (0, virtual_numeric_profile_utils_1.aggregateProfile)(output, output.channel);
+        const step = output.step ?? profile.outputStep;
+        const evidence = readEvidence?.(now) ??
+            inputs.map((input) => ({
+                id: input.id,
+                sourceIdentity: input.sourcePropertyIdentity,
+                sample: null,
+                weight: input.weight,
+            }));
+        let result = (0, virtual_aggregate_evaluator_1.evaluateAggregate)(config.operator, config.minimumValidInputs, config.maximumAgeSeconds, evidence, now, step, config.outlierFilter);
+        const revoked = !graphCurrent() || revision !== graphRevision || (saved?.revision ?? 0) !== config.revision - 1;
+        const reason = revoked
+            ? 'preview_revoked'
+            : !readEvidence
+                ? 'runtime_unavailable'
+                : output.channel.device &&
+                    output.channel.device.enabled === false
+                    ? 'output_disabled'
+                    : null;
+        if (reason)
+            result = {
+                ...result,
+                value: null,
+                quality: 'unavailable',
+                reasons: [reason],
+                sampledAt: null,
+                expiresAt: null,
+                inputs: result.inputs.map((input) => ({
+                    ...input,
+                    value: null,
+                    sampledAt: null,
+                    ageSeconds: null,
+                    exclusion: 'invalid',
+                })),
+            };
+        const model = this.describeAggregate(prepared, graphRevision);
+        model.preview_result = Object.assign(new producer_response_model_1.VirtualAggregatePreviewModel(), {
+            evaluated_at: now.toISOString(),
+            sampled_at: result.sampledAt?.toISOString() ?? null,
+            expires_at: result.expiresAt?.toISOString() ?? null,
+            profile: config.profile,
+            unit: profile.unit,
+            output_step: step ?? null,
+            value: result.value,
+            quality: result.quality,
+            reasons: [...result.reasons],
+            inputs: inputs.map((input) => {
+                const diagnostic = result.inputs.find((candidate) => candidate.id === input.id);
+                return Object.assign(this.bindingModel(input), {
+                    ...(!profile.binary ? { weight: input.weight ?? 1 } : {}),
+                    current_value: diagnostic.value,
+                    sampled_at: diagnostic.sampledAt,
+                    age_seconds: diagnostic.ageSeconds,
+                    exclusion: diagnostic.exclusion,
+                });
+            }),
+        });
+        return model;
+    }
+    async previewAggregate(outputPropertyId, dto) {
+        return this.structureLock.runExclusive(async () => {
+            const graphCurrent = this.graph.capturePublishGuard();
+            const revision = await this.graph.revision();
+            if (dto.expectedGraphRevision !== undefined && dto.expectedGraphRevision !== revision)
+                throw new devices_exceptions_1.DevicesValidationException('Virtual dependency graph revision changed; reload and retry.');
+            const prepared = await this.prepareAggregate(this.dataSource.manager, outputPropertyId, dto, undefined, true);
+            return this.previewPreparedAggregate(prepared, revision, graphCurrent);
+        });
+    }
+    async getAggregate(outputPropertyId) {
+        const config = await this.dataSource.manager.findOneBy(virtual_producer_entity_1.VirtualAggregateConfigEntity, { outputPropertyId });
+        if (!config)
+            throw new common_1.NotFoundException('Aggregate configuration does not exist.');
+        const inputs = await this.dataSource.manager.find(virtual_producer_entity_1.VirtualAggregateInputEntity, {
+            where: { outputPropertyId },
+            order: { id: 'ASC' },
+        });
+        const output = await this.property(this.dataSource.manager, outputPropertyId, true);
+        return this.aggregateModel(config, inputs, await this.graph.revision(), output.step);
+    }
+    async prepareAggregate(manager, outputPropertyId, dto, draftOutput, previewOnly = false) {
+        this.assertPolicy(dto);
+        const output = draftOutput ?? (await this.property(manager, outputPropertyId, previewOnly));
+        const channel = output.channel;
+        const device = channel.device;
+        if (!(0, virtual_numeric_profile_utils_1.isEligibleAggregateOutput)(output, channel, device))
+            throw new devices_exceptions_1.DevicesValidationException('Aggregate output must be a read-only derived sensor with a supported canonical aggregate profile.');
+        const profile = (0, virtual_numeric_profile_utils_1.aggregateProfile)(output, channel);
+        if (!(0, virtual_numeric_profile_utils_1.aggregateOperatorAllowed)(profile, dto.operator) ||
+            (profile.binary && (dto.outlierFilter != null || dto.inputs.some((input) => input.weight !== undefined))))
+            throw new devices_exceptions_1.DevicesValidationException('Aggregate profile does not support this operator, binary weights or filtering.');
+        const existing = await manager.findOneBy(virtual_producer_entity_1.VirtualAggregateConfigEntity, { outputPropertyId });
+        this.assertRevision(existing?.revision ?? 0, dto.expectedRevision);
+        const previous = await manager.find(virtual_producer_entity_1.VirtualAggregateInputEntity, { where: { outputPropertyId } });
+        const inputs = [];
+        const identities = new Set();
+        for (const proposed of dto.inputs) {
+            const old = proposed.id
+                ? previous.find((input) => input.id === proposed.id)
+                : previous.find((input) => input.sourcePropertyIdentity === proposed.sourcePropertyId);
+            if (proposed.id && !old)
+                throw new devices_exceptions_1.DevicesValidationException('Aggregate binding UUID is not owned by this output.');
+            if (!proposed.sourcePropertyId) {
+                if (!old ||
+                    old.sourcePropertyId !== null ||
+                    old.quantity !== String(profile.quantity) ||
+                    old.unit !== profile.unit ||
+                    existing?.profile !== profile.id)
+                    throw new devices_exceptions_1.DevicesValidationException('Only an existing missing input can retain a null source.');
+                inputs.push(manager.create(virtual_producer_entity_1.VirtualAggregateInputEntity, { ...old, weight: proposed.weight ?? 1 }));
+            }
+            else {
+                const source = await this.property(manager, proposed.sourcePropertyId, previewOnly);
+                const sourceChannel = source.channel;
+                const sourceDevice = sourceChannel.device;
+                if (!(0, virtual_numeric_profile_utils_1.isEligibleAggregateSource)(source, sourceChannel, sourceDevice) ||
+                    (0, virtual_numeric_profile_utils_1.aggregateProfile)(source, sourceChannel)?.id !== profile.id)
+                    throw new devices_exceptions_1.DevicesValidationException(sourceDevice.type === 'virtual'
+                        ? 'Aggregate inputs require matching physical profiles or read-only canonical transformed temperatures (temperature composition only).'
+                        : 'Aggregate input must match the output canonical quantity, channel, unit and type.');
+                inputs.push(manager.create(virtual_producer_entity_1.VirtualAggregateInputEntity, {
+                    id: old?.id ?? (0, uuid_1.v4)(),
+                    weight: proposed.weight ?? 1,
+                    outputPropertyId,
+                    sourcePropertyId: source.id,
+                    sourcePropertyIdentity: source.id,
+                    quantity: source.category,
+                    unit: (0, property_metadata_utils_1.resolvePropertyUnit)(source) ?? null,
+                }));
+            }
+            const identity = inputs[inputs.length - 1].sourcePropertyIdentity;
+            if (identities.has(identity))
+                throw new devices_exceptions_1.DevicesValidationException('Aggregate inputs must have distinct source identities.');
+            identities.add(identity);
+        }
+        if (new Set(inputs.map((input) => input.id)).size !== inputs.length)
+            throw new devices_exceptions_1.DevicesValidationException('Aggregate binding UUIDs must be distinct.');
+        await this.graph.validateReplacement(manager, [outputPropertyId], inputs
+            .filter((input) => input.sourcePropertyId)
+            .map((input) => ({ outputPropertyId, sourcePropertyId: input.sourcePropertyId })));
+        const config = manager.create(virtual_producer_entity_1.VirtualAggregateConfigEntity, {
+            outputPropertyId,
+            schemaVersion: 1,
+            profile: profile.id,
+            operator: dto.operator,
+            outlierFilter: dto.outlierFilter ?? null,
+            minimumValidInputs: dto.minimumValidInputs,
+            maximumAgeSeconds: dto.maximumAgeSeconds,
+            revision: (existing?.revision ?? 0) + 1,
+        });
+        return { config, inputs, output: output };
+    }
+    async configureLightGroup(groupChannelId, dto) {
+        const state = (0, creation_capture_1.captureCreation)(this.producerState, [
+            'captureConfigurationHandoff',
+            'withConfigurationWrite',
+            'recordConfiguration',
+            'installUnavailable',
+        ]);
+        const handoff = state.values.captureConfigurationHandoff.call(state.receiver);
+        return this.structureLock.runExclusive(async () => {
+            let outputs = [];
+            let committedProperties = [];
+            let committedRevision = 0;
+            await state.values.withConfigurationWrite.call(state.receiver, handoff, async (manager) => {
+                const prepared = await this.prepareLightGroup(manager, groupChannelId, dto);
+                await state.values.recordConfiguration.call(state.receiver, manager, handoff, {
+                    kind: 'light-group',
+                    config: prepared.config,
+                    members: prepared.members,
+                    bindings: prepared.bindings,
+                    outputs: prepared.outputs,
+                });
+                await this.persistLightGroup(manager, prepared);
+                outputs = [...new Set(prepared.bindings.map((binding) => binding.outputPropertyId))];
+                committedProperties = prepared.outputs;
+                committedRevision = prepared.config.revision;
+            }, dto.expectedGraphRevision, this.structureLock.captureExclusiveOwner());
+            for (const property of committedProperties)
+                state.values.installUnavailable.call(state.receiver, property, committedRevision);
+            await this.announceOutputs(outputs);
+            return this.getLightGroup(groupChannelId);
+        });
+    }
+    async persistLightGroup(manager, prepared) {
+        await manager.save(prepared.config);
+        await manager.delete(virtual_producer_entity_1.VirtualLightGroupMemberEntity, { groupChannelId: prepared.config.groupChannelId });
+        await manager.save(prepared.members);
+        await manager.save(prepared.bindings);
+    }
+    installLightGroup(prepared) {
+        for (const property of prepared.outputs)
+            this.producerState.installUnavailable(property, prepared.config.revision);
+    }
+    async previewLightGroup(groupChannelId, dto) {
+        return this.structureLock.runExclusive(async () => {
+            const prepared = await this.prepareLightGroup(this.dataSource.manager, groupChannelId, dto);
+            return this.groupModel(prepared.config, prepared.members, prepared.bindings, await this.graph.revision(), prepared.capabilities);
+        });
+    }
+    async getLightGroup(groupChannelId) {
+        const config = await this.dataSource.manager.findOneBy(virtual_producer_entity_1.VirtualLightGroupConfigEntity, { groupChannelId });
+        if (!config)
+            throw new common_1.NotFoundException('Light group configuration does not exist.');
+        const members = await this.dataSource.manager.find(virtual_producer_entity_1.VirtualLightGroupMemberEntity, {
+            where: { groupChannelId },
+            order: { id: 'ASC' },
+        });
+        const bindings = (await this.dataSource.manager.find(virtual_producer_entity_1.VirtualLightGroupBindingEntity)).filter((binding) => members.some((member) => member.id === binding.memberId));
+        const outputs = await this.dataSource.manager.find(devices_virtual_entity_1.VirtualChannelPropertyEntity, {
+            where: { channel: { id: groupChannelId } },
+            relations: ['channel'],
+        });
+        const capabilities = await this.commonContract(this.dataSource.manager, members, bindings, outputs, config.profile);
+        const model = this.groupModel(config, members, bindings, await this.graph.revision(), capabilities);
+        if (config.profile === virtual_producer_entity_1.VirtualLightGroupProfile.COVER) {
+            const readinessMembers = await Promise.all(members.map(async (member) => {
+                const channel = member.sourceChannelId
+                    ? await this.dataSource.manager.findOne(devices_entity_1.ChannelEntity, {
+                        where: { id: member.sourceChannelId },
+                        relations: ['device', 'properties'],
+                    })
+                    : null;
+                const contract = await (0, virtual_cover_contract_utils_1.loadCoverMemberContract)(this.dataSource.manager, member.id, member.sourceChannelId, outputs);
+                return { identity: member.sourceChannelIdentity, channel, reasons: contract.reasons };
+            }));
+            model.operations = await (0, virtual_cover_readiness_utils_1.coverOperationReadiness)(this.platforms, readinessMembers);
+        }
+        return model;
+    }
+    async prepareLightGroup(manager, groupChannelId, dto) {
+        if (!Object.hasOwn(virtual_group_profile_1.GROUP_PROFILES, dto.profile) ||
+            !Array.isArray(dto.members) ||
+            dto.members.length < 2 ||
+            dto.members.length > 256)
+            throw new devices_exceptions_1.DevicesValidationException('A group requires a supported profile and 2–256 members.');
+        const group = await manager
+            .createQueryBuilder(devices_entity_1.ChannelEntity, 'channel')
+            .leftJoinAndSelect('channel.device', 'device')
+            .where('channel.id = :id', { id: groupChannelId })
+            .callListeners(false)
+            .getOne();
+        const device = group?.device;
+        if (!group ||
+            device?.type !== 'virtual' ||
+            device.mode !== devices_virtual_entity_1.VirtualDeviceMode.ACTUATOR_GROUP ||
+            device.category !== virtual_group_profile_1.GROUP_PROFILES[dto.profile].deviceCategory ||
+            group.category !== virtual_group_profile_1.GROUP_PROFILES[dto.profile].channelCategory)
+            throw new devices_exceptions_1.DevicesValidationException('Group configuration requires an actuator-group device/channel matching its profile.');
+        const existing = await manager.findOneBy(virtual_producer_entity_1.VirtualLightGroupConfigEntity, { groupChannelId });
+        this.assertRevision(existing?.revision ?? 0, dto.expectedRevision);
+        if (existing && existing.profile !== dto.profile)
+            throw new common_1.ConflictException('An existing group profile cannot be changed');
+        const previousMembers = await manager.find(virtual_producer_entity_1.VirtualLightGroupMemberEntity, { where: { groupChannelId } });
+        const previousBindings = (await manager.find(virtual_producer_entity_1.VirtualLightGroupBindingEntity)).filter((binding) => previousMembers.some((member) => member.id === binding.memberId));
+        const outputs = await manager
+            .createQueryBuilder(devices_virtual_entity_1.VirtualChannelPropertyEntity, 'property')
+            .leftJoinAndSelect('property.channel', 'channel')
+            .leftJoinAndSelect('channel.device', 'device')
+            .where('channel.id = :id', { id: groupChannelId })
+            .callListeners(false)
+            .getMany();
+        if (!(0, virtual_group_profile_1.requiredGroupFields)(dto.profile).every((category) => outputs.some((property) => property.category === category && property.valueOrigin === devices_virtual_entity_1.VirtualValueOrigin.DERIVED)))
+            throw new devices_exceptions_1.DevicesValidationException('Group requires all derived profile outputs.');
+        const exposed = outputs.filter((property) => property.valueOrigin === devices_virtual_entity_1.VirtualValueOrigin.DERIVED);
+        if (exposed.some((property) => !(0, virtual_group_profile_1.groupBooleanContractIsSupported)(dto.profile, property)))
+            throw new devices_exceptions_1.DevicesValidationException('Switch/outlet outputs require an unrestricted two-state boolean contract.');
+        if (exposed.some((property) => !property.permissions.includes(devices_constants_1.PermissionType.READ_ONLY) ||
+            property.permissions.includes(devices_constants_1.PermissionType.READ_WRITE) ||
+            property.permissions.includes(devices_constants_1.PermissionType.WRITE_ONLY) ||
+            property.sourcePropertyId))
+            throw new devices_exceptions_1.DevicesValidationException('Initial light-group materialized outputs must be read-only and have no projection source.');
+        const members = [];
+        const bindings = [];
+        for (const proposed of dto.members) {
+            const old = proposed.id
+                ? previousMembers.find((member) => member.id === proposed.id)
+                : previousMembers.find((member) => member.sourceChannelIdentity === proposed.sourceChannelId);
+            if (proposed.id && !old)
+                throw new devices_exceptions_1.DevicesValidationException('Member UUID is not owned by this light group.');
+            const sourceChannel = proposed.sourceChannelId
+                ? await manager
+                    .createQueryBuilder(devices_entity_1.ChannelEntity, 'channel')
+                    .leftJoinAndSelect('channel.device', 'device')
+                    .where('channel.id = :id', { id: proposed.sourceChannelId })
+                    .callListeners(false)
+                    .getOne()
+                : null;
+            if (proposed.sourceChannelId &&
+                (!sourceChannel ||
+                    sourceChannel.device?.type === 'virtual' ||
+                    sourceChannel.category !== virtual_group_profile_1.GROUP_PROFILES[dto.profile].channelCategory ||
+                    (dto.profile !== virtual_producer_entity_1.VirtualLightGroupProfile.LIGHT &&
+                        sourceChannel.device?.category !== virtual_group_profile_1.GROUP_PROFILES[dto.profile].deviceCategory)))
+                throw new devices_exceptions_1.DevicesValidationException('Group members must be homogeneous physical channels matching the profile.');
+            if (!proposed.sourceChannelId && (!old || old.sourceChannelId !== null))
+                throw new devices_exceptions_1.DevicesValidationException('Only an existing missing member can retain a null channel.');
+            const member = manager.create(virtual_producer_entity_1.VirtualLightGroupMemberEntity, {
+                id: old?.id ?? (0, uuid_1.v4)(),
+                groupChannelId,
+                sourceChannelId: sourceChannel?.id ?? null,
+                sourceChannelIdentity: sourceChannel?.id ?? old.sourceChannelIdentity,
+            });
+            members.push(member);
+            if (!Array.isArray(proposed.bindings) ||
+                proposed.bindings.length !== exposed.length ||
+                new Set(proposed.bindings.map((binding) => binding.outputPropertyId)).size !== exposed.length)
+                throw new devices_exceptions_1.DevicesValidationException('Every member must bind each exposed group property exactly once.');
+            for (const proposedBinding of proposed.bindings) {
+                const output = exposed.find((property) => property.id === proposedBinding.outputPropertyId);
+                if (!output)
+                    throw new devices_exceptions_1.DevicesValidationException('Binding output does not belong to this group channel.');
+                const oldBinding = proposedBinding.id
+                    ? previousBindings.find((binding) => binding.id === proposedBinding.id &&
+                        binding.memberId === member.id &&
+                        binding.outputPropertyId === output.id)
+                    : previousBindings.find((binding) => binding.memberId === member.id && binding.outputPropertyId === output.id);
+                if (proposedBinding.id && !oldBinding)
+                    throw new devices_exceptions_1.DevicesValidationException('Binding UUID is not owned by this member/output.');
+                if (!proposedBinding.sourcePropertyId) {
+                    if (!oldBinding || oldBinding.sourcePropertyId !== null)
+                        throw new devices_exceptions_1.DevicesValidationException('Only an existing missing binding can retain a null source.');
+                    bindings.push(oldBinding);
+                    continue;
+                }
+                const source = await this.property(manager, proposedBinding.sourcePropertyId, true);
+                if (!sourceChannel ||
+                    source.channel.id !== sourceChannel.id ||
+                    source.category !== output.category ||
+                    source.dataType !== output.dataType ||
+                    (0, property_metadata_utils_1.resolvePropertyUnit)(source) !== (0, property_metadata_utils_1.resolvePropertyUnit)(output) ||
+                    !(0, virtual_group_profile_1.groupSourceSupports)(source, (0, virtual_group_profile_1.groupField)(dto.profile, output.category)) ||
+                    !(0, virtual_group_profile_1.groupBooleanContractIsSupported)(dto.profile, source) ||
+                    !(0, virtual_typed_group_utils_1.typedGroupSourceMatchesOutput)(dto.profile, (0, virtual_group_profile_1.groupField)(dto.profile, output.category), source, output)) {
+                    if (existing && output.category !== devices_constants_1.PropertyCategory.ON)
+                        throw new common_1.ConflictException(`Membership edit would remove capability ${output.category}; repair its scene/tile references and exposed contract explicitly.`);
+                    throw new devices_exceptions_1.DevicesValidationException('Member property must belong to its physical channel and match output quantity/type/unit with the profile-required access.');
+                }
+                bindings.push(manager.create(virtual_producer_entity_1.VirtualLightGroupBindingEntity, {
+                    id: oldBinding?.id ?? (0, uuid_1.v4)(),
+                    memberId: member.id,
+                    outputPropertyId: output.id,
+                    sourcePropertyId: source.id,
+                    sourcePropertyIdentity: source.id,
+                    quantity: source.category,
+                    unit: (0, property_metadata_utils_1.resolvePropertyUnit)(source) ?? null,
+                }));
+            }
+        }
+        if (new Set(members.map((member) => member.sourceChannelIdentity)).size !== members.length ||
+            new Set(members.map((member) => member.id)).size !== members.length ||
+            new Set(bindings.map((binding) => binding.id)).size !== bindings.length)
+            throw new devices_exceptions_1.DevicesValidationException('Member identities and binding UUIDs must be distinct.');
+        if (dto.profile === virtual_producer_entity_1.VirtualLightGroupProfile.COVER) {
+            for (const member of members) {
+                const memberBindings = bindings.filter((binding) => binding.memberId === member.id);
+                if (memberBindings.some((binding) => !binding.sourcePropertyId))
+                    continue;
+                const properties = await Promise.all(memberBindings.map((binding) => this.property(manager, binding.sourcePropertyId, true)));
+                const reasons = (0, virtual_cover_contract_utils_1.coverContractReasons)(properties, exposed);
+                if (reasons.length)
+                    throw new devices_exceptions_1.DevicesValidationException(reasons.join(', '));
+            }
+        }
+        const capabilities = await this.commonContract(manager, members, bindings, exposed, dto.profile);
+        for (const output of exposed) {
+            const liveSources = bindings.filter((binding) => binding.outputPropertyId === output.id && binding.sourcePropertyId);
+            if (liveSources.length !== members.length)
+                continue;
+            const common = capabilities.find((capability) => capability.category === output.category);
+            const change = (0, virtual_group_contract_utils_1.groupCapabilityChange)(dto.profile, common, output);
+            if (change === 'changed')
+                throw new common_1.ConflictException(`Membership edit would change capability ${output.category}; preserve the exact exposed contract.`);
+            if (change === 'removed') {
+                if (existing)
+                    throw new common_1.ConflictException(`Membership edit would remove capability ${output.category}; repair its scene/tile references and exposed contract explicitly.`);
+                throw new devices_exceptions_1.DevicesValidationException(`Exposed capability ${output.category} is not common to all members.`);
+            }
+        }
+        await this.graph.validateReplacement(manager, exposed.map((property) => property.id), bindings
+            .filter((binding) => binding.sourcePropertyId)
+            .map((binding) => ({
+            outputPropertyId: binding.outputPropertyId,
+            sourcePropertyId: binding.sourcePropertyId,
+        })));
+        return {
+            config: manager.create(virtual_producer_entity_1.VirtualLightGroupConfigEntity, {
+                groupChannelId,
+                schemaVersion: 1,
+                profile: dto.profile,
+                revision: (existing?.revision ?? 0) + 1,
+            }),
+            members,
+            bindings,
+            outputs: exposed,
+            capabilities,
+        };
+    }
+    async commonContract(manager, members, bindings, outputs, profile) {
+        return (0, virtual_group_profile_1.commonGroupCapabilities)(profile, await Promise.all(members.map(async (member) => {
+            const physical = member.sourceChannelId
+                ? await manager
+                    .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'property')
+                    .leftJoinAndSelect('property.channel', 'channel')
+                    .where('channel.id = :id', { id: member.sourceChannelId })
+                    .callListeners(false)
+                    .getMany()
+                : [];
+            const missing = bindings.filter((binding) => binding.memberId === member.id && !binding.sourcePropertyId);
+            for (const binding of missing) {
+                const output = outputs.find((output) => output.id === binding.outputPropertyId);
+                if (output)
+                    physical.push(Object.assign(new devices_entity_1.ChannelPropertyEntity(), output, { permissions: [devices_constants_1.PermissionType.READ_WRITE] }));
+            }
+            return physical;
+        })));
+    }
+    async property(manager, id, previewOnly = false) {
+        const property = previewOnly
+            ? await manager
+                .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'property')
+                .leftJoinAndSelect('property.channel', 'channel')
+                .leftJoinAndSelect('channel.device', 'device')
+                .where('property.id = :id', { id })
+                .callListeners(false)
+                .getOne()
+            : await manager.findOne(devices_entity_1.ChannelPropertyEntity, {
+                where: { id },
+                relations: ['channel', 'channel.device'],
+            });
+        if (!property || !property.channel || !property.channel.device)
+            throw new devices_exceptions_1.DevicesValidationException(`Source/output property id=${id} does not resolve to a complete device structure.`);
+        if (previewOnly)
+            await (0, virtual_measurement_metadata_utils_1.hydrateMeasurementContract)(manager, property);
+        return property;
+    }
+    assertPolicy(dto) {
+        if (!(0, virtual_aggregate_policy_utils_1.isValidAggregateFilter)(dto.outlierFilter))
+            throw new devices_exceptions_1.DevicesValidationException('Aggregate outlier filter requires a supported kind and a positive finite canonical-unit threshold.');
+        if (Array.isArray(dto.inputs) &&
+            dto.inputs.some((input) => !(0, virtual_aggregate_policy_utils_1.isValidAggregateWeight)(input.weight === undefined ? 1 : input.weight)))
+            throw new devices_exceptions_1.DevicesValidationException('Aggregate input weight must be finite and between 0.000001 and 1000000 (inclusive).');
+        if (!Object.values(virtual_producer_entity_1.VirtualAggregateOperator).includes(dto.operator) ||
+            !Array.isArray(dto.inputs) ||
+            dto.inputs.length < 2 ||
+            dto.inputs.length > 256 ||
+            !Number.isInteger(dto.minimumValidInputs) ||
+            dto.minimumValidInputs < 1 ||
+            dto.minimumValidInputs > dto.inputs.length ||
+            !Number.isInteger(dto.maximumAgeSeconds) ||
+            dto.maximumAgeSeconds < 1 ||
+            dto.maximumAgeSeconds > 86400)
+            throw new devices_exceptions_1.DevicesValidationException('Aggregate requires 2–256 inputs, a supported operator, valid quorum and positive bounded maximum age.');
+    }
+    assertRevision(actual, expected) {
+        if (!Number.isInteger(expected) || actual !== expected)
+            throw new devices_exceptions_1.DevicesValidationException('Producer configuration revision changed; reload and retry.');
+    }
+    bindingModel(binding) {
+        return Object.assign(new producer_response_model_1.VirtualProducerBindingModel(), {
+            id: binding.id,
+            output_property: binding.outputPropertyId,
+            source_property: binding.sourcePropertyId,
+            source_identity: binding.sourcePropertyIdentity,
+            quantity: binding.quantity,
+            unit: binding.unit,
+        });
+    }
+    aggregateModel(config, inputs, graphRevision, outputStep, includeRuntimeDiagnostics = true) {
+        return Object.assign(new producer_response_model_1.VirtualAggregateConfigurationModel(), {
+            output_property: config.outputPropertyId,
+            schema_version: config.schemaVersion,
+            profile: config.profile,
+            output_step: outputStep ?? virtual_numeric_profile_utils_1.aggregateProfiles.find((profile) => profile.id === config.profile)?.outputStep ?? null,
+            rounding: 'nearest_ties_positive',
+            operator: config.operator,
+            outlier_filter: config.outlierFilter ?? null,
+            minimum_valid_inputs: config.minimumValidInputs,
+            maximum_age_seconds: config.maximumAgeSeconds,
+            revision: config.revision,
+            graph_revision: graphRevision,
+            runtime_readiness: this.aggregateRuntime?.isActive() ? 'ready' : 'unavailable',
+            inputs: inputs.map((input) => {
+                const model = this.bindingModel(input);
+                if (!virtual_numeric_profile_utils_1.aggregateProfiles.find((profile) => profile.id === config.profile)?.binary)
+                    model.weight = input.weight ?? 1;
+                const diagnostic = includeRuntimeDiagnostics && input.sourcePropertyId !== null
+                    ? this.aggregateRuntime
+                        ?.readDiagnostics(config.outputPropertyId)
+                        ?.inputs.find((candidate) => candidate.id === input.id && candidate.sourceIdentity === input.sourcePropertyIdentity)
+                    : undefined;
+                if (diagnostic)
+                    Object.assign(model, {
+                        current_value: diagnostic.value,
+                        sampled_at: diagnostic.sampledAt,
+                        age_seconds: diagnostic.ageSeconds,
+                        exclusion: diagnostic.exclusion,
+                    });
+                return model;
+            }),
+        });
+    }
+    groupModel(config, members, bindings, graphRevision, capabilities) {
+        return Object.assign(new producer_response_model_1.VirtualLightGroupConfigurationModel(), {
+            group_channel: config.groupChannelId,
+            schema_version: config.schemaVersion,
+            profile: config.profile,
+            revision: config.revision,
+            graph_revision: graphRevision,
+            runtime_readiness: 'ready',
+            common_capabilities: capabilities.map((capability) => Object.assign(new producer_response_model_1.VirtualLightGroupCapabilityModel(), {
+                category: capability.category,
+                ...(config.profile === virtual_producer_entity_1.VirtualLightGroupProfile.LIGHT
+                    ? {}
+                    : { access: (0, virtual_group_profile_1.groupField)(config.profile, capability.category).access }),
+                data_type: capability.dataType,
+                unit: capability.unit,
+                format: capability.format,
+                step: capability.step,
+            })),
+            reported_state: this.lightGroups?.getReportedModel(config.groupChannelId, config.revision) ?? null,
+            members: members.map((member) => ({
+                id: member.id,
+                source_channel: member.sourceChannelId,
+                source_identity: member.sourceChannelIdentity,
+                bindings: bindings
+                    .filter((binding) => binding.memberId === member.id)
+                    .map((binding) => this.bindingModel(binding)),
+            })),
+        });
+    }
+    async announceOutputs(ids) {
+        for (const id of ids) {
+            const property = await this.dataSource.manager.findOne(devices_entity_1.ChannelPropertyEntity, {
+                where: { id },
+                relations: ['channel', 'channel.device'],
+            });
+            if (property)
+                this.eventEmitter.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_UPDATED, property);
+        }
+    }
+};
+exports.VirtualProducerConfigService = VirtualProducerConfigService;
+exports.VirtualProducerConfigService = VirtualProducerConfigService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(5, (0, common_1.Optional)()),
+    __param(6, (0, common_1.Optional)()),
+    __param(7, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        device_structure_lock_service_1.DeviceStructureLockService,
+        virtual_dependency_graph_service_1.VirtualDependencyGraphService,
+        event_emitter_1.EventEmitter2,
+        virtual_producer_state_service_1.VirtualProducerStateService,
+        virtual_light_group_state_service_1.VirtualLightGroupStateService,
+        virtual_aggregate_runtime_service_1.VirtualAggregateRuntimeService,
+        platform_registry_service_1.PlatformRegistryService])
+], VirtualProducerConfigService);
+//# sourceMappingURL=virtual-producer-config.service.js.map