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

package/dist/modules/devices/services/property-value.service.js

@@ -8,13 +8,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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.PropertyValueService = void 0;
 const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
 const extension_logger_service_1 = require("../../../common/logger/extension-logger.service");
 const storage_service_1 = require("../../storage/services/storage.service");
 const devices_constants_1 = require("../devices.constants");
 const property_value_state_model_1 = require("../models/property-value-state.model");
+const property_command_value_utils_1 = require("../utils/property-command-value.utils");
+const property_metadata_utils_1 = require("../utils/property-metadata.utils");
+const controller_publication_context_1 = require("./controller-publication-context");
+const property_producer_registry_service_1 = require("./property-producer.registry.service");
 const property_value_lock_service_1 = require("./property-value-lock.service");
 const property_value_source_registry_service_1 = require("./property-value-source.registry.service");
 const TREND_POINTS_COUNT = 5;
@@ -22,31 +30,382 @@ const BOUNDED_READ_MAX_PROPERTIES = 500;
 const BOUNDED_READ_SOURCE_CHUNK_SIZE = 50;
 const BOUNDED_READ_DEFAULT_DEADLINE_MS = 750;
 let PropertyValueService = class PropertyValueService {
-    constructor(storageService, valueSourceRegistry, valueLock) {
+    constructor(storageService, valueSourceRegistry, valueLock, producers, events) {
         this.storageService = storageService;
         this.valueSourceRegistry = valueSourceRegistry;
         this.valueLock = valueLock;
+        this.producers = producers;
+        this.events = events;
         this.logger = (0, extension_logger_service_1.createExtensionLogger)(devices_constants_1.DEVICES_MODULE_NAME, 'PropertyValueService');
         this.valuesMap = new Map();
         this.recentValuesMap = new Map();
         this.cacheVersions = new Map();
         this.valueTails = new Map();
+        this.sampleGeneration = 0;
+        this.liveEpochs = new Set();
+        this.samples = new Map();
+        this.liveWatermarks = new Map();
+        this.producers?.setEvidenceValidator((sources) => this.incorporatedEvidenceCurrent(sources));
     }
     async write(property, value, valueTimestamp) {
-        const key = this.valueSourceRegistry.resolve(property);
-        return (await this.withValueLock(key, () => this.writeInternal(property, value, false, undefined, valueTimestamp)))
-            .changed;
+        const publication = controller_publication_context_1.ControllerPublicationContext.current();
+        if (publication) {
+            const input = (0, controller_publication_context_1.ownControllerEffectValue)(property);
+            const timestamp = valueTimestamp ? new Date(valueTimestamp) : undefined;
+            const capture = this.valueSourceRegistry.captureReadSource(input);
+            try {
+                const key = this.valueSourceRegistry.readSourceKey(capture);
+                const eligible = () => publication.isEligible() && this.valueSourceRegistry.isReadSourceCurrent(capture);
+                return (await controller_publication_context_1.ControllerPublicationContext.effect('property.value', () => {
+                    const fields = this.storageFields(input.dataType, value);
+                    const pointTimestamp = timestamp ?? new Date();
+                    const point = fields
+                        ? {
+                            measurement: 'property_value',
+                            tags: { propertyId: key },
+                            fields,
+                            timestamp: pointTimestamp,
+                        }
+                        : undefined;
+                    const history = {
+                        timestamp: pointTimestamp,
+                        point,
+                        storage: this.storageService.captureControllerWrite(point ? [point] : []),
+                    };
+                    return this.withValueLock(key, () => this.writeInternal(input, key, value, false, undefined, timestamp, false, false, eligible, history));
+                })).changed;
+            }
+            finally {
+                this.valueSourceRegistry.closeReadSource(capture);
+            }
+        }
+        const key = this.resolveBestEffort(property, 'write');
+        if (key === null)
+            return false;
+        return (await this.withValueLock(key, () => this.writeInternal(property, key, value, false, undefined, valueTimestamp))).changed;
     }
     async writeWithState(property, value, valueTimestamp) {
-        const key = this.valueSourceRegistry.resolve(property);
-        return this.withValueLock(key, () => this.writeInternal(property, value, false, undefined, valueTimestamp));
+        const key = this.resolveBestEffort(property, 'write');
+        if (key === null)
+            return { changed: false, state: null };
+        return this.withValueLock(key, () => this.writeInternal(property, key, value, false, undefined, valueTimestamp));
     }
     async writeLiveWithState(property, value, valueTimestamp) {
         if (this.valueLock.isEnabled()) {
             return this.writeWithState(property, value, valueTimestamp);
         }
+        const key = this.resolveBestEffort(property, 'write');
+        if (key === null)
+            return { changed: false, state: null };
+        return this.withValueLock(key, () => this.writeInternal(property, key, value, false, undefined, valueTimestamp, true), false);
+    }
+    async writeSampleWithState(property, value, evidence) {
+        const key = this.resolveBestEffort(property, 'sample');
+        if (key === null || key !== property.id || this.producers?.owns(key))
+            return { changed: false, state: null };
+        return this.withValueLock(key, async () => {
+            if (this.producers?.owns(key) || evidence.isCurrent?.() === false || evidence.sourceIsCurrent?.() === false)
+                return { changed: false, state: null };
+            const sampledAt = evidence.sampledAt.getTime();
+            const receivedAt = evidence.receivedAt.getTime();
+            const watermark = this.liveWatermarks.get(key);
+            const live = evidence.provenance === 'live';
+            if (!live && this.liveEpochs.has(key))
+                return { changed: false, state: null };
+            if (watermark && (sampledAt < watermark.sampledAt || (sampledAt === watermark.sampledAt && watermark.invalid)))
+                return { changed: false, state: null };
+            const validClock = Number.isFinite(sampledAt) &&
+                Number.isFinite(receivedAt) &&
+                sampledAt <= receivedAt &&
+                receivedAt <= Date.now();
+            const validSemantic = evidence.semanticOrigin !== 'native_cover_tilt_percentage' ||
+                (property.category === devices_constants_1.PropertyCategory.TILT &&
+                    property.identifier === 'slat_pos' &&
+                    property.dataType === devices_constants_1.DataTypeType.UCHAR &&
+                    (0, property_metadata_utils_1.resolvePropertyUnit)(property) === '%');
+            if (!validClock || !validSemantic || !this.isSampleValueValid(property, value)) {
+                if (live) {
+                    this.liveEpochs.add(key);
+                    if (validClock)
+                        this.liveWatermarks.set(key, { sampledAt, invalid: true });
+                    this.samples.delete(key);
+                    this.events?.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_SAMPLE_INVALIDATED, Object.freeze({ propertyId: key, evidence: this.cloneEvidence(evidence) }));
+                }
+                return { changed: false, state: null };
+            }
+            const result = await this.writeInternal(property, key, value, false, undefined, evidence.sampledAt, !this.valueLock.isEnabled());
+            if (evidence.isCurrent?.() === false || evidence.sourceIsCurrent?.() === false)
+                return { changed: false, state: null };
+            if (result.state !== null) {
+                const sample = Object.freeze({
+                    propertyId: key,
+                    value: result.state.value,
+                    sampledAt: new Date(sampledAt),
+                    receivedAt: new Date(receivedAt),
+                    provenance: evidence.provenance,
+                    ...(evidence.semanticOrigin ? { semanticOrigin: evidence.semanticOrigin } : {}),
+                    ...(evidence.nativeCoverTagPresent !== undefined
+                        ? { nativeCoverTagPresent: evidence.nativeCoverTagPresent }
+                        : {}),
+                    ...(evidence.commandObservation ? { commandObservation: evidence.commandObservation } : {}),
+                    ...(live ? { acceptanceGeneration: ++this.sampleGeneration } : {}),
+                    quality: 'good',
+                    reasons: Object.freeze([]),
+                });
+                if (live) {
+                    this.liveEpochs.add(key);
+                    this.liveWatermarks.set(key, { sampledAt, invalid: false });
+                    this.samples.set(key, {
+                        ...sample,
+                        provenance: 'live',
+                        isCurrent: evidence.sourceIsCurrent ?? evidence.isCurrent,
+                    });
+                }
+                const snapshot = Object.assign(Object.create(Object.getPrototypeOf(property)), property);
+                snapshot.value = (0, property_value_state_model_1.clonePropertyValueState)(result.state);
+                this.events?.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_SAMPLE_ACCEPTED, Object.freeze({ propertyId: key, property: snapshot, sample: this.cloneSample(sample, false) }));
+            }
+            return result;
+        }, this.valueLock.isEnabled());
+    }
+    currentSampleGeneration() {
+        return this.sampleGeneration;
+    }
+    readSampleFreshness(property, maxAgeMs, now = new Date()) {
+        const key = this.resolveBestEffort(property, 'sample freshness');
+        const unavailable = this.valueSourceRegistry.unavailableReason(property);
+        const produced = key === null ? null : this.producers?.readDiagnosticState(key)?.producer;
+        const physical = key === null ? null : this.samples.get(key);
+        const incorporated = key === null ? null : this.producers?.readIncorporatedSamples(key);
+        const current = !unavailable &&
+            (produced ? !incorporated || this.incorporatedEvidenceCurrent(incorporated) : physical?.isCurrent?.() !== false);
+        const timestamp = produced?.sampledAt ?? physical?.sampledAt.toISOString() ?? null;
+        const sampled = timestamp === null ? NaN : Date.parse(timestamp);
+        const clockValid = Number.isFinite(now.getTime()) &&
+            sampled <= now.getTime() &&
+            (produced
+                ? Date.parse(produced.evaluatedAt) <= now.getTime()
+                : (physical?.receivedAt.getTime() ?? Infinity) <= now.getTime());
+        const evidence = Number.isFinite(maxAgeMs) &&
+            maxAgeMs >= 0 &&
+            current &&
+            clockValid &&
+            (!produced || produced.quality !== 'unavailable');
+        const age = evidence ? now.getTime() - sampled : null;
+        const expiry = evidence
+            ? Math.min(sampled + maxAgeMs, produced?.expiresAt ? Date.parse(produced.expiresAt) : Infinity)
+            : null;
+        const reasons = unavailable ? [unavailable] : [...(produced?.reasons ?? [])];
+        const stale = (age !== null &&
+            (age > maxAgeMs ||
+                (produced?.expiresAt !== null &&
+                    produced?.expiresAt !== undefined &&
+                    Date.parse(produced.expiresAt) <= now.getTime()))) ||
+            reasons.some((reason) => ['expired', 'stale'].includes(reason));
+        return {
+            status: stale ? 'stale' : evidence ? 'fresh' : 'unavailable',
+            quality: evidence ? (produced?.quality ?? physical?.quality ?? 'unavailable') : 'unavailable',
+            sampled_at: evidence ? timestamp : null,
+            age_seconds: age === null ? null : age / 1000,
+            expires_at: expiry !== null && Number.isFinite(new Date(expiry).getTime()) ? new Date(expiry).toISOString() : null,
+            reasons,
+        };
+    }
+    captureSampleSourceGuard(property) {
+        const key = this.resolveBestEffort(property, 'sample source lease');
+        const sample = key === null ? null : this.samples.get(key);
+        const guard = sample?.isCurrent;
+        return () => !!sample && guard?.() !== false;
+    }
+    readQualifiedSample(property, maxAgeMs, now = new Date()) {
+        return this.qualifySample(property, maxAgeMs, now, false);
+    }
+    readQualifiedSampleSnapshot(property, maxAgeMs, now) {
+        return this.qualifySample(property, maxAgeMs, now, true);
+    }
+    qualifySample(property, maxAgeMs, now, detached) {
+        if (!Number.isFinite(maxAgeMs) ||
+            maxAgeMs < 0 ||
+            !Number.isFinite(now.getTime()) ||
+            this.valueSourceRegistry.unavailableReason(property) !== null)
+            return null;
+        const key = this.resolveBestEffort(property, 'qualified sample');
+        if (key === null)
+            return null;
+        const produced = detached ? this.producers?.readDiagnosticState(key) : this.producers?.read(key);
+        if (produced) {
+            if (produced.value === null ||
+                produced.producer.quality === 'unavailable' ||
+                produced.producer.sampledAt === null)
+                return null;
+            const incorporated = this.producers.readIncorporatedSamples(key);
+            if (incorporated && !this.incorporatedEvidenceCurrent(incorporated))
+                return null;
+            const sampledAt = new Date(produced.producer.sampledAt);
+            if (!Number.isFinite(sampledAt.getTime()) ||
+                !Number.isFinite(Date.parse(produced.producer.evaluatedAt)) ||
+                Date.parse(produced.producer.evaluatedAt) < sampledAt.getTime() ||
+                sampledAt.getTime() > now.getTime() ||
+                Date.parse(produced.producer.evaluatedAt) > now.getTime() ||
+                now.getTime() - sampledAt.getTime() > maxAgeMs ||
+                (produced.producer.expiresAt !== null && Date.parse(produced.producer.expiresAt) <= now.getTime()))
+                return null;
+            return Object.freeze({
+                propertyId: key,
+                value: produced.value,
+                sampledAt,
+                receivedAt: new Date(produced.producer.evaluatedAt),
+                provenance: 'live',
+                quality: produced.producer.quality,
+                reasons: Object.freeze([...produced.producer.reasons]),
+                revision: produced.producer.revision,
+            });
+        }
+        const sample = this.samples.get(key);
+        if (!sample ||
+            sample.isCurrent?.() === false ||
+            sample.sampledAt.getTime() > now.getTime() ||
+            sample.receivedAt.getTime() > now.getTime() ||
+            now.getTime() - sample.sampledAt.getTime() > maxAgeMs)
+            return null;
+        return this.cloneSample(sample);
+    }
+    captureIncorporatedSample(property) {
+        const key = this.resolveBestEffort(property, 'incorporated evidence');
+        if (!key || this.valueSourceRegistry.unavailableReason(property) !== null)
+            return null;
+        if (this.producers?.owns(key))
+            return this.producers.captureEvidence(key);
+        const sample = this.samples.get(key);
+        if (!sample || sample.quality !== 'good' || sample.isCurrent?.() === false)
+            return null;
+        return Object.freeze({ propertyId: key, acceptanceGeneration: sample.acceptanceGeneration });
+    }
+    incorporatedEvidenceCurrent(sources) {
+        const visited = new Set();
+        const visit = (items, depth) => {
+            const evidence = items;
+            if (!Array.isArray(items) || !items.length || items.length > 32 || depth > 16)
+                return false;
+            for (const item of evidence) {
+                if (!item || visited.has(item.propertyId) || visited.size >= 256)
+                    return false;
+                visited.add(item.propertyId);
+                if (item.producer) {
+                    if (!this.producers?.isPublicationCurrent(item) || !visit(item.sources, depth + 1))
+                        return false;
+                }
+                else {
+                    const sample = this.samples.get(item.propertyId);
+                    if (item.sources ||
+                        !Number.isSafeInteger(item.acceptanceGeneration) ||
+                        !sample ||
+                        sample.acceptanceGeneration !== item.acceptanceGeneration ||
+                        sample.isCurrent?.() === false ||
+                        sample.quality !== 'good' ||
+                        sample.receivedAt.getTime() > Date.now() ||
+                        sample.sampledAt.getTime() > Date.now())
+                        return false;
+                }
+            }
+            return true;
+        };
+        return visit(sources, 0);
+    }
+    async publishDerived(property, lease, value, publication, evaluation) {
+        if ((publication.sourceSample && publication.sourceSamples) ||
+            (publication.sourceSamples && !this.incorporatedEvidenceCurrent(publication.sourceSamples)) ||
+            (publication.sourceSample && !this.incorporatedEvidenceCurrent([publication.sourceSample])))
+            return { changed: false, state: null };
+        publication = Object.freeze({
+            ...publication,
+            reasons: Object.freeze([...publication.reasons]),
+            sampledAt: new Date(publication.sampledAt),
+            evaluatedAt: new Date(publication.evaluatedAt),
+            expiresAt: new Date(publication.expiresAt),
+            sourceSample: publication.sourceSample
+                ? this.freezeIncorporatedEvidence([publication.sourceSample])[0]
+                : undefined,
+            sourceSamples: publication.sourceSamples ? this.freezeIncorporatedEvidence(publication.sourceSamples) : undefined,
+        });
         const key = this.valueSourceRegistry.resolve(property);
-        return this.withValueLock(key, () => this.writeInternal(property, value, false, undefined, valueTimestamp, true), false);
+        const epoch = evaluation?.epoch ?? this.producers?.version(lease) ?? null;
+        if (key !== property.id ||
+            this.valueSourceRegistry.unavailableReason(property) !== null ||
+            lease.propertyId !== key ||
+            !this.producers?.canCommit(lease, publication, epoch, evaluation?.generation))
+            return { changed: false, state: null };
+        return this.withValueLock(key, async () => {
+            if (this.valueSourceRegistry.unavailableReason(property) !== null ||
+                !this.producers.canCommit(lease, publication, epoch, evaluation?.generation))
+                return { changed: false, state: null };
+            if (!this.isSampleValueValid(property, value)) {
+                this.producers.invalidate(lease, ['invalid_value'], publication.evaluatedAt);
+                return { changed: false, state: this.producers.read(key) };
+            }
+            const result = await this.writeInternal(property, key, value, false, undefined, publication.sampledAt, false, true);
+            if (!result.state || !this.producers.commit(lease, result.state, publication, epoch, evaluation?.generation))
+                return { changed: false, state: this.producers.read(key) };
+            return { changed: result.changed, state: this.producers.read(key) };
+        });
+    }
+    freezeIncorporatedEvidence(sources, depth = 0) {
+        const evidence = sources;
+        if (!Array.isArray(sources) || !sources.length || sources.length > 32 || depth > 16)
+            return Object.freeze([]);
+        return Object.freeze(evidence.map((source) => Object.freeze({
+            ...source,
+            producer: source.producer ? Object.freeze({ ...source.producer }) : undefined,
+            sources: source.sources ? this.freezeIncorporatedEvidence(source.sources, depth + 1) : undefined,
+        })));
+    }
+    invalidateDerived(property, lease, reasons, evaluatedAt = new Date()) {
+        return (lease.propertyId === property.id &&
+            this.valueSourceRegistry.resolve(property) === property.id &&
+            (this.producers?.invalidate(lease, reasons, evaluatedAt) ?? false));
+    }
+    cloneEvidence(evidence) {
+        return Object.freeze({
+            sampledAt: new Date(evidence.sampledAt),
+            receivedAt: new Date(evidence.receivedAt),
+            provenance: evidence.provenance,
+            ...(evidence.semanticOrigin ? { semanticOrigin: evidence.semanticOrigin } : {}),
+            ...(evidence.observedAt ? { observedAt: new Date(evidence.observedAt) } : {}),
+        });
+    }
+    cloneSample(sample, includeCommandProof = true) {
+        const { commandObservation, ...ordinary } = sample;
+        return Object.freeze({
+            ...ordinary,
+            ...(includeCommandProof && commandObservation ? { commandObservation } : {}),
+            sampledAt: new Date(sample.sampledAt),
+            receivedAt: new Date(sample.receivedAt),
+            reasons: Object.freeze([...sample.reasons]),
+        });
+    }
+    isSampleValueValid(property, value) {
+        return (0, property_command_value_utils_1.validatePropertyCommandValue)({ ...property, invalid: property.invalid ?? null, step: null }, value).valid;
+    }
+    overlay(property, state) {
+        const key = this.resolveBestEffort(property, 'producer overlay');
+        const produced = key === null ? null : this.producers?.read(key);
+        const reason = this.valueSourceRegistry.unavailableReason(property);
+        return this.overlaySource(produced, reason, state);
+    }
+    overlaySource(produced, reason, state) {
+        if (reason) {
+            const blocked = new property_value_state_model_1.PropertyValueState();
+            blocked.producer = Object.assign(new property_value_state_model_1.PropertyProducerState(), {
+                quality: 'unavailable',
+                reasons: [reason],
+                sampledAt: null,
+                evaluatedAt: new Date().toISOString(),
+                expiresAt: null,
+                revision: produced?.producer?.revision ?? 0,
+            });
+            return blocked;
+        }
+        return produced ?? state;
     }
     flushHistory() {
         return this.storageService.flushQueuedWrites();
@@ -56,7 +415,7 @@ let PropertyValueService = class PropertyValueService {
     }
     async writeStrictWithState(property, value, storageBinding, valueTimestamp) {
         const key = this.valueSourceRegistry.resolve(property);
-        return this.withValueLock(key, () => this.writeInternal(property, value, true, storageBinding, valueTimestamp));
+        return this.withValueLock(key, () => this.writeInternal(property, key, value, true, storageBinding, valueTimestamp));
     }
     async writeStrictIfPersistedDifferent(property, value, expectedPersistedState, beforeWrite, valueTimestamp) {
         const key = this.valueSourceRegistry.resolve(property);
@@ -73,11 +432,31 @@ let PropertyValueService = class PropertyValueService {
                 throw new Error('Persisted property value read did not bind a storage backend');
             }
             await valueLease.assertOwned();
-            return this.writeInternal(property, value, true, latest.storageBinding, valueTimestamp);
+            return this.writeInternal(property, key, value, true, latest.storageBinding, valueTimestamp);
         });
     }
-    async writeInternal(property, value, strict, storageBinding, valueTimestamp, deferHistory = false) {
-        const key = this.valueSourceRegistry.resolve(property);
+    storageFields(dataType, value) {
+        switch (dataType) {
+            case devices_constants_1.DataTypeType.ENUM:
+            case devices_constants_1.DataTypeType.STRING:
+                return { stringValue: String(value) };
+            case devices_constants_1.DataTypeType.BOOL:
+                return { stringValue: String(value ? 'true' : 'false') };
+            case devices_constants_1.DataTypeType.CHAR:
+            case devices_constants_1.DataTypeType.UCHAR:
+            case devices_constants_1.DataTypeType.SHORT:
+            case devices_constants_1.DataTypeType.USHORT:
+            case devices_constants_1.DataTypeType.INT:
+            case devices_constants_1.DataTypeType.UINT:
+            case devices_constants_1.DataTypeType.FLOAT:
+                return { numberValue: Number(value) };
+            default:
+                return undefined;
+        }
+    }
+    async writeInternal(property, key, value, strict, storageBinding, valueTimestamp, deferHistory = false, producerWrite = false, ownedCurrent, ownedHistory) {
+        if (!producerWrite && this.producers?.owns(key))
+            return { changed: false, state: null };
         if (key !== property.id) {
             this.logger.debug(`Skipping write for projected property id=${property.id}: its value belongs to source property id=${key}`);
             return { changed: false, state: null };
@@ -91,6 +470,8 @@ let PropertyValueService = class PropertyValueService {
         }
         const cached = this.valuesMap.get(key);
         if (!strict && cached && cached.value === value) {
+            if (ownedCurrent && !ownedCurrent())
+                return { changed: false, state: (0, property_value_state_model_1.clonePropertyValueState)(cached) };
             cached.lastUpdated = (valueTimestamp ?? new Date()).toISOString();
             this.bumpCacheVersion(key);
             return { changed: false, state: cached };
@@ -100,31 +481,14 @@ let PropertyValueService = class PropertyValueService {
             this.logger.warn(`Invalid value for property id=${property.id}: ${validationError}. Value=${JSON.stringify(value)}`);
             return { changed: false, state: null };
         }
-        const formattedValue = {};
-        switch (property.dataType) {
-            case devices_constants_1.DataTypeType.ENUM:
-            case devices_constants_1.DataTypeType.STRING:
-                formattedValue.stringValue = String(value);
-                break;
-            case devices_constants_1.DataTypeType.BOOL:
-                formattedValue.stringValue = String(value ? 'true' : 'false');
-                break;
-            case devices_constants_1.DataTypeType.CHAR:
-            case devices_constants_1.DataTypeType.UCHAR:
-            case devices_constants_1.DataTypeType.SHORT:
-            case devices_constants_1.DataTypeType.USHORT:
-            case devices_constants_1.DataTypeType.INT:
-            case devices_constants_1.DataTypeType.UINT:
-            case devices_constants_1.DataTypeType.FLOAT:
-                formattedValue.numberValue = Number(value);
-                break;
-            default:
-                this.logger.error(`Unsupported data type dataType=${property.dataType} id=${property.id}`);
-                return { changed: false, state: null };
+        const formattedValue = ownedHistory ? ownedHistory.point?.fields : this.storageFields(property.dataType, value);
+        if (!formattedValue) {
+            this.logger.error(`Unsupported data type dataType=${property.dataType} id=${property.id}`);
+            return { changed: false, state: null };
         }
-        const timestamp = valueTimestamp ?? new Date();
+        const timestamp = ownedHistory?.timestamp ?? valueTimestamp ?? new Date();
         const now = timestamp.toISOString();
-        const point = {
+        const point = ownedHistory?.point ?? {
             measurement: 'property_value',
             tags: { propertyId: key },
             fields: formattedValue,
@@ -133,12 +497,13 @@ let PropertyValueService = class PropertyValueService {
         const cacheVersionAtWriteStart = this.cacheVersion(key);
         if (strict) {
             await this.storageService.writePointsStrict([point], storageBinding);
-            if (this.cacheVersion(key) !== cacheVersionAtWriteStart) {
+            if (this.cacheVersion(key) !== cacheVersionAtWriteStart || (ownedCurrent && !ownedCurrent())) {
                 return { changed: true, state: new property_value_state_model_1.PropertyValueState(value, now) };
             }
         }
-        if (typeof value === 'number' ||
-            (typeof value === 'string' && !isNaN(Number(value)) && this.isNumericDataType(property.dataType))) {
+        if ((!ownedCurrent || ownedCurrent()) &&
+            (typeof value === 'number' ||
+                (typeof value === 'string' && !isNaN(Number(value)) && this.isNumericDataType(property.dataType)))) {
             const numValue = Number(value);
             const recent = this.recentValuesMap.get(key) ?? [];
             recent.push(numValue);
@@ -149,108 +514,191 @@ let PropertyValueService = class PropertyValueService {
         }
         const trend = this.computeTrend(property, key);
         const state = new property_value_state_model_1.PropertyValueState(value, now, trend);
-        this.setCachedState(key, state);
+        if (!ownedCurrent || ownedCurrent())
+            this.setCachedState(key, state);
         if (strict) {
             return { changed: true, state };
         }
-        if (!this.storageService.isConnected()) {
+        if (!(ownedHistory ? ownedHistory.storage.connection() : this.storageService.isConnected())) {
             return { changed: true, state };
         }
         try {
             if (deferHistory) {
                 await this.storageService.enqueueWritePoint(point);
             }
+            else if (ownedHistory) {
+                await ownedHistory.storage.write();
+            }
             else {
                 await this.storageService.writePoints([point]);
             }
             this.logger.debug(`Value ${deferHistory ? 'queued' : 'saved'} id=${property.id} dataType=${property.dataType}`);
         }
         catch (error) {
+            if (ownedHistory) {
+                try {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.logger.error(`Failed to write original property history id=${property.id} error=${message}`);
+                }
+                catch {
+                }
+                return { changed: true, state };
+            }
             const err = error;
             this.logger.error(`Failed to write value to storage id=${property.id} dataType=${property.dataType} error=${err.message}`, err.stack);
         }
         return { changed: true, state };
     }
     async readLatest(property) {
-        return (await this.readLatestInternal(property, false)).state;
+        return (await this.readSingleProperty(property, false)).state;
     }
     async readLatestStrict(property) {
-        return (await this.readLatestInternal(property, true)).state;
+        return (await this.readSingleProperty(property, true)).state;
     }
     async readLatestPersisted(property) {
         return (await this.readLatestPersistedSnapshot(property)).state;
     }
     async readLatestPersistedSnapshot(property) {
-        await this.flushHistory();
-        const result = await this.readLatestInternal(property, true, true, true);
+        const result = await this.readSingleProperty(property, true, true);
         if (!result.storageBinding) {
             throw new Error('Persisted property value read did not bind a storage backend');
         }
         return { state: result.state, storageBinding: result.storageBinding };
     }
-    async readLatestManyStrict(properties) {
-        const states = new Map();
-        const missingByKey = new Map();
-        const keyByProperty = new Map();
-        for (const property of properties) {
-            const key = this.valueSourceRegistry.resolve(property);
-            keyByProperty.set(property.id, key);
-            const cached = this.valuesMap.get(key);
-            if (cached) {
-                states.set(property.id, cached);
+    async readSingleProperty(property, strict, persisted = false) {
+        let capture;
+        try {
+            capture = this.valueSourceRegistry.captureReadSource(property);
+        }
+        catch (error) {
+            if (strict)
+                throw error;
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error(`Failed to capture property value source error=${err.message}`, err.stack);
+            return { state: null };
+        }
+        try {
+            const input = this.valueSourceRegistry.readSourceInput(capture);
+            const key = this.valueSourceRegistry.readSourceKey(capture);
+            const reason = this.valueSourceRegistry.readSourceUnavailableReason(capture);
+            const overlay = (state) => {
+                this.assertReadSourceCurrent(capture);
+                return this.overlaySource(this.producers?.read(key), reason, state);
+            };
+            if (!persisted) {
+                const produced = overlay(null);
+                if (produced)
+                    return { state: produced };
             }
-            else if (!missingByKey.has(key)) {
-                missingByKey.set(key, property);
+            try {
+                if (persisted) {
+                    await this.flushHistory();
+                    this.assertReadSourceCurrent(capture);
+                }
+                const result = await this.readLatestInternal(input, strict, persisted, persisted, capture);
+                return { ...result, state: overlay(result.state) };
+            }
+            catch (error) {
+                try {
+                    if (!persisted && this.valueSourceRegistry.isReadSourceCurrent(capture)) {
+                        const produced = overlay(null);
+                        if (produced)
+                            return { state: produced };
+                    }
+                }
+                catch {
+                }
+                throw error;
             }
         }
-        if (missingByKey.size === 0) {
-            return states;
+        catch (error) {
+            if (strict)
+                throw error;
+            return { state: null };
         }
-        if (!this.storageService.isConnected()) {
-            throw new Error('Property value storage is unavailable');
+        finally {
+            this.valueSourceRegistry.closeReadSource(capture);
         }
-        const predicate = Array.from(missingByKey.keys())
-            .map((key) => `propertyId = '${this.escapeTagValue(key)}'`)
-            .join(' OR ');
-        const query = `
-        SELECT *
-        FROM property_value
-        WHERE (${predicate})
-		GROUP BY "propertyId"
-		ORDER BY time DESC
-		LIMIT ${TREND_POINTS_COUNT}
-      `;
+    }
+    assertReadSourceCurrent(capture) {
+        if (!this.valueSourceRegistry.isReadSourceCurrent(capture)) {
+            throw new Error('Property value source changed during read');
+        }
+    }
+    async readLatestManyStrict(properties) {
+        const captures = [];
         try {
-            const rows = await this.storageService.queryStrict(query);
-            const rowsByKey = new Map();
-            for (const row of rows) {
-                rowsByKey.set(row.propertyId, [...(rowsByKey.get(row.propertyId) ?? []), row]);
+            const entries = properties.map((property) => {
+                const capture = this.valueSourceRegistry.captureReadSource(property);
+                captures.push(capture);
+                return {
+                    capture,
+                    input: this.valueSourceRegistry.readSourceInput(capture),
+                    key: this.valueSourceRegistry.readSourceKey(capture),
+                    reason: this.valueSourceRegistry.readSourceUnavailableReason(capture),
+                };
+            });
+            const overlay = (entry, state) => {
+                this.assertReadSourceCurrent(entry.capture);
+                return this.overlaySource(this.producers?.read(entry.key), entry.reason, state);
+            };
+            const cachedStates = new Map();
+            const missingByKey = new Map();
+            const versions = new Map();
+            for (const entry of entries) {
+                const state = overlay(entry, null) ?? this.valuesMap.get(entry.key);
+                if (state) {
+                    cachedStates.set(entry.capture, state);
+                }
+                else if (!missingByKey.has(entry.key)) {
+                    missingByKey.set(entry.key, entry);
+                    versions.set(entry.key, this.cacheVersion(entry.key));
+                }
             }
-            for (const [key, property] of missingByKey) {
-                const propertyRows = rowsByKey.get(key) ?? [];
-                if (this.isNumericDataType(property.dataType)) {
-                    this.recentValuesMap.set(key, propertyRows
-                        .map((row) => row.numberValue)
-                        .filter((value) => value !== undefined)
-                        .reverse());
+            const rowsByKey = new Map();
+            if (missingByKey.size > 0) {
+                if (!this.storageService.isConnected()) {
+                    throw new Error('Property value storage is unavailable');
                 }
-                const state = propertyRows[0] ? this.toState(property, key, propertyRows[0]) : null;
-                if (state) {
-                    this.setCachedState(key, state);
+                const query = this.buildBoundedPropertyValueQuery([...missingByKey.keys()]);
+                const rows = await this.storageService.queryStrict(query);
+                for (const row of rows) {
+                    rowsByKey.set(row.propertyId, [...(rowsByKey.get(row.propertyId) ?? []), row]);
                 }
             }
-            for (const property of properties) {
-                if (!states.has(property.id)) {
-                    states.set(property.id, this.valuesMap.get(keyByProperty.get(property.id) ?? property.id) ?? null);
+            for (const entry of entries)
+                this.assertReadSourceCurrent(entry.capture);
+            const admitted = new Set();
+            for (const [key, entry] of missingByKey) {
+                if (this.cacheVersion(key) !== versions.get(key))
+                    continue;
+                const propertyRows = rowsByKey.get(key) ?? [];
+                admitted.add(key);
+                this.updateRecentValuesFromRows(entry.input, key, propertyRows);
+                if (propertyRows[0]) {
+                    this.setCachedState(key, this.toState(entry.input, key, propertyRows[0]));
                 }
             }
+            const states = new Map();
+            for (const entry of entries) {
+                const row = rowsByKey.get(entry.key)?.[0];
+                const state = cachedStates.get(entry.capture) ??
+                    (row && admitted.has(entry.key)
+                        ? this.toState(entry.input, entry.key, row)
+                        : (this.valuesMap.get(entry.key) ?? null));
+                states.set(entry.input.id, overlay(entry, state));
+            }
             return states;
         }
         catch (error) {
-            const err = error;
+            const err = error instanceof Error ? error : new Error(String(error));
             this.logger.error(`Failed to batch read latest property values from storage error=${err.message}`, err.stack);
             throw error;
         }
+        finally {
+            for (const capture of captures)
+                this.valueSourceRegistry.closeReadSource(capture);
+        }
     }
     async readLatestManyBounded(properties, options = {}) {
         if (properties.length > BOUNDED_READ_MAX_PROPERTIES) {
@@ -263,67 +711,129 @@ let PropertyValueService = class PropertyValueService {
         }
         const deadlineAt = Math.min(requestedDeadlineAt, startedAt + BOUNDED_READ_DEFAULT_DEADLINE_MS);
         const items = new Array(properties.length);
-        const sourcePropertyIds = new Array(properties.length);
+        const captures = [];
+        const entries = [];
         const unresolvedBySource = new Map();
-        for (const [index, property] of properties.entries()) {
-            const sourcePropertyId = this.valueSourceRegistry.resolve(property);
-            sourcePropertyIds[index] = sourcePropertyId;
-            const cached = this.valuesMap.get(sourcePropertyId);
-            if (cached) {
-                items[index] = this.toBoundedItem(property.id, sourcePropertyId, cached, 'cache');
-                continue;
-            }
-            const group = unresolvedBySource.get(sourcePropertyId);
-            if (group) {
-                group.indexes.push(index);
-            }
-            else {
-                unresolvedBySource.set(sourcePropertyId, { property, indexes: [index] });
+        let sourceResolutionFailed = false;
+        try {
+            for (const [index, property] of properties.entries()) {
+                let id = '';
+                try {
+                    id = Object.getOwnPropertyDescriptor(property, 'id')?.value;
+                    const capture = this.valueSourceRegistry.captureReadSource(property);
+                    captures.push(capture);
+                    entries[index] = {
+                        capture,
+                        input: this.valueSourceRegistry.readSourceInput(capture),
+                        key: this.valueSourceRegistry.readSourceKey(capture),
+                        reason: this.valueSourceRegistry.readSourceUnavailableReason(capture),
+                    };
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    this.logger.error(`Failed to capture bounded property value source error=${err.message}`, err.stack);
+                    sourceResolutionFailed = true;
+                    items[index] = {
+                        propertyId: typeof id === 'string' ? id : '',
+                        sourcePropertyId: null,
+                        status: 'unprocessed',
+                        source: null,
+                        state: null,
+                    };
+                }
             }
-        }
-        if (unresolvedBySource.size === 0) {
-            return this.buildBoundedResult(items, 'not_needed');
-        }
-        if (Date.now() >= deadlineAt) {
-            this.refreshBoundedItemsFromCache(items, properties, sourcePropertyIds);
-            this.fillUnprocessedBoundedItems(items, properties, unresolvedBySource);
-            return this.buildBoundedResult(items, 'timed_out');
-        }
-        if (!this.storageService.isConnected()) {
-            this.refreshBoundedItemsFromCache(items, properties, sourcePropertyIds);
-            this.fillUnprocessedBoundedItems(items, properties, unresolvedBySource);
-            return this.buildBoundedResult(items, 'disconnected');
-        }
-        const sourceEntries = [...unresolvedBySource.entries()];
-        let storageStatus = 'available';
-        for (let offset = 0; offset < sourceEntries.length; offset += BOUNDED_READ_SOURCE_CHUNK_SIZE) {
-            if (Date.now() >= deadlineAt) {
-                storageStatus = 'timed_out';
-                break;
+            for (const [index, entry] of entries.entries()) {
+                if (!entry || !this.valueSourceRegistry.isReadSourceCurrent(entry.capture))
+                    continue;
+                const produced = this.overlaySource(this.producers?.read(entry.key), entry.reason, null);
+                if (!this.valueSourceRegistry.isReadSourceCurrent(entry.capture))
+                    continue;
+                const state = produced ?? this.valuesMap.get(entry.key);
+                if (state) {
+                    items[index] = this.toBoundedItem(entry.input.id, entry.key, state, 'cache');
+                    entry.resultVersion = this.cacheVersion(entry.key);
+                    continue;
+                }
+                const group = unresolvedBySource.get(entry.key);
+                if (group)
+                    group.indexes.push(index);
+                else
+                    unresolvedBySource.set(entry.key, { indexes: [index], version: this.cacheVersion(entry.key) });
             }
-            const chunk = sourceEntries.slice(offset, offset + BOUNDED_READ_SOURCE_CHUNK_SIZE);
-            const query = this.buildBoundedPropertyValueQuery(chunk.map(([sourcePropertyId]) => sourcePropertyId));
-            try {
-                const queryResult = await this.queryPropertyValuesBeforeDeadline(query, deadlineAt);
-                if (queryResult === null) {
+            const finish = (status) => {
+                this.refreshBoundedItemsFromCache(items, entries);
+                this.overlayBoundedItems(items, entries);
+                return this.buildBoundedResult(items, status);
+            };
+            if (unresolvedBySource.size === 0)
+                return finish(sourceResolutionFailed ? 'failed' : 'not_needed');
+            if (Date.now() >= deadlineAt)
+                return finish('timed_out');
+            if (!this.storageService.isConnected())
+                return finish('disconnected');
+            const sourceEntries = [...unresolvedBySource.entries()];
+            let storageStatus = sourceResolutionFailed ? 'failed' : 'available';
+            for (let offset = 0; offset < sourceEntries.length; offset += BOUNDED_READ_SOURCE_CHUNK_SIZE) {
+                if (Date.now() >= deadlineAt) {
                     storageStatus = 'timed_out';
                     break;
                 }
-                this.applyBoundedStorageRows(items, properties, chunk, queryResult);
-                for (const [sourcePropertyId] of chunk) {
-                    unresolvedBySource.delete(sourcePropertyId);
+                const chunk = sourceEntries.slice(offset, offset + BOUNDED_READ_SOURCE_CHUNK_SIZE);
+                const query = this.buildBoundedPropertyValueQuery(chunk.map(([key]) => key));
+                try {
+                    const rows = await this.queryPropertyValuesBeforeDeadline(query, deadlineAt);
+                    if (rows === null) {
+                        storageStatus = 'timed_out';
+                        break;
+                    }
+                    this.applyBoundedStorageRows(items, entries, chunk, rows);
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    this.logger.error(`Failed to bounded-batch read latest property values error=${err.message}`, err.stack);
+                    storageStatus = 'failed';
+                    break;
                 }
             }
-            catch (error) {
-                const err = error;
-                this.logger.error(`Failed to bounded-batch read latest property values error=${err.message}`, err.stack);
-                storageStatus = 'failed';
-                break;
+            return finish(storageStatus);
+        }
+        finally {
+            for (const capture of captures)
+                this.valueSourceRegistry.closeReadSource(capture);
+        }
+    }
+    overlayBoundedItems(items, entries) {
+        for (const [index, entry] of entries.entries()) {
+            if (!entry)
+                continue;
+            if (!this.valueSourceRegistry.isReadSourceCurrent(entry.capture)) {
+                items[index] = undefined;
             }
+            else {
+                const produced = this.overlaySource(this.producers?.read(entry.key), entry.reason, null);
+                if (!this.valueSourceRegistry.isReadSourceCurrent(entry.capture))
+                    items[index] = undefined;
+                else if (produced)
+                    items[index] = this.toBoundedItem(entry.input.id, entry.key, produced, items[index]?.source ?? 'cache');
+            }
+        }
+        for (const [index, entry] of entries.entries()) {
+            if (entry && !this.valueSourceRegistry.isReadSourceCurrent(entry.capture))
+                items[index] = undefined;
+        }
+        for (const [index, entry] of entries.entries()) {
+            if (!entry)
+                continue;
+            if (!this.valueSourceRegistry.isReadSourceStructurallyCurrent(entry.capture))
+                items[index] = undefined;
+            items[index] ??= {
+                propertyId: entry.input.id,
+                sourcePropertyId: entry.key,
+                status: 'unprocessed',
+                source: null,
+                state: null,
+            };
         }
-        this.refreshBoundedItemsFromCache(items, properties, sourcePropertyIds);
-        this.fillUnprocessedBoundedItems(items, properties, unresolvedBySource);
-        return this.buildBoundedResult(items, storageStatus);
     }
     buildBoundedPropertyValueQuery(sourcePropertyIds) {
         const predicate = sourcePropertyIds
@@ -344,42 +854,59 @@ let PropertyValueService = class PropertyValueService {
             return null;
         }
         const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(new Error('Property value storage query timed out')), remainingMs);
+        let timeout;
+        const expired = () => {
+            controller.abort(new Error('Property value storage query timed out'));
+            return null;
+        };
         try {
-            return await this.storageService.queryStrict(query, { signal: controller.signal });
+            const deadline = new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(expired()), remainingMs);
+            });
+            const result = await Promise.race([
+                this.storageService.queryStrict(query, { signal: controller.signal }),
+                deadline,
+            ]);
+            return Date.now() >= deadlineAt ? expired() : result;
         }
         catch (error) {
-            if (controller.signal.aborted) {
-                return null;
-            }
+            if (Date.now() >= deadlineAt || controller.signal.aborted)
+                return expired();
             throw error;
         }
         finally {
             clearTimeout(timeout);
         }
     }
-    applyBoundedStorageRows(items, properties, chunk, rows) {
+    applyBoundedStorageRows(items, entries, chunk, rows) {
         const rowsBySource = new Map();
-        for (const row of rows) {
+        for (const row of rows)
             rowsBySource.set(row.propertyId, [...(rowsBySource.get(row.propertyId) ?? []), row]);
-        }
-        for (const [sourcePropertyId, group] of chunk) {
-            const sourceRows = rowsBySource.get(sourcePropertyId) ?? [];
+        for (const [key, group] of chunk) {
+            const currentEntries = group.indexes.flatMap((index) => {
+                const entry = entries[index];
+                return entry && this.valueSourceRegistry.isReadSourceCurrent(entry.capture) ? [{ index, entry }] : [];
+            });
+            const representative = currentEntries.find(({ entry }) => this.valueSourceRegistry.isReadSourceCurrent(entry.capture))?.entry;
+            if (!representative)
+                continue;
+            const sourceRows = rowsBySource.get(key) ?? [];
             const firstRow = sourceRows[0];
-            let storedState = firstRow ? this.toState(group.property, sourcePropertyId, firstRow) : null;
-            const concurrentCache = this.valuesMap.get(sourcePropertyId);
-            const useCache = concurrentCache !== undefined && this.isStateNewerOrEqual(concurrentCache, storedState);
-            if (!useCache && firstRow) {
-                this.updateRecentValuesFromRows(group.property, sourcePropertyId, sourceRows);
-                storedState = this.toState(group.property, sourcePropertyId, firstRow);
-            }
-            const state = useCache ? concurrentCache : storedState;
-            const source = useCache ? 'cache' : 'storage';
-            if (!useCache && storedState) {
-                this.setCachedState(sourcePropertyId, storedState);
+            const storedState = firstRow ? this.toState(representative.input, key, firstRow) : null;
+            const cached = this.valuesMap.get(key);
+            const changed = this.cacheVersion(key) !== group.version;
+            const useCache = changed || (cached !== undefined && this.isStateNewerOrEqual(cached, storedState));
+            if (!useCache) {
+                this.updateRecentValuesFromRows(representative.input, key, sourceRows);
+                if (firstRow)
+                    this.setCachedState(key, this.toState(representative.input, key, firstRow));
             }
-            for (const index of group.indexes) {
-                items[index] = this.toBoundedItem(properties[index].id, sourcePropertyId, state, source);
+            for (const { index, entry } of currentEntries) {
+                if (changed && !cached)
+                    continue;
+                const state = useCache ? (cached ?? null) : firstRow ? this.toState(entry.input, key, firstRow) : null;
+                items[index] = this.toBoundedItem(entry.input.id, key, state, useCache ? 'cache' : 'storage');
+                entry.resultVersion = this.cacheVersion(key);
             }
         }
     }
@@ -407,6 +934,16 @@ let PropertyValueService = class PropertyValueService {
         this.valuesMap.set(key, state);
         this.bumpCacheVersion(key);
     }
+    resolveBestEffort(property, operation) {
+        try {
+            return this.valueSourceRegistry.resolve(property);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error(`Failed to resolve property value source during ${operation} id=${property.id} error=${err.message}`, err.stack);
+            return null;
+        }
+    }
     samePersistedState(left, right) {
         return left?.value === right?.value && left?.lastUpdated === right?.lastUpdated;
     }
@@ -451,37 +988,21 @@ let PropertyValueService = class PropertyValueService {
             state: state,
         };
     }
-    refreshBoundedItemsFromCache(items, properties, sourcePropertyIds) {
-        for (const [index, property] of properties.entries()) {
-            const sourcePropertyId = sourcePropertyIds[index];
-            const cached = this.valuesMap.get(sourcePropertyId);
-            if (!cached) {
+    refreshBoundedItemsFromCache(items, entries) {
+        for (const [index, entry] of entries.entries()) {
+            if (!entry || !this.valueSourceRegistry.isReadSourceCurrent(entry.capture))
                 continue;
-            }
+            const cached = this.valuesMap.get(entry.key);
             const current = items[index];
-            if (current?.state === cached) {
+            if (entry.resultVersion !== undefined && this.cacheVersion(entry.key) !== entry.resultVersion) {
+                items[index] = cached ? this.toBoundedItem(entry.input.id, entry.key, cached, 'cache') : undefined;
                 continue;
             }
-            if (current?.state && !this.isStateNewerOrEqual(cached, current.state)) {
+            if (!cached || current?.state === cached)
                 continue;
-            }
-            items[index] = this.toBoundedItem(property.id, sourcePropertyId, cached, 'cache');
-        }
-    }
-    fillUnprocessedBoundedItems(items, properties, groups) {
-        for (const [sourcePropertyId, group] of groups) {
-            for (const index of group.indexes) {
-                if (items[index] !== undefined) {
-                    continue;
-                }
-                items[index] = {
-                    propertyId: properties[index].id,
-                    sourcePropertyId,
-                    status: 'unprocessed',
-                    source: null,
-                    state: null,
-                };
-            }
+            if (current?.state && this.isStateNewerOrEqual(current.state, cached))
+                continue;
+            items[index] = this.toBoundedItem(entry.input.id, entry.key, cached, 'cache');
         }
     }
     buildBoundedResult(items, storageStatus) {
@@ -515,8 +1036,22 @@ let PropertyValueService = class PropertyValueService {
             freshnessUnknownCount,
         };
     }
-    async readLatestInternal(property, strict, bypassCache = false, activeBackendOnly = false) {
-        const key = this.valueSourceRegistry.resolve(property);
+    async readLatestInternal(property, strict, bypassCache = false, activeBackendOnly = false, capture) {
+        const publication = controller_publication_context_1.ControllerPublicationContext.current();
+        const health = publication ? this.storageService.captureControllerReadHealth() : null;
+        let key;
+        try {
+            if (capture)
+                this.assertReadSourceCurrent(capture);
+            key = capture ? this.valueSourceRegistry.readSourceKey(capture) : this.valueSourceRegistry.resolve(property);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error(`Failed to resolve property value source id=${property.id} error=${err.message}`, err.stack);
+            if (strict)
+                throw error;
+            return { state: null };
+        }
         const cacheVersionAtQueryStart = this.cacheVersion(key);
         const cached = this.valuesMap.get(key);
         if (!bypassCache && cached) {
@@ -545,6 +1080,12 @@ let PropertyValueService = class PropertyValueService {
                 : strict
                     ? await this.storageService.queryStrict(query)
                     : await this.storageService.query(query);
+            if (capture)
+                this.assertReadSourceCurrent(capture);
+            if (publication && (!publication.isEligible() || !health())) {
+                const current = this.valuesMap.get(key);
+                return { state: current ? (0, property_value_state_model_1.clonePropertyValueState)(current) : null, storageBinding: boundResult?.binding };
+            }
             if (!result.length) {
                 this.logger.debug(`No stored value found for id=${property.id}`);
                 if (bypassCache && this.cacheVersion(key) === cacheVersionAtQueryStart) {
@@ -576,7 +1117,7 @@ let PropertyValueService = class PropertyValueService {
             return { state, storageBinding: boundResult?.binding };
         }
         catch (error) {
-            const err = error;
+            const err = error instanceof Error ? error : new Error(String(error));
             this.logger.error(`Failed to read latest value from storage id=${property.id} error=${err.message}`, err.stack);
             if (strict) {
                 throw error;
@@ -619,13 +1160,19 @@ let PropertyValueService = class PropertyValueService {
         return value.replaceAll('\\', '\\\\').replaceAll("'", "\\'");
     }
     async delete(property) {
-        const key = this.valueSourceRegistry.resolve(property);
+        const key = this.resolveBestEffort(property, 'delete');
+        if (key === null)
+            return;
         return this.withValueLock(key, () => this.deleteInternal(property, key));
     }
     async deleteInternal(property, key) {
         if (key !== property.id) {
             return;
         }
+        this.liveEpochs.delete(property.id);
+        this.samples.delete(property.id);
+        this.liveWatermarks.delete(property.id);
+        this.producers?.remove(property.id);
         this.valuesMap.delete(property.id);
         this.recentValuesMap.delete(property.id);
         this.bumpCacheVersion(property.id);
@@ -762,8 +1309,12 @@ let PropertyValueService = class PropertyValueService {
 exports.PropertyValueService = PropertyValueService;
 exports.PropertyValueService = PropertyValueService = __decorate([
     (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [storage_service_1.StorageService,
         property_value_source_registry_service_1.PropertyValueSourceRegistryService,
-        property_value_lock_service_1.PropertyValueLockService])
+        property_value_lock_service_1.PropertyValueLockService,
+        property_producer_registry_service_1.PropertyProducerRegistryService,
+        event_emitter_1.EventEmitter2])
 ], PropertyValueService);
 //# sourceMappingURL=property-value.service.js.map