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

package/dist/modules/devices/services/channels.properties.service.d.ts

@@ -6,9 +6,11 @@ import { ChannelCategory, DataTypeType, DeviceCategory, PermissionType, Property
 import { CreateChannelPropertyDto } from '../dto/create-channel-property.dto';
 import { UpdateChannelPropertyDto } from '../dto/update-channel-property.dto';
 import { ChannelPropertyEntity } from '../entities/devices.entity';
+import { PropertySampleEvidence } from '../models/property-sample.model';
 import { PropertyValueState } from '../models/property-value-state.model';
-import { ChannelsPropertiesTypeMapperService } from './channels.properties-type-mapper.service';
+import { type ChannelPropertyTypeMapping, ChannelsPropertiesTypeMapperService } from './channels.properties-type-mapper.service';
 import { CommandLatencyTraceCollectorService } from './command-latency-trace-collector.service';
+import { DeviceCreationContext } from './device-creation-context';
 import { DeviceStructureLockService } from './device-structure-lock.service';
 import { PropertyCommandWindowHandle, PropertyCommandWindowService } from './property-command-window.service';
 import { PropertyMetadataService } from './property-metadata.service';
@@ -78,6 +80,7 @@ export interface VisiblePropertySearchSummaryPage {
     total: number;
 }
 export interface ChannelPropertyUpdateOptions {
+    sampleEvidence?: PropertySampleEvidence;
     skipUnchangedMetadata?: boolean;
     strictValuePersistence?: boolean;
     storageBinding?: StorageBackendBinding;
@@ -118,7 +121,13 @@ export declare class ChannelsPropertiesService implements OnModuleInit, OnModule
     exists(id: string, channelId?: string): Promise<boolean>;
     findOne<TProperty extends ChannelPropertyEntity>(id: string, channelId?: string, type?: string): Promise<TProperty | null>;
     findOneBy<TProperty extends ChannelPropertyEntity>(column: 'id' | 'category' | 'identifier' | 'name', value: string | number | boolean, channelId?: string, type?: string): Promise<TProperty | null>;
-    create<TProperty extends ChannelPropertyEntity, TCreateDTO extends CreateChannelPropertyDto>(channelId: string, createDto: TCreateDTO): Promise<TProperty>;
+    captureCreationCatalog(type: string): {
+        property: import("./creation-capture").CreationCapture<ChannelPropertyTypeMapping<ChannelPropertyEntity, CreateChannelPropertyDto, UpdateChannelPropertyDto>>;
+        current: () => boolean;
+    };
+    create<TProperty extends ChannelPropertyEntity, TCreateDTO extends CreateChannelPropertyDto>(channelId: string, createDto: TCreateDTO, creation?: DeviceCreationContext): Promise<TProperty>;
+    private createCatalog;
+    reportSample<TProperty extends ChannelPropertyEntity, TUpdateDTO extends UpdateChannelPropertyDto>(id: string, updateDto: TUpdateDTO, evidence: PropertySampleEvidence, options?: Pick<ChannelPropertyUpdateOptions, 'skipUnchangedMetadata'>): Promise<TProperty>;
     update<TProperty extends ChannelPropertyEntity, TUpdateDTO extends UpdateChannelPropertyDto>(id: string, updateDto: TUpdateDTO, options?: ChannelPropertyUpdateOptions): Promise<TProperty>;
     private updateInternal;
     private publishValueSet;

package/dist/modules/devices/services/channels.properties.service.js

@@ -24,6 +24,7 @@ const typeorm_1 = require("typeorm");
 const common_1 = require("@nestjs/common");
 const event_emitter_1 = require("@nestjs/event-emitter");
 const typeorm_2 = require("@nestjs/typeorm");
+const sqlite_data_source_1 = require("../../../common/database/sqlite-data-source");
 const extension_logger_service_1 = require("../../../common/logger/extension-logger.service");
 const sqlite_fts_utils_1 = require("../../../common/utils/sqlite-fts.utils");
 const transform_utils_1 = require("../../../common/utils/transform.utils");
@@ -36,6 +37,9 @@ const property_metadata_utils_1 = require("../utils/property-metadata.utils");
 const unique_constraint_utils_1 = require("../utils/unique-constraint.utils");
 const channels_properties_type_mapper_service_1 = require("./channels.properties-type-mapper.service");
 const command_latency_trace_collector_service_1 = require("./command-latency-trace-collector.service");
+const controller_publication_context_1 = require("./controller-publication-context");
+const creation_capture_1 = require("./creation-capture");
+const device_creation_context_1 = require("./device-creation-context");
 const device_structure_lock_service_1 = require("./device-structure-lock.service");
 const property_command_window_service_1 = require("./property-command-window.service");
 const property_metadata_service_1 = require("./property-metadata.service");
@@ -89,6 +93,8 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                     .innerJoinAndSelect('channel.device', 'device')
                     .where('channel.id IN (:...channelIds)', { channelIds: channelId })
                     .getMany());
+                for (const property of properties)
+                    property.unit = (0, property_metadata_utils_1.resolvePropertyUnit)(property);
                 this.logger.debug(`Found ${properties.length} properties for channelIds=${channelId.join(', ')}`);
                 return properties;
             }
@@ -100,12 +106,16 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                     .innerJoinAndSelect('channel.device', 'device')
                     .where('channel.id = :channelId', { channelId })
                     .getMany());
+                for (const property of properties)
+                    property.unit = (0, property_metadata_utils_1.resolvePropertyUnit)(property);
                 this.logger.debug(`Found ${properties.length} properties for channelId=${channelId}`);
                 return properties;
             }
         }
         this.logger.debug('Fetching all properties');
         const properties = (await repository.find({ relations: ['channel', 'channel.device'] }));
+        for (const property of properties)
+            property.unit = (0, property_metadata_utils_1.resolvePropertyUnit)(property);
         this.logger.debug(`Found ${properties.length} properties`);
         return properties;
     }
@@ -461,24 +471,57 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
         }
         return property;
     }
-    async create(channelId, createDto) {
+    captureCreationCatalog(type) {
+        const api = (0, creation_capture_1.captureCreation)(this, [
+            'captureCreationCatalog',
+            'create',
+            'createCatalog',
+            'validateDto',
+            'getOneOrThrow',
+            'propertiesMapperService',
+            'structureLock',
+            'dataSource',
+            'eventEmitter',
+        ]);
+        const events = (0, creation_capture_1.captureCreation)(this.eventEmitter, ['emit']);
+        const mapper = (0, creation_capture_1.captureCreation)(this.propertiesMapperService, ['captureMapping', 'getMapping']);
+        const property = mapper.values.captureMapping.call(this.propertiesMapperService, type);
+        return { property, current: () => api.current() && events.current() && mapper.current() && property.current() };
+    }
+    async create(channelId, createDto, creation) {
+        device_creation_context_1.DeviceCreationContext.assertGenuine(creation);
+        if (device_creation_context_1.DeviceCreationContext.isPinned(creation))
+            return creation.catalog('property', createDto, (child) => {
+                child.assertParent(channelId);
+                return this.createCatalog(channelId, createDto, child);
+            });
+        return this.createCatalog(channelId, createDto, creation);
+    }
+    async createCatalog(channelId, createDto, creation) {
         const { type } = createDto;
+        creation?.assertType(type);
         if (!type) {
             this.logger.error('Validation failed: Missing required "type" attribute in data.');
             throw new devices_exceptions_1.DevicesException('Channel property attribute type is required.');
         }
-        const mapping = this.propertiesMapperService.getMapping(type);
-        const dtoInstance = await this.validateDto(mapping.createDto, createDto);
-        const errors = await (0, class_validator_1.validate)(dtoInstance, {
+        const mapping = device_creation_context_1.DeviceCreationContext.isPinned(creation)
+            ? (0, creation_capture_1.creationMapping)(creation.mapping('property'))
+            : this.propertiesMapperService.getMapping(type);
+        const dtoInstance = await device_creation_context_1.DeviceCreationContext.check(creation, () => this.validateDto(mapping.createDto, createDto));
+        const errors = await device_creation_context_1.DeviceCreationContext.check(creation, () => (0, class_validator_1.validate)(dtoInstance, {
             whitelist: true,
             forbidNonWhitelisted: true,
             stopAtFirstError: false,
-        });
+        }));
         if (errors.length > 0) {
             this.logger.error(`Validation failed:Validation failed for channel property creation error=${JSON.stringify(errors)}`);
             throw new devices_exceptions_1.DevicesValidationException('Provided channel property data are invalid.');
         }
-        const repository = this.dataSource.getRepository(mapping.class);
+        const repository = creation
+            ? creation.manager.getRepository(mapping.class)
+            : this.dataSource.getRepository(mapping.class);
+        if (creation && createDto.value != null)
+            throw new devices_exceptions_1.DevicesValidationException('Atomic creation cannot seed property values.');
         const property = repository.create((0, transform_utils_1.toInstance)(mapping.class, {
             ...dtoInstance,
             channel: channelId,
@@ -488,37 +531,93 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
             throw new devices_exceptions_1.DevicesValidationException('Channel property value cannot be set on a property whose value is stored by its source property.');
         }
         if (property.id) {
-            const existing = await this.repository.findOne({ where: { id: property.id } });
+            const existing = creation
+                ? await device_creation_context_1.DeviceCreationContext.check(creation, () => creation.manager
+                    .createQueryBuilder(devices_entity_1.ChannelPropertyEntity, 'row')
+                    .select('row.id')
+                    .where('row.id = :id', { id: property.id })
+                    .callListeners(false)
+                    .getOne())
+                : await device_creation_context_1.DeviceCreationContext.check(creation, () => this.repository.findOne({ where: { id: property.id } }));
             if (existing) {
                 this.logger.error(`[VALIDATION FAILED] Channel property id=${property.id} already exists, refusing to create over it`);
                 throw new devices_exceptions_1.DevicesValidationException(`Channel property with id=${property.id} already exists. Creating a channel property with an id already in use is not allowed.`);
             }
         }
-        const raw = await this.structureLock.runExclusive(async () => {
-            if (mapping.beforeCreate) {
-                await mapping.beforeCreate(property, channelId);
-            }
-            await repository
-                .insert(property)
-                .catch((error) => {
-                if ((0, unique_constraint_utils_1.isPrimaryKeyCollision)(error)) {
-                    this.logger.error(`[VALIDATION FAILED] Channel property id=${property.id} was created concurrently by another request`);
-                    throw new devices_exceptions_1.DevicesValidationException(`Channel property with id=${property.id} already exists. Creating a channel property with an id already in use is not allowed.`);
+        return this.structureLock.runExclusive(async () => {
+            const persist = async (manager) => {
+                const writeRepository = manager ? manager.getRepository(mapping.class) : repository;
+                if (mapping.beforeCreate) {
+                    if (manager)
+                        await device_creation_context_1.DeviceCreationContext.check(creation, () => mapping.beforeCreate(property, channelId, manager));
+                    else
+                        await device_creation_context_1.DeviceCreationContext.check(creation, () => mapping.beforeCreate(property, channelId));
                 }
-                throw error;
-            });
-            return property;
+                await device_creation_context_1.DeviceCreationContext.check(creation, () => (creation
+                    ? writeRepository
+                        .createQueryBuilder()
+                        .insert()
+                        .values(property)
+                        .updateEntity(false)
+                        .execute()
+                    : writeRepository.insert(property)).catch((error) => {
+                    if ((0, unique_constraint_utils_1.isPrimaryKeyCollision)(error)) {
+                        this.logger.error(`[VALIDATION FAILED] Channel property id=${property.id} was created concurrently by another request`);
+                        throw new devices_exceptions_1.DevicesValidationException(`Channel property with id=${property.id} already exists. Creating a channel property with an id already in use is not allowed.`);
+                    }
+                    throw error;
+                }));
+                return property;
+            };
+            const raw = creation
+                ? await device_creation_context_1.DeviceCreationContext.check(creation, () => persist(creation.manager))
+                : mapping.withStructuralWrite
+                    ? await device_creation_context_1.DeviceCreationContext.check(creation, () => mapping.withStructuralWrite(persist))
+                    : await device_creation_context_1.DeviceCreationContext.check(creation, () => persist());
+            if (!creation && typeof createDto.value !== 'undefined') {
+                await device_creation_context_1.DeviceCreationContext.check(creation, () => this.propertyValueService.write(raw, createDto.value));
+            }
+            let savedProperty = creation
+                ? await device_creation_context_1.DeviceCreationContext.check(creation, () => creation.manager
+                    .createQueryBuilder(mapping.class, 'row')
+                    .where('row.id = :id', { id: property.id })
+                    .callListeners(false)
+                    .getOneOrFail())
+                : (await device_creation_context_1.DeviceCreationContext.check(creation, () => this.getOneOrThrow(property.id)));
+            if (mapping.afterCreate && !creation) {
+                await device_creation_context_1.DeviceCreationContext.check(creation, () => mapping.afterCreate(savedProperty));
+                savedProperty = (await device_creation_context_1.DeviceCreationContext.check(creation, () => this.getOneOrThrow(property.id)));
+            }
+            if (creation)
+                creation.defer(async () => {
+                    creation.assertPublication();
+                    if (mapping.afterCreate)
+                        await mapping.afterCreate(savedProperty);
+                    creation.assertPublication();
+                    const published = await this.getOneOrThrow(savedProperty.id);
+                    creation.assertPublication();
+                    this.eventEmitter.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_CREATED, published);
+                }, savedProperty.type === 'virtual' && 'valueOrigin' in savedProperty && savedProperty.valueOrigin === 'derived');
+            else
+                this.eventEmitter.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_CREATED, savedProperty);
+            return savedProperty;
         });
-        if (typeof createDto.value !== 'undefined') {
-            await this.propertyValueService.write(raw, createDto.value);
-        }
-        let savedProperty = (await this.getOneOrThrow(property.id));
-        if (mapping.afterCreate) {
-            await mapping.afterCreate(savedProperty);
-            savedProperty = (await this.getOneOrThrow(property.id));
-        }
-        this.eventEmitter.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_CREATED, savedProperty);
-        return savedProperty;
+    }
+    reportSample(id, updateDto, evidence, options = {}) {
+        const captured = Object.freeze({
+            sampledAt: new Date(evidence.sampledAt),
+            receivedAt: new Date(evidence.receivedAt),
+            provenance: evidence.provenance,
+            ...(evidence.semanticOrigin ? { semanticOrigin: evidence.semanticOrigin } : {}),
+            ...(evidence.nativeCoverTagPresent !== undefined
+                ? { nativeCoverTagPresent: evidence.nativeCoverTagPresent }
+                : {}),
+            ...(evidence.commandObservation ? { commandObservation: evidence.commandObservation } : {}),
+            ...(evidence.isCurrent ? { isCurrent: evidence.isCurrent } : {}),
+            ...(evidence.sourceIsCurrent ? { sourceIsCurrent: evidence.sourceIsCurrent } : {}),
+            ...(evidence.observedAt ? { observedAt: new Date(evidence.observedAt) } : {}),
+        });
+        return this.update(id, updateDto, { ...options, sampleEvidence: captured });
     }
     async update(id, updateDto, options = {}) {
         const windowGeneration = options.commandOrigin?.handle.generation ??
@@ -538,7 +637,7 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                 ? this.getValueOnlyMapping(updateDto.type)
                 : undefined;
             if (valueOnlyMapping !== null) {
-                const result = await this.updateValueOnly(id, updateDto, valueOnlyMapping, options.skipUnchangedMetadata);
+                const result = await this.updateValueOnly(id, updateDto, valueOnlyMapping, options.skipUnchangedMetadata, options.sampleEvidence);
                 if ('property' in result) {
                     return result.property;
                 }
@@ -554,24 +653,37 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
         const repository = this.dataSource.getRepository(mapping.class);
         const updateFields = (0, lodash_omitby_1.default)((0, transform_utils_1.toInstance)(mapping.class, dtoInstance), lodash_isundefined_1.default);
         return this.structureLock.runExclusive(async () => {
-            const current = (await this.getOneOrThrow(id));
-            const previousCanonicalPropertyId = this.valueSourceRegistry.resolve(current);
-            const entityFieldsChanged = this.hasEntityFieldChanges(current, updateFields);
-            if (entityFieldsChanged) {
-                await this.propertyValueService.flushHistory();
-            }
-            Object.assign(current, updateFields);
-            if (entityFieldsChanged) {
-                const nextCanonicalPropertyId = this.valueSourceRegistry.resolve(current);
-                if (nextCanonicalPropertyId !== previousCanonicalPropertyId) {
-                    this.propertyCommandWindowService.cancel(previousCanonicalPropertyId);
-                    this.propertyCommandWindowService.cancel(nextCanonicalPropertyId);
+            let entityFieldsChanged = false;
+            const persist = async (manager) => {
+                const current = manager
+                    ? await manager
+                        .getRepository(mapping.class)
+                        .findOne({ where: { id }, relations: ['channel', 'channel.device'] })
+                    : (await this.getOneOrThrow(id));
+                if (!current)
+                    throw new devices_exceptions_1.DevicesNotFoundException(`Channel property with id=${id} does not exist.`);
+                const previousCanonicalPropertyId = this.valueSourceRegistry.resolve(current);
+                entityFieldsChanged = this.hasEntityFieldChanges(current, updateFields);
+                if (entityFieldsChanged) {
+                    await this.propertyValueService.flushHistory();
                 }
-            }
-            if (mapping.beforeUpdate) {
-                await mapping.beforeUpdate(current);
-            }
-            const raw = await repository.save(current);
+                Object.assign(current, updateFields);
+                if (entityFieldsChanged) {
+                    const nextCanonicalPropertyId = this.valueSourceRegistry.resolve(current);
+                    if (nextCanonicalPropertyId !== previousCanonicalPropertyId) {
+                        this.propertyCommandWindowService.cancel(previousCanonicalPropertyId);
+                        this.propertyCommandWindowService.cancel(nextCanonicalPropertyId);
+                    }
+                }
+                if (mapping.beforeUpdate) {
+                    if (manager)
+                        await mapping.beforeUpdate(current, manager);
+                    else
+                        await mapping.beforeUpdate(current);
+                }
+                return await (manager ? manager.getRepository(mapping.class) : repository).save(current);
+            };
+            const raw = mapping.withStructuralWrite ? await mapping.withStructuralWrite(persist) : await persist();
             let valueChanged = false;
             let persistedValueState = null;
             let forceConfirmationValueEvent = false;
@@ -588,6 +700,8 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                     return null;
                 };
                 const writeWithoutWindow = async () => {
+                    if (options.sampleEvidence)
+                        return this.propertyValueService.writeSampleWithState(raw, updateDto.value, options.sampleEvidence);
                     const strictResult = await writeStrictValue();
                     if (strictResult !== null) {
                         return strictResult;
@@ -598,6 +712,8 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                     };
                 };
                 const writeWithWindow = async () => {
+                    if (options.sampleEvidence)
+                        return this.propertyValueService.writeSampleWithState(raw, updateDto.value, options.sampleEvidence);
                     const strictResult = await writeStrictValue();
                     return strictResult ?? this.propertyValueService.writeWithState(raw, updateDto.value, valueTimestamp);
                 };
@@ -605,7 +721,7 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                     ? await this.commitWindowedProviderValue(raw, updateDto.value, {
                         unwindowed: writeWithoutWindow,
                         windowed: writeWithWindow,
-                    })
+                    }, options.sampleEvidence)
                     : await this.commitCommandOriginValue(raw, updateDto.value, options.commandOrigin, writeWithWindow);
                 valueChanged = windowed.changed;
                 persistedValueState = windowed.state;
@@ -647,7 +763,7 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
         this.commandLatencyTraceCollector.recordSourcePublication(property);
         this.eventEmitter.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_VALUE_SET, property);
     }
-    async updateValueOnly(id, updateDto, knownMapping, skipUnchangedMetadata = false) {
+    async updateValueOnly(id, updateDto, knownMapping, skipUnchangedMetadata = false, evidence) {
         return this.structureLock.runShared(() => this.propertyStateCoordinator.run(id, async () => {
             const current = (await this.findOneForValueUpdate(id));
             const mapping = knownMapping ?? this.propertiesMapperService.getMapping(current.type);
@@ -672,8 +788,10 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                 return { type: current.type };
             }
             const commit = async () => {
-                const write = () => this.propertyValueService.writeLiveWithState(current, value);
-                const result = await this.commitWindowedProviderValue(current, value, { unwindowed: write, windowed: write });
+                const write = () => evidence
+                    ? this.propertyValueService.writeSampleWithState(current, value, evidence)
+                    : this.propertyValueService.writeLiveWithState(current, value);
+                const result = await this.commitWindowedProviderValue(current, value, { unwindowed: write, windowed: write }, evidence);
                 this.commandLatencyTraceCollector.recordWriteComplete(current, {
                     changed: result.changed,
                     held: result.held,
@@ -694,22 +812,47 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
             return canonicalPropertyId === id ? commit() : this.propertyStateCoordinator.run(canonicalPropertyId, commit);
         }));
     }
-    async commitWindowedProviderValue(property, value, writers) {
+    async commitWindowedProviderValue(property, value, writers, evidence) {
         const canonicalPropertyId = this.valueSourceRegistry.resolve(property);
+        if (evidence?.isCurrent?.() === false || evidence?.sourceIsCurrent?.() === false)
+            return { changed: false, state: null, held: true, forceValueEvent: false };
         const validation = (0, property_command_value_utils_1.validatePropertyCommandValue)(property, value);
         if (!validation.valid || validation.value === undefined) {
             const result = await writers.unwindowed();
             return { ...result, held: false, forceValueEvent: false };
         }
+        const activeWindow = this.propertyCommandWindowService.get(canonicalPropertyId);
+        if (activeWindow &&
+            (evidence || activeWindow.requiresLiveEvidence) &&
+            (!evidence ||
+                evidence.provenance !== 'live' ||
+                !evidence.observedAt ||
+                !Number.isFinite(evidence.observedAt.getTime()) ||
+                evidence.observedAt.getTime() < activeWindow.openedAt ||
+                evidence.observedAt.getTime() > evidence.receivedAt.getTime())) {
+            if (!evidence && activeWindow.state === 'pending') {
+                this.propertyCommandWindowService.hold({ canonicalPropertyId, generation: activeWindow.generation }, { value: validation.value, receivedAt: Date.now() });
+            }
+            return { changed: false, state: null, held: true, forceValueEvent: false };
+        }
         this.propertyCommandWindowService.expire(canonicalPropertyId);
         const window = this.propertyCommandWindowService.get(canonicalPropertyId);
         if (window === null) {
             const reconcilesCommand = this.propertyCommandWindowService.cancelRecovery(canonicalPropertyId);
             const result = await (reconcilesCommand ? writers.windowed() : writers.unwindowed());
+            if (evidence?.isCurrent?.() === false || evidence?.sourceIsCurrent?.() === false)
+                return { changed: false, state: null, held: false, forceValueEvent: false };
             return { ...result, held: false, forceValueEvent: reconcilesCommand && result.state !== null };
         }
         const handle = { canonicalPropertyId, generation: window.generation };
         const receipt = { value: validation.value, receivedAt: Date.now() };
+        if (window.proofKind === 'cover_action') {
+            if (evidence && [devices_constants_1.PropertyCategory.POSITION, devices_constants_1.PropertyCategory.TILT].includes(property.category)) {
+                const result = await writers.unwindowed();
+                return { ...result, held: false, forceValueEvent: false };
+            }
+            return { changed: false, state: null, held: true, forceValueEvent: false };
+        }
         const isConfirmation = validation.value === window.commandedValue;
         if (!isConfirmation && window.previousValue !== null && validation.value === window.previousValue) {
             if (window.state === 'pending') {
@@ -719,8 +862,8 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
         }
         const firstConfirmation = isConfirmation && window.state === 'pending';
         const result = await writers.windowed();
-        if (result.state === null) {
-            return { ...result, held: false, forceValueEvent: false };
+        if (result.state === null || evidence?.isCurrent?.() === false || evidence?.sourceIsCurrent?.() === false) {
+            return { changed: false, state: null, held: false, forceValueEvent: false };
         }
         if (isConfirmation) {
             this.propertyCommandWindowService.confirm(handle, receipt);
@@ -789,7 +932,10 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
         }
     }
     async remove(id, manager = this.dataSource.manager) {
-        return this.structureLock.runExclusive(async () => {
+        const standalone = !this.structureLock.hasCurrentStructuralLease() &&
+            !(0, sqlite_data_source_1.hasCurrentSqliteConnectionLease)(this.dataSource) &&
+            !manager.queryRunner?.isTransactionActive;
+        const removeOriginal = () => this.structureLock.runExclusive(controller_publication_context_1.ControllerPublicationContext.captureCallback(async () => {
             const property = await manager.findOne(devices_entity_1.ChannelPropertyEntity, {
                 where: { id },
             });
@@ -797,13 +943,22 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
                 this.logger.warn(`Property with id=${id} not found during removal (skipping)`);
                 return;
             }
-            this.propertyCommandWindowService.cancel(id);
-            this.propertyCommandWindowService.cancel(this.valueSourceRegistry.resolve(property));
-            const propertyForEvent = { ...property };
-            await manager.remove(property);
-            this.logger.log(`Successfully removed property with id=${id}`);
-            this.eventEmitter.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_DELETED, propertyForEvent);
-        });
+            const remove = async () => {
+                this.propertyCommandWindowService.cancel(id);
+                this.propertyCommandWindowService.cancel(this.valueSourceRegistry.resolve(property));
+                const propertyForEvent = { ...property };
+                if (standalone && manager === this.dataSource.manager && this.dataSource instanceof sqlite_data_source_1.SqliteDataSource)
+                    await this.dataSource.transactionWithWriteIntent((scoped) => scoped.remove(property));
+                else
+                    await manager.remove(property);
+                this.logger.log(`Successfully removed property with id=${id}`);
+                this.eventEmitter.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_DELETED, propertyForEvent);
+            };
+            if (standalone && property.type === 'virtual')
+                return new controller_publication_context_1.ControllerPublicationContext(() => false).run(remove);
+            return remove();
+        }));
+        return standalone ? controller_publication_context_1.ControllerPublicationContext.complete(removeOriginal, true) : removeOriginal();
     }
     async getOneOrThrow(id) {
         const property = await this.findOne(id);
@@ -878,7 +1033,7 @@ let ChannelsPropertiesService = ChannelsPropertiesService_1 = class ChannelsProp
         return property;
     }
     snapshotValueState(state) {
-        return state === null ? null : new property_value_state_model_1.PropertyValueState(state.value, state.lastUpdated, state.trend);
+        return state === null ? null : (0, property_value_state_model_1.clonePropertyValueState)(state);
     }
     async validateDto(DtoClass, dto) {
         const dtoInstance = (0, transform_utils_1.toInstance)(DtoClass, dto, {