@milaboratories/pl-tree 1.8.47 → 1.8.49

package/dist/state.js

@@ -1,627 +1,491 @@
-import { resourceIdToString, isNotNullResourceId, NullResourceId, isNullResourceId, stringifyWithResourceId } from '@milaboratories/pl-client';
-import { ChangeSource, KeyedChangeSource } from '@milaboratories/computable';
-import { PlTreeEntry } from './accessors.js';
-import { cachedDecode, cachedDeserialize, notEmpty } from '@milaboratories/ts-helpers';
+import { PlTreeEntry } from "./accessors.js";
+import { NullResourceId, isNotNullResourceId, isNullResourceId, resourceIdToString, stringifyWithResourceId } from "@milaboratories/pl-client";
+import { ChangeSource, KeyedChangeSource } from "@milaboratories/computable";
+import { cachedDecode, cachedDeserialize, notEmpty } from "@milaboratories/ts-helpers";
 
-class TreeStateUpdateError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-class PlTreeField {
-    name;
-    type;
-    value;
-    error;
-    status;
-    valueIsFinal;
-    resourceVersion;
-    change = new ChangeSource();
-    constructor(name, type, value, error, status, valueIsFinal, 
-    /** Last version of resource this field was observed, used to garbage collect fields in tree patching procedure */
-    resourceVersion) {
-        this.name = name;
-        this.type = type;
-        this.value = value;
-        this.error = error;
-        this.status = status;
-        this.valueIsFinal = valueIsFinal;
-        this.resourceVersion = resourceVersion;
-    }
-    get state() {
-        return {
-            name: this.name,
-            type: this.type,
-            status: this.status,
-            value: this.value,
-            error: this.error,
-            valueIsFinal: this.valueIsFinal,
-        };
-    }
-}
+//#region src/state.ts
+var TreeStateUpdateError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
+var PlTreeField = class {
+	change = new ChangeSource();
+	constructor(name, type, value, error, status, valueIsFinal, resourceVersion) {
+		this.name = name;
+		this.type = type;
+		this.value = value;
+		this.error = error;
+		this.status = status;
+		this.valueIsFinal = valueIsFinal;
+		this.resourceVersion = resourceVersion;
+	}
+	get state() {
+		return {
+			name: this.name,
+			type: this.type,
+			status: this.status,
+			value: this.value,
+			error: this.error,
+			valueIsFinal: this.valueIsFinal
+		};
+	}
+};
 const InitialResourceVersion = 0;
 /** Never store instances of this class, always get fresh instance from {@link PlTreeState} */
-class PlTreeResource {
-    /** Tracks number of other resources referencing this resource. Used to perform garbage collection in tree patching procedure */
-    refCount = 0;
-    /** Increments each time resource is checked for difference with new state */
-    version = InitialResourceVersion;
-    /** Set to resource version when resource state, or it's fields have changed */
-    dataVersion = InitialResourceVersion;
-    fieldsMap = new Map();
-    kv = new Map();
-    resourceRemoved = new ChangeSource();
-    // following change source are removed when resource is marked as final
-    finalChanged = new ChangeSource();
-    resourceStateChange = new ChangeSource();
-    lockedChange = new ChangeSource();
-    inputAndServiceFieldListChanged = new ChangeSource();
-    outputFieldListChanged = new ChangeSource();
-    dynamicFieldListChanged = new ChangeSource();
-    // kvChangedGlobal? = new ChangeSource();
-    kvChangedPerKey = new KeyedChangeSource();
-    id;
-    originalResourceId;
-    kind;
-    type;
-    data;
-    dataAsString;
-    dataAsJson;
-    error;
-    inputsLocked;
-    outputsLocked;
-    resourceReady;
-    finalFlag;
-    /** Set externally by the tree, using {@link FinalResourceDataPredicate} */
-    _finalState = false;
-    logger;
-    constructor(initialState, logger) {
-        this.id = initialState.id;
-        this.originalResourceId = initialState.originalResourceId;
-        this.kind = initialState.kind;
-        this.type = initialState.type;
-        this.data = initialState.data;
-        this.error = initialState.error;
-        this.inputsLocked = initialState.inputsLocked;
-        this.outputsLocked = initialState.outputsLocked;
-        this.resourceReady = initialState.resourceReady;
-        this.finalFlag = initialState.final;
-        this.logger = logger;
-    }
-    // TODO add logging
-    info(msg) {
-        if (this.logger !== undefined)
-            this.logger.info(msg);
-    }
-    warn(msg) {
-        if (this.logger !== undefined)
-            this.logger.warn(msg);
-    }
-    get final() {
-        return this.finalFlag;
-    }
-    get finalState() {
-        return this._finalState;
-    }
-    get fields() {
-        return [...this.fieldsMap.values()];
-    }
-    getField(watcher, _step, onUnstable = () => { }) {
-        const step = typeof _step === "string" ? { field: _step } : _step;
-        const field = this.fieldsMap.get(step.field);
-        if (field === undefined) {
-            if (step.errorIfFieldNotFound || step.errorIfFieldNotSet)
-                throw new Error(`Field "${step.field}" not found in resource ${resourceIdToString(this.id)}`);
-            if (!this.inputsLocked)
-                this.inputAndServiceFieldListChanged?.attachWatcher(watcher);
-            else if (step.assertFieldType === "Service" || step.assertFieldType === "Input") {
-                if (step.allowPermanentAbsence)
-                    // stable absence of field
-                    return undefined;
-                else
-                    throw new Error(`Service or input field not found ${step.field}.`);
-            }
-            if (!this.outputsLocked)
-                this.outputFieldListChanged?.attachWatcher(watcher);
-            else if (step.assertFieldType === "Output") {
-                if (step.allowPermanentAbsence)
-                    // stable absence of field
-                    return undefined;
-                else
-                    throw new Error(`Output field not found ${step.field}.`);
-            }
-            this.dynamicFieldListChanged?.attachWatcher(watcher);
-            if (!this._finalState && !step.stableIfNotFound)
-                onUnstable("field_not_found:" + step.field);
-            return undefined;
-        }
-        else {
-            if (step.assertFieldType !== undefined && field.type !== step.assertFieldType)
-                throw new Error(`Unexpected field type: expected ${step.assertFieldType} but got ${field.type} for the field name ${step.field}`);
-            const ret = {};
-            if (isNotNullResourceId(field.value))
-                ret.value = field.value;
-            if (isNotNullResourceId(field.error))
-                ret.error = field.error;
-            if (ret.value === undefined && ret.error === undefined)
-                // this method returns value and error of the field, thus those values are considered to be accessed;
-                // any existing but not resolved field here is considered to be unstable, in the sense it is
-                // considered to acquire some resolved value eventually
-                onUnstable("field_not_resolved:" + step.field);
-            field.change.attachWatcher(watcher);
-            return ret;
-        }
-    }
-    getInputsLocked(watcher) {
-        if (!this.inputsLocked)
-            // reverse transition can't happen, so there is no reason to wait for value to change
-            this.resourceStateChange?.attachWatcher(watcher);
-        return this.inputsLocked;
-    }
-    getOutputsLocked(watcher) {
-        if (!this.outputsLocked)
-            // reverse transition can't happen, so there is no reason to wait for value to change
-            this.resourceStateChange?.attachWatcher(watcher);
-        return this.outputsLocked;
-    }
-    get isReadyOrError() {
-        return (this.error !== NullResourceId ||
-            this.resourceReady ||
-            this.originalResourceId !== NullResourceId);
-    }
-    getIsFinal(watcher) {
-        this.finalChanged?.attachWatcher(watcher);
-        return this._finalState;
-    }
-    getIsReadyOrError(watcher) {
-        if (!this.isReadyOrError)
-            // reverse transition can't happen, so there is no reason to wait for value to change if it is already true
-            this.resourceStateChange?.attachWatcher(watcher);
-        return this.isReadyOrError;
-    }
-    getError(watcher) {
-        if (isNullResourceId(this.error)) {
-            this.resourceStateChange?.attachWatcher(watcher);
-            return undefined;
-        }
-        else {
-            // reverse transition can't happen, so there is no reason to wait for value to change, if error already set
-            return this.error;
-        }
-    }
-    listInputFields(watcher) {
-        const ret = [];
-        this.fieldsMap.forEach((field, name) => {
-            if (field.type === "Input" || field.type === "Service")
-                ret.push(name);
-        });
-        if (!this.inputsLocked)
-            this.inputAndServiceFieldListChanged?.attachWatcher(watcher);
-        return ret;
-    }
-    listOutputFields(watcher) {
-        const ret = [];
-        this.fieldsMap.forEach((field, name) => {
-            if (field.type === "Output")
-                ret.push(name);
-        });
-        if (!this.outputsLocked)
-            this.outputFieldListChanged?.attachWatcher(watcher);
-        return ret;
-    }
-    listDynamicFields(watcher) {
-        const ret = [];
-        this.fieldsMap.forEach((field, name) => {
-            if (field.type !== "Input" && field.type !== "Output")
-                ret.push(name);
-        });
-        this.dynamicFieldListChanged?.attachWatcher(watcher);
-        return ret;
-    }
-    getKeyValue(watcher, key) {
-        this.kvChangedPerKey?.attachWatcher(key, watcher);
-        return this.kv.get(key);
-    }
-    getKeyValueString(watcher, key) {
-        const bytes = this.getKeyValue(watcher, key);
-        if (bytes === undefined)
-            return undefined;
-        return cachedDecode(bytes);
-    }
-    getKeyValueAsJson(watcher, key) {
-        const bytes = this.getKeyValue(watcher, key);
-        if (bytes === undefined)
-            return undefined;
-        return cachedDeserialize(bytes);
-    }
-    getDataAsString() {
-        if (this.data === undefined)
-            return undefined;
-        if (this.dataAsString === undefined)
-            this.dataAsString = cachedDecode(this.data);
-        return this.dataAsString;
-    }
-    getDataAsJson() {
-        if (this.data === undefined)
-            return undefined;
-        if (this.dataAsJson === undefined)
-            this.dataAsJson = cachedDeserialize(this.data);
-        return this.dataAsJson;
-    }
-    verifyReadyState() {
-        if (this.resourceReady && !this.inputsLocked)
-            throw new Error(`ready without input or output lock: ${stringifyWithResourceId(this.basicState)}`);
-    }
-    get basicState() {
-        return {
-            id: this.id,
-            kind: this.kind,
-            type: this.type,
-            data: this.data,
-            resourceReady: this.resourceReady,
-            inputsLocked: this.inputsLocked,
-            outputsLocked: this.outputsLocked,
-            error: this.error,
-            originalResourceId: this.originalResourceId,
-            final: this.finalFlag,
-        };
-    }
-    get extendedState() {
-        return {
-            ...this.basicState,
-            fields: this.fields,
-            kv: Array.from(this.kv.entries()).map(([key, value]) => ({ key, value })),
-        };
-    }
-    /** Called when {@link FinalResourceDataPredicate} returns true for the state. */
-    markFinal() {
-        if (this._finalState)
-            return;
-        this._finalState = true;
-        notEmpty(this.finalChanged).markChanged("marked final");
-        this.finalChanged = undefined;
-        this.resourceStateChange = undefined;
-        this.dynamicFieldListChanged = undefined;
-        this.inputAndServiceFieldListChanged = undefined;
-        this.outputFieldListChanged = undefined;
-        this.lockedChange = undefined;
-        // this.kvChangedGlobal = undefined;
-        this.kvChangedPerKey = undefined;
-    }
-    /** Used for invalidation */
-    markAllChanged() {
-        this.fieldsMap.forEach((field) => field.change.markChanged("marked all changed"));
-        this.finalChanged?.markChanged("marked all changed");
-        this.resourceStateChange?.markChanged("marked all changed");
-        this.lockedChange?.markChanged("marked all changed");
-        this.inputAndServiceFieldListChanged?.markChanged("marked all changed");
-        this.outputFieldListChanged?.markChanged("marked all changed");
-        this.dynamicFieldListChanged?.markChanged("marked all changed");
-        // this.kvChangedGlobal?.markChanged('marked all changed');
-        this.kvChangedPerKey?.markAllChanged("marked all changed");
-        this.resourceRemoved.markChanged("marked all changed");
-    }
-}
-class PlTreeState {
-    root;
-    isFinalPredicate;
-    /** resource heap */
-    resources = new Map();
-    resourcesAdded = new ChangeSource();
-    /** Resets to false if any invalid state transitions are registered,
-     * after that tree will produce errors for any read or write operations */
-    _isValid = true;
-    invalidationMessage;
-    constructor(
-    /** This will be the only resource not deleted during GC round */
-    root, isFinalPredicate) {
-        this.root = root;
-        this.isFinalPredicate = isFinalPredicate;
-    }
-    forEachResource(cb) {
-        this.resources.forEach((v) => cb(v));
-    }
-    checkValid() {
-        if (!this._isValid)
-            throw new Error(this.invalidationMessage ?? "tree is in invalid state");
-    }
-    get(watcher, rid) {
-        this.checkValid();
-        const res = this.resources.get(rid);
-        if (res === undefined) {
-            // to make recovery from resource not found possible, considering some
-            // race conditions, where computable is created before tree is updated
-            this.resourcesAdded.attachWatcher(watcher);
-            throw new Error(`resource ${resourceIdToString(rid)} not found in the tree`);
-        }
-        res.resourceRemoved.attachWatcher(watcher);
-        return res;
-    }
-    updateFromResourceData(resourceData, allowOrphanInputs = false) {
-        this.checkValid();
-        // All resources for which recount should be incremented, first are aggregated in this list
-        const incrementRefs = [];
-        const decrementRefs = [];
-        // patching / creating resources
-        for (const rd of resourceData) {
-            let resource = this.resources.get(rd.id);
-            const statBeforeMutation = resource?.basicState;
-            const unexpectedTransitionError = (reason) => {
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const { fields, ...rdWithoutFields } = rd;
-                this.invalidateTree();
-                throw new TreeStateUpdateError(`Unexpected resource state transition (${reason}): ${stringifyWithResourceId(rdWithoutFields)} -> ${stringifyWithResourceId(statBeforeMutation)}`);
-            };
-            if (resource !== undefined) {
-                // updating existing resource
-                if (resource.finalState)
-                    unexpectedTransitionError("resource state can\t be updated after it is marked as final");
-                let changed = false;
-                // updating resource version, even if it was not changed
-                resource.version += 1;
-                // duplicate / original
-                if (resource.originalResourceId !== rd.originalResourceId) {
-                    if (resource.originalResourceId !== NullResourceId)
-                        unexpectedTransitionError("originalResourceId can't change after it is set");
-                    resource.originalResourceId = rd.originalResourceId;
-                    // duplicate status of the resource counts as ready for the external observer
-                    notEmpty(resource.resourceStateChange).markChanged(`originalResourceId changed for ${resourceIdToString(resource.id)}`);
-                    changed = true;
-                }
-                // error
-                if (resource.error !== rd.error) {
-                    if (isNotNullResourceId(resource.error))
-                        unexpectedTransitionError("resource can't change attached error after it is set");
-                    resource.error = rd.error;
-                    incrementRefs.push(resource.error);
-                    notEmpty(resource.resourceStateChange).markChanged(`error changed for ${resourceIdToString(resource.id)}`);
-                    changed = true;
-                }
-                // updating fields
-                for (const fd of rd.fields) {
-                    let field = resource.fieldsMap.get(fd.name);
-                    if (!field) {
-                        // new field
-                        field = new PlTreeField(fd.name, fd.type, fd.value, fd.error, fd.status, fd.valueIsFinal, resource.version);
-                        if (isNotNullResourceId(fd.value))
-                            incrementRefs.push(fd.value);
-                        if (isNotNullResourceId(fd.error))
-                            incrementRefs.push(fd.error);
-                        if (fd.type === "Input" || fd.type === "Service") {
-                            if (resource.inputsLocked)
-                                unexpectedTransitionError(`adding ${fd.type} (${fd.name}) field while inputs locked`);
-                            notEmpty(resource.inputAndServiceFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
-                        }
-                        else if (fd.type === "Output") {
-                            if (resource.outputsLocked)
-                                unexpectedTransitionError(`adding ${fd.type} (${fd.name}) field while outputs locked`);
-                            notEmpty(resource.outputFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
-                        }
-                        else {
-                            notEmpty(resource.dynamicFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
-                        }
-                        resource.fieldsMap.set(fd.name, field);
-                        changed = true;
-                    }
-                    else {
-                        // change of old field
-                        // in principle this transition is possible, see assertions below
-                        if (field.type !== fd.type) {
-                            if (field.type !== "Dynamic")
-                                unexpectedTransitionError(`field changed type ${field.type} -> ${fd.type}`);
-                            notEmpty(resource.dynamicFieldListChanged).markChanged(`field ${fd.name} changed type from Dynamic to ${fd.type} in ${resourceIdToString(resource.id)}`);
-                            if (field.type === "Input" || field.type === "Service") {
-                                if (resource.inputsLocked)
-                                    unexpectedTransitionError(`adding input field "${fd.name}", while corresponding list is locked`);
-                                notEmpty(resource.inputAndServiceFieldListChanged).markChanged(`field ${fd.name} changed to type ${fd.type} in ${resourceIdToString(resource.id)}`);
-                            }
-                            if (field.type === "Output") {
-                                if (resource.outputsLocked)
-                                    unexpectedTransitionError(`adding output field "${fd.name}", while corresponding list is locked`);
-                                notEmpty(resource.outputFieldListChanged).markChanged(`field ${fd.name} changed to type ${fd.type} in ${resourceIdToString(resource.id)}`);
-                            }
-                            field.type = fd.type;
-                            field.change.markChanged(`field ${fd.name} type changed to ${fd.type} in ${resourceIdToString(resource.id)}`);
-                            changed = true;
-                        }
-                        // field value
-                        if (field.value !== fd.value) {
-                            if (isNotNullResourceId(field.value))
-                                decrementRefs.push(field.value);
-                            field.value = fd.value;
-                            if (isNotNullResourceId(fd.value))
-                                incrementRefs.push(fd.value);
-                            field.change.markChanged(`field ${fd.name} value changed in ${resourceIdToString(resource.id)}`);
-                            changed = true;
-                        }
-                        // field error
-                        if (field.error !== fd.error) {
-                            if (isNotNullResourceId(field.error))
-                                decrementRefs.push(field.error);
-                            field.error = fd.error;
-                            if (isNotNullResourceId(fd.error))
-                                incrementRefs.push(fd.error);
-                            field.change.markChanged(`field ${fd.name} error changed in ${resourceIdToString(resource.id)}`);
-                            changed = true;
-                        }
-                        // field status
-                        if (field.status !== fd.status) {
-                            field.status = fd.status;
-                            field.change.markChanged(`field ${fd.name} status changed to ${fd.status} in ${resourceIdToString(resource.id)}`);
-                            changed = true;
-                        }
-                        // field valueIsFinal flag
-                        if (field.valueIsFinal !== fd.valueIsFinal) {
-                            field.valueIsFinal = fd.valueIsFinal;
-                            field.change.markChanged(`field ${fd.name} valueIsFinal changed to ${fd.valueIsFinal} in ${resourceIdToString(resource.id)}`);
-                            changed = true;
-                        }
-                        field.resourceVersion = resource.version;
-                    }
-                }
-                // detecting removed fields
-                resource.fieldsMap.forEach((field, fieldName, fields) => {
-                    if (field.resourceVersion !== resource.version) {
-                        if (field.type === "Input" || field.type === "Service" || field.type === "Output")
-                            unexpectedTransitionError(`removal of ${field.type} field ${fieldName}`);
-                        field.change.markChanged(`dynamic field ${fieldName} removed from ${resourceIdToString(resource.id)}`);
-                        fields.delete(fieldName);
-                        if (isNotNullResourceId(field.value))
-                            decrementRefs.push(field.value);
-                        if (isNotNullResourceId(field.error))
-                            decrementRefs.push(field.error);
-                        notEmpty(resource.dynamicFieldListChanged).markChanged(`dynamic field ${fieldName} removed from ${resourceIdToString(resource.id)}`);
-                    }
-                });
-                // inputsLocked
-                if (resource.inputsLocked !== rd.inputsLocked) {
-                    if (resource.inputsLocked)
-                        unexpectedTransitionError("inputs unlocking is not permitted");
-                    resource.inputsLocked = rd.inputsLocked;
-                    notEmpty(resource.lockedChange).markChanged(`inputs locked for ${resourceIdToString(resource.id)}`);
-                    changed = true;
-                }
-                // outputsLocked
-                if (resource.outputsLocked !== rd.outputsLocked) {
-                    if (resource.outputsLocked)
-                        unexpectedTransitionError("outputs unlocking is not permitted");
-                    resource.outputsLocked = rd.outputsLocked;
-                    notEmpty(resource.lockedChange).markChanged(`outputs locked for ${resourceIdToString(resource.id)}`);
-                    changed = true;
-                }
-                // ready flag
-                if (resource.resourceReady !== rd.resourceReady) {
-                    const readyStateBefore = resource.resourceReady;
-                    resource.resourceReady = rd.resourceReady;
-                    resource.verifyReadyState();
-                    if (!resource.isReadyOrError)
-                        unexpectedTransitionError(`resource can't lose it's ready or error state (ready state before ${readyStateBefore})`);
-                    notEmpty(resource.resourceStateChange).markChanged(`ready flag changed to ${rd.resourceReady} for ${resourceIdToString(resource.id)}`);
-                    changed = true;
-                }
-                // syncing kv
-                for (const kv of rd.kv) {
-                    const current = resource.kv.get(kv.key);
-                    if (current === undefined) {
-                        resource.kv.set(kv.key, kv.value);
-                        notEmpty(resource.kvChangedPerKey).markChanged(kv.key, `kv added for ${resourceIdToString(resource.id)}: ${kv.key}`);
-                    }
-                    else if (Buffer.compare(current, kv.value) !== 0) {
-                        resource.kv.set(kv.key, kv.value);
-                        notEmpty(resource.kvChangedPerKey).markChanged(kv.key, `kv changed for ${resourceIdToString(resource.id)}: ${kv.key}`);
-                    }
-                }
-                if (resource.kv.size > rd.kv.length) {
-                    // only it this case it makes sense to check for deletions
-                    const newStateKeys = new Set(rd.kv.map((kv) => kv.key));
-                    // deleting keys not present in resource anymore
-                    resource.kv.forEach((_value, key, map) => {
-                        if (!newStateKeys.has(key)) {
-                            map.delete(key);
-                            notEmpty(resource.kvChangedPerKey).markChanged(key, `kv deleted for ${resourceIdToString(resource.id)}: ${key}`);
-                        }
-                    });
-                }
-                if (changed) {
-                    // if resource was changed, updating resource data version
-                    resource.dataVersion = resource.version;
-                    if (this.isFinalPredicate(resource))
-                        resource.markFinal();
-                }
-            }
-            else {
-                // creating new resource
-                resource = new PlTreeResource(rd);
-                resource.verifyReadyState();
-                if (isNotNullResourceId(resource.error))
-                    incrementRefs.push(resource.error);
-                for (const fd of rd.fields) {
-                    const field = new PlTreeField(fd.name, fd.type, fd.value, fd.error, fd.status, fd.valueIsFinal, InitialResourceVersion);
-                    if (isNotNullResourceId(fd.value))
-                        incrementRefs.push(fd.value);
-                    if (isNotNullResourceId(fd.error))
-                        incrementRefs.push(fd.error);
-                    resource.fieldsMap.set(fd.name, field);
-                }
-                // adding kv
-                for (const kv of rd.kv)
-                    resource.kv.set(kv.key, kv.value);
-                // checking that resource is final, and if so, marking it
-                if (this.isFinalPredicate(resource))
-                    resource.markFinal();
-                // adding the resource to the heap
-                this.resources.set(resource.id, resource);
-                this.resourcesAdded.markChanged(`new resource ${resourceIdToString(resource.id)} added`);
-            }
-        }
-        // applying refCount increments
-        for (const rid of incrementRefs) {
-            const res = this.resources.get(rid);
-            if (!res) {
-                this.invalidateTree();
-                throw new TreeStateUpdateError(`orphan resource ${rid}`);
-            }
-            res.refCount++;
-        }
-        // recursively applying refCount decrements / doing garbage collection
-        let currentRefs = decrementRefs;
-        while (currentRefs.length > 0) {
-            const nextRefs = [];
-            for (const rid of currentRefs) {
-                const res = this.resources.get(rid);
-                if (!res) {
-                    this.invalidateTree();
-                    throw new TreeStateUpdateError(`orphan resource ${rid}`);
-                }
-                res.refCount--;
-                // garbage collection
-                if (res.refCount === 0 && res.id !== this.root) {
-                    // removing fields
-                    res.fieldsMap.forEach((field) => {
-                        if (isNotNullResourceId(field.value))
-                            nextRefs.push(field.value);
-                        if (isNotNullResourceId(field.error))
-                            nextRefs.push(field.error);
-                        field.change.markChanged(`field ${field.name} removed during garbage collection of ${resourceIdToString(res.id)}`);
-                    });
-                    if (isNotNullResourceId(res.error))
-                        nextRefs.push(res.error);
-                    res.resourceRemoved.markChanged(`resource removed during garbage collection: ${resourceIdToString(res.id)}`);
-                    this.resources.delete(rid);
-                }
-            }
-            currentRefs = nextRefs;
-        }
-        // checking for orphans (maybe removed in the future)
-        if (!allowOrphanInputs) {
-            for (const rd of resourceData) {
-                if (!this.resources.has(rd.id)) {
-                    this.invalidateTree();
-                    throw new TreeStateUpdateError(`orphan input resource ${rd.id}`);
-                }
-            }
-        }
-    }
-    /** @deprecated use "entry" instead */
-    accessor(rid = this.root) {
-        this.checkValid();
-        return this.entry(rid);
-    }
-    entry(rid = this.root) {
-        this.checkValid();
-        return new PlTreeEntry({ treeProvider: () => this }, rid);
-    }
-    invalidateTree(msg) {
-        this._isValid = false;
-        this.invalidationMessage = msg;
-        this.resources.forEach((res) => {
-            res.markAllChanged();
-        });
-    }
-    dumpState() {
-        return Array.from(this.resources.values()).map((res) => res.extendedState);
-    }
-}
+var PlTreeResource = class {
+	/** Tracks number of other resources referencing this resource. Used to perform garbage collection in tree patching procedure */
+	refCount = 0;
+	/** Increments each time resource is checked for difference with new state */
+	version = InitialResourceVersion;
+	/** Set to resource version when resource state, or it's fields have changed */
+	dataVersion = InitialResourceVersion;
+	fieldsMap = /* @__PURE__ */ new Map();
+	kv = /* @__PURE__ */ new Map();
+	resourceRemoved = new ChangeSource();
+	finalChanged = new ChangeSource();
+	resourceStateChange = new ChangeSource();
+	lockedChange = new ChangeSource();
+	inputAndServiceFieldListChanged = new ChangeSource();
+	outputFieldListChanged = new ChangeSource();
+	dynamicFieldListChanged = new ChangeSource();
+	kvChangedPerKey = new KeyedChangeSource();
+	id;
+	originalResourceId;
+	kind;
+	type;
+	data;
+	dataAsString;
+	dataAsJson;
+	error;
+	inputsLocked;
+	outputsLocked;
+	resourceReady;
+	finalFlag;
+	/** Set externally by the tree, using {@link FinalResourceDataPredicate} */
+	_finalState = false;
+	logger;
+	constructor(initialState, logger) {
+		this.id = initialState.id;
+		this.originalResourceId = initialState.originalResourceId;
+		this.kind = initialState.kind;
+		this.type = initialState.type;
+		this.data = initialState.data;
+		this.error = initialState.error;
+		this.inputsLocked = initialState.inputsLocked;
+		this.outputsLocked = initialState.outputsLocked;
+		this.resourceReady = initialState.resourceReady;
+		this.finalFlag = initialState.final;
+		this.logger = logger;
+	}
+	info(msg) {
+		if (this.logger !== void 0) this.logger.info(msg);
+	}
+	warn(msg) {
+		if (this.logger !== void 0) this.logger.warn(msg);
+	}
+	get final() {
+		return this.finalFlag;
+	}
+	get finalState() {
+		return this._finalState;
+	}
+	get fields() {
+		return [...this.fieldsMap.values()];
+	}
+	getField(watcher, _step, onUnstable = () => {}) {
+		const step = typeof _step === "string" ? { field: _step } : _step;
+		const field = this.fieldsMap.get(step.field);
+		if (field === void 0) {
+			if (step.errorIfFieldNotFound || step.errorIfFieldNotSet) throw new Error(`Field "${step.field}" not found in resource ${resourceIdToString(this.id)}`);
+			if (!this.inputsLocked) this.inputAndServiceFieldListChanged?.attachWatcher(watcher);
+			else if (step.assertFieldType === "Service" || step.assertFieldType === "Input") if (step.allowPermanentAbsence) return void 0;
+			else throw new Error(`Service or input field not found ${step.field}.`);
+			if (!this.outputsLocked) this.outputFieldListChanged?.attachWatcher(watcher);
+			else if (step.assertFieldType === "Output") if (step.allowPermanentAbsence) return void 0;
+			else throw new Error(`Output field not found ${step.field}.`);
+			this.dynamicFieldListChanged?.attachWatcher(watcher);
+			if (!this._finalState && !step.stableIfNotFound) onUnstable("field_not_found:" + step.field);
+			return;
+		} else {
+			if (step.assertFieldType !== void 0 && field.type !== step.assertFieldType) throw new Error(`Unexpected field type: expected ${step.assertFieldType} but got ${field.type} for the field name ${step.field}`);
+			const ret = {};
+			if (isNotNullResourceId(field.value)) ret.value = field.value;
+			if (isNotNullResourceId(field.error)) ret.error = field.error;
+			if (ret.value === void 0 && ret.error === void 0) onUnstable("field_not_resolved:" + step.field);
+			field.change.attachWatcher(watcher);
+			return ret;
+		}
+	}
+	getInputsLocked(watcher) {
+		if (!this.inputsLocked) this.resourceStateChange?.attachWatcher(watcher);
+		return this.inputsLocked;
+	}
+	getOutputsLocked(watcher) {
+		if (!this.outputsLocked) this.resourceStateChange?.attachWatcher(watcher);
+		return this.outputsLocked;
+	}
+	get isReadyOrError() {
+		return this.error !== NullResourceId || this.resourceReady || this.originalResourceId !== NullResourceId;
+	}
+	getIsFinal(watcher) {
+		this.finalChanged?.attachWatcher(watcher);
+		return this._finalState;
+	}
+	getIsReadyOrError(watcher) {
+		if (!this.isReadyOrError) this.resourceStateChange?.attachWatcher(watcher);
+		return this.isReadyOrError;
+	}
+	getError(watcher) {
+		if (isNullResourceId(this.error)) {
+			this.resourceStateChange?.attachWatcher(watcher);
+			return;
+		} else return this.error;
+	}
+	listInputFields(watcher) {
+		const ret = [];
+		this.fieldsMap.forEach((field, name) => {
+			if (field.type === "Input" || field.type === "Service") ret.push(name);
+		});
+		if (!this.inputsLocked) this.inputAndServiceFieldListChanged?.attachWatcher(watcher);
+		return ret;
+	}
+	listOutputFields(watcher) {
+		const ret = [];
+		this.fieldsMap.forEach((field, name) => {
+			if (field.type === "Output") ret.push(name);
+		});
+		if (!this.outputsLocked) this.outputFieldListChanged?.attachWatcher(watcher);
+		return ret;
+	}
+	listDynamicFields(watcher) {
+		const ret = [];
+		this.fieldsMap.forEach((field, name) => {
+			if (field.type !== "Input" && field.type !== "Output") ret.push(name);
+		});
+		this.dynamicFieldListChanged?.attachWatcher(watcher);
+		return ret;
+	}
+	getKeyValue(watcher, key) {
+		this.kvChangedPerKey?.attachWatcher(key, watcher);
+		return this.kv.get(key);
+	}
+	getKeyValueString(watcher, key) {
+		const bytes = this.getKeyValue(watcher, key);
+		if (bytes === void 0) return void 0;
+		return cachedDecode(bytes);
+	}
+	getKeyValueAsJson(watcher, key) {
+		const bytes = this.getKeyValue(watcher, key);
+		if (bytes === void 0) return void 0;
+		return cachedDeserialize(bytes);
+	}
+	getDataAsString() {
+		if (this.data === void 0) return void 0;
+		if (this.dataAsString === void 0) this.dataAsString = cachedDecode(this.data);
+		return this.dataAsString;
+	}
+	getDataAsJson() {
+		if (this.data === void 0) return void 0;
+		if (this.dataAsJson === void 0) this.dataAsJson = cachedDeserialize(this.data);
+		return this.dataAsJson;
+	}
+	verifyReadyState() {
+		if (this.resourceReady && !this.inputsLocked) throw new Error(`ready without input or output lock: ${stringifyWithResourceId(this.basicState)}`);
+	}
+	get basicState() {
+		return {
+			id: this.id,
+			kind: this.kind,
+			type: this.type,
+			data: this.data,
+			resourceReady: this.resourceReady,
+			inputsLocked: this.inputsLocked,
+			outputsLocked: this.outputsLocked,
+			error: this.error,
+			originalResourceId: this.originalResourceId,
+			final: this.finalFlag
+		};
+	}
+	get extendedState() {
+		return {
+			...this.basicState,
+			fields: this.fields,
+			kv: Array.from(this.kv.entries()).map(([key, value]) => ({
+				key,
+				value
+			}))
+		};
+	}
+	/** Called when {@link FinalResourceDataPredicate} returns true for the state. */
+	markFinal() {
+		if (this._finalState) return;
+		this._finalState = true;
+		notEmpty(this.finalChanged).markChanged("marked final");
+		this.finalChanged = void 0;
+		this.resourceStateChange = void 0;
+		this.dynamicFieldListChanged = void 0;
+		this.inputAndServiceFieldListChanged = void 0;
+		this.outputFieldListChanged = void 0;
+		this.lockedChange = void 0;
+		this.kvChangedPerKey = void 0;
+	}
+	/** Used for invalidation */
+	markAllChanged() {
+		this.fieldsMap.forEach((field) => field.change.markChanged("marked all changed"));
+		this.finalChanged?.markChanged("marked all changed");
+		this.resourceStateChange?.markChanged("marked all changed");
+		this.lockedChange?.markChanged("marked all changed");
+		this.inputAndServiceFieldListChanged?.markChanged("marked all changed");
+		this.outputFieldListChanged?.markChanged("marked all changed");
+		this.dynamicFieldListChanged?.markChanged("marked all changed");
+		this.kvChangedPerKey?.markAllChanged("marked all changed");
+		this.resourceRemoved.markChanged("marked all changed");
+	}
+};
+var PlTreeState = class {
+	/** resource heap */
+	resources = /* @__PURE__ */ new Map();
+	resourcesAdded = new ChangeSource();
+	/** Resets to false if any invalid state transitions are registered,
+	* after that tree will produce errors for any read or write operations */
+	_isValid = true;
+	invalidationMessage;
+	constructor(root, isFinalPredicate) {
+		this.root = root;
+		this.isFinalPredicate = isFinalPredicate;
+	}
+	forEachResource(cb) {
+		this.resources.forEach((v) => cb(v));
+	}
+	checkValid() {
+		if (!this._isValid) throw new Error(this.invalidationMessage ?? "tree is in invalid state");
+	}
+	get(watcher, rid) {
+		this.checkValid();
+		const res = this.resources.get(rid);
+		if (res === void 0) {
+			this.resourcesAdded.attachWatcher(watcher);
+			throw new Error(`resource ${resourceIdToString(rid)} not found in the tree`);
+		}
+		res.resourceRemoved.attachWatcher(watcher);
+		return res;
+	}
+	updateFromResourceData(resourceData, allowOrphanInputs = false) {
+		this.checkValid();
+		const incrementRefs = [];
+		const decrementRefs = [];
+		for (const rd of resourceData) {
+			let resource = this.resources.get(rd.id);
+			const statBeforeMutation = resource?.basicState;
+			const unexpectedTransitionError = (reason) => {
+				const { fields, ...rdWithoutFields } = rd;
+				this.invalidateTree();
+				throw new TreeStateUpdateError(`Unexpected resource state transition (${reason}): ${stringifyWithResourceId(rdWithoutFields)} -> ${stringifyWithResourceId(statBeforeMutation)}`);
+			};
+			if (resource !== void 0) {
+				if (resource.finalState) unexpectedTransitionError("resource state can	 be updated after it is marked as final");
+				let changed = false;
+				resource.version += 1;
+				if (resource.originalResourceId !== rd.originalResourceId) {
+					if (resource.originalResourceId !== NullResourceId) unexpectedTransitionError("originalResourceId can't change after it is set");
+					resource.originalResourceId = rd.originalResourceId;
+					notEmpty(resource.resourceStateChange).markChanged(`originalResourceId changed for ${resourceIdToString(resource.id)}`);
+					changed = true;
+				}
+				if (resource.error !== rd.error) {
+					if (isNotNullResourceId(resource.error)) unexpectedTransitionError("resource can't change attached error after it is set");
+					resource.error = rd.error;
+					incrementRefs.push(resource.error);
+					notEmpty(resource.resourceStateChange).markChanged(`error changed for ${resourceIdToString(resource.id)}`);
+					changed = true;
+				}
+				for (const fd of rd.fields) {
+					let field = resource.fieldsMap.get(fd.name);
+					if (!field) {
+						field = new PlTreeField(fd.name, fd.type, fd.value, fd.error, fd.status, fd.valueIsFinal, resource.version);
+						if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
+						if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);
+						if (fd.type === "Input" || fd.type === "Service") {
+							if (resource.inputsLocked) unexpectedTransitionError(`adding ${fd.type} (${fd.name}) field while inputs locked`);
+							notEmpty(resource.inputAndServiceFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
+						} else if (fd.type === "Output") {
+							if (resource.outputsLocked) unexpectedTransitionError(`adding ${fd.type} (${fd.name}) field while outputs locked`);
+							notEmpty(resource.outputFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
+						} else notEmpty(resource.dynamicFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
+						resource.fieldsMap.set(fd.name, field);
+						changed = true;
+					} else {
+						if (field.type !== fd.type) {
+							if (field.type !== "Dynamic") unexpectedTransitionError(`field changed type ${field.type} -> ${fd.type}`);
+							notEmpty(resource.dynamicFieldListChanged).markChanged(`field ${fd.name} changed type from Dynamic to ${fd.type} in ${resourceIdToString(resource.id)}`);
+							if (field.type === "Input" || field.type === "Service") {
+								if (resource.inputsLocked) unexpectedTransitionError(`adding input field "${fd.name}", while corresponding list is locked`);
+								notEmpty(resource.inputAndServiceFieldListChanged).markChanged(`field ${fd.name} changed to type ${fd.type} in ${resourceIdToString(resource.id)}`);
+							}
+							if (field.type === "Output") {
+								if (resource.outputsLocked) unexpectedTransitionError(`adding output field "${fd.name}", while corresponding list is locked`);
+								notEmpty(resource.outputFieldListChanged).markChanged(`field ${fd.name} changed to type ${fd.type} in ${resourceIdToString(resource.id)}`);
+							}
+							field.type = fd.type;
+							field.change.markChanged(`field ${fd.name} type changed to ${fd.type} in ${resourceIdToString(resource.id)}`);
+							changed = true;
+						}
+						if (field.value !== fd.value) {
+							if (isNotNullResourceId(field.value)) decrementRefs.push(field.value);
+							field.value = fd.value;
+							if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
+							field.change.markChanged(`field ${fd.name} value changed in ${resourceIdToString(resource.id)}`);
+							changed = true;
+						}
+						if (field.error !== fd.error) {
+							if (isNotNullResourceId(field.error)) decrementRefs.push(field.error);
+							field.error = fd.error;
+							if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);
+							field.change.markChanged(`field ${fd.name} error changed in ${resourceIdToString(resource.id)}`);
+							changed = true;
+						}
+						if (field.status !== fd.status) {
+							field.status = fd.status;
+							field.change.markChanged(`field ${fd.name} status changed to ${fd.status} in ${resourceIdToString(resource.id)}`);
+							changed = true;
+						}
+						if (field.valueIsFinal !== fd.valueIsFinal) {
+							field.valueIsFinal = fd.valueIsFinal;
+							field.change.markChanged(`field ${fd.name} valueIsFinal changed to ${fd.valueIsFinal} in ${resourceIdToString(resource.id)}`);
+							changed = true;
+						}
+						field.resourceVersion = resource.version;
+					}
+				}
+				resource.fieldsMap.forEach((field, fieldName, fields) => {
+					if (field.resourceVersion !== resource.version) {
+						if (field.type === "Input" || field.type === "Service" || field.type === "Output") unexpectedTransitionError(`removal of ${field.type} field ${fieldName}`);
+						field.change.markChanged(`dynamic field ${fieldName} removed from ${resourceIdToString(resource.id)}`);
+						fields.delete(fieldName);
+						if (isNotNullResourceId(field.value)) decrementRefs.push(field.value);
+						if (isNotNullResourceId(field.error)) decrementRefs.push(field.error);
+						notEmpty(resource.dynamicFieldListChanged).markChanged(`dynamic field ${fieldName} removed from ${resourceIdToString(resource.id)}`);
+					}
+				});
+				if (resource.inputsLocked !== rd.inputsLocked) {
+					if (resource.inputsLocked) unexpectedTransitionError("inputs unlocking is not permitted");
+					resource.inputsLocked = rd.inputsLocked;
+					notEmpty(resource.lockedChange).markChanged(`inputs locked for ${resourceIdToString(resource.id)}`);
+					changed = true;
+				}
+				if (resource.outputsLocked !== rd.outputsLocked) {
+					if (resource.outputsLocked) unexpectedTransitionError("outputs unlocking is not permitted");
+					resource.outputsLocked = rd.outputsLocked;
+					notEmpty(resource.lockedChange).markChanged(`outputs locked for ${resourceIdToString(resource.id)}`);
+					changed = true;
+				}
+				if (resource.resourceReady !== rd.resourceReady) {
+					const readyStateBefore = resource.resourceReady;
+					resource.resourceReady = rd.resourceReady;
+					resource.verifyReadyState();
+					if (!resource.isReadyOrError) unexpectedTransitionError(`resource can't lose it's ready or error state (ready state before ${readyStateBefore})`);
+					notEmpty(resource.resourceStateChange).markChanged(`ready flag changed to ${rd.resourceReady} for ${resourceIdToString(resource.id)}`);
+					changed = true;
+				}
+				for (const kv of rd.kv) {
+					const current = resource.kv.get(kv.key);
+					if (current === void 0) {
+						resource.kv.set(kv.key, kv.value);
+						notEmpty(resource.kvChangedPerKey).markChanged(kv.key, `kv added for ${resourceIdToString(resource.id)}: ${kv.key}`);
+					} else if (Buffer.compare(current, kv.value) !== 0) {
+						resource.kv.set(kv.key, kv.value);
+						notEmpty(resource.kvChangedPerKey).markChanged(kv.key, `kv changed for ${resourceIdToString(resource.id)}: ${kv.key}`);
+					}
+				}
+				if (resource.kv.size > rd.kv.length) {
+					const newStateKeys = new Set(rd.kv.map((kv) => kv.key));
+					resource.kv.forEach((_value, key, map) => {
+						if (!newStateKeys.has(key)) {
+							map.delete(key);
+							notEmpty(resource.kvChangedPerKey).markChanged(key, `kv deleted for ${resourceIdToString(resource.id)}: ${key}`);
+						}
+					});
+				}
+				if (changed) {
+					resource.dataVersion = resource.version;
+					if (this.isFinalPredicate(resource)) resource.markFinal();
+				}
+			} else {
+				resource = new PlTreeResource(rd);
+				resource.verifyReadyState();
+				if (isNotNullResourceId(resource.error)) incrementRefs.push(resource.error);
+				for (const fd of rd.fields) {
+					const field = new PlTreeField(fd.name, fd.type, fd.value, fd.error, fd.status, fd.valueIsFinal, InitialResourceVersion);
+					if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
+					if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);
+					resource.fieldsMap.set(fd.name, field);
+				}
+				for (const kv of rd.kv) resource.kv.set(kv.key, kv.value);
+				if (this.isFinalPredicate(resource)) resource.markFinal();
+				this.resources.set(resource.id, resource);
+				this.resourcesAdded.markChanged(`new resource ${resourceIdToString(resource.id)} added`);
+			}
+		}
+		for (const rid of incrementRefs) {
+			const res = this.resources.get(rid);
+			if (!res) {
+				this.invalidateTree();
+				throw new TreeStateUpdateError(`orphan resource ${rid}`);
+			}
+			res.refCount++;
+		}
+		let currentRefs = decrementRefs;
+		while (currentRefs.length > 0) {
+			const nextRefs = [];
+			for (const rid of currentRefs) {
+				const res = this.resources.get(rid);
+				if (!res) {
+					this.invalidateTree();
+					throw new TreeStateUpdateError(`orphan resource ${rid}`);
+				}
+				res.refCount--;
+				if (res.refCount === 0 && res.id !== this.root) {
+					res.fieldsMap.forEach((field) => {
+						if (isNotNullResourceId(field.value)) nextRefs.push(field.value);
+						if (isNotNullResourceId(field.error)) nextRefs.push(field.error);
+						field.change.markChanged(`field ${field.name} removed during garbage collection of ${resourceIdToString(res.id)}`);
+					});
+					if (isNotNullResourceId(res.error)) nextRefs.push(res.error);
+					res.resourceRemoved.markChanged(`resource removed during garbage collection: ${resourceIdToString(res.id)}`);
+					this.resources.delete(rid);
+				}
+			}
+			currentRefs = nextRefs;
+		}
+		if (!allowOrphanInputs) {
+			for (const rd of resourceData) if (!this.resources.has(rd.id)) {
+				this.invalidateTree();
+				throw new TreeStateUpdateError(`orphan input resource ${rd.id}`);
+			}
+		}
+	}
+	/** @deprecated use "entry" instead */
+	accessor(rid = this.root) {
+		this.checkValid();
+		return this.entry(rid);
+	}
+	entry(rid = this.root) {
+		this.checkValid();
+		return new PlTreeEntry({ treeProvider: () => this }, rid);
+	}
+	invalidateTree(msg) {
+		this._isValid = false;
+		this.invalidationMessage = msg;
+		this.resources.forEach((res) => {
+			res.markAllChanged();
+		});
+	}
+	dumpState() {
+		return Array.from(this.resources.values()).map((res) => res.extendedState);
+	}
+};
 
+//#endregion
 export { PlTreeResource, PlTreeState, TreeStateUpdateError };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map