@elyx-code/editor-ui 0.0.2

package/src/services/execution/value-resolution.ts

@@ -0,0 +1,4087 @@
+import {
+	EntityType,
+	PrimitiveTypes,
+	LiteralValueType,
+	UntypedObjectValue,
+	VARIABLE_TYPES,
+	ValueReadingEntityState,
+	VariableState,
+	generate,
+	toCamelCase,
+	ChangeSet,
+	ILiteralValueTransfer,
+	createStateFromTypeAndSubscribe,
+	ChangeSetEntityChangeType,
+	ValueAsTypeState,
+	getDeclaration,
+	UntypedValue,
+	DefinitionEntityState,
+	EntityId,
+	filterOutDuplicateEntities,
+	checkShouldInputOrOutputBePartOfFinalVariableObjectValue,
+	TERMINATION_TYPES,
+	EntityWithDefaultValueState,
+	checkIsLiteralValueEmpty,
+	ENTITY_WITH_DEFAULT_VALUE_TYPES,
+	PASS_THROUGH_CALLABLE_TYPES_WITH_OUTPUTS,
+	getParentCallableEntity,
+	CallableEntityState,
+	TerminationEntityState,
+	checkIsLiteralValueExplicitlyEmpty,
+	OperationState,
+	InternalCallState,
+	FunctionCallState,
+	checkIsRequiredValue,
+	SearchState,
+	ValueWritingEntityState,
+	checkIsNullable,
+	generatePlaceholderValueStore,
+	isObject,
+	BuiltInBaseEntityState,
+	OutputMapParentChildRelation,
+	resolveEntityName
+} from '@elyx-code/project-logic-tree';
+import {
+	ArgumentDeclarationState,
+	DraggableCallerEntityState,
+	DataTypeState,
+	EntityWithValueState,
+	DraggableExecutableEntityState,
+	OutputMapState,
+	InputMapState,
+	VariableDeclarationState,
+	VariableInstanceState,
+	ProjectState,
+	PropertyState,
+	ValueDescriptorState
+} from '@elyx-code/project-logic-tree';
+import {
+	DynamicValueTypes,
+	IDynamicValue,
+	IValueInheritanceLink,
+	IValueStoreClient
+} from '../editor/value-store';
+import { getParentCanvasEntity } from '@elyx-code/project-logic-tree';
+import { LiteralValueState } from '@elyx-code/project-logic-tree';
+import { safeResolveEntityName } from '@elyx-code/project-logic-tree';
+import { Execution, ExecutionState } from '.';
+
+const resolving = new Set<string>();
+
+// A payload that is passed to the value resolution function
+// To give optional context about the resolution of the value
+// For example, if only a local values' store should be used
+export interface IValueResolutionContext {
+	// Current execution instance in progress
+	execution?: Execution | null;
+	// The parent project
+	project: ProjectState;
+	// Local test values that the user can set in the canvas
+	localTestValues: IValueStoreClient;
+	// Resolved values cached so the calculation doesn't have to be done every time
+	resolvedValues: IValueStoreClient;
+	// Values saved from previous executions results
+	persistedExecutionResults: IValueStoreClient;
+	// Last execution results values from the last execution of their respective entities
+	// This values are temporary and used to save them to the 'persistedExecutionResults' or discard them after the execution
+	lastExecutionResults: IValueStoreClient;
+
+	// Value type preference for the resolution
+	getValueTypePreference: (
+		valueOwnerId: EntityId
+	) => DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null;
+	setValueTypePreference: (
+		valueOwnerId: EntityId,
+		valueTypePreference:
+			| DynamicValueTypes.DefaultValue
+			| DynamicValueTypes.Testing
+			| null
+	) => void;
+}
+
+export function generatePlaceholderValueResolutionContext(
+	project: ProjectState
+): IValueResolutionContext {
+	return {
+		execution: null,
+		project: project,
+		localTestValues: generatePlaceholderValueStore(
+			'local-test-values',
+			project
+		),
+		resolvedValues: generatePlaceholderValueStore(
+			'resolved-values',
+			project
+		),
+		persistedExecutionResults: generatePlaceholderValueStore(
+			'persisted-execution-results',
+			project
+		),
+		lastExecutionResults: generatePlaceholderValueStore(
+			'last-execution-results',
+			project
+		),
+		getValueTypePreference: () => null,
+		setValueTypePreference: () => {}
+	};
+}
+
+export function assembleAndAddLiteralValueFromDataType(
+	dataType: DataTypeState | null,
+	valueOwner: EntityWithDefaultValueState,
+	project: ProjectState,
+	changeSet: ChangeSet | null
+): LiteralValueState {
+	// Find existing literal value instance
+	let primitiveTypeName: PrimitiveTypes;
+
+	if (dataType?.entity?.type === EntityType.PrimitiveEntity) {
+		switch (dataType.entity.name) {
+			case PrimitiveTypes.EntityTemplate:
+				primitiveTypeName = PrimitiveTypes.EntityTemplate;
+				break;
+			case PrimitiveTypes.String:
+				primitiveTypeName = PrimitiveTypes.String;
+				break;
+			case PrimitiveTypes.Number:
+				primitiveTypeName = PrimitiveTypes.Number;
+				break;
+			case PrimitiveTypes.Boolean:
+				primitiveTypeName = PrimitiveTypes.Boolean;
+				break;
+			case PrimitiveTypes.Null:
+				primitiveTypeName = PrimitiveTypes.Null;
+				break;
+			case PrimitiveTypes.Enum:
+				primitiveTypeName = PrimitiveTypes.Enum;
+				break;
+			case PrimitiveTypes.KeyValue:
+				primitiveTypeName = PrimitiveTypes.KeyValue;
+				break;
+			case PrimitiveTypes.Untyped:
+				primitiveTypeName = PrimitiveTypes.Untyped;
+				break;
+			case PrimitiveTypes.KeyValue:
+				primitiveTypeName = PrimitiveTypes.KeyValue;
+				break;
+			case PrimitiveTypes.Date:
+				primitiveTypeName = PrimitiveTypes.Date;
+				break;
+			case PrimitiveTypes.UUID:
+				primitiveTypeName = PrimitiveTypes.UUID;
+				break;
+			case PrimitiveTypes.File:
+				primitiveTypeName = PrimitiveTypes.File;
+				break;
+			case PrimitiveTypes.Void:
+				primitiveTypeName = PrimitiveTypes.Void;
+				break;
+			case PrimitiveTypes.ActionDescriptor:
+				primitiveTypeName = PrimitiveTypes.ActionDescriptor;
+				break;
+			case PrimitiveTypes.Bytes:
+				primitiveTypeName = PrimitiveTypes.Bytes;
+				break;
+			case PrimitiveTypes.SqlProgram:
+				primitiveTypeName = PrimitiveTypes.SqlProgram;
+				break;
+			default:
+				throw new Error(
+					`Primitive type ${safeResolveEntityName(
+						dataType.entity,
+						project
+					)} is not supported`
+				);
+		}
+	} else {
+		// This is a definition entity as a data type, so we always use an object
+		primitiveTypeName = PrimitiveTypes.Untyped;
+	}
+
+	const newLiteralValueTransfer: ILiteralValueTransfer =
+		LiteralValueState.new(changeSet);
+	newLiteralValueTransfer.name = primitiveTypeName;
+	newLiteralValueTransfer.parent = valueOwner.toReference();
+
+	const instance: LiteralValueState = createStateFromTypeAndSubscribe(
+		newLiteralValueTransfer,
+		project
+	) as LiteralValueState;
+
+	instance.hydrateAncestors();
+
+	changeSet?.add(instance, ChangeSetEntityChangeType.Added);
+
+	instance.addSelfToProject(changeSet);
+	instance.initChildren(changeSet);
+
+	return instance;
+}
+
+export function getEntitiesToPropagateValuesTo(
+	entity: EntityWithValueState,
+	project: ProjectState,
+	seenInRecursion: Set<EntityId> = new Set<EntityId>()
+): EntityWithValueState[] {
+	if (seenInRecursion.has(entity.id)) {
+		return [];
+	}
+
+	seenInRecursion.add(entity.id);
+
+	if (VARIABLE_TYPES.includes(entity.type)) {
+		const declaration = getDeclaration(entity as VariableState);
+
+		// The value always goes only to the variable declaration, from which all instances read from
+		return filterOutDuplicateEntities([
+			declaration,
+			...[declaration].flatMap((ent) =>
+				getEntitiesToPropagateValuesTo(ent, project, seenInRecursion)
+			)
+		]) as EntityWithValueState[];
+	} else if (entity.type === EntityType.OutputMap) {
+		if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			return filterOutDuplicateEntities([
+				entity,
+				entity.declaration,
+				...[entity, entity.declaration].flatMap((ent) =>
+					getEntitiesToPropagateValuesTo(
+						ent,
+						project,
+						seenInRecursion
+					)
+				)
+			]) as EntityWithValueState[];
+		}
+	} else if (entity.type === EntityType.InputMap) {
+		if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration?.static
+		) {
+			return filterOutDuplicateEntities([
+				entity.declaration,
+				...[entity.declaration].flatMap((ent) =>
+					getEntitiesToPropagateValuesTo(
+						ent,
+						project,
+						seenInRecursion
+					)
+				)
+			]) as EntityWithValueState[];
+		}
+		// } else if (TERMINATION_TYPES.includes(entity.parent.type)) {
+		// 	const equivalentInputMaps = [entity, ...entity.getCounterparts()];
+
+		// 	return filterOutDuplicateEntities([
+		// 		...equivalentInputMaps,
+		// 		...equivalentInputMaps.flatMap((ent) =>
+		// 			getEntitiesToPropagateValuesTo(ent, project, seenInRecursion)
+		// 		),
+		// 	]) as EntityWithValueState[];
+		// }
+	} else if (entity.type === EntityType.ValueDescriptor) {
+		if (entity.parent?.type === EntityType.Search) {
+			const counterpartInputMap = (
+				entity.parent as SearchState
+			).inputs.find((input) => input.declaration?.id === entity.id);
+
+			if (counterpartInputMap) {
+				return [counterpartInputMap];
+			}
+		}
+	}
+
+	return [entity];
+}
+
+/*
+	Values could be stale and no longer match the data-type of the entity
+	We need to check if the value is still valid,
+	if not, we attempt an auto-migration (when possible),
+	otherwise we discard the value and return `null`
+*/
+export function hydrateOrDiscardLiteralValue(
+	value: LiteralValueState,
+	_valueOwner: EntityWithValueState,
+	_project: ProjectState
+): LiteralValueState | null {
+	return value;
+}
+
+export function readValueFromWritter(
+	entity: ValueReadingEntityState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	const writerEntity = entity.readsValue;
+	let value: IDynamicValue | null = null;
+
+	const writersValue = resolveValue(
+		writerEntity as ValueWritingEntityState,
+		context,
+		onlyDefault
+	);
+
+	if (writersValue) {
+		const valueInheritanceLink: IValueInheritanceLink = {
+			sources: [writersValue],
+			target: entity
+		};
+
+		value = {
+			value: writersValue.value,
+			valueOwner: entity,
+			type: DynamicValueTypes.Inherited,
+			inheritanceLink: valueInheritanceLink
+		};
+	} else {
+		value = {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Inherited,
+			inheritanceLink: null
+		};
+	}
+
+	return value;
+}
+
+export function assembleStandaloneLiteralValueFromDataType(
+	dataType: DataTypeState | null,
+	valueOwner: EntityWithValueState | ValueDescriptorState | PropertyState,
+	project: ProjectState
+): LiteralValueState | null {
+	if (!valueOwner) {
+		return null;
+	}
+
+	// Find existing literal value instance
+	let primitiveTypeName: PrimitiveTypes;
+
+	if (dataType?.entity?.type === EntityType.PrimitiveEntity) {
+		switch (dataType.entity.name) {
+			case PrimitiveTypes.EntityTemplate:
+				primitiveTypeName = PrimitiveTypes.EntityTemplate;
+				break;
+			case PrimitiveTypes.String:
+				primitiveTypeName = PrimitiveTypes.String;
+				break;
+			case PrimitiveTypes.Number:
+				primitiveTypeName = PrimitiveTypes.Number;
+				break;
+			case PrimitiveTypes.Boolean:
+				primitiveTypeName = PrimitiveTypes.Boolean;
+				break;
+			case PrimitiveTypes.Null:
+				primitiveTypeName = PrimitiveTypes.Null;
+				break;
+			case PrimitiveTypes.Enum:
+				primitiveTypeName = PrimitiveTypes.Enum;
+				break;
+			case PrimitiveTypes.KeyValue:
+				primitiveTypeName = PrimitiveTypes.KeyValue;
+				break;
+			case PrimitiveTypes.Untyped:
+				primitiveTypeName = PrimitiveTypes.Untyped;
+				break;
+			case PrimitiveTypes.KeyValue:
+				primitiveTypeName = PrimitiveTypes.KeyValue;
+				break;
+			case PrimitiveTypes.Date:
+				primitiveTypeName = PrimitiveTypes.Date;
+				break;
+			case PrimitiveTypes.UUID:
+				primitiveTypeName = PrimitiveTypes.UUID;
+				break;
+			case PrimitiveTypes.File:
+				primitiveTypeName = PrimitiveTypes.File;
+				break;
+			case PrimitiveTypes.Void:
+				primitiveTypeName = PrimitiveTypes.Void;
+				break;
+			case PrimitiveTypes.ActionDescriptor:
+				primitiveTypeName = PrimitiveTypes.ActionDescriptor;
+				break;
+			case PrimitiveTypes.Bytes:
+				primitiveTypeName = PrimitiveTypes.Bytes;
+				break;
+			case PrimitiveTypes.SqlProgram:
+				primitiveTypeName = PrimitiveTypes.SqlProgram;
+				break;
+			default:
+				throw new Error(
+					`Primitive type ${safeResolveEntityName(
+						dataType.entity,
+						project
+					)} is not supported`
+				);
+		}
+	} else {
+		// This is a definition entity as a data type, so we always use an object
+		primitiveTypeName = PrimitiveTypes.Untyped;
+	}
+
+	const valueOwnerIsInProject = project.get(valueOwner.id);
+
+	if (!valueOwnerIsInProject) {
+		return null;
+	}
+
+	const newLiteralValueTransfer: ILiteralValueTransfer =
+		LiteralValueState.new(null);
+	newLiteralValueTransfer.name = primitiveTypeName;
+	newLiteralValueTransfer.standaloneParent = valueOwner.toReference();
+
+	let instance: LiteralValueState = new LiteralValueState(
+		newLiteralValueTransfer,
+		project
+	);
+
+	instance.hydrateAncestors();
+	instance.standalone = true;
+	instance.setStandaloneParent(valueOwner, null);
+
+	instance.initChildren(null);
+
+	return instance;
+}
+
+export function resolvePassThroughCallableValue(
+	entity:
+		| OperationState
+		| InternalCallState
+		| FunctionCallState
+		| SearchState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			const resolvedValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return resolvedValue;
+		}
+	}
+
+	const testValue = context.localTestValues?.readValue(entity.id);
+
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (
+		!!testValue &&
+		!onlyDefault &&
+		(preferrerType === null ||
+			preferrerType !== DynamicValueTypes.DefaultValue)
+	) {
+		const resolvedValue: IDynamicValue = {
+			value: testValue,
+			valueOwner: entity,
+			type: DynamicValueTypes.Testing,
+			inheritanceLink: null
+		};
+
+		return resolvedValue;
+	}
+
+	return {
+		value: null,
+		valueOwner: entity,
+		type: DynamicValueTypes.QueuedAutocalculation,
+		inheritanceLink: null
+	};
+}
+
+export function aggregateVariableInputsValues(
+	objectData: UntypedObjectValue,
+	entity: VariableDeclarationState | TerminationEntityState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): UntypedObjectValue {
+	const workingObject: UntypedObjectValue = {
+		...objectData
+	};
+	const inputs =
+		entity.type === EntityType.VariableDeclaration
+			? entity.inputs
+			: TERMINATION_TYPES.includes(entity.type)
+				? entity.outputs
+				: [];
+
+	if (!inputs || inputs.length === 0) {
+		return workingObject;
+	}
+
+	for (const input of inputs) {
+		if (!checkShouldInputOrOutputBePartOfFinalVariableObjectValue(input)) {
+			continue;
+		}
+
+		// We use the standalone value resolution directly
+		// so the value is not inherited from the parent which would cause an endless loop
+		const value = resolveInputMapStandaloneValue(
+			input,
+			context,
+			onlyDefault
+		);
+
+		if (value && value.value) {
+			try {
+				// Not 'safe' resolveEntityName because if it fails we want to know, and skip the property
+				const resolvedName = resolveEntityName(input, context.project);
+				const codeName =
+					input.codeName ||
+					input.declaration?.codeName ||
+					toCamelCase(resolvedName);
+
+				workingObject[codeName] = checkIsLiteralValueEmpty(
+					value?.value || null
+				)
+					? workingObject[codeName]
+					: value?.value?.value;
+			} catch (error) {
+				// Do nothing, the name of the property couldn't be resolved, so we skip it
+			}
+		}
+	}
+
+	return workingObject;
+}
+
+export function aggregateVariableInputsNextValues(
+	objectData: UntypedObjectValue,
+	entity: VariableDeclarationState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): UntypedObjectValue {
+	const workingObject: UntypedObjectValue = {
+		...objectData
+	};
+	const inputs = entity.inputs;
+
+	if (!inputs) {
+		return workingObject;
+	}
+
+	for (const input of inputs) {
+		if (!checkShouldInputOrOutputBePartOfFinalVariableObjectValue(input)) {
+			continue;
+		}
+
+		// We use the standalone value resolution directly
+		// so the value is not inherited from the parent which would cause an endless loop
+		const value = resolveInputMapNextStandaloneValue(
+			input,
+			context,
+			onlyDefault
+		);
+
+		if (value && value.value) {
+			const resolvedName = safeResolveEntityName(input, context.project);
+			const codeName =
+				input.codeName ||
+				input.declaration?.codeName ||
+				toCamelCase(resolvedName);
+			workingObject[codeName] = value?.value?.value;
+		}
+	}
+
+	return workingObject;
+}
+
+/*
+	When setting values of a variable in the canvas. The values will be distributed in the following order:
+		1- The full value of the variabe is resolved first. From a connected value writer.
+		2- The full value resolved, pre-existing value.
+		3- Each input-map from their value writers.
+		4- Each input-map pre-existing values.
+
+	All values wrtte to the variables value state, as the single source of truth. Any test values assigned to the input maps are deleted.
+	Static property inputs are skipped, they don't inherit its part of the value from the parent.
+	They need to be written directly.
+*/
+export function resolveVarDeclarationNextAggregateObjectValue(
+	entity: VariableDeclarationState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	// The working object to add data to
+	let initialDefaultValue: UntypedObjectValue = {};
+
+	if (
+		entity.getDataType(null)?.entity?.type === EntityType.DefinitionEntity
+	) {
+		initialDefaultValue = {
+			...initialDefaultValue,
+			...(
+				entity.getDataType(null)?.entity as DefinitionEntityState
+			).getActiveRawDefaultValue()
+		};
+	}
+
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			if (isObject(lastExecutionValue.value)) {
+				const aggregate = {
+					...initialDefaultValue,
+					...(lastExecutionValue.value as UntypedObjectValue)
+				};
+
+				const newRawValue = {
+					...aggregateVariableInputsNextValues(
+						aggregate,
+						entity,
+						context,
+						onlyDefault
+					)
+				};
+
+				lastExecutionValue.metaSync(
+					{
+						value: newRawValue
+					},
+					null
+				);
+			}
+
+			const varDeclarationValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return varDeclarationValue;
+		}
+	}
+
+	const isThereActiveTest = !!context.execution?.entities.length;
+	const isPartOfTest = context.execution?.hasEntity(entity);
+
+	const writerEntity = entity.readsValue;
+	let value: IDynamicValue | null = null;
+
+	if (!!writerEntity) {
+		const isWriterPartOfTest = context.execution?.hasEntity(writerEntity);
+
+		// Should only read the value from the entity writing it, if:
+		const shouldInheritFromWriter =
+			// There isn't an active test
+			!isThereActiveTest ||
+			// Or there is an active test, and both entities are part of it
+			(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+			// Or there is an active test, but neither entity is a part it
+			(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+
+		if (shouldInheritFromWriter) {
+			value = readValueFromWritter(entity, context, onlyDefault);
+
+			// Aggregate the inputs values
+			if (value && value.value) {
+				if (isObject(value.value.value)) {
+					const aggregate = {
+						...initialDefaultValue,
+						...(value.value.value as UntypedObjectValue)
+					};
+
+					const newRawValue = {
+						...aggregateVariableInputsNextValues(
+							aggregate,
+							entity,
+							context,
+							onlyDefault
+						)
+					};
+
+					value.value.metaSync(
+						{
+							value: newRawValue
+						},
+						null
+					);
+				}
+			}
+		}
+	}
+
+	const defaultValue = entity.defaultValue;
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (!value && defaultValue) {
+		const literalValue: LiteralValueState | null = defaultValue;
+
+		if (
+			literalValue &&
+			literalValue.value === null &&
+			!!literalValue.autogeneration
+		) {
+			const autogeneratedValue = generate(literalValue);
+
+			literalValue.metaSync(
+				{
+					value: autogeneratedValue
+				},
+				null
+			);
+
+			if (isObject(autogeneratedValue)) {
+				const newRawValue = {
+					...aggregateVariableInputsNextValues(
+						autogeneratedValue as UntypedObjectValue,
+						entity,
+						context,
+						onlyDefault
+					)
+				};
+
+				literalValue.metaSync(
+					{
+						value: newRawValue
+					},
+					null
+				);
+			}
+		}
+
+		if (
+			onlyDefault ||
+			preferrerType === null ||
+			preferrerType !== DynamicValueTypes.Testing
+		) {
+			value = {
+				value: literalValue,
+				valueOwner: entity,
+				type: checkIsLiteralValueEmpty(literalValue)
+					? !!entity.readsValue
+						? DynamicValueTypes.Inherited
+						: DynamicValueTypes.Empty
+					: DynamicValueTypes.DefaultValue,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	if (
+		!value ||
+		((value.type === DynamicValueTypes.DefaultValue ||
+			value.type === DynamicValueTypes.External) &&
+			!onlyDefault) ||
+		preferrerType === DynamicValueTypes.Testing
+	) {
+		const localTestValue = context.localTestValues?.readValue(entity.id);
+
+		if (!!localTestValue) {
+			if (isObject(localTestValue.value)) {
+				const aggregate = {
+					...initialDefaultValue,
+					...(localTestValue.value as UntypedObjectValue)
+				};
+
+				const newRawValue = {
+					...aggregateVariableInputsNextValues(
+						aggregate,
+						entity,
+						context,
+						onlyDefault
+					)
+				};
+
+				localTestValue.metaSync(
+					{
+						value: newRawValue
+					},
+					null
+				);
+			}
+
+			return {
+				value: localTestValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	// Check if it is part of test but not required, then set as "empty"
+	if (checkIsLiteralValueEmpty(value?.value || null)) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: !!entity.readsValue
+				? DynamicValueTypes.Inherited
+				: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	return value;
+}
+
+/*
+	When variables' data-type is an object, with key-value pairs
+	The value of the variable is aggregated from different sources
+	The main variable's value as well as the collective resolved values of its inputs
+*/
+export function resolveVarDeclarationAggregateObjectValue(
+	entity: VariableDeclarationState | TerminationEntityState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	// The working object to add data to
+	let initialDefaultValue: UntypedObjectValue = {};
+
+	if (
+		entity.getDataType(null)?.entity?.type === EntityType.DefinitionEntity
+	) {
+		initialDefaultValue = {
+			...initialDefaultValue,
+			...(
+				entity.getDataType(null)?.entity as DefinitionEntityState
+			).getActiveRawDefaultValue()
+		};
+	} else if (
+		entity.getDataType(null)?.entity?.type === EntityType.BuiltInBaseEntity
+	) {
+		initialDefaultValue = {
+			...initialDefaultValue,
+			...(
+				entity.getDataType(null)?.entity as BuiltInBaseEntityState
+			).getRawDefaultValue()
+		};
+	}
+
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			if (isObject(lastExecutionValue.value)) {
+				const aggregate = {
+					...initialDefaultValue,
+					...(lastExecutionValue.value as UntypedObjectValue)
+				};
+
+				const valueWithAggregatedInputs = aggregateVariableInputsValues(
+					aggregate,
+					entity,
+					context,
+					onlyDefault
+				);
+
+				lastExecutionValue?.metaSync(
+					{
+						value: valueWithAggregatedInputs
+					},
+					null
+				);
+			}
+
+			const variableDeclarationValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return variableDeclarationValue;
+		}
+	}
+
+	const testValue = context.localTestValues?.readValue(entity.id);
+
+	let shouldInheritFromWriter = false;
+	if (entity.type === EntityType.VariableDeclaration) {
+		const varEntity = entity as VariableDeclarationState;
+		const isThereActiveTest = !!context.execution?.entities.length;
+		const isPartOfTest = context.execution?.hasEntity(entity);
+		const writerEntity = varEntity.readsValue;
+
+		if (!!writerEntity) {
+			const isWriterPartOfTest =
+				context.execution?.hasEntity(writerEntity);
+
+			shouldInheritFromWriter =
+				!isThereActiveTest ||
+				(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+				(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+		}
+	}
+
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (
+		!!testValue &&
+		!onlyDefault &&
+		(!shouldInheritFromWriter ||
+			preferrerType === DynamicValueTypes.Testing)
+	) {
+		if (isObject(testValue.value)) {
+			const aggregate = {
+				...initialDefaultValue,
+				...(testValue.value as UntypedObjectValue)
+			};
+
+			const valueWithAggregatedInputs = aggregateVariableInputsValues(
+				aggregate,
+				entity,
+				context,
+				onlyDefault
+			);
+
+			testValue.metaSync(
+				{
+					value: valueWithAggregatedInputs
+				},
+				null
+			);
+		}
+
+		const variableDeclarationValue: IDynamicValue = {
+			value: testValue,
+			valueOwner: entity,
+			type: DynamicValueTypes.Testing,
+			inheritanceLink: null
+		};
+
+		return variableDeclarationValue;
+	}
+
+	if (
+		!!entity.getDataType(null)?.entity &&
+		(entity.getDataType(null)?.entity?.type ===
+			EntityType.DefinitionEntity ||
+			entity.getDataType(null)?.entity?.type ===
+				EntityType.BuiltInBaseEntity) &&
+		entity.getDataType(null)?.isObject()
+	) {
+		const objectValue = assembleStandaloneLiteralValueFromDataType(
+			entity.dataType,
+			entity,
+			context.project
+		);
+
+		const valueWithAggregatedInputs = aggregateVariableInputsValues(
+			initialDefaultValue,
+			entity,
+			context,
+			onlyDefault
+		);
+
+		objectValue?.metaSync(
+			{
+				value: valueWithAggregatedInputs
+			},
+			null
+		);
+
+		const variableDeclarationValue: IDynamicValue = {
+			value: objectValue,
+			valueOwner: entity,
+			type: DynamicValueTypes.DefaultValue,
+			inheritanceLink: null
+		};
+
+		return variableDeclarationValue;
+	}
+
+	return null;
+}
+
+export function resolveVarDeclarationNextValue(
+	entity: VariableDeclarationState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (entity.dataType?.isObject()) {
+		return resolveVarDeclarationNextAggregateObjectValue(
+			entity,
+			context,
+			onlyDefault
+		);
+	}
+
+	const canvasParent = getParentCanvasEntity(entity) as
+		| DraggableExecutableEntityState
+		| DraggableCallerEntityState
+		| VariableDeclarationState;
+	const isThereActiveTest = !!context.execution?.entities.length;
+	const isPartOfTest = context.execution?.hasEntity(canvasParent);
+
+	const writerEntity = entity.readsValue;
+	let value: IDynamicValue | null = null;
+
+	if (!!writerEntity) {
+		const isWriterPartOfTest = context.execution?.hasEntity(writerEntity);
+
+		// Should only read the value from the entity writing it, if:
+		const shouldInheritFromWriter =
+			// There isn't an active test
+			!isThereActiveTest ||
+			// Or there is an active test, and both entities are part of it
+			(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+			// Or there is an active test, but neither entity is a part it
+			(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+
+		if (shouldInheritFromWriter) {
+			value = readValueFromWritter(entity, context, onlyDefault);
+		}
+	}
+
+	const defaultValue = entity.defaultValue;
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (!value && defaultValue) {
+		const literalValue: LiteralValueState | null = defaultValue;
+
+		if (
+			literalValue &&
+			literalValue.value === null &&
+			!!literalValue.autogeneration
+		) {
+			const autogeneratedValue = generate(literalValue);
+
+			literalValue.metaSync(
+				{
+					value: autogeneratedValue
+				},
+				null
+			);
+		}
+
+		if (
+			onlyDefault ||
+			preferrerType === null ||
+			preferrerType !== DynamicValueTypes.Testing
+		) {
+			value = {
+				value: literalValue,
+				valueOwner: entity,
+				type: checkIsLiteralValueEmpty(literalValue)
+					? !!entity.readsValue
+						? DynamicValueTypes.Inherited
+						: DynamicValueTypes.Empty
+					: DynamicValueTypes.DefaultValue,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	if (
+		!value ||
+		((value.type === DynamicValueTypes.DefaultValue ||
+			value.type === DynamicValueTypes.External) &&
+			!onlyDefault) ||
+		preferrerType === DynamicValueTypes.Testing
+	) {
+		const localTestValue = context.localTestValues?.readValue(entity.id);
+
+		if (!!localTestValue) {
+			return {
+				value: localTestValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	// Check if it is part of test but not required, then set as "empty"
+	if (checkIsLiteralValueEmpty(value?.value || null)) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: !!entity.readsValue
+				? DynamicValueTypes.Inherited
+				: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	return value;
+}
+
+export function resolveVarDeclarationValue(
+	entity: VariableDeclarationState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (entity.dataType?.isObject() || !!entity.outputs.length) {
+		return resolveVarDeclarationAggregateObjectValue(
+			entity,
+			context,
+			onlyDefault
+		);
+	}
+
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			const variableDeclarationValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return variableDeclarationValue;
+		}
+	}
+
+	const result = resolveVarDeclarationNextValue(entity, context, onlyDefault);
+	return result;
+}
+
+export function resolveVarInstanceNextValue(
+	entity: VariableInstanceState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	const isThereActiveTest = !!context.execution?.entities.length;
+	const isPartOfTest = context.execution?.hasEntity(entity);
+
+	let value: IDynamicValue | null = null;
+
+	const writerEntity = entity.readsValue;
+
+	if (!!writerEntity) {
+		const isWriterPartOfTest = context.execution?.hasEntity(writerEntity);
+
+		// Should only read the value from the entity writing it, if:
+		const shouldInheritFromWriter =
+			// There isn't an active test
+			!isThereActiveTest ||
+			// Or there is an active test, and both entities are part of it
+			(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+			// Or there is an active test, but neither entity is a part it
+			(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+
+		if (shouldInheritFromWriter) {
+			value = readValueFromWritter(entity, context, onlyDefault);
+		}
+	}
+
+	// Get the value of the declaration
+	const varDeclaration = entity.declaration;
+
+	if (!value && varDeclaration) {
+		const declarationValue = resolveVarDeclarationNextValue(
+			varDeclaration,
+			context,
+			onlyDefault
+		);
+
+		if (declarationValue && declarationValue.value) {
+			value = declarationValue;
+		}
+	}
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (
+		!value ||
+		((value.type === DynamicValueTypes.DefaultValue ||
+			value.type === DynamicValueTypes.External) &&
+			!onlyDefault) ||
+		preferrerType === DynamicValueTypes.Testing
+	) {
+		const localTestValue = context.localTestValues?.readValue(entity.id);
+
+		if (!!localTestValue) {
+			return {
+				value: localTestValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	const isDefinitionRequired = checkIsRequiredValue(entity);
+
+	const dataType = entity.getDataType(null);
+
+	const isMissing =
+		isDefinitionRequired &&
+		isPartOfTest &&
+		(!value?.value ||
+			(!checkIsNullable(dataType) &&
+				checkIsLiteralValueExplicitlyEmpty(
+					value?.value as LiteralValueState
+				)));
+
+	if (isMissing) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Missing,
+			inheritanceLink: null
+		};
+	}
+
+	// Check if it is part of test but not required, then set as "empty"
+	if (
+		isPartOfTest &&
+		!isDefinitionRequired &&
+		checkIsLiteralValueEmpty(value?.value || null)
+	) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: !!entity.readsValue
+				? DynamicValueTypes.Inherited
+				: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	// If there is a value return that one, otherwise return the definition of "External"
+	return (
+		value || {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.External,
+			inheritanceLink: null
+		}
+	);
+}
+
+export function resolveVarInstanceValue(
+	entity: VariableInstanceState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	return resolveVarDeclarationValue(
+		entity.declaration,
+		context,
+		onlyDefault
+	) as IDynamicValue | null;
+}
+
+export function resolveArgumentDeclarationValue(
+	entity: ArgumentDeclarationState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (
+		!onlyDefault &&
+		!!context.execution &&
+		context.execution.hasEntity(entity)
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			const argumentValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return argumentValue;
+		}
+	}
+
+	const isTopLevelExecution =
+		!context.execution || !context.execution.parentExecution;
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (isTopLevelExecution) {
+		const localTestValue = context.localTestValues?.readValue(entity.id);
+
+		if (
+			!!localTestValue &&
+			!onlyDefault &&
+			(preferrerType === null ||
+				preferrerType !== DynamicValueTypes.DefaultValue)
+		) {
+			return {
+				value: localTestValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	const canvasParent = getParentCanvasEntity(entity) as
+		| DraggableExecutableEntityState
+		| DraggableCallerEntityState
+		| VariableDeclarationState;
+
+	const loopBodyParent =
+		entity.parent.type === EntityType.FunctionDeclaration &&
+		entity.parent.parent.type === EntityType.Loop
+			? entity.parent
+			: null;
+
+	const isPartOfTest =
+		!!context.execution?.hasEntity(canvasParent) ||
+		(!!loopBodyParent && !!context.execution?.hasEntity(loopBodyParent));
+
+	let value: IDynamicValue | null = null;
+
+	const defaultValue = entity.defaultValue;
+
+	if (defaultValue) {
+		const literalValue: LiteralValueState | null = defaultValue || null;
+
+		if (
+			literalValue &&
+			literalValue.value === null &&
+			!!literalValue.autogeneration
+		) {
+			const autogeneratedValue = generate(literalValue);
+
+			literalValue.metaSync(
+				{
+					value: autogeneratedValue
+				},
+				null
+			);
+		}
+
+		if (
+			onlyDefault ||
+			preferrerType === null ||
+			preferrerType !== DynamicValueTypes.Testing
+		) {
+			value = {
+				value: literalValue,
+				valueOwner: entity,
+				type: checkIsLiteralValueEmpty(literalValue)
+					? DynamicValueTypes.Empty
+					: DynamicValueTypes.DefaultValue,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	if (
+		!value ||
+		((value.type === DynamicValueTypes.DefaultValue ||
+			value.type === DynamicValueTypes.External) &&
+			!onlyDefault) ||
+		preferrerType === DynamicValueTypes.Testing
+	) {
+		// Test value has been moved to the top of the function
+	}
+
+	const isDefinitionRequired = checkIsRequiredValue(entity);
+
+	const dataType = entity.getDataType(null);
+
+	let isMissing =
+		isDefinitionRequired &&
+		isPartOfTest &&
+		(!value?.value ||
+			(!checkIsNullable(dataType) &&
+				checkIsLiteralValueExplicitlyEmpty(
+					value?.value as LiteralValueState
+				)));
+
+	// The argument declaration of the body of a loop will be given values dynamically, so we don't need to check if it is missing
+	if (canvasParent.type === EntityType.Loop && isPartOfTest) {
+		isMissing = false;
+	}
+
+	if (isMissing) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Missing,
+			inheritanceLink: null
+		};
+	}
+
+	// Check if it is part of test but not required, then set as "empty"
+	if (
+		isPartOfTest &&
+		!isDefinitionRequired &&
+		checkIsLiteralValueEmpty(value?.value || null)
+	) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	// If there is a value return that one, otherwise return the definition of "External"
+	return (
+		value || {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.External,
+			inheritanceLink: null
+		}
+	);
+}
+
+export function resolveTerminationEntityValue(
+	entity: TerminationEntityState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (entity.getDataType(null)?.isObject() || !!entity.outputs.length) {
+		return resolveVarDeclarationAggregateObjectValue(entity, context);
+	}
+
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			const returnDeclarationValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return returnDeclarationValue;
+		}
+	}
+
+	const canvasParent = getParentCanvasEntity(entity) as
+		| DraggableExecutableEntityState
+		| DraggableCallerEntityState
+		| VariableDeclarationState;
+	const isThereActiveTest = !!context.execution?.entities.length;
+	const isPartOfTest = context.execution?.hasEntity(canvasParent);
+
+	const writerEntity = entity.readsValue;
+	let value: IDynamicValue | null = null;
+
+	if (!!writerEntity) {
+		const isWriterPartOfTest = context.execution?.hasEntity(writerEntity);
+
+		// Should only read the value from the entity writing it, if:
+		const shouldInheritFromWriter =
+			// There isn't an active test
+			!isThereActiveTest ||
+			// Or there is an active test, and both entities are part of it
+			(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+			// Or there is an active test, but neither entity is a part it
+			(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+
+		if (shouldInheritFromWriter) {
+			value = readValueFromWritter(entity, context, onlyDefault);
+		}
+	}
+
+	const defaultValue = entity.defaultValue;
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (!value && defaultValue) {
+		const literalValue: LiteralValueState | null = defaultValue;
+
+		if (
+			onlyDefault ||
+			preferrerType === null ||
+			preferrerType !== DynamicValueTypes.Testing
+		) {
+			value = {
+				value: literalValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.DefaultValue,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	if (
+		!value ||
+		((value.type === DynamicValueTypes.DefaultValue ||
+			value.type === DynamicValueTypes.External) &&
+			!onlyDefault) ||
+		preferrerType === DynamicValueTypes.Testing
+	) {
+		const localTestValue = context.localTestValues?.readValue(entity.id);
+
+		if (!!localTestValue) {
+			return {
+				value: localTestValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	const isDefinitionRequired = checkIsRequiredValue(entity);
+
+	const dataType = entity.getDataType(null);
+
+	const isMissing =
+		isDefinitionRequired &&
+		(!value?.value ||
+			(!checkIsNullable(dataType) &&
+				checkIsLiteralValueExplicitlyEmpty(
+					value?.value as LiteralValueState
+				)));
+
+	if (isMissing) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Missing,
+			inheritanceLink: null
+		};
+	}
+
+	if (!entity.defaultValue && !entity.readsValue) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Undefined,
+			inheritanceLink: null
+		};
+	}
+
+	// Check if it is part of test but not required, then set as "empty"
+	if (
+		!isDefinitionRequired &&
+		checkIsLiteralValueEmpty(value?.value || null)
+	) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: !!entity.readsValue
+				? DynamicValueTypes.Inherited
+				: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	return value;
+}
+
+export function resolveOutputMapValue(
+	entity: OutputMapState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			const outputValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return outputValue;
+		}
+	}
+
+	// If the outputMap is part of a test, and it is currently running, we shouldn't resolve the previously persisted execution value
+	// This could confuse users into thinking that this value is a result of the ongoing execution
+	const canvasParent = getParentCallableEntity(entity) as CallableEntityState;
+
+	if (PASS_THROUGH_CALLABLE_TYPES_WITH_OUTPUTS.includes(canvasParent.type)) {
+		const parentVarValue = resolveValue(
+			canvasParent as VariableState,
+			context,
+			onlyDefault
+		);
+
+		// Take own property from the parent variable
+		const resolveCodeName =
+			entity.codeName ||
+			entity.declaration?.codeName ||
+			toCamelCase(safeResolveEntityName(entity, context.project));
+
+		if (
+			!!parentVarValue?.value &&
+			// If the parent has a value, we want to read from it as a property of an object
+			// But that isn't the case for thrown errors. They are standalone values unrelated to the main returned value of the parent node
+			entity.parentRelationType !== OutputMapParentChildRelation.Error
+		) {
+			const propertyValue = ((parentVarValue.value
+				.value as UntypedObjectValue) || {})[resolveCodeName];
+
+			if (propertyValue === undefined) {
+				return {
+					value: null,
+					valueOwner: entity,
+					type: DynamicValueTypes.Undefined,
+					inheritanceLink: null
+				};
+			}
+
+			const literalValue = assembleStandaloneLiteralValueFromDataType(
+				entity.getDataType(null),
+				entity,
+				context.project
+			);
+
+			literalValue?.metaSync(
+				{
+					value: propertyValue,
+					rawString: typeof propertyValue === 'string' && typeof (parentVarValue?.value as any)?.rawString === 'string' ? (parentVarValue?.value as any)?.rawString : undefined
+				},
+				null
+			);
+
+			return {
+				value: literalValue,
+				valueOwner: entity,
+				type:
+					!VARIABLE_TYPES.includes(canvasParent.type) &&
+					parentVarValue.type === DynamicValueTypes.Empty
+						? DynamicValueTypes.QueuedAutocalculation
+						: parentVarValue.type,
+				inheritanceLink: {
+					sources: [parentVarValue],
+					target: entity
+				}
+			};
+		}
+
+		return {
+			value: null,
+			valueOwner: entity,
+			type: !VARIABLE_TYPES.includes(canvasParent.type)
+				? DynamicValueTypes.QueuedAutocalculation
+				: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	const isPartOfTest = context.execution?.hasEntity(canvasParent);
+	const isTestRunning = context.execution?.state === ExecutionState.Running;
+
+	if (
+		context.persistedExecutionResults?.values[entity.id] &&
+		!isPartOfTest &&
+		!isTestRunning &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.persistedExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (
+			lastExecutionValue?.value !== null ||
+			lastExecutionValue?.valueAsType !== null
+		) {
+			const outputValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return outputValue;
+		}
+	}
+
+	return null;
+}
+
+/*
+	The valve resolution of an input-map that belongs to an object variable, should try to resolve its value in the following order:
+		1- If it is a static property, resolve the global test value assingned to the owning property.
+		2- If it is a static property, resolve the default value of the owning property.
+		3- Take its part (object property) from the parent variable's test value.
+		4- Take its part from the parent var's default value.
+		5- Take its test value.
+		6- Take its default value.
+		7- Take its declaration's default value.
+*/
+export function resolveInputMapNextValueAsPropertyOfAnObject(
+	entity: InputMapState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (
+		![...TERMINATION_TYPES, ...VARIABLE_TYPES].includes(entity.parent.type)
+	) {
+		return null;
+	}
+
+	if (!checkShouldInputOrOutputBePartOfFinalVariableObjectValue(entity)) {
+		return null;
+	}
+
+	// Check if the declaration is a 'static' property
+	if (
+		entity.declaration?.type === EntityType.Property &&
+		entity.declaration.static
+	) {
+		const propertyValue = resolveValue(entity.declaration, context);
+
+		return propertyValue;
+	}
+
+	const nextValue = resolveInputMapNextStandaloneValue(
+		entity,
+		context,
+		onlyDefault
+	);
+
+	if (
+		!!nextValue &&
+		nextValue.type !== DynamicValueTypes.Empty &&
+		nextValue.type !== DynamicValueTypes.Missing &&
+		nextValue.type !== DynamicValueTypes.Undefined
+	) {
+		return nextValue;
+	}
+
+	const parentVar = getDeclaration(entity.parent as VariableState);
+	const parentVarValue = resolveNextValue(parentVar, context, onlyDefault);
+
+	// Take its own property from the parent variable
+	const resolveCodeName =
+		entity.codeName ||
+		entity.declaration?.codeName ||
+		toCamelCase(safeResolveEntityName(entity, context.project));
+
+	const literalValue = assembleStandaloneLiteralValueFromDataType(
+		entity.getDataType(null),
+		entity,
+		context.project
+	);
+
+	const isDefinitionRequired = checkIsRequiredValue(entity);
+
+	// If the parent variable has a value, and it is an object, then we can take the property from it
+	const rawParentObjectValue = parentVarValue?.value
+		?.value as UntypedObjectValue;
+
+	if (!!rawParentObjectValue) {
+		let ownRawValue = (rawParentObjectValue || {})[resolveCodeName];
+
+		// If falsy but not 'false' or '0', set as null
+		if (rawParentObjectValue[resolveCodeName] === undefined) {
+			return {
+				value: null,
+				valueOwner: entity,
+				type: DynamicValueTypes.Undefined,
+				inheritanceLink: {
+					sources: !!parentVarValue
+						? [parentVarValue as IDynamicValue]
+						: [],
+					target: entity
+				}
+			};
+		}
+
+		literalValue?.metaSync(
+			{
+				value: ownRawValue,
+				rawString: typeof ownRawValue === 'string' && typeof (parentVarValue?.value as any)?.rawString === 'string' ? (parentVarValue?.value as any)?.rawString : undefined
+			},
+			null
+		);
+
+		const isDefinitionRequired = checkIsRequiredValue(entity);
+
+		const dataType = entity.getDataType(null);
+
+		const isMissing =
+			isDefinitionRequired &&
+			(!literalValue ||
+				(!checkIsNullable(dataType) &&
+					checkIsLiteralValueExplicitlyEmpty(
+						literalValue as LiteralValueState
+					)));
+
+		if (isMissing) {
+			return {
+				value: null,
+				valueOwner: entity,
+				type: DynamicValueTypes.Missing,
+				inheritanceLink: null
+			};
+		}
+
+		return {
+			value: literalValue,
+			valueOwner: entity,
+			type: (parentVarValue as IDynamicValue).type,
+			inheritanceLink: {
+				sources: !!parentVarValue
+					? [parentVarValue as IDynamicValue]
+					: [],
+				target: entity
+			}
+		};
+	}
+
+	if (
+		parentVarValue?.type &&
+		parentVarValue.type !== DynamicValueTypes.Missing &&
+		parentVarValue.type !== DynamicValueTypes.Empty &&
+		parentVarValue.type !== DynamicValueTypes.Undefined
+	) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: parentVarValue.type,
+			inheritanceLink: {
+				sources: !!parentVarValue
+					? [parentVarValue as IDynamicValue]
+					: [],
+				target: entity
+			}
+		};
+	}
+
+	const isMissing = isDefinitionRequired;
+
+	if (isMissing) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Missing,
+			inheritanceLink: null
+		};
+	}
+
+	return {
+		value: null,
+		valueOwner: entity,
+		type: !!entity.readsValue
+			? DynamicValueTypes.Inherited
+			: DynamicValueTypes.Empty,
+		inheritanceLink: null
+	};
+}
+
+export function resolveInputMapValueAsPropertyOfAnObject(
+	entity: InputMapState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (
+		![...TERMINATION_TYPES, ...VARIABLE_TYPES].includes(entity.parent.type)
+	) {
+		return null;
+	}
+
+	if (!checkShouldInputOrOutputBePartOfFinalVariableObjectValue(entity)) {
+		return null;
+	}
+
+	// Check if the declaration is a 'static' property
+	if (
+		entity.declaration?.type === EntityType.Property &&
+		entity.declaration.static
+	) {
+		const propertyValue = resolveValue(
+			entity.declaration,
+			context,
+			onlyDefault
+		);
+
+		return propertyValue;
+	}
+
+	const parentVar: VariableDeclarationState | TerminationEntityState =
+		TERMINATION_TYPES.includes(entity.parent.type)
+			? (entity.parent as TerminationEntityState)
+			: getDeclaration(entity.parent as VariableState);
+	const parentVarValue = resolveValue(parentVar, context, onlyDefault);
+
+	let entityToUse: InputMapState = entity;
+
+	if (parentVar.type === EntityType.VariableDeclaration) {
+		const counterPartInDeclaration =
+			entity.parent === parentVar
+				? entity
+				: parentVar.inputs.find(
+						(input) =>
+							input.declaration?.id === entity.declaration?.id
+					);
+
+		entityToUse = counterPartInDeclaration || entity;
+	}
+
+	const ownValue = resolveInputMapStandaloneValue(
+		entityToUse as InputMapState,
+		context,
+		onlyDefault
+	);
+
+	const resolveCodeName =
+		entity.codeName ||
+		entity.declaration?.codeName ||
+		toCamelCase(safeResolveEntityName(entity, context.project));
+
+	const literalValue =
+		entity.defaultValue ||
+		assembleStandaloneLiteralValueFromDataType(
+			entity.getDataType(null),
+			entity,
+			context.project
+		);
+
+	// If the parent variable has a value, and it is an object, then we can take the property from it
+	const rawParentObjectValue = parentVarValue?.value
+		?.value as UntypedObjectValue;
+
+	if (
+		(parentVarValue?.type === DynamicValueTypes.ExecutionResult ||
+			parentVarValue?.type === DynamicValueTypes.Testing) &&
+		!onlyDefault
+	) {
+		if (!!rawParentObjectValue) {
+			let ownRawValue = (rawParentObjectValue || {})[resolveCodeName];
+
+			// If falsy but not 'false' or '0', set as null
+			if (
+				rawParentObjectValue[resolveCodeName] === undefined &&
+				!entity.readsValue &&
+				!entity.defaultValue
+			) {
+				return {
+					value: null,
+					valueOwner: entity,
+					type: DynamicValueTypes.Undefined,
+					inheritanceLink: {
+						sources: !!parentVarValue
+							? [parentVarValue as IDynamicValue]
+							: [],
+						target: entity
+					}
+				};
+			}
+
+			literalValue?.metaSync(
+				{
+					value: ownRawValue,
+					rawString: typeof ownRawValue === 'string' && typeof (parentVarValue?.value as any)?.rawString === 'string' ? (parentVarValue?.value as any)?.rawString : undefined
+				},
+				null
+			);
+
+			return {
+				value: literalValue,
+				valueOwner: entity,
+				type: (parentVarValue as IDynamicValue).type,
+				inheritanceLink: {
+					sources: !!parentVarValue
+						? [parentVarValue as IDynamicValue]
+						: [],
+					target: entity
+				}
+			};
+		}
+	}
+
+	if (
+		!!ownValue &&
+		ownValue.type !== DynamicValueTypes.Empty &&
+		ownValue.type !== DynamicValueTypes.Missing &&
+		ownValue.type !== DynamicValueTypes.Undefined
+	) {
+		return ownValue;
+	}
+
+	if (!!rawParentObjectValue) {
+		let ownRawValue = (rawParentObjectValue || {})[resolveCodeName];
+		// If falsy but not 'false' or '0', set as null
+		if (
+			rawParentObjectValue[resolveCodeName] !== undefined &&
+			!!literalValue?.standaloneParent
+		) {
+			literalValue?.metaSync(
+				{
+					value: ownRawValue,
+					rawString: typeof ownRawValue === 'string' && typeof (parentVarValue?.value as any)?.rawString === 'string' ? (parentVarValue?.value as any)?.rawString : undefined
+				},
+				null
+			);
+		}
+
+		const isDefinitionRequired = checkIsRequiredValue(entity);
+
+		const dataType = entity.getDataType(null);
+
+		const isMissing =
+			isDefinitionRequired &&
+			(!literalValue ||
+				(!checkIsNullable(dataType) &&
+					checkIsLiteralValueExplicitlyEmpty(
+						literalValue as LiteralValueState
+					)));
+
+		const isThereActiveTest = !!context.execution?.entities.length;
+		const isPartOfTest = context.execution?.hasEntity(parentVar);
+
+		const parentWriterEntity = parentVar.readsValue;
+
+		if (!!parentWriterEntity) {
+			const isWriterPartOfTest =
+				context.execution?.hasEntity(parentWriterEntity);
+
+			// Should only read the value from the entity writing it, if:
+			const parentIsInheriting =
+				// There isn't an active test
+				!isThereActiveTest ||
+				// Or there is an active test, and both entities are part of it
+				(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+				// Or there is an active test, but neither entity is a part it
+				(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+
+			if (isMissing && parentIsInheriting) {
+				return {
+					value: null,
+					valueOwner: entity,
+					type: DynamicValueTypes.Inherited,
+					inheritanceLink: null
+				};
+			}
+		}
+
+		if (!!entity.readsValue) {
+			const isWriterPartOfTest = context.execution?.hasEntity(
+				entity.readsValue
+			);
+
+			// Should only read the value from the entity writing it, if:
+			const isInheriting =
+				// There isn't an active test
+				!isThereActiveTest ||
+				// Or there is an active test, and both entities are part of it
+				(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+				// Or there is an active test, but neither entity is a part it
+				(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+
+			if (isMissing && isInheriting) {
+				return {
+					value: null,
+					valueOwner: entity,
+					type: DynamicValueTypes.Inherited,
+					inheritanceLink: null
+				};
+			}
+		}
+
+		if (isMissing) {
+			return {
+				value: null,
+				valueOwner: entity,
+				type: DynamicValueTypes.Missing,
+				inheritanceLink: null
+			};
+		}
+
+		if (
+			rawParentObjectValue[resolveCodeName] === undefined &&
+			!entity.readsValue &&
+			!entity.defaultValue
+		) {
+			return {
+				value: null,
+				valueOwner: entity,
+				type: DynamicValueTypes.Undefined,
+				inheritanceLink: {
+					sources: !!parentVarValue
+						? [parentVarValue as IDynamicValue]
+						: [],
+					target: entity
+				}
+			};
+		}
+
+		return {
+			value: literalValue,
+			valueOwner: entity,
+			type:
+				checkIsLiteralValueEmpty(literalValue) && !entity.readsValue
+					? DynamicValueTypes.Empty
+					: DynamicValueTypes.Inherited,
+			inheritanceLink: null
+		};
+	}
+
+	return {
+		value: null,
+		valueOwner: entity,
+		type: DynamicValueTypes.Undefined,
+		inheritanceLink: null
+	};
+}
+
+export function resolveInputMapNextStandaloneValue(
+	entity: InputMapState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	const canvasParent = getParentCanvasEntity(entity) as
+		| DraggableExecutableEntityState
+		| DraggableCallerEntityState
+		| VariableDeclarationState;
+	const isThereActiveTest = !!context.execution?.entities.length;
+	const isPartOfTest = context.execution?.hasEntity(canvasParent);
+
+	const writerEntity = entity.readsValue;
+	let value: IDynamicValue | null = null;
+	let shouldInheritFromWriter = false;
+
+	if (!!writerEntity) {
+		const isWriterPartOfTest = context.execution?.hasEntity(writerEntity);
+
+		// Should only read the value from the entity writing it, if:
+		shouldInheritFromWriter =
+			// There isn't an active test
+			!isThereActiveTest ||
+			// Or there is an active test, and both entities are part of it
+			(isThereActiveTest && isWriterPartOfTest && isPartOfTest) ||
+			// Or there is an active test, but neither entity is a part it
+			(isThereActiveTest && !isWriterPartOfTest && !isPartOfTest);
+
+		if (shouldInheritFromWriter) {
+			value = readValueFromWritter(entity, context, onlyDefault);
+		}
+	}
+
+	const hasEffectiveWriter = !!writerEntity && shouldInheritFromWriter;
+
+	const defaultValue = entity.defaultValue;
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (
+		!value &&
+		defaultValue &&
+		(onlyDefault ||
+			preferrerType === null ||
+			preferrerType !== DynamicValueTypes.Testing)
+	) {
+		value = {
+			value: defaultValue,
+			valueOwner: entity,
+			type: checkIsLiteralValueExplicitlyEmpty(defaultValue)
+				? DynamicValueTypes.Empty
+				: DynamicValueTypes.DefaultValue,
+			inheritanceLink: null
+		};
+	}
+
+	if (
+		(!value ||
+			value.type === DynamicValueTypes.DefaultValue ||
+			value?.type === DynamicValueTypes.Empty ||
+			preferrerType === DynamicValueTypes.Testing) &&
+		!hasEffectiveWriter
+	) {
+		const lastExecutionValue = context.persistedExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (!!lastExecutionValue && !onlyDefault) {
+			return {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+
+		const localTestValue = context.localTestValues?.readValue(entity.id);
+
+		if (
+			!!localTestValue &&
+			!onlyDefault &&
+			(preferrerType === null ||
+				preferrerType === DynamicValueTypes.Testing)
+		) {
+			return {
+				value: localTestValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	const isDefinitionRequired = checkIsRequiredValue(entity);
+
+	const dataType = entity.getDataType(null);
+
+	const isMissing =
+		isDefinitionRequired &&
+		(!value?.value ||
+			(!checkIsNullable(dataType) &&
+				checkIsLiteralValueExplicitlyEmpty(
+					value?.value as LiteralValueState
+				)));
+
+	if (hasEffectiveWriter) {
+		if (isMissing) {
+			return {
+				value: null,
+				valueOwner: entity,
+				type: DynamicValueTypes.Inherited,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	if (isMissing) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Missing,
+			inheritanceLink: value?.inheritanceLink || null
+		};
+	}
+
+	if (!value && !entity.defaultValue && !hasEffectiveWriter) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Undefined,
+			inheritanceLink: null
+		};
+	}
+
+	if (
+		!isDefinitionRequired &&
+		(!value || value.type === DynamicValueTypes.Inherited) &&
+		!value?.inheritanceLink
+	) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: hasEffectiveWriter
+				? DynamicValueTypes.Inherited
+				: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	return value;
+}
+
+// Resolved its own value ignoring the value of any potential parent object
+export function resolveInputMapStandaloneValue(
+	entity: InputMapState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			const inputMapValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return inputMapValue;
+		}
+	}
+
+	const result = resolveInputMapNextStandaloneValue(
+		entity,
+		context,
+		onlyDefault
+	);
+	return result;
+}
+
+export function resolveInputMapNextValue(
+	entity: InputMapState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (VARIABLE_TYPES.includes(entity.parent.type)) {
+		const variableDeclaration = getDeclaration(
+			entity.parent as VariableState
+		);
+
+		if (variableDeclaration.dataType?.isObject()) {
+			return resolveInputMapNextValueAsPropertyOfAnObject(
+				entity,
+				context,
+				onlyDefault
+			);
+		}
+	}
+
+	if (TERMINATION_TYPES.includes(entity.parent.type)) {
+		if (entity.parent.getDataType(null)?.isObject()) {
+			return resolveInputMapNextValueAsPropertyOfAnObject(
+				entity,
+				context,
+				onlyDefault
+			);
+		}
+	}
+
+	return resolveInputMapNextStandaloneValue(entity, context, onlyDefault);
+}
+
+export function resolveInputMapValue(
+	entity: InputMapState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (VARIABLE_TYPES.includes(entity.parent.type)) {
+		const variableDeclaration = getDeclaration(
+			entity.parent as VariableState
+		);
+
+		if (
+			variableDeclaration.dataType?.isObject() ||
+			!!variableDeclaration.inputs.length
+		) {
+			return resolveInputMapValueAsPropertyOfAnObject(
+				entity,
+				context,
+				onlyDefault
+			);
+		}
+	}
+
+	if (TERMINATION_TYPES.includes(entity.parent.type)) {
+		if (
+			entity.parent.getDataType(null)?.isObject() ||
+			!!(entity.parent as TerminationEntityState).outputs.length
+		) {
+			return resolveInputMapValueAsPropertyOfAnObject(
+				entity,
+				context,
+				onlyDefault
+			);
+		}
+	}
+
+	return resolveInputMapStandaloneValue(entity, context, onlyDefault);
+}
+
+export function resolvePropertyValue(
+	entity: PropertyState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (!entity.static) {
+		// Only static properties can hold value at the 'property' or prototype level
+		// When a property is part of a living value or instance, it is represented by input and output maps
+		return null;
+	}
+
+	// We don't check whether it is part of the test, because it is a global value (static property)
+	if (!!context.execution) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue && !onlyDefault) {
+			const returnDeclarationValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return returnDeclarationValue;
+		}
+	}
+
+	const isTopLevelExecution =
+		!context.execution || !context.execution.parentExecution;
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (isTopLevelExecution) {
+		const testValue = context.localTestValues?.readValue(entity.id);
+
+		if (
+			!!testValue &&
+			!onlyDefault &&
+			(preferrerType === null ||
+				preferrerType !== DynamicValueTypes.DefaultValue)
+		) {
+			return {
+				value: testValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	const defaultValue = entity.defaultValue;
+	let value: IDynamicValue | null = null;
+
+	if (
+		defaultValue &&
+		(onlyDefault ||
+			preferrerType === null ||
+			preferrerType !== DynamicValueTypes.Testing)
+	) {
+		const literalValue: LiteralValueState = defaultValue;
+
+		value = {
+			value: literalValue,
+			valueOwner: entity,
+			type: DynamicValueTypes.DefaultValue,
+			inheritanceLink: null
+		};
+	}
+
+	const isDefinitionRequired = checkIsRequiredValue(entity);
+
+	const dataType = entity.getDataType(null);
+
+	const isMissing =
+		isDefinitionRequired &&
+		(!value?.value ||
+			(!checkIsNullable(dataType) &&
+				checkIsLiteralValueExplicitlyEmpty(
+					value?.value as LiteralValueState
+				)));
+
+	if (isMissing) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Missing,
+			inheritanceLink: null
+		};
+	}
+
+	// Check if it is part of test but not required, then set as "empty"
+	if (checkIsLiteralValueEmpty(value?.value as LiteralValueState)) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	// If there is a value return that one, otherwise return the definition of "External"
+	return value;
+}
+
+export function resolveValueDescriptorValue(
+	entity: ValueDescriptorState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (
+		!!context.execution &&
+		context.execution.hasEntity(entity) &&
+		!onlyDefault
+	) {
+		const lastExecutionValue = context.lastExecutionResults?.readValue(
+			entity.id
+		);
+
+		if (lastExecutionValue) {
+			const returnDeclarationValue: IDynamicValue = {
+				value: lastExecutionValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: null
+			};
+
+			return returnDeclarationValue;
+		}
+	}
+
+	const isTopLevelExecution =
+		!context.execution || !context.execution.parentExecution;
+	const preferrerType = context.getValueTypePreference(entity.id);
+
+	if (isTopLevelExecution) {
+		const testValue = context.localTestValues?.readValue(entity.id);
+
+		if (
+			!!testValue &&
+			!onlyDefault &&
+			(preferrerType === null ||
+				preferrerType !== DynamicValueTypes.DefaultValue)
+		) {
+			return {
+				value: testValue,
+				valueOwner: entity,
+				type: DynamicValueTypes.Testing,
+				inheritanceLink: null
+			};
+		}
+	}
+
+	const defaultValue = entity.defaultValue;
+	let value: IDynamicValue | null = null;
+
+	if (
+		defaultValue &&
+		(onlyDefault ||
+			preferrerType === null ||
+			preferrerType !== DynamicValueTypes.Testing)
+	) {
+		const literalValue: LiteralValueState = defaultValue;
+
+		value = {
+			value: literalValue,
+			valueOwner: entity,
+			type: DynamicValueTypes.DefaultValue,
+			inheritanceLink: null
+		};
+	}
+
+	/*
+		We don't check wether value-descriptors are missing, because they aren't used at runtime.
+		They are used as templates for how to use other value owning entities,
+		so, forcing the user to give them a value would not make sense.
+
+		Except if they are the "hidden" declaration of a search input
+	*/
+
+	if (entity.parent?.type === EntityType.Search) {
+		const counterpartInputMap = (entity.parent as SearchState).inputs.find(
+			(input) => input.declaration?.id === entity.id
+		);
+
+		if (counterpartInputMap) {
+			return resolveInputMapValue(
+				counterpartInputMap,
+				context,
+				onlyDefault
+			);
+		}
+	}
+
+	// Check if it is part of test but not required, then set as "empty"
+	if (checkIsLiteralValueEmpty(value?.value || null)) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Empty,
+			inheritanceLink: null
+		};
+	}
+
+	// If there is a value return that one, otherwise return the definition of "External"
+	return value;
+}
+
+export function resolveValue(
+	entity: EntityWithValueState | PropertyState | ValueDescriptorState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (resolving.has(entity.id)) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Undefined,
+			inheritanceLink: null
+		};
+	}
+
+	resolving.add(entity.id);
+	try {
+		switch (entity.type) {
+			case EntityType.ArgumentDeclaration:
+				return resolveArgumentDeclarationValue(
+					entity,
+					context,
+					onlyDefault
+				);
+			case EntityType.InputMap:
+				return resolveInputMapValue(entity, context, onlyDefault);
+			case EntityType.VariableDeclaration:
+				return resolveVarDeclarationValue(entity, context, onlyDefault);
+			case EntityType.VariableInstance:
+				return resolveVarInstanceValue(entity, context, onlyDefault);
+			case EntityType.OutputMap:
+				return resolveOutputMapValue(entity, context, onlyDefault);
+			case EntityType.ReturnStatement:
+			case EntityType.BreakStatement:
+			case EntityType.ContinueStatement:
+				return resolveTerminationEntityValue(entity, context, onlyDefault);
+			case EntityType.Property:
+				return resolvePropertyValue(entity, context, onlyDefault);
+			case EntityType.ValueDescriptor:
+				return resolveValueDescriptorValue(entity, context, onlyDefault);
+			case EntityType.Operation:
+			case EntityType.FunctionCall:
+			case EntityType.InternalCall:
+			case EntityType.Search:
+				return resolvePassThroughCallableValue(
+					entity,
+					context,
+					onlyDefault
+				);
+			default:
+				return null;
+		}
+	} finally {
+		resolving.delete(entity.id);
+	}
+}
+
+export function resolveNextValue(
+	entity: ValueReadingEntityState,
+	context: IValueResolutionContext,
+	onlyDefault = false
+): IDynamicValue | null {
+	if (resolving.has(entity.id)) {
+		return {
+			value: null,
+			valueOwner: entity,
+			type: DynamicValueTypes.Undefined,
+			inheritanceLink: null
+		};
+	}
+
+	resolving.add(entity.id);
+	try {
+		switch (entity.type) {
+			case EntityType.InputMap:
+				return resolveInputMapNextValue(entity, context, onlyDefault);
+			case EntityType.VariableDeclaration:
+				return resolveVarDeclarationNextValue(entity, context, onlyDefault);
+			case EntityType.VariableInstance:
+				return resolveVarInstanceNextValue(entity, context, onlyDefault);
+			case EntityType.ReturnStatement:
+			case EntityType.BreakStatement:
+			case EntityType.ContinueStatement:
+				return resolveTerminationEntityValue(entity, context, onlyDefault);
+			default:
+				return null;
+		}
+	} finally {
+		resolving.delete(entity.id);
+	}
+}
+
+// If the default value which is part of the project logic tree is the one resolved for this entity
+// We create a new standalone literal-value instance to store the value
+// This way we create a local test value instead of editing the default value of the entity in the canvas
+export function generateStandaloneIfDefault(
+	dynamicValue: IDynamicValue
+): IDynamicValue {
+	if (
+		!!dynamicValue &&
+		dynamicValue.type === DynamicValueTypes.DefaultValue &&
+		!!dynamicValue.value &&
+		!!dynamicValue.valueOwner &&
+		(!ENTITY_WITH_DEFAULT_VALUE_TYPES.includes(
+			dynamicValue.valueOwner.type
+		) ||
+			(dynamicValue.valueOwner as EntityWithDefaultValueState)
+				.defaultValue?.id === dynamicValue.value.id)
+	) {
+		const newInstance = assembleStandaloneLiteralValueFromDataType(
+			dynamicValue.valueOwner.getDataType(null),
+			dynamicValue.valueOwner,
+			dynamicValue.valueOwner.project
+		);
+
+		newInstance?.metaSync(
+			{
+				value: (dynamicValue.value as any)?.value,
+				rawString: typeof (dynamicValue.value as any)?.value === 'string' && typeof (dynamicValue.value as any)?.rawString === 'string' ? (dynamicValue.value as any)?.rawString : undefined
+			},
+			null
+		);
+
+		return {
+			// It is still a default value, but it is now detached from the entity (standalone)
+			type: DynamicValueTypes.DefaultValue,
+			value: newInstance,
+			valueOwner: dynamicValue.valueOwner,
+			inheritanceLink: null
+		};
+	}
+
+	return dynamicValue;
+}
+
+export function propagateNewStaticPropertyValueToVariables(
+	entity: PropertyState,
+	project: ProjectState,
+	newValue: LiteralValueType,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	// Propagate to the value of any variable declaration whos data-type entity is the parent of this property
+	const parentEntity = entity.parent as DefinitionEntityState;
+
+	const variableDeclarations = project.getVariableDeclarations();
+
+	variableDeclarations.forEach((variableDeclaration) => {
+		const variableDeclarationDataType =
+			variableDeclaration.getDataType(null);
+
+		if (variableDeclarationDataType?.entity?.id === parentEntity.id) {
+			let existingLiteralValue = onlyDefault
+				? variableDeclaration.defaultValue
+				: valueStore?.readValue(variableDeclaration.id);
+
+			if (!existingLiteralValue) {
+				if (onlyDefault) {
+					// Create new test value
+					existingLiteralValue =
+						assembleAndAddLiteralValueFromDataType(
+							variableDeclaration.getDataType(null),
+							variableDeclaration,
+							project,
+							changeSet
+						);
+				} else {
+					existingLiteralValue =
+						assembleStandaloneLiteralValueFromDataType(
+							variableDeclaration.getDataType(null),
+							variableDeclaration,
+							project
+						);
+				}
+			} else if (
+				!onlyDefault &&
+				!!existingLiteralValue &&
+				existingLiteralValue.id === variableDeclaration.defaultValue?.id
+			) {
+				// If the value instance is the default value, we should generate a standalone value
+				existingLiteralValue =
+					assembleStandaloneLiteralValueFromDataType(
+						variableDeclaration.getDataType(null),
+						variableDeclaration,
+						project
+					);
+			}
+
+			const propertyName = safeResolveEntityName(entity, project);
+			const resolveCodeName =
+				entity.codeName ||
+				entity.extends?.codeName ||
+				entity.implements[0]?.codeName ||
+				toCamelCase(propertyName);
+
+			let initialDefaultValue: UntypedObjectValue = {};
+
+			if (
+				variableDeclaration.dataType?.entity?.type ===
+				EntityType.DefinitionEntity
+			) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...variableDeclaration.dataType.entity.getActiveRawDefaultValue()
+				};
+			}
+
+			if (isObject(existingLiteralValue?.value)) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...(existingLiteralValue.value as UntypedObjectValue)
+				};
+			}
+
+			initialDefaultValue[resolveCodeName] = newValue;
+
+			existingLiteralValue?.metaSync(
+				{
+					value: initialDefaultValue
+				},
+				changeSet
+			);
+
+			if (!onlyDefault) {
+				valueStore?.writeValue(
+					variableDeclaration,
+					existingLiteralValue as LiteralValueState
+				);
+			}
+			return;
+		}
+	});
+
+	return changeSet;
+}
+
+export function propagateNewInputOrOutputMapValueToParentVariable(
+	entity: InputMapState | OutputMapState,
+	project: ProjectState,
+	newValue: LiteralValueType,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	const variableDeclaration = getDeclaration(entity.parent as VariableState);
+
+	const variableDeclarationDataType = variableDeclaration.getDataType(null);
+
+	if (!variableDeclarationDataType?.isObject()) {
+		return changeSet;
+	}
+
+	let existingLiteralValue = onlyDefault
+		? variableDeclaration.defaultValue
+		: valueStore?.readValue(variableDeclaration.id);
+
+	if (!existingLiteralValue) {
+		if (onlyDefault) {
+			// Create new test value
+			existingLiteralValue = assembleAndAddLiteralValueFromDataType(
+				variableDeclaration.getDataType(null),
+				variableDeclaration,
+				project,
+				changeSet
+			);
+		} else {
+			existingLiteralValue = assembleStandaloneLiteralValueFromDataType(
+				variableDeclaration.getDataType(null),
+				variableDeclaration,
+				project
+			);
+		}
+	} else if (
+		!onlyDefault &&
+		!!existingLiteralValue &&
+		existingLiteralValue.id === variableDeclaration.defaultValue?.id
+	) {
+		// If the value instance is the default value, we should generate a standalone value
+		existingLiteralValue = assembleStandaloneLiteralValueFromDataType(
+			variableDeclaration.getDataType(null),
+			variableDeclaration,
+			project
+		);
+	}
+
+	const resolvedEntityName = safeResolveEntityName(entity, project);
+	const resolveCodeName =
+		entity.codeName ||
+		entity.declaration?.codeName ||
+		toCamelCase(resolvedEntityName);
+
+	let initialDefaultValue: UntypedObjectValue = {};
+
+	if (
+		variableDeclaration.dataType?.entity?.type ===
+		EntityType.DefinitionEntity
+	) {
+		initialDefaultValue = {
+			...initialDefaultValue,
+			...variableDeclaration.dataType.entity.getActiveRawDefaultValue()
+		};
+	}
+
+	if (isObject(existingLiteralValue?.value)) {
+		initialDefaultValue = {
+			...initialDefaultValue,
+			...(existingLiteralValue.value as UntypedObjectValue)
+		};
+	}
+
+	initialDefaultValue[resolveCodeName] = newValue;
+
+	existingLiteralValue?.metaSync(
+		{
+			value: initialDefaultValue
+		},
+		changeSet
+	);
+
+	if (!onlyDefault) {
+		valueStore?.writeValue(
+			variableDeclaration,
+			existingLiteralValue as LiteralValueState
+		);
+	}
+
+	if (
+		(newValue === '' || newValue === null || newValue === undefined) &&
+		entity.type === EntityType.OutputMap
+	) {
+		// Find the corresponding input map and delete its value too
+		const counterpartInput = variableDeclaration.inputs.find(
+			(input) =>
+				input.declaration?.id === entity.declaration?.id ||
+				safeResolveEntityName(input, project) === resolvedEntityName
+		);
+
+		if (counterpartInput) {
+			let existingInputLiteralValue = onlyDefault
+				? counterpartInput.defaultValue
+				: valueStore?.readValue(counterpartInput.id);
+
+			if (existingInputLiteralValue) {
+				existingInputLiteralValue.metaSync(
+					{
+						value: null
+					},
+					changeSet
+				);
+			}
+
+			if (!onlyDefault) {
+				valueStore?.removeValue(counterpartInput.id);
+			}
+		}
+	}
+
+	return changeSet;
+}
+
+export function afterLiteralValueDeleteSideEffects(
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	if (VARIABLE_TYPES.includes(entity.type)) {
+		const declaration = getDeclaration(entity as VariableState);
+
+		if (declaration.dataType?.isObject()) {
+			declaration.inputs.forEach((input) => {
+				if (
+					input.declaration?.type === EntityType.Property &&
+					input.declaration.static
+				) {
+					let existingLiteralValue = onlyDefault
+						? (
+								input as EntityWithDefaultValueState
+							).getDefaultValue?.() || null
+						: valueStore?.readValue(input.declaration.id);
+
+					if (!existingLiteralValue) {
+						if (onlyDefault) {
+							// Create new test value
+							existingLiteralValue =
+								assembleAndAddLiteralValueFromDataType(
+									input.declaration.getDataType(null),
+									input.declaration,
+									project,
+									changeSet
+								);
+						} else {
+							existingLiteralValue =
+								assembleStandaloneLiteralValueFromDataType(
+									input.declaration.getDataType(null),
+									input.declaration,
+									project
+								);
+						}
+					} else if (
+						!onlyDefault &&
+						!!existingLiteralValue &&
+						existingLiteralValue.id ===
+							input.declaration.defaultValue?.id
+					) {
+						// If the value instance is the default value, we should generate a standalone value
+						existingLiteralValue =
+							assembleStandaloneLiteralValueFromDataType(
+								input.declaration.getDataType(null),
+								input.declaration,
+								project
+							);
+					}
+
+					existingLiteralValue?.metaSync(
+						{
+							value: null
+						},
+						changeSet
+					);
+
+					if (!onlyDefault) {
+						valueStore?.removeValue(input.declaration?.id);
+					}
+				} else if (input.declaration?.type === EntityType.Property) {
+					let existingLiteralValue = onlyDefault
+						? (
+								input as EntityWithDefaultValueState
+							).getDefaultValue?.() || null
+						: valueStore?.readValue(input.id);
+
+					// Delete the value if it exists
+					if (existingLiteralValue) {
+						existingLiteralValue.metaSync(
+							{
+								value: null
+							},
+							changeSet
+						);
+					}
+
+					if (!onlyDefault) {
+						valueStore?.removeValue(input.id);
+					}
+				}
+
+				return;
+			});
+		}
+	} else if (entity.type === EntityType.InputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueToVariables(
+				entity.declaration,
+				project,
+				null,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueToParentVariable(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.OutputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueToVariables(
+				entity.declaration,
+				project,
+				null,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueToParentVariable(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.Property) {
+		if (entity.static) {
+			propagateNewStaticPropertyValueToVariables(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	}
+
+	return changeSet;
+}
+
+export function afterLiteralValueChangeSideEffects(
+	newValue: LiteralValueType,
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	if (VARIABLE_TYPES.includes(entity.type)) {
+		const declaration = getDeclaration(entity as VariableState);
+
+		if (declaration.dataType?.isObject()) {
+			let initialDefaultValue: UntypedObjectValue = {};
+
+			if (
+				declaration.dataType?.entity?.type ===
+				EntityType.DefinitionEntity
+			) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...declaration.dataType.entity.getActiveRawDefaultValue()
+				};
+			}
+			const parentVariableObjectValue = isObject(newValue)
+				? (newValue as {
+						[key: string]: UntypedValue;
+					})
+				: initialDefaultValue;
+
+			declaration.inputs.forEach((input) => {
+				if (
+					input.declaration?.type === EntityType.Property &&
+					input.declaration.static
+				) {
+					let existingLiteralValue = onlyDefault
+						? (
+								entity as EntityWithDefaultValueState
+							).getDefaultValue?.() || null
+						: valueStore?.readValue(input.declaration.id);
+
+					if (!existingLiteralValue) {
+						if (onlyDefault) {
+							// Create new test value
+							existingLiteralValue =
+								assembleAndAddLiteralValueFromDataType(
+									input.declaration.getDataType(null),
+									input.declaration,
+									project,
+									changeSet
+								);
+						} else {
+							existingLiteralValue =
+								assembleStandaloneLiteralValueFromDataType(
+									input.declaration.getDataType(null),
+									input.declaration,
+									project
+								);
+						}
+					} else if (
+						!onlyDefault &&
+						!!existingLiteralValue &&
+						existingLiteralValue.id ===
+							input.declaration.defaultValue?.id
+					) {
+						// If the value instance is the default value, we should generate a standalone value
+						existingLiteralValue =
+							assembleStandaloneLiteralValueFromDataType(
+								input.declaration.getDataType(null),
+								input.declaration,
+								project
+							);
+					}
+
+					const inputName = safeResolveEntityName(input, project);
+					const resolveCodeName =
+						input.codeName ||
+						input.declaration?.codeName ||
+						toCamelCase(inputName);
+
+					const newRawValue =
+						parentVariableObjectValue[resolveCodeName];
+
+					existingLiteralValue?.metaSync(
+						{
+							value: newRawValue
+						},
+						changeSet
+					);
+
+					if (!onlyDefault) {
+						valueStore?.writeValue(
+							input.declaration,
+							existingLiteralValue as LiteralValueState
+						);
+					}
+				} else if (input.declaration?.type === EntityType.Property) {
+					let existingLiteralValue = onlyDefault
+						? (
+								entity as EntityWithDefaultValueState
+							).getDefaultValue?.() || null
+						: valueStore?.readValue(input.id);
+
+					// Delete the value if it exists
+					if (existingLiteralValue) {
+						existingLiteralValue.metaSync(
+							{
+								value: null
+							},
+							changeSet
+						);
+					}
+
+					if (!onlyDefault) {
+						valueStore?.removeValue(input.id);
+					}
+				}
+
+				return;
+			});
+		}
+	} else if (entity.type === EntityType.InputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueToVariables(
+				entity.declaration,
+				project,
+				newValue,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueToParentVariable(
+				entity,
+				project,
+				newValue,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.OutputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueToVariables(
+				entity.declaration,
+				project,
+				null,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueToParentVariable(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.Property) {
+		if (entity.static) {
+			propagateNewStaticPropertyValueToVariables(
+				entity,
+				project,
+				newValue,
+				storage
+			);
+		}
+	}
+
+	return changeSet;
+}
+
+export function handleLiteralValueDelete(
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	// Propagate values
+	const propagatedValueOwners = getEntitiesToPropagateValuesTo(
+		entity,
+		project
+	);
+
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	propagatedValueOwners.forEach((propagatedValueOwner) => {
+		let valueInstance = onlyDefault
+			? (
+					propagatedValueOwner as EntityWithDefaultValueState
+				).getDefaultValue?.() || null
+			: valueStore?.readValue(propagatedValueOwner.id);
+
+		if (!onlyDefault) {
+			valueStore?.removeValue(propagatedValueOwner.id);
+		} else {
+			valueInstance?.remove({ ignoreUpstream: false }, changeSet);
+		}
+
+		afterLiteralValueDeleteSideEffects(
+			propagatedValueOwner,
+			project,
+			storage
+		);
+	});
+
+	return changeSet;
+}
+
+export function handleLiteralValueChange(
+	newValue: LiteralValueType,
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient,
+	asCastedType?: PrimitiveTypes,
+	rawString?: string | null
+): ChangeSet | null {
+	// Propagate values
+	const propagatedValueOwners = getEntitiesToPropagateValuesTo(
+		entity,
+		project
+	) as EntityWithDefaultValueState[];
+
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	if (project.diggestedBuiltInBaseEntitiesIds.has(entity.id)) {
+		return changeSet;
+	}
+
+	propagatedValueOwners.forEach((propagatedValueOwner) => {
+		if (
+			project.diggestedBuiltInBaseEntitiesIds.has(propagatedValueOwner.id)
+		) {
+			return;
+		}
+
+		let valueInstance = null;
+
+		if (onlyDefault) {
+			const resolvedValueInstance =
+				propagatedValueOwner.getDefaultValue?.() || null;
+
+			if (!!resolvedValueInstance) {
+				if (
+					project.diggestedBuiltInBaseEntitiesIds.has(
+						resolvedValueInstance.id
+					) ||
+					resolvedValueInstance.parent?.id !== propagatedValueOwner.id
+				) {
+					const clonedValueInstance = resolvedValueInstance.clone(
+						changeSet,
+						propagatedValueOwner
+					);
+
+					valueInstance = clonedValueInstance;
+				} else {
+					valueInstance = resolvedValueInstance;
+				}
+			}
+		} else {
+			valueInstance = valueStore?.readValue(propagatedValueOwner.id);
+		}
+
+		if (!valueInstance) {
+			if (onlyDefault) {
+				// Create new test value
+				valueInstance = assembleAndAddLiteralValueFromDataType(
+					propagatedValueOwner.getDataType(null),
+					propagatedValueOwner as EntityWithDefaultValueState,
+					project,
+					changeSet
+				);
+				changeSet?.add(valueInstance, ChangeSetEntityChangeType.Added);
+			} else {
+				valueInstance = assembleStandaloneLiteralValueFromDataType(
+					propagatedValueOwner.getDataType(null),
+					propagatedValueOwner,
+					project
+				);
+			}
+		} else if (
+			!onlyDefault &&
+			!!valueInstance &&
+			valueInstance.id ===
+				(
+					propagatedValueOwner as EntityWithDefaultValueState
+				).getDefaultValue?.()?.id
+		) {
+			// If the value instance is the default value, we should generate a standalone value
+			valueInstance = assembleStandaloneLiteralValueFromDataType(
+				propagatedValueOwner.getDataType(null),
+				propagatedValueOwner,
+				project
+			);
+		}
+
+		valueInstance?.setValueAsType(null, changeSet);
+
+		let newName: PrimitiveTypes =
+			asCastedType || (valueInstance?.name as PrimitiveTypes);
+
+		if (
+			(!valueInstance?.name ||
+				valueInstance?.name === PrimitiveTypes.Untyped) &&
+			!asCastedType
+		) {
+			if (typeof newValue === 'string') {
+				newName = PrimitiveTypes.String;
+			} else if (newValue === null) {
+				newName = PrimitiveTypes.Null;
+			} else if (typeof newValue === 'number') {
+				newName = PrimitiveTypes.Number;
+			} else if (typeof newValue === 'boolean') {
+				newName = PrimitiveTypes.Boolean;
+			}
+		}
+
+		valueInstance?.metaSync(
+			{
+				value: newValue,
+				name: newName,
+				rawString: rawString !== undefined ? rawString : null
+			},
+			changeSet
+		);
+
+		if (!onlyDefault) {
+			valueStore?.writeValue(
+				propagatedValueOwner,
+				valueInstance as LiteralValueState
+			);
+		}
+
+		afterLiteralValueChangeSideEffects(
+			newValue,
+			propagatedValueOwner,
+			project,
+			storage
+		);
+	});
+
+	return changeSet;
+}
+
+export function propagateNewStaticPropertyValueAsTypeToVariables(
+	entity: PropertyState,
+	project: ProjectState,
+	newValue: ValueAsTypeState | ValueAsTypeState[] | null,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	// Propagate to the value of any variable declaration whos data-type entity is the parent of this property
+	const parentEntity = entity.parent as DefinitionEntityState;
+
+	const variableDeclarations = project.getVariableDeclarations();
+
+	variableDeclarations.forEach((variableDeclaration) => {
+		const variableDeclarationDataType =
+			variableDeclaration.getDataType(null);
+
+		if (variableDeclarationDataType?.entity?.id === parentEntity.id) {
+			let existingLiteralValue = onlyDefault
+				? variableDeclaration.defaultValue
+				: valueStore?.readValue(variableDeclaration.id);
+
+			if (!existingLiteralValue) {
+				if (onlyDefault) {
+					// Create new test value
+					existingLiteralValue =
+						assembleAndAddLiteralValueFromDataType(
+							variableDeclaration.getDataType(null),
+							variableDeclaration,
+							project,
+							changeSet
+						);
+				} else {
+					existingLiteralValue =
+						assembleStandaloneLiteralValueFromDataType(
+							variableDeclaration.getDataType(null),
+							variableDeclaration,
+							project
+						);
+				}
+			} else if (
+				!onlyDefault &&
+				!!existingLiteralValue &&
+				existingLiteralValue.id === variableDeclaration.defaultValue?.id
+			) {
+				// If the value instance is the default value, we should generate a standalone value
+				existingLiteralValue =
+					assembleStandaloneLiteralValueFromDataType(
+						variableDeclaration.getDataType(null),
+						variableDeclaration,
+						project
+					);
+			}
+
+			const propertyName = safeResolveEntityName(entity, project);
+			const resolveCodeName =
+				entity.codeName ||
+				entity.extends?.codeName ||
+				entity.implements[0]?.codeName ||
+				toCamelCase(propertyName);
+
+			let initialDefaultValue: UntypedObjectValue = {};
+
+			if (
+				variableDeclaration.dataType?.entity?.type ===
+				EntityType.DefinitionEntity
+			) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...variableDeclaration.dataType.entity.getActiveRawDefaultValue()
+				};
+			}
+
+			if (isObject(existingLiteralValue?.value)) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...(existingLiteralValue.value as UntypedObjectValue)
+				};
+			}
+
+			if (Array.isArray(newValue)) {
+				// @ts-ignore
+				initialDefaultValue[resolveCodeName] =
+					newValue?.map((val) => val.toShallowJSON()) || null;
+			} else {
+				// @ts-ignore
+				initialDefaultValue[resolveCodeName] =
+					newValue?.toShallowJSON() || null;
+			}
+
+			existingLiteralValue?.metaSync(
+				{
+					value: initialDefaultValue
+				},
+				changeSet
+			);
+
+			if (!onlyDefault) {
+				valueStore?.writeValue(
+					variableDeclaration,
+					existingLiteralValue as LiteralValueState
+				);
+			}
+			return;
+		}
+	});
+
+	return changeSet;
+}
+
+export function propagateNewInputOrOutputMapValueAsTypeToParentVariable(
+	entity: InputMapState | OutputMapState,
+	project: ProjectState,
+	newValue: ValueAsTypeState | ValueAsTypeState[] | null,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	const variableDeclaration = getDeclaration(entity.parent as VariableState);
+
+	const variableDeclarationDataType = variableDeclaration.getDataType(null);
+
+	if (!variableDeclarationDataType?.isObject()) {
+		return changeSet;
+	}
+
+	let existingLiteralValue = onlyDefault
+		? variableDeclaration.defaultValue
+		: valueStore?.readValue(variableDeclaration.id);
+
+	if (!existingLiteralValue) {
+		if (onlyDefault) {
+			// Create new test value
+			existingLiteralValue = assembleAndAddLiteralValueFromDataType(
+				variableDeclaration.getDataType(null),
+				variableDeclaration,
+				project,
+				changeSet
+			);
+		} else {
+			existingLiteralValue = assembleStandaloneLiteralValueFromDataType(
+				variableDeclaration.getDataType(null),
+				variableDeclaration,
+				project
+			);
+		}
+	} else if (
+		!onlyDefault &&
+		!!existingLiteralValue &&
+		existingLiteralValue.id === variableDeclaration.defaultValue?.id
+	) {
+		// If the value instance is the default value, we should generate a standalone value
+		existingLiteralValue = assembleStandaloneLiteralValueFromDataType(
+			variableDeclaration.getDataType(null),
+			variableDeclaration,
+			project
+		);
+	}
+
+	const resolvedEntityName = safeResolveEntityName(entity, project);
+	const resolveCodeName =
+		entity.codeName ||
+		entity.declaration?.codeName ||
+		toCamelCase(resolvedEntityName);
+
+	let initialDefaultValue: UntypedObjectValue = {};
+
+	if (
+		variableDeclaration.dataType?.entity?.type ===
+		EntityType.DefinitionEntity
+	) {
+		initialDefaultValue = {
+			...initialDefaultValue,
+			...variableDeclaration.dataType.entity.getActiveRawDefaultValue()
+		};
+	}
+
+	if (isObject(existingLiteralValue?.value)) {
+		initialDefaultValue = {
+			...initialDefaultValue,
+			...(existingLiteralValue.value as UntypedObjectValue)
+		};
+	}
+
+	if (Array.isArray(newValue)) {
+		// @ts-ignore
+		initialDefaultValue[resolveCodeName] =
+			newValue?.map((val) => val.toShallowJSON()) || null;
+	} else {
+		// @ts-ignore
+		initialDefaultValue[resolveCodeName] =
+			newValue?.toShallowJSON() || null;
+	}
+
+	existingLiteralValue?.metaSync(
+		{
+			value: initialDefaultValue
+		},
+		changeSet
+	);
+
+	if (!onlyDefault) {
+		valueStore?.writeValue(
+			variableDeclaration,
+			existingLiteralValue as LiteralValueState
+		);
+	}
+
+	if (
+		(newValue === null || newValue === undefined) &&
+		entity.type === EntityType.OutputMap
+	) {
+		// Find the corresponding input map and delete its value too
+		const counterpartInput = variableDeclaration.inputs.find(
+			(input) =>
+				input.declaration?.id === entity.declaration?.id ||
+				safeResolveEntityName(input, project) === resolvedEntityName
+		);
+
+		if (counterpartInput) {
+			let existingInputLiteralValue = onlyDefault
+				? counterpartInput.defaultValue
+				: valueStore?.readValue(counterpartInput.id);
+
+			if (existingInputLiteralValue) {
+				if (Array.isArray(newValue)) {
+					existingInputLiteralValue?.setValueAsTypeList(
+						newValue,
+						changeSet
+					);
+				} else {
+					existingInputLiteralValue?.setValueAsTypeSingle(
+						newValue,
+						changeSet
+					);
+				}
+			}
+
+			if (!onlyDefault) {
+				valueStore?.removeValue(counterpartInput.id);
+			}
+		}
+	}
+
+	return changeSet;
+}
+
+export function afterLiteralValueAsTypeDeleteSideEffects(
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	if (entity.type === EntityType.InputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueAsTypeToVariables(
+				entity.declaration,
+				project,
+				null,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueAsTypeToParentVariable(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.OutputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueAsTypeToVariables(
+				entity.declaration,
+				project,
+				null,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueAsTypeToParentVariable(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.Property) {
+		if (entity.static) {
+			propagateNewStaticPropertyValueAsTypeToVariables(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	}
+
+	return storage as ChangeSet;
+}
+
+export function afterLiteralValueAsTypeChangeSideEffects(
+	newValue: ValueAsTypeState | ValueAsTypeState[] | null,
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	if (entity.type === EntityType.InputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueAsTypeToVariables(
+				entity.declaration,
+				project,
+				newValue,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueAsTypeToParentVariable(
+				entity,
+				project,
+				newValue,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.OutputMap) {
+		if (
+			entity.declaration?.type === EntityType.Property &&
+			entity.declaration.static
+		) {
+			propagateNewStaticPropertyValueAsTypeToVariables(
+				entity.declaration,
+				project,
+				null,
+				storage
+			);
+		} else if (
+			VARIABLE_TYPES.includes(entity.parent.type) &&
+			entity.declaration?.type === EntityType.Property
+		) {
+			propagateNewInputOrOutputMapValueAsTypeToParentVariable(
+				entity,
+				project,
+				null,
+				storage
+			);
+		}
+	} else if (entity.type === EntityType.Property) {
+		if (entity.static) {
+			propagateNewStaticPropertyValueAsTypeToVariables(
+				entity,
+				project,
+				newValue,
+				storage
+			);
+		}
+	}
+
+	return storage as ChangeSet;
+}
+
+export function handleValueAsTypeDelete(
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	// Propagate values
+	const propagatedValueOwners = getEntitiesToPropagateValuesTo(
+		entity,
+		project
+	);
+
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	propagatedValueOwners.forEach((propagatedValueOwner) => {
+		let valueInstance = onlyDefault
+			? (
+					propagatedValueOwner as EntityWithDefaultValueState
+				).getDefaultValue?.()
+			: valueStore?.readValue(propagatedValueOwner.id);
+
+		if (!onlyDefault) {
+			valueStore?.removeValue(propagatedValueOwner.id);
+		} else {
+			valueInstance?.remove({ ignoreUpstream: false }, changeSet);
+		}
+
+		afterLiteralValueAsTypeDeleteSideEffects(
+			propagatedValueOwner,
+			project,
+			storage
+		);
+	});
+
+	return changeSet;
+}
+
+export function handleValueAsTypeChange(
+	newValue: ValueAsTypeState | ValueAsTypeState[] | null,
+	entity: EntityWithValueState,
+	project: ProjectState,
+	storage: ChangeSet | IValueStoreClient
+): ChangeSet | null {
+	// Propagate values
+	const propagatedValueOwners = getEntitiesToPropagateValuesTo(
+		entity,
+		project
+	);
+
+	let onlyDefault = false;
+	let changeSet: ChangeSet | null = null;
+	let valueStore: IValueStoreClient | null = null;
+
+	if (storage instanceof ChangeSet) {
+		onlyDefault = true;
+		changeSet = storage as ChangeSet;
+		valueStore = null;
+	} else {
+		changeSet = null;
+		valueStore = storage as IValueStoreClient;
+	}
+
+	propagatedValueOwners.forEach((propagatedValueOwner) => {
+		let valueInstance = onlyDefault
+			? (
+					propagatedValueOwner as EntityWithDefaultValueState
+				).getDefaultValue?.()
+			: valueStore?.readValue(propagatedValueOwner.id);
+
+		if (!valueInstance) {
+			if (onlyDefault) {
+				// Create new test value
+
+				valueInstance = assembleAndAddLiteralValueFromDataType(
+					propagatedValueOwner.getDataType(null),
+					propagatedValueOwner as EntityWithDefaultValueState,
+					project,
+					changeSet
+				);
+			} else {
+				valueInstance = assembleStandaloneLiteralValueFromDataType(
+					propagatedValueOwner.getDataType(null),
+					propagatedValueOwner,
+					project
+				);
+			}
+		} else if (
+			!onlyDefault &&
+			!!valueInstance &&
+			valueInstance.id ===
+				(
+					propagatedValueOwner as EntityWithDefaultValueState
+				).getDefaultValue?.()?.id
+		) {
+			// If the value instance is the default value, we should generate a standalone value
+
+			valueInstance = assembleStandaloneLiteralValueFromDataType(
+				propagatedValueOwner.getDataType(null),
+				propagatedValueOwner,
+				propagatedValueOwner.project
+			);
+		}
+
+		if (Array.isArray(newValue)) {
+			valueInstance?.setValueAsTypeList(newValue, changeSet);
+		} else {
+			valueInstance?.setValueAsTypeSingle(newValue, changeSet);
+		}
+
+		valueInstance?.metaSync(
+			{
+				value: null
+			},
+			changeSet
+		);
+
+		if (!onlyDefault) {
+			valueStore?.writeValue(
+				propagatedValueOwner,
+				valueInstance as LiteralValueState
+			);
+		}
+
+		afterLiteralValueAsTypeChangeSideEffects(
+			newValue,
+			propagatedValueOwner,
+			project,
+			storage
+		);
+	});
+
+	return changeSet;
+}