@elyx-code/editor-ui 0.0.2

package/src/services/execution/index.ts

@@ -0,0 +1,4747 @@
+import {
+	ArgumentDeclarationState,
+	BreakStatementState,
+	BUILT_IN_BASE_ENTITY_IDS,
+	CallableEntityState,
+	ContinueStatementState,
+	createStateFromType,
+	DataTypeState,
+	EntityId,
+	EntityState,
+	EntityType,
+	EntityWithValueState,
+	ExecutionTerminationType,
+	getDeclaration,
+	IPrimitiveExecutionResult,
+	ILiteralValueTransfer,
+	LoopState,
+	PASS_THROUGH_CALLABLE_TYPES,
+	PassThroughCallableEntityState,
+	ProjectState,
+	resolveEntityName,
+	SearchState,
+	StandaloneOperatorTypes,
+	TERMINATION_TYPES,
+	TerminationEntityState,
+	toCamelCase,
+	UntypedObjectValue,
+	ValueReadingEntityState,
+	InputMapState,
+	ENTRY_POINT_TYPES,
+	VALUE_READING_TYPES,
+	PassThroughCallableEntityWithOutputs,
+	ExecutableEntityState,
+	InternalCallState,
+	BuiltInFunctionIds,
+	CALLER_TYPES,
+	CALLABLE_TYPES,
+	ConditionState,
+	FunctionCallState,
+	OperationState,
+	VariableDeclarationState,
+	FunctionDeclarationState,
+	DraggableExecutableEntityState,
+	DraggableCallerEntityState,
+	ReturnStatementState,
+	EntryPointEntityState,
+	flattenRelatedCanvasElementsOnTheRight,
+	VariableState,
+	LiteralValueState,
+	ISearchNodeImplementationModule,
+	DEFAULT_MODULE_IDS,
+	IBaseExtensionsContext,
+	DEFAULT_BASE_EXTENSIONS_CONTEXT,
+	BuiltInFunctionImplementationModule,
+	BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX,
+	GroupOperatorTypes,
+	flattenElementCalls,
+	CallerEntityState,
+	isObject,
+	getScopeOwner
+} from '@elyx-code/project-logic-tree';
+import {
+	resolveValue,
+	resolveNextValue,
+	assembleStandaloneLiteralValueFromDataType,
+	IValueResolutionContext,
+	getEntitiesToPropagateValuesTo
+} from './value-resolution';
+import {
+	DynamicValueTypes,
+	EfimeralValueStore,
+	IDynamicValue,
+	IValueStoreClient
+} from '../editor/value-store';
+import { getLiteralValueNameFromDataType } from './utils';
+import {
+	Events,
+	Logger,
+	YieldOptions,
+	YieldTracker
+} from '@elyx-code/common-ts-utils';
+
+export type TestableEntityState = ExecutableEntityState;
+
+export interface IExecutionResult {
+	value: ExecutionTerminationType;
+	entity: TestableEntityState;
+	error: IDynamicValue | null;
+	result: IDynamicValue | null;
+}
+
+export interface IExecutionCallbackContext {
+	detached: boolean;
+	execution?: Execution;
+}
+
+/*
+	This interface defines the methods that the execution client should implement
+
+	It is used to decouple the execution logic from the business logic that is executing it
+	This way, the execution logic can be reused in different contexts
+
+	It provides the callbacks to hook into lifecycle events of the execution
+*/
+export interface IExecutionClient {
+	onBeforeEntityExecution?: (
+		entity: TestableEntityState,
+		inputs: IDynamicValue[],
+		context: IExecutionCallbackContext
+	) => Promise<any>;
+	onEntityExecuted?: (
+		entity: TestableEntityState,
+		result: IExecutionResult,
+		context: IExecutionCallbackContext
+	) => Promise<any>;
+}
+
+/**
+ * Converts an Error or unknown error object into a plain object
+ * with enumerable properties so it can be stringified/inspected.
+ */
+function serializeError(err: any): any {
+	if (!(err instanceof Error) && typeof err === 'object' && err !== null) {
+		return err; // It's already a plain object
+	}
+
+	if (err instanceof Error) {
+		return {
+			// @ts-ignore
+			name: err.name,
+			// @ts-ignore
+			message: err.message,
+			stack: err.stack,
+			// Capture any custom properties added to the Error object
+			...err
+		};
+	}
+
+	return err; // Primitive (string, number, etc.)
+}
+
+function extractRawValue(val: any): { single: any; list: any[] | null } {
+	if (val && typeof val === 'object' && 'value' in val) {
+		const dynamicVal = val as IDynamicValue;
+		return {
+			single:
+				dynamicVal.value?.valueAsTypeSingle ?? dynamicVal.value?.value,
+			list: dynamicVal.value?.valueAsTypeList ?? null
+		};
+	}
+	return {
+		single: val,
+		list: Array.isArray(val) ? val : null
+	};
+}
+
+const EXECUTION_CLIENT_DEFAULTS: IExecutionClient = {
+	onBeforeEntityExecution: async () => {},
+	onEntityExecuted: async () => {}
+};
+
+export class ExecutionStoppedError extends Error {
+	constructor() {
+		super('Execution was stopped');
+		this.name = 'ExecutionStoppedError';
+	}
+}
+
+export enum ExecutionState {
+	FinishedSuccess = 'finished-success',
+	FinishedError = 'finished-error',
+	Running = 'running',
+	Paused = 'paused',
+	Stopped = 'stopped',
+	NotStarted = 'not-started'
+}
+
+export interface IExecutionInstanceParentContext extends IBaseExtensionsContext {
+	// 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 const DEFAULT_EXECUTION_INSTANCE_PARENT_CONTEXT: IExecutionInstanceParentContext =
+	{
+		...DEFAULT_BASE_EXTENSIONS_CONTEXT,
+		getValueTypePreference: () => null,
+		setValueTypePreference: () => {}
+	};
+
+// Now Execution extends CombinedEfimeralValueStoreAndEvents and has both behaviors.
+export class Execution extends Events {
+	project: ProjectState;
+	entryPoint: TestableEntityState;
+	state: ExecutionState = ExecutionState.NotStarted;
+
+	events: Events = new Events('fe-exec-inst-events');
+
+	// The entities that are part of the test
+	// Regardless of their execution state
+	entities: TestableEntityState[] = [];
+
+	// The parent execution of the current execution
+	// Null if the current execution is the root execution
+	parentExecution: Execution | null = null;
+
+	// The entities that are part of the test
+	// And are being executed at any given moment
+	executing: TestableEntityState[] = [];
+
+	// The entities that are part of the test
+	// And have already been executed
+	executed: TestableEntityState[] = [];
+
+	// The entities that are part of the test
+	// and which branch was skipped, so they will not be executed
+	skipped: TestableEntityState[] = [];
+
+	// Entities who have at least one of their callers having already completed its execution
+	// But have other callers that haven't completed yet, so they are "waiting" for them
+	scheduled: TestableEntityState[] = [];
+
+	// Local test values that the user can set in the canvas
+	localTestValues: EfimeralValueStore;
+	// Resolved values cached so the calculation doesn't have to be done every time
+	resolvedValues: EfimeralValueStore;
+	// Values saved from previous executions results
+	persistedExecutionResults: EfimeralValueStore;
+	// 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: EfimeralValueStore;
+
+	onAddToSkippedListCallback:
+		| null
+		| ((
+				entity: TestableEntityState,
+				options?: YieldOptions & {
+					skipValidate?: boolean;
+					skipRender?: boolean;
+					skipNotify?: boolean;
+				}
+		  ) => Promise<void> | void) = null;
+	onRemoveFromSkippedListCallback:
+		| null
+		| ((
+				entity: TestableEntityState,
+				options?: YieldOptions & {
+					skipValidate?: boolean;
+					skipRender?: boolean;
+					skipNotify?: boolean;
+				}
+		  ) => Promise<void> | void) = null;
+	onAddEntityCallback:
+		| null
+		| ((
+				entity: TestableEntityState,
+				options?: YieldOptions & {
+					skipValidate?: boolean;
+					skipRender?: boolean;
+					skipNotify?: boolean;
+				}
+		  ) => Promise<void> | void) = null;
+	onRemoveEntityCallback:
+		| null
+		| ((
+				entity: TestableEntityState,
+				options?: YieldOptions & {
+					skipValidate?: boolean;
+					skipRender?: boolean;
+					skipNotify?: boolean;
+				}
+		  ) => Promise<void> | void) = null;
+	onAbortExecutionCallback:
+		| null
+		| ((
+				entity: TestableEntityState,
+				options?: YieldOptions & {
+					skipValidate?: boolean;
+					skipRender?: boolean;
+					skipNotify?: boolean;
+				}
+		  ) => Promise<void> | void) = null;
+
+	constructor(
+		project: ProjectState,
+		entities: TestableEntityState[],
+		entryPoint: TestableEntityState,
+		parentExecution: Execution | null = null,
+		public readonly parentContext: IExecutionInstanceParentContext = DEFAULT_EXECUTION_INSTANCE_PARENT_CONTEXT
+	) {
+		super();
+		this.entities = entities;
+		this.entryPoint = entryPoint;
+		this.project = project;
+		this.parentExecution = parentExecution;
+
+		this.localTestValues = new EfimeralValueStore(
+			ProjectState.UUID.uuid(),
+			this.project
+		);
+		this.resolvedValues = new EfimeralValueStore(
+			ProjectState.UUID.uuid(),
+			this.project
+		);
+		this.persistedExecutionResults = new EfimeralValueStore(
+			ProjectState.UUID.uuid(),
+			this.project
+		);
+		this.lastExecutionResults = new EfimeralValueStore(
+			ProjectState.UUID.uuid(),
+			this.project
+		);
+	}
+
+	get valueResolutionContext(): IValueResolutionContext {
+		return {
+			execution: this,
+			project: this.project,
+			// Local test values that the user can set in the canvas
+			localTestValues: this.localTestValues as IValueStoreClient,
+			// Resolved values cached so the calculation doesn't have to be done every time
+			resolvedValues: this.resolvedValues as IValueStoreClient,
+			// Values saved from previous executions results
+			persistedExecutionResults: this
+				.persistedExecutionResults as 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: this
+				.lastExecutionResults as IValueStoreClient,
+			getValueTypePreference: this.parentContext.getValueTypePreference,
+			setValueTypePreference: this.parentContext.setValueTypePreference
+		};
+	}
+
+	get rootExecution(): Execution {
+		let current: Execution = this;
+		while (current.parentExecution) {
+			current = current.parentExecution;
+		}
+		return current;
+	}
+
+	get rootState(): ExecutionState {
+		return this.rootExecution.state;
+	}
+
+	isStopped(): boolean {
+		return (
+			this.state === ExecutionState.Stopped ||
+			this.rootExecution.state === ExecutionState.Stopped
+		);
+	}
+
+	isPaused(): boolean {
+		return (
+			this.state === ExecutionState.Paused ||
+			this.rootExecution.state === ExecutionState.Paused
+		);
+	}
+
+	async checkStateAndPause(): Promise<void> {
+		if (this.isStopped()) {
+			throw new ExecutionStoppedError();
+		}
+		while (this.isPaused()) {
+			if (this.isStopped()) {
+				throw new ExecutionStoppedError();
+			}
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+	}
+
+	skip(entity: TestableEntityState): void {
+		if (!this.hasEntity(entity)) {
+			return;
+		}
+
+		// If the entity is scheduled, remove it from the scheduled list
+		this.removeFromScheduledList(entity);
+
+		if (!!this.skipped.includes(entity)) {
+			return;
+		}
+
+		this.skipped.push(entity);
+
+		if (this.onAddToSkippedListCallback) {
+			this.onAddToSkippedListCallback(entity);
+		}
+
+		// Flatten its calls and skipp all of them
+		if (CALLER_TYPES.includes(entity.type)) {
+			flattenElementCalls(entity as CallerEntityState).forEach((callee) =>
+				this.skip(callee)
+			);
+		}
+	}
+
+	// If all its callers have completed their execution, execute the entity
+	// Otherwise add it to the scheduled list
+	async schedule(
+		entity: TestableEntityState,
+		inputs?: IDynamicValue[],
+		client?: IExecutionClient
+	): Promise<IExecutionResult | null> {
+		if (this.hasExecuted(entity)) {
+			return null;
+		}
+
+		if (ENTRY_POINT_TYPES.includes(entity.type)) {
+			return this.executeBranch(
+				entity as EntryPointEntityState,
+				client,
+				inputs
+			);
+		} else if (CALLABLE_TYPES.includes(entity.type)) {
+			const allCallersCompleted = (
+				entity as CallableEntityState
+			).calledBy.every((caller) => {
+				// Check if the caller has been executed or if it not part of the execution
+				return this.hasExecuted(caller) || !this.hasEntity(caller);
+			});
+
+			if (allCallersCompleted) {
+				return this.executeBranch(
+					entity as EntryPointEntityState,
+					client,
+					inputs
+				);
+			} else {
+				if (!this.scheduled.includes(entity)) {
+					this.scheduled.push(entity);
+				}
+			}
+		}
+
+		return null;
+	}
+
+	// For entities that can be executed with external values,
+	// this function takes a list of external dynamic values
+	// as well as the entity itself, and it merges them based on the value owner
+	// And returns a resolved list of dynamic values to be used during the execution
+	mergeExernalValuesWithInternalInputs(
+		externalValues: IDynamicValue[],
+		entity: EntityState
+	): IDynamicValue[] {
+		const childrenEntitiesWithValues: (
+			| ValueReadingEntityState
+			| ArgumentDeclarationState
+		)[] = [];
+
+		if (
+			[...PASS_THROUGH_CALLABLE_TYPES, ...ENTRY_POINT_TYPES].includes(
+				entity.type
+			)
+		) {
+			childrenEntitiesWithValues.push(
+				...(
+					entity as
+						| PassThroughCallableEntityState
+						| EntryPointEntityState
+				).inputs
+			);
+		} else if (TERMINATION_TYPES.includes(entity.type)) {
+			childrenEntitiesWithValues.push(
+				...(entity as TerminationEntityState).outputs
+			);
+		}
+
+		const resolvedInputs = childrenEntitiesWithValues.map(
+			(childEntityWithValue) => {
+				// Here get the external value for the input or the resolved 'next' value
+				let foundExternalValue = externalValues.find(
+					(value) => value.valueOwner.id === childEntityWithValue.id
+				);
+
+				if (foundExternalValue) {
+					return foundExternalValue;
+				}
+
+				if (
+					!foundExternalValue &&
+					ENTRY_POINT_TYPES.includes(entity.type)
+				) {
+					foundExternalValue = externalValues.find(
+						(value) =>
+							(value.valueOwner as InputMapState).declaration
+								?.id === childEntityWithValue.id
+					);
+				}
+
+				if (foundExternalValue) {
+					const clonedLiteralValue =
+						foundExternalValue.value?.clone(null);
+
+					clonedLiteralValue?.setStandaloneParent(
+						childEntityWithValue,
+						null
+					);
+
+					const dynamicValue: IDynamicValue = {
+						...foundExternalValue,
+						valueOwner: childEntityWithValue,
+						value: clonedLiteralValue || null,
+						inheritanceLink: {
+							sources: [foundExternalValue],
+							target: childEntityWithValue
+						}
+					};
+
+					return dynamicValue;
+				}
+
+				if (VALUE_READING_TYPES.includes(childEntityWithValue.type)) {
+					const resolvedValue = resolveNextValue(
+						childEntityWithValue as ValueReadingEntityState,
+						this.valueResolutionContext
+					);
+					return resolvedValue;
+				} else {
+					const resolvedValue = resolveValue(
+						childEntityWithValue,
+						this.valueResolutionContext
+					);
+					return resolvedValue;
+				}
+			}
+		);
+
+		return resolvedInputs
+			.reduce((acc, value) => {
+				const entitiesToPropagateTo = getEntitiesToPropagateValuesTo(
+					value?.valueOwner as EntityWithValueState,
+					this.project
+				);
+
+				const propagatedValues: IDynamicValue[] = !!value
+					? [value]
+					: [];
+
+				entitiesToPropagateTo.forEach((entityToPropagateTo) => {
+					if (entityToPropagateTo.id === value?.valueOwner.id) {
+						return;
+					}
+
+					const newValue: LiteralValueState | null =
+						assembleStandaloneLiteralValueFromDataType(
+							entityToPropagateTo.getDataType(null),
+							entityToPropagateTo,
+							this.project
+						);
+
+					newValue?.metaSync(
+						{
+							value: value?.value?.value
+						},
+						null
+					);
+
+					newValue?.setValueAsTypeList(
+						value?.value?.valueAsTypeList || null
+					);
+					newValue?.setValueAsTypeSingle(
+						value?.value?.valueAsTypeSingle || null
+					);
+
+					const newDynamicValue: IDynamicValue = {
+						...(value as IDynamicValue),
+						valueOwner: entityToPropagateTo,
+						value: newValue
+					};
+
+					propagatedValues.push(newDynamicValue);
+				});
+
+				return [...acc, ...propagatedValues];
+			}, [] as IDynamicValue[])
+			.sort(
+				(a, b) =>
+					(a.valueOwner as InputMapState).index -
+					(b.valueOwner as InputMapState).index
+			);
+	}
+
+	inheritValuesFromContext(context: IValueResolutionContext) {
+		this.localTestValues = context.localTestValues as IValueStoreClient;
+		this.resolvedValues = context.resolvedValues as IValueStoreClient;
+		this.persistedExecutionResults =
+			context.persistedExecutionResults as IValueStoreClient;
+		// this.lastExecutionResults = context.lastExecutionResults as IValueStoreClient;
+	}
+
+	async executeInternalCall(
+		entity: InternalCallState,
+		inputs: IDynamicValue[],
+		project: ProjectState,
+		client: IExecutionClient = {}
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeInternalCall', entity, inputs);
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client
+		};
+
+		// Execute the operation based on its "implementation"
+		try {
+			let oPResult: IPrimitiveExecutionResult = {
+				value: ExecutionTerminationType.Success,
+				error: null,
+				result: null
+			};
+
+			// Sort inputs based on 'index'
+			inputs.sort(
+				(a, b) =>
+					(a.valueOwner as InputMapState).index -
+					(b.valueOwner as InputMapState).index
+			);
+
+			if (
+				Object.values(BuiltInFunctionIds).includes(
+					entity.declaration.id as BuiltInFunctionIds
+				)
+			) {
+				const implementation =
+					this.parentContext.requestExtension<BuiltInFunctionImplementationModule>(
+						BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX +
+							entity.declaration.id
+					).module.main;
+
+				if (implementation) {
+					oPResult = await implementation(entity, inputs, this);
+				} else {
+					Logger.warn(
+						`No implementation found for built-in function: ${entity.declaration.id}`
+					);
+				}
+			} else {
+				// Execute the function-declaration as a detached function
+				const detachedResult =
+					await this.executeDetachedFullFunctionDeclarationLogic(
+						entity.declaration as FunctionDeclarationState,
+						inputs,
+						project,
+						clientWithDefaults
+					);
+				oPResult = {
+					value: detachedResult.value,
+					error: detachedResult.error,
+					result: detachedResult.result
+				};
+			}
+
+			let errorValue: IDynamicValue | null = null;
+
+			if (oPResult.error && !!entity.error) {
+				Logger.warn(`Raw error executing entity: `, oPResult.error);
+				const { single: rawErrorSingle, list: rawErrorList } =
+					extractRawValue(oPResult.error);
+				const richError = serializeError(rawErrorSingle);
+				const resolvedDataType = entity.error?.getDataType(null);
+				const literalValueInstance =
+					assembleStandaloneLiteralValueFromDataType(
+						resolvedDataType || null,
+						entity.error as EntityWithValueState,
+						project
+					);
+
+				if (!!resolvedDataType?.asType) {
+					if (rawErrorList !== null) {
+						literalValueInstance?.setValueAsTypeList(rawErrorList);
+					} else {
+						literalValueInstance?.setValueAsTypeSingle(
+							rawErrorSingle
+						);
+					}
+				} else {
+					const sanitizedError = isObject(richError)
+						? JSON.stringify(richError, null, 2)
+						: richError;
+					literalValueInstance?.metaSync(
+						{
+							value: sanitizedError
+						},
+						null
+					);
+				}
+
+				errorValue = {
+					valueOwner: entity.error as EntityWithValueState,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: literalValueInstance
+				};
+			}
+
+			const resolvedDataType = entity?.getDataType(null);
+			const literalValueInstance =
+				assembleStandaloneLiteralValueFromDataType(
+					resolvedDataType,
+					entity,
+					project
+				);
+
+			const { single: rawResultSingle, list: rawResultList } =
+				extractRawValue(oPResult.result);
+			if (!!resolvedDataType?.asType) {
+				if (rawResultList !== null) {
+					literalValueInstance?.setValueAsTypeList(rawResultList);
+				} else {
+					literalValueInstance?.setValueAsTypeSingle(rawResultSingle);
+				}
+			} else {
+				literalValueInstance?.metaSync(
+					{
+						value: rawResultSingle
+					},
+					null
+				);
+			}
+
+			return {
+				value: oPResult.value,
+				entity: entity,
+				error: errorValue,
+				result: {
+					value: literalValueInstance || null,
+					valueOwner: entity,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null
+				}
+			};
+		} catch (e) {
+			if (
+				e &&
+				((e as any).name === 'ExecutionStoppedError' ||
+					(e as any).message === 'Execution was stopped')
+			)
+				throw e;
+			Logger.warn(`Internal call execution error: `, e);
+			let resolvedErrorValue: IDynamicValue | null = null;
+
+			// TODO: Add error to entity if not present
+			if (!!entity.error) {
+				const richError = serializeError(e);
+				const resolvedDataType = entity.error?.getDataType(null);
+				const literalValueInstance =
+					assembleStandaloneLiteralValueFromDataType(
+						resolvedDataType,
+						entity.error,
+						project
+					);
+
+				if (!!resolvedDataType?.asType) {
+					literalValueInstance?.setValueAsTypeSingle(e as any);
+				} else {
+					const sanitizedError = isObject(richError)
+						? JSON.stringify(richError, null, 2)
+						: richError;
+					literalValueInstance?.metaSync(
+						{
+							value: sanitizedError
+						},
+						null
+					);
+				}
+
+				resolvedErrorValue = {
+					valueOwner: entity.error,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: literalValueInstance
+				};
+			}
+
+			return {
+				value:
+					entity.catchesError || entity.errorCalls.length
+						? ExecutionTerminationType.CaughtError
+						: ExecutionTerminationType.UnhandledError,
+				entity: entity,
+				error: resolvedErrorValue,
+				result: null
+			};
+		}
+	}
+
+	static async executeOperation(
+		operation: OperationState,
+		inputs: IDynamicValue[],
+		project: ProjectState,
+		execution?: Execution
+	): Promise<IExecutionResult> {
+		if (execution) {
+			execution.logBeforeExecution('executeOperation', operation, inputs);
+		} else {
+			console.log(
+				`executeOperation (${operation.type}) -> [${resolveEntityName(operation, project)}] Inputs:${!!inputs.length ? `\n   ` : ''}${inputs
+					.map(
+						(d) =>
+							`${d.valueOwner?.type} (${d.valueOwner?.id}) "${resolveEntityName(d.valueOwner as any, project)}": ${JSON.stringify(d.value?.value, null, 2)}`
+					)
+					.join('\n   ')}\n`
+			);
+		}
+		// Execute the operation based on its "implementation"
+		try {
+			let oPResult: IPrimitiveExecutionResult = {
+				value: ExecutionTerminationType.Success,
+				error: null,
+				result: null
+			};
+
+			// Sort inputs based on 'index'
+			inputs.sort(
+				(a, b) =>
+					(a.valueOwner as InputMapState).index -
+					(b.valueOwner as InputMapState).index
+			);
+
+			if (operation.declaration.implementation) {
+				oPResult = await operation.declaration.implementation(
+					operation,
+					inputs.sort(
+						(a, b) =>
+							(a.valueOwner as InputMapState).index -
+							(b.valueOwner as InputMapState).index
+					)
+				);
+			}
+
+			let errorValue: IDynamicValue | null = null;
+
+			if (oPResult.error && !!operation.error) {
+				const richError = serializeError(oPResult.error);
+
+				const resolvedDataType =
+					operation.error?.getDataType(null) || null;
+				const literalValueInstance =
+					assembleStandaloneLiteralValueFromDataType(
+						resolvedDataType,
+						operation.error,
+						project
+					);
+
+				if (!!resolvedDataType?.asType) {
+					literalValueInstance?.setValueAsTypeSingle(oPResult.error);
+				} else {
+					// Make payload digestible
+					const sanitizedError = isObject(richError)
+						? JSON.stringify(richError, null, 2) // Pretty print helps debugging
+						: richError;
+
+					literalValueInstance?.metaSync(
+						{
+							value: sanitizedError
+						},
+						null
+					);
+				}
+
+				errorValue = {
+					valueOwner: operation.error,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: literalValueInstance
+				};
+			}
+
+			const resolvedDataType = operation?.getDataType(null);
+			const literalValueInstance =
+				assembleStandaloneLiteralValueFromDataType(
+					resolvedDataType,
+					operation,
+					project
+				);
+
+			if (!!resolvedDataType?.asType) {
+				literalValueInstance?.setValueAsTypeSingle(oPResult.result);
+			} else {
+				literalValueInstance?.metaSync(
+					{
+						value: oPResult.result
+					},
+					null
+				);
+			}
+
+			return {
+				value: oPResult.value,
+				entity: operation,
+				error: errorValue,
+				result: {
+					value: literalValueInstance || null,
+					valueOwner: operation,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null
+				}
+			};
+		} catch (e) {
+			if (
+				e &&
+				((e as any).name === 'ExecutionStoppedError' ||
+					(e as any).message === 'Execution was stopped')
+			)
+				throw e;
+			console.warn(`Operation execution error: `, e);
+			let resolvedErrorValue: IDynamicValue | null = null;
+
+			// TODO: Add error to entity if not present
+			if (!!operation.error) {
+				const richError = serializeError(e);
+				const resolvedDataType = operation.error?.getDataType(null);
+				const literalValueInstance =
+					assembleStandaloneLiteralValueFromDataType(
+						resolvedDataType,
+						operation.error,
+						project
+					);
+
+				if (!!resolvedDataType?.asType) {
+					literalValueInstance?.setValueAsTypeSingle(e as any);
+				} else {
+					const sanitizedError = isObject(richError)
+						? JSON.stringify(richError, null, 2)
+						: richError;
+					literalValueInstance?.metaSync(
+						{
+							value: sanitizedError
+						},
+						null
+					);
+				}
+
+				resolvedErrorValue = {
+					valueOwner: operation.error,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: literalValueInstance
+				};
+			}
+
+			return {
+				value:
+					operation.catchesError || operation.errorCalls.length
+						? ExecutionTerminationType.CaughtError
+						: ExecutionTerminationType.UnhandledError,
+				entity: operation,
+				error: resolvedErrorValue,
+				result: null
+			};
+		}
+	}
+
+	async executeSearch(
+		entity: SearchState,
+		inputs: IDynamicValue[],
+		project: ProjectState
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeSearch', entity, inputs);
+		try {
+			let oPResult: IPrimitiveExecutionResult = {
+				value: ExecutionTerminationType.Success,
+				error: null,
+				result: null
+			};
+
+			const newValue = await (
+				await this.parentContext.requestExtension<ISearchNodeImplementationModule>(
+					DEFAULT_MODULE_IDS.SEARCH_NODE_IMPLEMENTATION
+				)
+			).module.main(entity, inputs);
+
+			// Create a new literal value instance
+			const resolvedDataType = entity?.getDataType(null);
+			const literalValueInstance =
+				assembleStandaloneLiteralValueFromDataType(
+					resolvedDataType,
+					entity,
+					project
+				);
+
+			literalValueInstance?.metaSync(
+				{
+					value: newValue
+				},
+				null
+			);
+
+			if (newValue.error) {
+				return {
+					value: ExecutionTerminationType.UnhandledError,
+					entity: entity,
+					error: {
+						valueOwner: entity,
+						type: DynamicValueTypes.ExecutionResult,
+						inheritanceLink: null,
+						value: literalValueInstance
+					},
+					result: null
+				};
+			}
+
+			return {
+				value: oPResult.value,
+				entity: entity,
+				error: null,
+				result: {
+					value: literalValueInstance,
+					valueOwner: entity,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null
+				}
+			};
+		} catch (e) {
+			if (
+				e &&
+				((e as any).name === 'ExecutionStoppedError' ||
+					(e as any).message === 'Execution was stopped')
+			)
+				throw e;
+			Logger.warn(`Search node execution error: ${e}`);
+			if (!entity.error) {
+				return {
+					value:
+						entity.catchesError || entity.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					entity: entity,
+					error: null,
+					result: null
+				};
+			}
+
+			const richError = serializeError(e);
+			const resolvedDataType = entity.error?.getDataType(null);
+
+			const errorLiteralValueInstance =
+				assembleStandaloneLiteralValueFromDataType(
+					resolvedDataType,
+					entity.error,
+					project
+				);
+
+			const sanitizedError = isObject(richError)
+				? JSON.stringify(richError, null, 2)
+				: richError;
+			errorLiteralValueInstance?.metaSync(
+				{
+					value: sanitizedError
+				},
+				null
+			);
+
+			return {
+				value:
+					entity.catchesError || entity.errorCalls.length
+						? ExecutionTerminationType.CaughtError
+						: ExecutionTerminationType.UnhandledError,
+				entity: entity,
+				error: {
+					valueOwner: entity.error,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: errorLiteralValueInstance
+				},
+				result: null
+			};
+		}
+	}
+
+	async executeLoop(
+		loop: LoopState,
+		inputs: IDynamicValue[],
+		project: ProjectState,
+		client: IExecutionClient = {}
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeLoop', loop, inputs);
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client
+		};
+
+		/*
+			Execute the loop based on its "declaration"
+			Each loop type works differently, but executing a loop always means executing its body function-declaration
+			What changes are the inputs and outputs, both of the loop and the body function-declaration
+			
+			In this function, we:
+				- Keep track of the iterations and add a circuit breaker to avoid infinite loops
+				- Based on the loop type, pass the correct values as the arguments of the body function on each iteration
+				- Agregate any returned values from the body function and pass them as the next iteration's arguments
+				- Terminate the loop if a break statement is called/executed
+				- Terminate the loop if a return statement is called/executed
+				- Map the final aggregated results if any, to the loop's output map values
+
+			All loop types are passed the current iteration number as an argument to the body function
+			Loops that iterate over an iterable value are passed the current value of the iterable as an argument to the body function
+		*/
+		try {
+			let oPResult: IPrimitiveExecutionResult = {
+				value: ExecutionTerminationType.Success,
+				error: null,
+				result: null
+			};
+
+			const rawInputValues = inputs.map(
+				(argValue) =>
+					argValue?.value?.valueAsType || argValue?.value?.value
+			);
+
+			let aggregateListResults: {
+				[key: EntityId]: IDynamicValue;
+			} = {};
+
+			const uniqueInputMaps = loop.getUniqueInputMaps();
+
+			// Initialized the aggregateListResults with empty arrays for each return declaration
+			uniqueInputMaps.forEach((inputMap) => {
+				const input = loop.body.inputs.find(
+					(input) =>
+						resolveEntityName(input, project) ===
+						resolveEntityName(inputMap, project)
+				);
+
+				const resolvedDataType = inputMap?.getDataType(null);
+				const literalValueInstance =
+					assembleStandaloneLiteralValueFromDataType(
+						resolvedDataType,
+						input as EntityWithValueState,
+						project
+					);
+
+				if (!!resolvedDataType?.asType) {
+					literalValueInstance?.setValueAsTypeList([]);
+				} else {
+					literalValueInstance?.metaSync(
+						{
+							value: []
+						},
+						null
+					);
+				}
+
+				this.lastExecutionResults.writeValue(
+					input as EntityWithValueState,
+					literalValueInstance as LiteralValueState
+				);
+
+				const newDynamicValue: IDynamicValue = {
+					value: literalValueInstance,
+					valueOwner: input as EntityWithValueState,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null
+				};
+
+				aggregateListResults[(input as EntityWithValueState).id] =
+					newDynamicValue;
+			});
+
+			let lastBodyResult: IExecutionResult = {
+				value: ExecutionTerminationType.Success,
+				entity: loop.body,
+				error: null,
+				result: null
+			};
+
+			switch (loop.declaration.id) {
+				case BUILT_IN_BASE_ENTITY_IDS.loop['counted-loop'].id: {
+					const maxCount = rawInputValues[0] as number;
+
+					let currentIteration = 1;
+
+					while (
+						currentIteration <= maxCount &&
+						currentIteration <= 50
+					) {
+						await this.checkStateAndPause();
+						const resolvedBodyInputsForCurrentIteration =
+							loop.body.inputs
+								.map((input) => {
+									if (
+										input ===
+										loop.currentIterationNumberArgumentDeclaration
+									) {
+										const resolvedDataType: DataTypeState | null =
+											loop.currentIterationNumberArgumentDeclaration.getDataType(
+												null
+											);
+										const resolvedLiteralValueName =
+											getLiteralValueNameFromDataType(
+												resolvedDataType
+											);
+
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentIteration
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner:
+														loop.currentIterationNumberArgumentDeclaration,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+											aggregateListResults[input.id] =
+												existingDynamicValue;
+
+											return existingDynamicValue;
+										}
+
+										const newLiteralValueTransfer: ILiteralValueTransfer =
+											{
+												id: ProjectState.UUID.uuid(),
+												deletable: true,
+												editable: true,
+												type: EntityType.LiteralValue,
+												autogeneration: null,
+												version:
+													ProjectState.UUID.uuid(),
+												createdAt:
+													new Date().toISOString(),
+												author: ProjectState.sessionAuthor,
+												deleted: false,
+												previousVersion: null,
+												value: currentIteration,
+												valueAsTypeSingle: null,
+												valueAsTypeList: null,
+												parent: null,
+												name: resolvedLiteralValueName,
+												standaloneParent:
+													input.toReference()
+											};
+
+										const newLiteralValueInstance =
+											createStateFromType(
+												newLiteralValueTransfer,
+												project
+											) as LiteralValueState;
+
+										this.lastExecutionResults.writeValue(
+											input,
+											newLiteralValueInstance
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: newLiteralValueInstance,
+											valueOwner:
+												loop.currentIterationNumberArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										aggregateListResults[input.id] =
+											newDynamicValue;
+
+										return newDynamicValue;
+									} else {
+										return aggregateListResults[input.id];
+									}
+								})
+								.filter((input) => !!input) as IDynamicValue[];
+
+						lastBodyResult =
+							await this.executeFullFunctionDeclarationLogic(
+								loop.body,
+								resolvedBodyInputsForCurrentIteration,
+								clientWithDefaults
+							);
+
+						// Aggregate the results of the body function to their list values in 'aggregateListResults'
+						// @ts-ignore
+						(lastBodyResult.results || []).forEach((value) => {
+							// Only returned values can be aggregated
+							if (
+								value.valueOwner.type !== EntityType.InputMap ||
+								TERMINATION_TYPES.includes(
+									value.valueOwner.parent.type
+								)
+							) {
+								return;
+							}
+
+							const input = loop.body.inputs.find(
+								(input) =>
+									resolveEntityName(input, project) ===
+									resolveEntityName(
+										value.valueOwner as InputMapState,
+										project
+									)
+							);
+
+							const lastRawValue: any[] =
+								(aggregateListResults?.[
+									(input as EntityWithValueState).id
+								]?.value?.value as any[]) || [];
+
+							const newValue = [
+								...lastRawValue,
+								value?.value?.value || null
+							];
+
+							aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.metaSync(
+								{
+									value: newValue
+								},
+								null
+							);
+
+							this.lastExecutionResults.writeValue(
+								input as EntityWithValueState,
+								aggregateListResults[
+									(input as EntityWithValueState).id
+								].value as LiteralValueState
+							);
+						});
+
+						if (
+							[
+								ExecutionTerminationType.CaughtError,
+								ExecutionTerminationType.UnhandledError,
+								ExecutionTerminationType.Break,
+								ExecutionTerminationType.Return
+							].includes(lastBodyResult.value)
+						) {
+							break;
+						}
+
+						currentIteration++;
+					}
+
+					break;
+				}
+				case BUILT_IN_BASE_ENTITY_IDS.loop['manual-flow-loop'].id: {
+					let currentIteration = 1;
+
+					while (currentIteration <= 50) {
+						await this.checkStateAndPause();
+						const resolvedBodyInputsForCurrentIteration =
+							loop.body.inputs
+								.map((input) => {
+									if (
+										input ===
+										loop.currentIterationNumberArgumentDeclaration
+									) {
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentIteration
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+											aggregateListResults[input.id] =
+												existingDynamicValue;
+
+											return existingDynamicValue;
+										}
+
+										const resolvedDataType: DataTypeState | null =
+											loop.currentIterationNumberArgumentDeclaration.getDataType(
+												null
+											);
+										const literalValueInstance =
+											assembleStandaloneLiteralValueFromDataType(
+												resolvedDataType,
+												input,
+												project
+											);
+
+										literalValueInstance?.metaSync(
+											{
+												value: currentIteration
+											},
+											null
+										);
+
+										this.lastExecutionResults.writeValue(
+											input,
+											literalValueInstance as LiteralValueState
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: literalValueInstance,
+											valueOwner: input,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else {
+										return aggregateListResults[input.id];
+									}
+								})
+								.filter((input) => !!input) as IDynamicValue[];
+
+						lastBodyResult =
+							await this.executeFullFunctionDeclarationLogic(
+								loop.body,
+								resolvedBodyInputsForCurrentIteration,
+								clientWithDefaults
+							);
+
+						// Aggregate the results of the body function to their list values in 'aggregateListResults'
+						// @ts-ignore
+						(lastBodyResult.results || []).forEach((value) => {
+							// Only returned values can be aggregated
+							if (
+								value.valueOwner.type !== EntityType.InputMap ||
+								TERMINATION_TYPES.includes(
+									value.valueOwner.parent.type
+								)
+							) {
+								return;
+							}
+
+							const input = loop.body.inputs.find(
+								(input) =>
+									resolveEntityName(input, project) ===
+									resolveEntityName(
+										value.valueOwner as InputMapState,
+										project
+									)
+							);
+
+							const lastRawValue: any[] = aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.value as any[];
+
+							const newValue = [
+								...lastRawValue,
+								value.value?.value || null
+							];
+
+							aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.metaSync(
+								{
+									value: newValue
+								},
+								null
+							);
+
+							this.lastExecutionResults.writeValue(
+								input as EntityWithValueState,
+								aggregateListResults[
+									(input as EntityWithValueState).id
+								].value as LiteralValueState
+							);
+						});
+
+						if (
+							[
+								ExecutionTerminationType.CaughtError,
+								ExecutionTerminationType.UnhandledError,
+								ExecutionTerminationType.Break,
+								ExecutionTerminationType.Return
+							].includes(lastBodyResult.value)
+						) {
+							break;
+						}
+
+						currentIteration++;
+					}
+
+					break;
+				}
+				case BUILT_IN_BASE_ENTITY_IDS.loop['list-loop'].id: {
+					const iterable = rawInputValues[0];
+
+					let currentIteration = 1;
+
+					const iterableListOfValues = iterable as any[];
+
+					for (let i = 0; i < iterableListOfValues.length; i++) {
+						await this.checkStateAndPause();
+						const currentValue = iterableListOfValues[i];
+
+						const resolvedBodyInputsForCurrentIteration =
+							loop.body.inputs
+								.map((input) => {
+									if (
+										input ===
+										loop.currentIterationNumberArgumentDeclaration
+									) {
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentIteration
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const resolvedDataType: DataTypeState | null =
+											loop.currentIterationNumberArgumentDeclaration.getDataType(
+												null
+											);
+										const literalValueInstance =
+											assembleStandaloneLiteralValueFromDataType(
+												resolvedDataType,
+												input,
+												project
+											);
+
+										literalValueInstance?.metaSync(
+											{
+												value: currentIteration
+											},
+											null
+										);
+
+										this.lastExecutionResults.writeValue(
+											input,
+											literalValueInstance as LiteralValueState
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: literalValueInstance,
+											valueOwner:
+												loop.currentIterationNumberArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else if (
+										input ===
+										loop.currentValueArgumentDeclaration
+									) {
+										const resolvedDataType: DataTypeState | null =
+											loop.currentValueArgumentDeclaration.getDataType(
+												null
+											);
+										const resolvedLiteralValueName =
+											getLiteralValueNameFromDataType(
+												resolvedDataType
+											);
+
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentValue
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const newLiteralValueTransfer: ILiteralValueTransfer =
+											{
+												id: ProjectState.UUID.uuid(),
+												deletable: true,
+												editable: true,
+												type: EntityType.LiteralValue,
+												autogeneration: null,
+												version:
+													ProjectState.UUID.uuid(),
+												createdAt:
+													new Date().toISOString(),
+												author: ProjectState.sessionAuthor,
+												deleted: false,
+												previousVersion: null,
+												value: currentValue,
+												valueAsTypeSingle: null,
+												valueAsTypeList: null,
+												parent: null,
+												name: resolvedLiteralValueName,
+												standaloneParent:
+													input.toReference()
+											};
+
+										const newLiteralValueInstance =
+											createStateFromType(
+												newLiteralValueTransfer,
+												project
+											) as LiteralValueState;
+
+										this.lastExecutionResults.writeValue(
+											input,
+											newLiteralValueInstance
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: newLiteralValueInstance,
+											valueOwner:
+												loop.currentValueArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else {
+										return aggregateListResults[input.id];
+									}
+								})
+								.filter((input) => !!input) as IDynamicValue[];
+
+						lastBodyResult =
+							await this.executeFullFunctionDeclarationLogic(
+								loop.body,
+								resolvedBodyInputsForCurrentIteration,
+								clientWithDefaults
+							);
+
+						// Aggregate the results of the body function to their list values in 'aggregateListResults'
+						// @ts-ignore
+						(lastBodyResult.results || []).forEach((value) => {
+							// Only returned values can be aggregated
+							if (
+								value.valueOwner.type !== EntityType.InputMap ||
+								TERMINATION_TYPES.includes(
+									value.valueOwner.parent.type
+								)
+							) {
+								return;
+							}
+
+							const input = loop.body.inputs.find(
+								(input) =>
+									resolveEntityName(input, project) ===
+									resolveEntityName(
+										value.valueOwner as InputMapState,
+										project
+									)
+							);
+
+							const lastRawValue: any[] = aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.value as any[];
+
+							const newValue = [
+								...lastRawValue,
+								value.value?.value || null
+							];
+
+							aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.metaSync(
+								{
+									value: newValue
+								},
+								null
+							);
+
+							this.lastExecutionResults.writeValue(
+								input as EntityWithValueState,
+								aggregateListResults[
+									(input as EntityWithValueState).id
+								].value as LiteralValueState
+							);
+						});
+
+						if (
+							[
+								ExecutionTerminationType.CaughtError,
+								ExecutionTerminationType.UnhandledError,
+								ExecutionTerminationType.Break,
+								ExecutionTerminationType.Return
+							].includes(lastBodyResult.value)
+						) {
+							break;
+						}
+
+						currentIteration++;
+					}
+
+					break;
+				}
+				case BUILT_IN_BASE_ENTITY_IDS.loop['object-keys-loop'].id: {
+					const iterable = rawInputValues[0];
+
+					let currentIteration = 1;
+
+					const iterableListOfValues = !!iterable
+						? Object.keys(iterable)
+						: [];
+
+					for (let i = 0; i < iterableListOfValues.length; i++) {
+						await this.checkStateAndPause();
+						const currentValue = iterableListOfValues[i];
+
+						const resolvedBodyInputsForCurrentIteration =
+							loop.body.inputs
+								.map((input) => {
+									if (
+										input ===
+										loop.currentIterationNumberArgumentDeclaration
+									) {
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentIteration
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const resolvedDataType: DataTypeState | null =
+											loop.currentIterationNumberArgumentDeclaration.getDataType(
+												null
+											);
+										const literalValueInstance =
+											assembleStandaloneLiteralValueFromDataType(
+												resolvedDataType,
+												input,
+												project
+											);
+
+										literalValueInstance?.metaSync(
+											{
+												value: currentIteration
+											},
+											null
+										);
+
+										this.lastExecutionResults.writeValue(
+											input,
+											literalValueInstance as LiteralValueState
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: literalValueInstance,
+											valueOwner:
+												loop.currentIterationNumberArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else if (
+										input ===
+										loop.currentValueArgumentDeclaration
+									) {
+										const resolvedDataType: DataTypeState | null =
+											loop.currentValueArgumentDeclaration.getDataType(
+												null
+											);
+										const resolvedLiteralValueName =
+											getLiteralValueNameFromDataType(
+												resolvedDataType
+											);
+
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentValue
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const newLiteralValueTransfer: ILiteralValueTransfer =
+											{
+												id: ProjectState.UUID.uuid(),
+												deletable: true,
+												editable: true,
+												type: EntityType.LiteralValue,
+												autogeneration: null,
+												version:
+													ProjectState.UUID.uuid(),
+												createdAt:
+													new Date().toISOString(),
+												author: ProjectState.sessionAuthor,
+												deleted: false,
+												previousVersion: null,
+												value: currentValue,
+												valueAsTypeSingle: null,
+												valueAsTypeList: null,
+												parent: null,
+												name: resolvedLiteralValueName,
+												standaloneParent:
+													input.toReference()
+											};
+
+										const newLiteralValueInstance =
+											createStateFromType(
+												newLiteralValueTransfer,
+												project
+											) as LiteralValueState;
+
+										this.lastExecutionResults.writeValue(
+											input,
+											newLiteralValueInstance
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: newLiteralValueInstance,
+											valueOwner:
+												loop.currentValueArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else {
+										return aggregateListResults[input.id];
+									}
+								})
+								.filter((input) => !!input) as IDynamicValue[];
+
+						lastBodyResult =
+							await this.executeFullFunctionDeclarationLogic(
+								loop.body,
+								resolvedBodyInputsForCurrentIteration,
+								clientWithDefaults
+							);
+
+						// Aggregate the results of the body function to their list values in 'aggregateListResults'
+						// @ts-ignore
+						(lastBodyResult.results || []).forEach((value) => {
+							// Only returned values can be aggregated
+							if (
+								value.valueOwner.type !== EntityType.InputMap ||
+								TERMINATION_TYPES.includes(
+									value.valueOwner.parent.type
+								)
+							) {
+								return;
+							}
+
+							const input = loop.body.inputs.find(
+								(input) =>
+									resolveEntityName(input, project) ===
+									resolveEntityName(
+										value.valueOwner as InputMapState,
+										project
+									)
+							);
+
+							const lastRawValue: any[] = aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.value as any[];
+
+							const newValue = [
+								...lastRawValue,
+								value.value?.value || null
+							];
+
+							aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.metaSync(
+								{
+									value: newValue
+								},
+								null
+							);
+
+							this.lastExecutionResults.writeValue(
+								input as EntityWithValueState,
+								aggregateListResults[
+									(input as EntityWithValueState).id
+								].value as LiteralValueState
+							);
+						});
+
+						if (
+							[
+								ExecutionTerminationType.CaughtError,
+								ExecutionTerminationType.UnhandledError,
+								ExecutionTerminationType.Break,
+								ExecutionTerminationType.Return
+							].includes(lastBodyResult.value)
+						) {
+							break;
+						}
+
+						currentIteration++;
+					}
+
+					break;
+				}
+				case BUILT_IN_BASE_ENTITY_IDS.loop['object-values-loop'].id: {
+					const iterable = rawInputValues[0];
+
+					let currentIteration = 1;
+
+					const iterableListOfValues = !!iterable
+						? Object.values(iterable)
+						: [];
+
+					for (let i = 0; i < iterableListOfValues.length; i++) {
+						await this.checkStateAndPause();
+						const currentValue = iterableListOfValues[i];
+
+						const resolvedBodyInputsForCurrentIteration =
+							loop.body.inputs
+								.map((input) => {
+									if (
+										input ===
+										loop.currentIterationNumberArgumentDeclaration
+									) {
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentIteration
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const resolvedDataType: DataTypeState | null =
+											loop.currentIterationNumberArgumentDeclaration.getDataType(
+												null
+											);
+										const literalValueInstance =
+											assembleStandaloneLiteralValueFromDataType(
+												resolvedDataType,
+												input,
+												project
+											);
+
+										literalValueInstance?.metaSync(
+											{
+												value: currentIteration
+											},
+											null
+										);
+
+										this.lastExecutionResults.writeValue(
+											input,
+											literalValueInstance as LiteralValueState
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: literalValueInstance,
+											valueOwner:
+												loop.currentIterationNumberArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else if (
+										input ===
+										loop.currentValueArgumentDeclaration
+									) {
+										const resolvedDataType: DataTypeState | null =
+											loop.currentValueArgumentDeclaration.getDataType(
+												null
+											);
+										const resolvedLiteralValueName =
+											getLiteralValueNameFromDataType(
+												resolvedDataType
+											);
+
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentValue
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const newLiteralValueTransfer: ILiteralValueTransfer =
+											{
+												id: ProjectState.UUID.uuid(),
+												deletable: true,
+												editable: true,
+												type: EntityType.LiteralValue,
+												autogeneration: null,
+												version:
+													ProjectState.UUID.uuid(),
+												createdAt:
+													new Date().toISOString(),
+												author: ProjectState.sessionAuthor,
+												deleted: false,
+												previousVersion: null,
+												value: currentValue,
+												valueAsTypeSingle: null,
+												valueAsTypeList: null,
+												parent: null,
+												name: resolvedLiteralValueName,
+												standaloneParent:
+													input.toReference()
+											};
+
+										const newLiteralValueInstance =
+											createStateFromType(
+												newLiteralValueTransfer,
+												project
+											) as LiteralValueState;
+
+										this.lastExecutionResults.writeValue(
+											input,
+											newLiteralValueInstance
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: newLiteralValueInstance,
+											valueOwner:
+												loop.currentValueArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else {
+										return aggregateListResults[input.id];
+									}
+								})
+								.filter((input) => !!input) as IDynamicValue[];
+
+						lastBodyResult =
+							await this.executeFullFunctionDeclarationLogic(
+								loop.body,
+								resolvedBodyInputsForCurrentIteration,
+								clientWithDefaults
+							);
+
+						// Aggregate the results of the body function to their list values in 'aggregateListResults'
+						// @ts-ignore
+						(lastBodyResult.results || []).forEach((value) => {
+							// Only returned values can be aggregated
+							if (
+								value.valueOwner.type !== EntityType.InputMap ||
+								TERMINATION_TYPES.includes(
+									value.valueOwner.parent.type
+								)
+							) {
+								return;
+							}
+
+							const input = loop.body.inputs.find(
+								(input) =>
+									resolveEntityName(input, project) ===
+									resolveEntityName(
+										value.valueOwner as InputMapState,
+										project
+									)
+							);
+
+							const lastRawValue: any[] = aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.value as any[];
+
+							const newValue = [
+								...lastRawValue,
+								value.value?.value || null
+							];
+
+							aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.metaSync(
+								{
+									value: newValue
+								},
+								null
+							);
+
+							this.lastExecutionResults.writeValue(
+								input as EntityWithValueState,
+								aggregateListResults[
+									(input as EntityWithValueState).id
+								].value as LiteralValueState
+							);
+						});
+
+						if (
+							[
+								ExecutionTerminationType.CaughtError,
+								ExecutionTerminationType.UnhandledError,
+								ExecutionTerminationType.Break,
+								ExecutionTerminationType.Return
+							].includes(lastBodyResult.value)
+						) {
+							break;
+						}
+
+						currentIteration++;
+					}
+
+					break;
+				}
+				case BUILT_IN_BASE_ENTITY_IDS.loop['string-loop'].id: {
+					const iterable = rawInputValues[0];
+
+					let currentIteration = 1;
+
+					const iterableListOfValues = (iterable as string).split('');
+
+					for (let i = 0; i < iterableListOfValues.length; i++) {
+						await this.checkStateAndPause();
+						const currentValue = iterableListOfValues[i];
+
+						const resolvedBodyInputsForCurrentIteration =
+							loop.body.inputs
+								.map((input) => {
+									if (
+										input ===
+										loop.currentIterationNumberArgumentDeclaration
+									) {
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentIteration
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const resolvedDataType: DataTypeState | null =
+											loop.currentIterationNumberArgumentDeclaration.getDataType(
+												null
+											);
+										const literalValueInstance =
+											assembleStandaloneLiteralValueFromDataType(
+												resolvedDataType,
+												input,
+												project
+											);
+
+										literalValueInstance?.metaSync(
+											{
+												value: currentIteration
+											},
+											null
+										);
+
+										this.lastExecutionResults.writeValue(
+											input,
+											literalValueInstance as LiteralValueState
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: literalValueInstance,
+											valueOwner:
+												loop.currentIterationNumberArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else if (
+										input ===
+										loop.currentValueArgumentDeclaration
+									) {
+										const resolvedDataType: DataTypeState | null =
+											loop.currentValueArgumentDeclaration.getDataType(
+												null
+											);
+										const resolvedLiteralValueName =
+											getLiteralValueNameFromDataType(
+												resolvedDataType
+											);
+
+										const existingValue =
+											this.lastExecutionResults.readValue(
+												input.id
+											);
+
+										if (existingValue) {
+											existingValue.metaSync(
+												{
+													value: currentValue
+												},
+												null
+											);
+
+											this.lastExecutionResults.writeValue(
+												input,
+												existingValue
+											);
+
+											const existingDynamicValue: IDynamicValue =
+												{
+													value: existingValue,
+													valueOwner: input,
+													type: DynamicValueTypes.ExecutionResult,
+													inheritanceLink: null
+												};
+
+											return existingDynamicValue;
+										}
+
+										const newLiteralValueTransfer: ILiteralValueTransfer =
+											{
+												id: ProjectState.UUID.uuid(),
+												deletable: true,
+												editable: true,
+												type: EntityType.LiteralValue,
+												autogeneration: null,
+												version:
+													ProjectState.UUID.uuid(),
+												createdAt:
+													new Date().toISOString(),
+												author: ProjectState.sessionAuthor,
+												deleted: false,
+												previousVersion: null,
+												value: currentValue,
+												valueAsTypeSingle: null,
+												valueAsTypeList: null,
+												parent: null,
+												name: resolvedLiteralValueName,
+												standaloneParent:
+													input.toReference()
+											};
+
+										const newLiteralValueInstance =
+											createStateFromType(
+												newLiteralValueTransfer,
+												project
+											) as LiteralValueState;
+
+										this.lastExecutionResults.writeValue(
+											input,
+											newLiteralValueInstance
+										);
+
+										const newDynamicValue: IDynamicValue = {
+											value: newLiteralValueInstance,
+											valueOwner:
+												loop.currentValueArgumentDeclaration,
+											type: DynamicValueTypes.ExecutionResult,
+											inheritanceLink: null
+										};
+
+										return newDynamicValue;
+									} else {
+										return aggregateListResults[input.id];
+									}
+								})
+								.filter((input) => !!input) as IDynamicValue[];
+
+						lastBodyResult =
+							await this.executeFullFunctionDeclarationLogic(
+								loop.body,
+								resolvedBodyInputsForCurrentIteration,
+								clientWithDefaults
+							);
+
+						// Aggregate the results of the body function to their list values in 'aggregateListResults'
+						// @ts-ignore
+						(lastBodyResult.results || []).forEach((value) => {
+							// Only returned values can be aggregated
+							if (
+								value.valueOwner.type !== EntityType.InputMap ||
+								TERMINATION_TYPES.includes(
+									value.valueOwner.parent.type
+								)
+							) {
+								return;
+							}
+
+							const input = loop.body.inputs.find(
+								(input) =>
+									resolveEntityName(input, project) ===
+									resolveEntityName(
+										value.valueOwner as InputMapState,
+										project
+									)
+							);
+
+							const lastRawValue: any[] = aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.value as any[];
+
+							const newValue = [
+								...lastRawValue,
+								value.value?.value || null
+							];
+
+							aggregateListResults[
+								(input as EntityWithValueState).id
+							].value?.metaSync(
+								{
+									value: newValue
+								},
+								null
+							);
+
+							this.lastExecutionResults.writeValue(
+								input as EntityWithValueState,
+								aggregateListResults[
+									(input as EntityWithValueState).id
+								].value as LiteralValueState
+							);
+						});
+
+						if (
+							[
+								ExecutionTerminationType.CaughtError,
+								ExecutionTerminationType.UnhandledError,
+								ExecutionTerminationType.Break,
+								ExecutionTerminationType.Return
+							].includes(lastBodyResult.value)
+						) {
+							break;
+						}
+
+						currentIteration++;
+					}
+
+					break;
+				}
+			}
+
+			let value = ExecutionTerminationType.Success;
+
+			if (
+				lastBodyResult.value === ExecutionTerminationType.UnhandledError
+			) {
+				if (loop.catchesError || loop.errorCalls.length) {
+					value = ExecutionTerminationType.CaughtError;
+				} else {
+					value = ExecutionTerminationType.UnhandledError;
+				}
+			} else if (
+				[
+					ExecutionTerminationType.CaughtError,
+					ExecutionTerminationType.Return
+				].includes(lastBodyResult.value)
+			) {
+				value = lastBodyResult.value;
+			}
+
+			oPResult = {
+				value: value,
+				error: lastBodyResult.error?.value?.value || null,
+				result: lastBodyResult?.result?.value?.value || null
+			};
+
+			if (
+				oPResult.value === ExecutionTerminationType.UnhandledError ||
+				oPResult.value === ExecutionTerminationType.CaughtError
+			) {
+				let errorValue: IDynamicValue | null = null;
+				if (!!loop.error) {
+					const richError = serializeError(oPResult.error);
+					const resolvedDataType = loop.error?.getDataType(null);
+					const literalValueInstance =
+						assembleStandaloneLiteralValueFromDataType(
+							resolvedDataType || null,
+							loop.error,
+							project
+						);
+
+					if (!!resolvedDataType?.asType) {
+						literalValueInstance?.setValueAsTypeSingle(
+							oPResult.error
+						);
+					} else {
+						const sanitizedError = isObject(richError)
+							? JSON.stringify(richError, null, 2)
+							: richError;
+						literalValueInstance?.metaSync(
+							{
+								value: sanitizedError
+							},
+							null
+						);
+					}
+
+					errorValue = {
+						valueOwner: loop.error,
+						type: DynamicValueTypes.ExecutionResult,
+						inheritanceLink: null,
+						value: literalValueInstance
+					};
+				}
+
+				return {
+					value: oPResult.value,
+					entity: loop,
+					error: errorValue,
+					result: null
+				};
+			}
+
+			const resolvedDataType = loop?.getDataType(null);
+			const literalValueInstance =
+				assembleStandaloneLiteralValueFromDataType(
+					resolvedDataType,
+					loop,
+					project
+				);
+
+			if (!!resolvedDataType?.asType) {
+				literalValueInstance?.setValueAsTypeSingle(oPResult.result);
+			} else {
+				literalValueInstance?.metaSync(
+					{
+						value: oPResult.result
+					},
+					null
+				);
+			}
+
+			return {
+				value: oPResult.value,
+				entity: loop,
+				error: null,
+				result: {
+					value: literalValueInstance || null,
+					valueOwner: loop,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null
+				}
+			};
+		} catch (e) {
+			if (
+				e &&
+				((e as any).name === 'ExecutionStoppedError' ||
+					(e as any).message === 'Execution was stopped')
+			)
+				throw e;
+			Logger.warn('Error executing loop: ', e);
+			// TODO: Add error to entity if not present
+			if (loop.error) {
+				const richError = serializeError(e);
+				const resolvedDataType = loop.error?.getDataType(null);
+				const literalValueInstance =
+					assembleStandaloneLiteralValueFromDataType(
+						resolvedDataType,
+						loop.error,
+						project
+					);
+
+				if (!!resolvedDataType?.asType) {
+					literalValueInstance?.setValueAsTypeSingle(e as any);
+				} else {
+					const sanitizedError = isObject(richError)
+						? JSON.stringify(richError, null, 2)
+						: richError;
+					literalValueInstance?.metaSync(
+						{
+							value: sanitizedError
+						},
+						null
+					);
+				}
+
+				return {
+					value:
+						loop.catchesError || loop.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					entity: loop,
+					error: {
+						valueOwner: loop.error,
+						type: DynamicValueTypes.ExecutionResult,
+						inheritanceLink: null,
+						value: literalValueInstance
+					},
+					result: null
+				};
+			} else {
+				return {
+					value:
+						loop.catchesError || loop.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					entity: loop,
+					error: null,
+					result: null
+				};
+			}
+		}
+	}
+
+	async executeFunctionCall(
+		functionCall: FunctionCallState,
+		inputs: IDynamicValue[],
+		project: ProjectState,
+		client: IExecutionClient = {}
+	): Promise<IExecutionResult> {
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client
+		};
+
+		// Execute the functionCall based on its "implementation"
+		try {
+			this.logBeforeExecution(
+				'executeFunctionCall',
+				functionCall,
+				inputs
+			);
+			const oPResult =
+				await this.executeDetachedFullFunctionDeclarationLogic(
+					functionCall.declaration as FunctionDeclarationState,
+					inputs,
+					project,
+					clientWithDefaults
+				);
+
+			let errorValue: IDynamicValue | null = null;
+
+			if (oPResult.error && !!functionCall.error) {
+				Logger.warn(`Raw error executing entity: `, oPResult.error);
+				const resolvedErrorDataType =
+					functionCall.error?.getDataType(null);
+				const errorLiteralValueInstance =
+					assembleStandaloneLiteralValueFromDataType(
+						resolvedErrorDataType || null,
+						functionCall.error,
+						project
+					);
+
+				if (!!resolvedErrorDataType?.asType) {
+					if (!!oPResult.error?.value?.valueAsTypeSingle) {
+						errorLiteralValueInstance?.setValueAsTypeSingle(
+							oPResult.error?.value?.valueAsTypeSingle
+						);
+					} else if (
+						!!oPResult.error?.value?.valueAsTypeList &&
+						Array.isArray(oPResult.error?.value?.valueAsTypeList)
+					) {
+						errorLiteralValueInstance?.setValueAsTypeList(
+							oPResult.error?.value?.valueAsTypeList
+						);
+					}
+				} else {
+					errorLiteralValueInstance?.metaSync(
+						{
+							value: oPResult.error?.value?.value
+						},
+						null
+					);
+				}
+
+				errorValue = {
+					valueOwner: functionCall.error,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: errorLiteralValueInstance
+				};
+			}
+
+			let value = ExecutionTerminationType.Success;
+
+			if (oPResult.value === ExecutionTerminationType.UnhandledError) {
+				if (
+					functionCall.catchesError ||
+					functionCall.errorCalls.length
+				) {
+					value = ExecutionTerminationType.CaughtError;
+				} else {
+					value = ExecutionTerminationType.UnhandledError;
+				}
+			}
+
+			const resolvedDataType = functionCall?.getDataType(null);
+			const literalValueInstance =
+				assembleStandaloneLiteralValueFromDataType(
+					resolvedDataType,
+					functionCall,
+					project
+				);
+
+			if (!!resolvedDataType?.asType) {
+				if (!!oPResult.result?.value?.valueAsTypeSingle) {
+					literalValueInstance?.setValueAsTypeSingle(
+						oPResult.result?.value?.valueAsTypeSingle
+					);
+				} else if (
+					!!oPResult.result?.value?.valueAsTypeList &&
+					Array.isArray(oPResult.result?.value?.valueAsTypeList)
+				) {
+					literalValueInstance?.setValueAsTypeList(
+						oPResult.result?.value?.valueAsTypeList
+					);
+				}
+			} else {
+				literalValueInstance?.metaSync(
+					{
+						value: oPResult.result?.value?.value || null
+					},
+					null
+				);
+			}
+
+			return {
+				value: value,
+				entity: functionCall,
+				error: errorValue,
+				result: {
+					value: literalValueInstance || null,
+					valueOwner: functionCall,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null
+				}
+			};
+		} catch (e) {
+			if (
+				e &&
+				((e as any).name === 'ExecutionStoppedError' ||
+					(e as any).message === 'Execution was stopped')
+			)
+				throw e;
+			if (!functionCall.error) {
+				return {
+					value:
+						functionCall.catchesError ||
+						functionCall.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					entity: functionCall,
+					error: null,
+					result: null
+				};
+			}
+
+			const richError = serializeError(e);
+			const resolvedDataType = functionCall.error?.getDataType(null);
+			const literalValueInstance =
+				assembleStandaloneLiteralValueFromDataType(
+					resolvedDataType,
+					functionCall.error,
+					project
+				);
+
+			if (!!resolvedDataType?.asType) {
+				literalValueInstance?.setValueAsTypeSingle(e as any);
+			} else {
+				const sanitizedError = isObject(richError)
+					? JSON.stringify(richError, null, 2)
+					: richError;
+				literalValueInstance?.metaSync(
+					{
+						value: sanitizedError
+					},
+					null
+				);
+			}
+			return {
+				value:
+					functionCall.catchesError || functionCall.errorCalls.length
+						? ExecutionTerminationType.CaughtError
+						: ExecutionTerminationType.UnhandledError,
+				entity: functionCall,
+				error: {
+					valueOwner: functionCall.error,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: literalValueInstance
+				},
+				result: null
+			};
+		}
+	}
+
+	async executeCondition(
+		condition: ConditionState,
+		inputs: IDynamicValue[]
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeCondition', condition, inputs);
+		let hasConditionBeenMet = false;
+
+		switch (condition.declaration.id) {
+			/* ------------------------ BOOLEAN ----------------------- */
+			case StandaloneOperatorTypes.BooleanIsTrue: {
+				const v = inputs[0]?.value?.value;
+				if (typeof v !== 'boolean') {
+					throw new TypeError(
+						'BooleanIsTrue expects a boolean input.'
+					);
+				}
+				hasConditionBeenMet = v === true;
+				break;
+			}
+			case StandaloneOperatorTypes.BooleanIsFalse: {
+				const v = inputs[0]?.value?.value;
+				if (typeof v !== 'boolean') {
+					throw new TypeError(
+						'BooleanIsFalse expects a boolean input.'
+					);
+				}
+				hasConditionBeenMet = v === false;
+				break;
+			}
+
+			case GroupOperatorTypes.And: {
+				const results = await Promise.all(
+					(condition.andChildrenGroup as ConditionState[]).map(
+						async (childCondition) => {
+							const resolvedInputs =
+								this.mergeExernalValuesWithInternalInputs(
+									inputs,
+									childCondition
+								);
+
+							const nestedResult = await this.executeCondition(
+								childCondition,
+								resolvedInputs
+							);
+							return (
+								nestedResult.value ===
+								ExecutionTerminationType.Success
+							);
+						}
+					)
+				);
+				hasConditionBeenMet = results.every((result) => result);
+				break;
+			}
+			case GroupOperatorTypes.Or: {
+				const results = await Promise.all(
+					(condition.orChildrenGroup as ConditionState[]).map(
+						async (childCondition) => {
+							const resolvedInputs =
+								this.mergeExernalValuesWithInternalInputs(
+									inputs,
+									childCondition
+								);
+
+							const nestedResult = await this.executeCondition(
+								childCondition,
+								resolvedInputs
+							);
+							return (
+								nestedResult.value ===
+								ExecutionTerminationType.Success
+							);
+						}
+					)
+				);
+
+				hasConditionBeenMet = results.some((result) => result);
+				break;
+			}
+			default: {
+				throw new Error(
+					`Condition declaration ${condition.declaration.name} does not have an implementation.`
+				);
+			}
+		}
+
+		return {
+			value: hasConditionBeenMet
+				? ExecutionTerminationType.Success
+				: ExecutionTerminationType.ConditionNotMet,
+			entity: condition,
+			error: null,
+			result: null
+		};
+	}
+
+	async executeDetachedFullFunctionDeclarationLogic(
+		functionDeclaration: FunctionDeclarationState,
+		inputs: IDynamicValue[],
+		project: ProjectState,
+		client: IExecutionClient = {}
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution(
+			'executeDetachedFullFunctionDeclarationLogic',
+			functionDeclaration,
+			inputs
+		);
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client,
+			onBeforeEntityExecution: (entity, values, context) => {
+				return (
+					client?.onBeforeEntityExecution?.(entity, values, {
+						...context,
+						detached: true
+					}) || Promise.resolve()
+				);
+			},
+			onEntityExecuted: (entity, result, context) => {
+				return (
+					client?.onEntityExecuted?.(entity, result, {
+						...context,
+						detached: true
+					}) || Promise.resolve()
+				);
+			}
+		};
+
+		// Execute the body of the function declaration
+		const functionBodyExecution = new Execution(
+			project,
+			[
+				functionDeclaration,
+				...(flattenRelatedCanvasElementsOnTheRight(
+					functionDeclaration
+				) as (
+					| DraggableExecutableEntityState
+					| DraggableCallerEntityState
+					| VariableDeclarationState
+				)[])
+			],
+			functionDeclaration,
+			this,
+			this.parentContext
+		);
+
+		functionBodyExecution.inheritValuesFromContext(this);
+
+		const result = await functionBodyExecution.execute(
+			clientWithDefaults,
+			inputs
+		);
+
+		return result;
+	}
+
+	async executeFullFunctionDeclarationLogic(
+		functionDeclaration: FunctionDeclarationState,
+		inputs: IDynamicValue[],
+		// project: ProjectState,
+		client: IExecutionClient = {}
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution(
+			'executeFullFunctionDeclarationLogic',
+			functionDeclaration,
+			inputs
+		);
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client
+		};
+
+		// Execute the body of the function declaration
+		// Add all children if they aren't already added
+		const childrenEntities = flattenRelatedCanvasElementsOnTheRight(
+			functionDeclaration
+		) as CallableEntityState[];
+
+		const internalCalls: CallableEntityState[] = [];
+		childrenEntities.forEach((entity) => {
+			if (
+				entity.type === EntityType.VariableDeclaration ||
+				entity.type === EntityType.VariableInstance
+			) {
+				const varState = entity as any;
+				if (varState.internalCalls) {
+					internalCalls.push(...varState.internalCalls);
+				}
+			}
+		});
+		childrenEntities.push(...internalCalls);
+
+		console.log(
+			`[executeFullFunctionDeclarationLogic] Reseting children for: ${resolveEntityName(functionDeclaration, this.project)}\nChildren:`,
+			childrenEntities.map((e) => `${e.type} "${resolveEntityName(e, this.project)}"`).join(', ')
+		);
+
+		childrenEntities.forEach((entity) => {
+			this.addEntity(entity);
+			this.removeFromAlreadyExecutedList(entity);
+			this.removeFromSkippedList(entity);
+			this.removeFromScheduledList(entity);
+		});
+
+		// Clear last executed values for the entities declared withing the scope of the function
+		const allDeclaredValueEntities = childrenEntities.reduce(
+			(acc: EntityWithValueState[], entity) => {
+				if (TERMINATION_TYPES.includes(entity.type)) {
+					return [
+						...acc,
+						...(entity as TerminationEntityState).outputs
+					];
+				} else if (
+					PASS_THROUGH_CALLABLE_TYPES.includes(entity.type) &&
+					entity.type !== EntityType.Condition
+				) {
+					return [
+						...acc,
+						...((entity as PassThroughCallableEntityWithOutputs)
+							.outputs as EntityWithValueState[]),
+						...((entity as PassThroughCallableEntityWithOutputs)
+							.inputs as EntityWithValueState[])
+					];
+				} else if (entity.type === EntityType.Condition) {
+					return [...acc, ...(entity as ConditionState).inputs];
+				}
+
+				return acc;
+			},
+			[] as EntityWithValueState[]
+		);
+
+		allDeclaredValueEntities.forEach((entity) => {
+			this.lastExecutionResults.removeValue(entity.id);
+		});
+
+		const result = await this.executeBranch(
+			functionDeclaration,
+			clientWithDefaults,
+			inputs
+		);
+
+		return {
+			...(result || {}),
+			value: result?.value || ExecutionTerminationType.Success,
+			entity: functionDeclaration,
+			error: result?.error || null,
+			result: result?.result || null
+		};
+	}
+
+	// This function only "executes" the individual entity, the entry point card.
+	// To execute the full logic of the body of the function declaration we have another function
+	static async executeEntryPointEntity(
+		entryPointEntity: EntryPointEntityState,
+		inputs: IDynamicValue[],
+		execution?: Execution
+	): Promise<IExecutionResult> {
+		if (execution) {
+			execution.logBeforeExecution(
+				'executeEntryPointEntity',
+				entryPointEntity,
+				inputs
+			);
+		} else {
+			console.log(
+				`executeEntryPointEntity (${entryPointEntity.type}) -> [${entryPointEntity.name || entryPointEntity.id}] Inputs:${!!inputs.length ? `\n   ` : ''}${inputs
+					.map(
+						(d) =>
+							`${d.valueOwner?.type} (${d.valueOwner?.id}) "${resolveEntityName(d.valueOwner as any, entryPointEntity.project)}": ${JSON.stringify(d.value?.value, null, 2)}`
+					)
+					.join('\n   ')}\n`
+			);
+		}
+		return {
+			value: ExecutionTerminationType.Success,
+			entity: entryPointEntity,
+			error: null,
+			result: null
+		};
+	}
+
+	async executeReturnStatement(
+		entity: ReturnStatementState,
+		inputs: IDynamicValue[]
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeReturnStatement', entity, inputs);
+		if (entity.throws?.readsValue) {
+			// Resolve the next value of the error, then return it
+			const errorValue = resolveNextValue(
+				entity.throws,
+				this.valueResolutionContext as IValueResolutionContext
+			);
+
+			return {
+				value: ExecutionTerminationType.UnhandledError,
+				entity: entity,
+				error: {
+					valueOwner: entity.throws,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: errorValue?.value || null
+				},
+				result: null
+			};
+		}
+
+		let returnedValue = resolveNextValue(
+			entity,
+			this.valueResolutionContext as IValueResolutionContext
+		);
+
+		const dataType = entity.getDataType(null);
+
+		if (dataType?.isObject()) {
+			// The working object to add data to
+			let initialDefaultValue: UntypedObjectValue = {};
+
+			if (dataType?.entity?.type === EntityType.DefinitionEntity) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...dataType.entity.getActiveRawDefaultValue()
+				};
+			}
+
+			if (!!returnedValue?.value) {
+				if (isObject(returnedValue?.value?.value)) {
+					initialDefaultValue = {
+						...initialDefaultValue,
+						...(returnedValue?.value?.value as UntypedObjectValue)
+					};
+				}
+
+				returnedValue?.value.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+			} else {
+				const newLiteralValueEntity =
+					assembleStandaloneLiteralValueFromDataType(
+						dataType,
+						entity,
+						this.project
+					);
+
+				newLiteralValueEntity?.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+
+				returnedValue = {
+					valueOwner: entity,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: newLiteralValueEntity
+				};
+			}
+
+			this.lastExecutionResults.writeValue(
+				entity,
+				returnedValue.value as LiteralValueState
+			);
+
+			entity.outputs.forEach((output) => {
+				if (
+					output.declaration?.type === EntityType.Property &&
+					output.declaration.static
+				) {
+					const existingValue = this.lastExecutionResults.readValue(
+						output.declaration.id
+					);
+
+					const inputName = resolveEntityName(output, this.project);
+					const resolveCodeName =
+						output.codeName ||
+						output.declaration?.codeName ||
+						toCamelCase(inputName);
+
+					if (existingValue) {
+						existingValue.metaSync(
+							{
+								value: initialDefaultValue[resolveCodeName]
+							},
+							null
+						);
+
+						this.lastExecutionResults.writeValue(
+							output.declaration,
+							existingValue
+						);
+					} else {
+						const literalValueInstance =
+							assembleStandaloneLiteralValueFromDataType(
+								output.getDataType(null),
+								output,
+								this.project
+							);
+
+						literalValueInstance?.metaSync(
+							{
+								value: initialDefaultValue[resolveCodeName]
+							},
+							null
+						);
+
+						this.lastExecutionResults.writeValue(
+							output.declaration,
+							literalValueInstance as LiteralValueState
+						);
+					}
+				}
+
+				return;
+			});
+		} else {
+			this.lastExecutionResults.writeValue(
+				entity,
+				returnedValue?.value as LiteralValueState
+			);
+		}
+
+		const activeOutputMapResults: IDynamicValue[] = [];
+
+		const newRawValue: { [key: string]: any } =
+			!!returnedValue?.value?.value &&
+			isObject(returnedValue.value?.value)
+				? returnedValue.value?.value || {}
+				: {};
+
+		entity.outputs.map((outputMap) => {
+			const resolveCodeName =
+				outputMap.codeName ||
+				outputMap.declaration?.codeName ||
+				toCamelCase(resolveEntityName(outputMap, this.project));
+
+			const propertyValue = (newRawValue as UntypedObjectValue)[
+				resolveCodeName
+			];
+
+			const literalValue = assembleStandaloneLiteralValueFromDataType(
+				outputMap.getDataType(null),
+				outputMap,
+				this.project
+			);
+
+			literalValue?.metaSync(
+				{
+					value: propertyValue
+				},
+				null
+			);
+
+			const newOutputDynamicValue: IDynamicValue = {
+				value: literalValue,
+				valueOwner: outputMap,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: !!returnedValue
+					? {
+							sources: [returnedValue],
+							target: entity
+						}
+					: null
+			};
+
+			activeOutputMapResults.push(newOutputDynamicValue);
+		});
+
+		(returnedValue as IDynamicValue).type =
+			DynamicValueTypes.ExecutionResult;
+
+		return {
+			value: ExecutionTerminationType.Return,
+			entity: entity,
+			error: null,
+			result: returnedValue
+		};
+	}
+
+	async executeContinueStatement(
+		entity: ContinueStatementState,
+		inputs: IDynamicValue[]
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeContinueStatement', entity, inputs);
+		if (entity.throws?.readsValue) {
+			// Resolve the next value of the error, then return it
+			const errorValue = resolveNextValue(
+				entity.throws,
+				this.valueResolutionContext as IValueResolutionContext
+			);
+
+			return {
+				value: ExecutionTerminationType.UnhandledError,
+				entity: entity,
+				error: {
+					valueOwner: entity.throws,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: errorValue?.value || null
+				},
+				result: null
+			};
+		}
+
+		let returnedValue = resolveNextValue(
+			entity,
+			this.valueResolutionContext as IValueResolutionContext
+		);
+
+		const dataType = entity.getDataType(null);
+
+		if (dataType?.isObject()) {
+			// The working object to add data to
+			let initialDefaultValue: UntypedObjectValue = {};
+
+			if (dataType?.entity?.type === EntityType.DefinitionEntity) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...dataType.entity.getActiveRawDefaultValue()
+				};
+			}
+
+			if (!!returnedValue?.value) {
+				if (isObject(returnedValue?.value?.value)) {
+					initialDefaultValue = {
+						...initialDefaultValue,
+						...(returnedValue?.value?.value as UntypedObjectValue)
+					};
+				}
+
+				returnedValue?.value.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+			} else {
+				const newLiteralValueEntity =
+					assembleStandaloneLiteralValueFromDataType(
+						dataType,
+						entity,
+						this.project
+					);
+
+				newLiteralValueEntity?.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+
+				returnedValue = {
+					valueOwner: entity,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: newLiteralValueEntity
+				};
+			}
+
+			this.lastExecutionResults.writeValue(
+				entity,
+				returnedValue.value as LiteralValueState
+			);
+
+			entity.outputs.forEach((output) => {
+				if (
+					output.declaration?.type === EntityType.Property &&
+					output.declaration.static
+				) {
+					const existingValue = this.lastExecutionResults.readValue(
+						output.declaration.id
+					);
+
+					const inputName = resolveEntityName(output, this.project);
+					const resolveCodeName =
+						output.codeName ||
+						output.declaration?.codeName ||
+						toCamelCase(inputName);
+
+					if (existingValue) {
+						existingValue.metaSync(
+							{
+								value: initialDefaultValue[resolveCodeName]
+							},
+							null
+						);
+
+						this.lastExecutionResults.writeValue(
+							output.declaration,
+							existingValue
+						);
+					} else {
+						const literalValueInstance =
+							assembleStandaloneLiteralValueFromDataType(
+								output.getDataType(null),
+								output,
+								this.project
+							);
+
+						literalValueInstance?.metaSync(
+							{
+								value: initialDefaultValue[resolveCodeName]
+							},
+							null
+						);
+
+						this.lastExecutionResults.writeValue(
+							output.declaration,
+							literalValueInstance as LiteralValueState
+						);
+					}
+				}
+
+				return;
+			});
+		} else {
+			this.lastExecutionResults.writeValue(
+				entity,
+				returnedValue?.value as LiteralValueState
+			);
+		}
+
+		const activeOutputMapResults: IDynamicValue[] = [];
+
+		const newRawValue: { [key: string]: any } =
+			!!returnedValue?.value?.value &&
+			isObject(returnedValue.value?.value)
+				? returnedValue.value?.value || {}
+				: {};
+
+		entity.outputs.map((outputMap) => {
+			const resolveCodeName =
+				outputMap.codeName ||
+				outputMap.declaration?.codeName ||
+				toCamelCase(resolveEntityName(outputMap, this.project));
+
+			const propertyValue = (newRawValue as UntypedObjectValue)[
+				resolveCodeName
+			];
+
+			const literalValue = assembleStandaloneLiteralValueFromDataType(
+				outputMap.getDataType(null),
+				outputMap,
+				this.project
+			);
+
+			literalValue?.metaSync(
+				{
+					value: propertyValue
+				},
+				null
+			);
+
+			const newOutputDynamicValue: IDynamicValue = {
+				value: literalValue,
+				valueOwner: outputMap,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: !!returnedValue
+					? {
+							sources: [returnedValue],
+							target: entity
+						}
+					: null
+			};
+
+			activeOutputMapResults.push(newOutputDynamicValue);
+		});
+
+		(returnedValue as IDynamicValue).type =
+			DynamicValueTypes.ExecutionResult;
+
+		return {
+			value: ExecutionTerminationType.Continue,
+			entity: entity,
+			error: null,
+			result: returnedValue
+		};
+	}
+
+	async executeBreakStatement(
+		entity: BreakStatementState,
+		inputs: IDynamicValue[]
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeBreakStatement', entity, inputs);
+		if (entity.throws?.readsValue) {
+			// Resolve the next value of the error, then return it
+			const errorValue = resolveNextValue(
+				entity.throws,
+				this.valueResolutionContext as IValueResolutionContext
+			);
+
+			return {
+				value: ExecutionTerminationType.UnhandledError,
+				entity: entity,
+				error: {
+					valueOwner: entity.throws,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: errorValue?.value || null
+				},
+				result: null
+			};
+		}
+
+		let returnedValue = resolveNextValue(
+			entity,
+			this.valueResolutionContext as IValueResolutionContext
+		);
+
+		const dataType = entity.getDataType(null);
+
+		if (dataType?.isObject()) {
+			// The working object to add data to
+			let initialDefaultValue: UntypedObjectValue = {};
+
+			if (dataType?.entity?.type === EntityType.DefinitionEntity) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...dataType.entity.getActiveRawDefaultValue()
+				};
+			}
+
+			if (!!returnedValue?.value) {
+				if (isObject(returnedValue?.value?.value)) {
+					initialDefaultValue = {
+						...initialDefaultValue,
+						...(returnedValue?.value?.value as UntypedObjectValue)
+					};
+				}
+
+				returnedValue?.value.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+			} else {
+				const newLiteralValueEntity =
+					assembleStandaloneLiteralValueFromDataType(
+						dataType,
+						entity,
+						this.project
+					);
+
+				newLiteralValueEntity?.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+
+				returnedValue = {
+					valueOwner: entity,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: newLiteralValueEntity
+				};
+			}
+
+			this.lastExecutionResults.writeValue(
+				entity,
+				returnedValue.value as LiteralValueState
+			);
+
+			entity.outputs.forEach((output) => {
+				if (
+					output.declaration?.type === EntityType.Property &&
+					output.declaration.static
+				) {
+					const existingValue = this.lastExecutionResults.readValue(
+						output.declaration.id
+					);
+
+					const inputName = resolveEntityName(output, this.project);
+					const resolveCodeName =
+						output.codeName ||
+						output.declaration?.codeName ||
+						toCamelCase(inputName);
+
+					if (existingValue) {
+						existingValue.metaSync(
+							{
+								value: initialDefaultValue[resolveCodeName]
+							},
+							null
+						);
+
+						this.lastExecutionResults.writeValue(
+							output.declaration,
+							existingValue
+						);
+					} else {
+						const literalValueInstance =
+							assembleStandaloneLiteralValueFromDataType(
+								output.getDataType(null),
+								output,
+								this.project
+							);
+
+						literalValueInstance?.metaSync(
+							{
+								value: initialDefaultValue[resolveCodeName]
+							},
+							null
+						);
+
+						this.lastExecutionResults.writeValue(
+							output.declaration,
+							literalValueInstance as LiteralValueState
+						);
+					}
+				}
+
+				return;
+			});
+		} else {
+			this.lastExecutionResults.writeValue(
+				entity,
+				returnedValue?.value as LiteralValueState
+			);
+		}
+
+		const activeOutputMapResults: IDynamicValue[] = [];
+
+		const newRawValue: { [key: string]: any } =
+			!!returnedValue?.value?.value &&
+			isObject(returnedValue.value?.value)
+				? returnedValue.value?.value || {}
+				: {};
+
+		entity.outputs.map((outputMap) => {
+			const resolveCodeName =
+				outputMap.codeName ||
+				outputMap.declaration?.codeName ||
+				toCamelCase(resolveEntityName(outputMap, this.project));
+
+			const propertyValue = (newRawValue as UntypedObjectValue)[
+				resolveCodeName
+			];
+
+			const literalValue = assembleStandaloneLiteralValueFromDataType(
+				outputMap.getDataType(null),
+				outputMap,
+				this.project
+			);
+
+			literalValue?.metaSync(
+				{
+					value: propertyValue
+				},
+				null
+			);
+
+			const newOutputDynamicValue: IDynamicValue = {
+				value: literalValue,
+				valueOwner: outputMap,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: !!returnedValue
+					? {
+							sources: [returnedValue],
+							target: entity
+						}
+					: null
+			};
+
+			activeOutputMapResults.push(newOutputDynamicValue);
+		});
+
+		(returnedValue as IDynamicValue).type =
+			DynamicValueTypes.ExecutionResult;
+
+		return {
+			value: ExecutionTerminationType.Break,
+			entity: entity,
+			error: null,
+			result: returnedValue
+		};
+	}
+
+	async executeVariable(
+		entity: VariableState,
+		inputs: IDynamicValue[]
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeVariable', entity, inputs);
+		let varValue = resolveNextValue(
+			entity,
+			this.valueResolutionContext as IValueResolutionContext
+		);
+
+		const varDeclaration = getDeclaration(entity);
+
+		const dataType = varDeclaration.getDataType(null);
+
+		if (dataType?.isObject()) {
+			// The working object to add data to
+			let initialDefaultValue: UntypedObjectValue = {};
+
+			if (dataType?.entity?.type === EntityType.DefinitionEntity) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...dataType.entity.getActiveRawDefaultValue()
+				};
+			} else if (
+				dataType?.entity?.type === EntityType.BuiltInBaseEntity
+			) {
+				initialDefaultValue = {
+					...initialDefaultValue,
+					...dataType.entity.getRawDefaultValue()
+				};
+			}
+
+			if (!!varValue?.value) {
+				if (isObject(varValue?.value?.value)) {
+					initialDefaultValue = {
+						...initialDefaultValue,
+						...(varValue?.value?.value as UntypedObjectValue)
+					};
+				}
+
+				varValue?.value.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+			} else {
+				const newLiteralValueEntity =
+					assembleStandaloneLiteralValueFromDataType(
+						dataType,
+						entity,
+						this.project
+					);
+
+				newLiteralValueEntity?.metaSync(
+					{
+						value: initialDefaultValue
+					},
+					null
+				);
+
+				varValue = {
+					valueOwner: varDeclaration,
+					type: DynamicValueTypes.ExecutionResult,
+					inheritanceLink: null,
+					value: newLiteralValueEntity
+				};
+			}
+
+			entity.inputs.forEach((input) => {
+				const inputNextValue = resolveNextValue(
+					input,
+					this.valueResolutionContext as IValueResolutionContext
+				);
+
+				const inputInVarDeclaration = varDeclaration.inputs.find(
+					(declInput) =>
+						declInput.declaration?.id === input.declaration?.id
+				);
+
+				if (
+					inputInVarDeclaration?.declaration?.type ===
+						EntityType.Property &&
+					inputInVarDeclaration?.declaration?.static
+				) {
+					if (inputNextValue?.value) {
+						this.lastExecutionResults.writeValue(
+							inputInVarDeclaration?.declaration,
+							inputNextValue?.value as LiteralValueState
+						);
+					} else {
+						this.lastExecutionResults.removeValue(
+							inputInVarDeclaration?.declaration.id
+						);
+					}
+				} else {
+					if (!!inputNextValue?.value) {
+						const inputName = resolveEntityName(
+							input,
+							this.project
+						);
+						const resolveCodeName =
+							input.codeName ||
+							input.declaration?.codeName ||
+							toCamelCase(inputName);
+
+						varValue?.value?.metaSync(
+							{
+								value: {
+									...(varValue.value?.value as {
+										[key: string]: any;
+									}),
+									[resolveCodeName]:
+										inputNextValue?.value?.value
+								}
+							},
+							null
+						);
+					}
+				}
+			});
+
+			this.lastExecutionResults.writeValue(
+				varDeclaration,
+				varValue.value as LiteralValueState
+			);
+		} else {
+			this.lastExecutionResults.writeValue(
+				varDeclaration,
+				varValue?.value as LiteralValueState
+			);
+		}
+
+		const activeOutputMapResults: IDynamicValue[] = [];
+
+		const newRawValue: { [key: string]: any } =
+			!!varValue?.value?.value && isObject(varValue.value?.value)
+				? varValue.value?.value || {}
+				: {};
+
+		entity.outputs.map((outputMap) => {
+			const resolveCodeName =
+				outputMap.codeName ||
+				outputMap.declaration?.codeName ||
+				toCamelCase(resolveEntityName(outputMap, this.project));
+
+			const propertyValue = (newRawValue as UntypedObjectValue)[
+				resolveCodeName
+			];
+
+			const literalValue = assembleStandaloneLiteralValueFromDataType(
+				outputMap.getDataType(null),
+				outputMap,
+				this.project
+			);
+
+			literalValue?.metaSync(
+				{
+					value: propertyValue
+				},
+				null
+			);
+
+			const newOutputDynamicValue: IDynamicValue = {
+				value: literalValue,
+				valueOwner: outputMap,
+				type: DynamicValueTypes.ExecutionResult,
+				inheritanceLink: !!varValue
+					? {
+							sources: [varValue],
+							target: entity
+						}
+					: null
+			};
+
+			activeOutputMapResults.push(newOutputDynamicValue);
+		});
+
+		(varValue as IDynamicValue).type = DynamicValueTypes.ExecutionResult;
+
+		return {
+			value: ExecutionTerminationType.Success,
+			entity: entity,
+			error: null,
+			result: varValue
+		};
+	}
+
+	// This function merges the values passed by previous entities's results of the execution
+	// And their own defined default values
+	// Based on the index, the input value is prioritized over the default value
+	mergeValues(
+		inputs: IDynamicValue[],
+		defaultValues: IDynamicValue[]
+	): IDynamicValue[] {
+		const mergedValues: IDynamicValue[] = [];
+
+		// Merge the values of the inputs with the default values
+		// If the input value is not null, it is prioritized over the default value
+		for (let i = 0; i < defaultValues.length; i++) {
+			if (inputs?.[i]) {
+				mergedValues.push(inputs[i]);
+			} else {
+				mergedValues.push(defaultValues[i]);
+			}
+		}
+
+		return mergedValues;
+	}
+
+	async executeEntity(
+		entity: ExecutableEntityState,
+		inputs: IDynamicValue[] = [],
+		client: IExecutionClient = {}
+	): Promise<IExecutionResult> {
+		this.logBeforeExecution('executeEntity', entity, inputs);
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client
+		};
+		const executionContext: IExecutionCallbackContext = {
+			detached: false,
+			execution: this
+		};
+
+		switch (entity.type) {
+			case EntityType.Condition: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeCondition(entity, resolvedInputs);
+			}
+			case EntityType.InternalCall: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeInternalCall(
+					entity,
+					resolvedInputs,
+					this.project
+				);
+			}
+			case EntityType.Operation: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return Execution.executeOperation(
+					entity,
+					resolvedInputs,
+					this.project,
+					this
+				);
+			}
+			case EntityType.VariableInstance:
+			case EntityType.VariableDeclaration: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+
+				return this.executeVariable(entity, resolvedInputs);
+			}
+			case EntityType.FunctionCall: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeFunctionCall(
+					entity as FunctionCallState,
+					resolvedInputs,
+					this.project
+				);
+			}
+			case EntityType.FunctionDeclaration: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+
+				resolvedInputs.forEach((input) => {
+					if (input.value && input.valueOwner) {
+						this.lastExecutionResults.writeValue(
+							input.valueOwner as EntityWithValueState,
+							input.value as LiteralValueState
+						);
+					}
+				});
+
+				return Execution.executeEntryPointEntity(
+					entity,
+					resolvedInputs,
+					this
+				);
+			}
+			case EntityType.Search: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeSearch(entity, resolvedInputs, this.project);
+			}
+			case EntityType.Loop: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeLoop(
+					entity,
+					resolvedInputs,
+					this.project,
+					clientWithDefaults
+				);
+			}
+			case EntityType.ReturnStatement: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeReturnStatement(entity, resolvedInputs);
+			}
+			case EntityType.ContinueStatement: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeContinueStatement(entity, resolvedInputs);
+			}
+			case EntityType.BreakStatement: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+				return this.executeBreakStatement(entity, resolvedInputs);
+			}
+			case EntityType.GlobalEvent: {
+				const resolvedInputs =
+					this.mergeExernalValuesWithInternalInputs(inputs, entity);
+
+				await clientWithDefaults.onBeforeEntityExecution?.(
+					entity,
+					resolvedInputs,
+					executionContext
+				);
+
+				resolvedInputs.forEach((input) => {
+					if (input.value && input.valueOwner) {
+						this.lastExecutionResults.writeValue(
+							input.valueOwner as EntityWithValueState,
+							input.value as LiteralValueState
+						);
+					}
+				});
+
+				return Execution.executeEntryPointEntity(
+					entity,
+					resolvedInputs,
+					this
+				);
+			}
+			default:
+				// If the entity is not recognized, we return an error
+				throw new Error(
+					// @ts-ignore
+					`Entity type ${entity?.type} is not recognized for execution.`
+				);
+		}
+	}
+
+	storeLastExecutionValues(result: IExecutionResult) {
+		if (result.error && !!result.error.valueOwner) {
+			this.lastExecutionResults.writeValue(
+				result.error.valueOwner,
+				result.error.value as LiteralValueState
+			);
+		}
+
+		if (!result.result || !result.result?.valueOwner) {
+			return;
+		}
+
+		const propagatedValueOwners = getEntitiesToPropagateValuesTo(
+			result.result?.valueOwner as EntityWithValueState,
+			this.project
+		);
+
+		if (!!result.result?.value) {
+			propagatedValueOwners.forEach((propagatedValueOwner) => {
+				this.lastExecutionResults.writeValue(
+					propagatedValueOwner,
+					result.result?.value as LiteralValueState
+				);
+			});
+		} else {
+			propagatedValueOwners.forEach((propagatedValueOwner) => {
+				this.lastExecutionResults.removeValue(propagatedValueOwner.id);
+			});
+		}
+	}
+
+	// Takes the given entity as the entry point to its own branch
+	// Then, it recursively executes its own branches
+	async executeBranch(
+		localEntryPoint: TestableEntityState,
+		client: IExecutionClient = {},
+		// A set of external values which take the place of internally resolved ones,
+		// Good for exernally executing a logic chain with specific arguments
+		values: IDynamicValue[] = []
+	): Promise<IExecutionResult | null> {
+		this.logBeforeExecution('executeBranch', localEntryPoint, values);
+		await this.checkStateAndPause();
+
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client
+		};
+		const executionContext: IExecutionCallbackContext = {
+			detached: false,
+			execution: this
+		};
+
+		const isPartOfTest = this.hasEntity(localEntryPoint);
+
+		if (!isPartOfTest) {
+			return null;
+		}
+
+		if (this.hasSkipped(localEntryPoint)) {
+			return null;
+		}
+
+		// Add entity to the list of entities that are currently being executed
+		this.addToExecutingList(localEntryPoint);
+
+		if (this.hasScheduled(localEntryPoint)) {
+			// Remove from scheduled
+			this.removeScheduled(localEntryPoint);
+		}
+
+		// Execute self first, then based on success or error cases
+		const result = await this.executeEntity(
+			localEntryPoint,
+			values,
+			clientWithDefaults
+		);
+
+		console.log(
+			`executeBranch (${localEntryPoint.type}) -> [${resolveEntityName(localEntryPoint, this.project)}] result:\n   ${result.error ? `Error: ${JSON.stringify(result.error.value?.value, null, 2)}` : `Value: ${JSON.stringify(result.result?.value?.value, null, 2)}`}`
+		);
+
+		// Remove entity from the list of entities that are currently being executed
+		this.removeFromExecutingList(localEntryPoint);
+		this.addToAlreadyExecutedList(localEntryPoint);
+
+		// Execute the results in the projects' execution values store
+		this.storeLastExecutionValues(result);
+
+		await clientWithDefaults.onEntityExecuted?.(
+			localEntryPoint,
+			result,
+			executionContext
+		);
+
+		// Recursively order based on dependency, and execute the respective branch (success, or error calls)
+		if (result.value === ExecutionTerminationType.Success) {
+			// Filter out entities called by the success branch that aren't part of the test
+			const successCallsInTest: CallableEntityState[] = (
+				(localEntryPoint as FunctionCallState).successCalls ||
+				(localEntryPoint as FunctionDeclarationState).calls ||
+				[]
+			).filter((call) => this.hasEntity(call));
+
+			const otherCallsInTest: CallableEntityState[] =
+				(localEntryPoint as FunctionCallState).errorCalls || [];
+
+			otherCallsInTest.forEach((call) => {
+				this.skip(call);
+			});
+
+			let agregateResults: IExecutionResult[] = [];
+
+			const groupResults: IExecutionResult[] = (
+				await Promise.all(
+					successCallsInTest.map((call) =>
+						this.schedule(call, [], clientWithDefaults)
+					)
+				)
+			).filter((result) => !!result) as IExecutionResult[];
+
+			const terminationResult = groupResults
+				// Filter out results that didn't go through the with their own execution
+				.filter((result) => !!result)
+				.find(
+					(result) =>
+						result.value === ExecutionTerminationType.CaughtError ||
+						result.value === ExecutionTerminationType.Return ||
+						result.value === ExecutionTerminationType.Break ||
+						result.value === ExecutionTerminationType.Continue
+				);
+
+			if (terminationResult) {
+				return terminationResult;
+			}
+
+			agregateResults = [...agregateResults, ...groupResults];
+
+			// If there are no success calls, return the result
+			return result;
+		} else if (
+			result.value === ExecutionTerminationType.CaughtError ||
+			result.value === ExecutionTerminationType.ConditionNotMet
+		) {
+			// Filter out entities called by the error branch that aren't part of the test
+			const errorCallsInTest: CallableEntityState[] = (
+				(localEntryPoint as FunctionCallState).errorCalls || []
+			).filter((call) => this.hasEntity(call));
+
+			const otherCallsInTest: CallableEntityState[] =
+				(localEntryPoint as FunctionCallState).successCalls ||
+				(localEntryPoint as FunctionDeclarationState).calls ||
+				[];
+
+			otherCallsInTest.forEach((call) => {
+				this.skip(call);
+			});
+
+			let agregateResults: IExecutionResult[] = [];
+
+			const groupResults: IExecutionResult[] = (
+				await Promise.all(
+					errorCallsInTest.map((call) =>
+						this.schedule(call, [], clientWithDefaults)
+					)
+				)
+			).filter((result) => !!result) as IExecutionResult[];
+
+			const terminationResult = groupResults
+				// Filter out results that didn't go through the with their own execution
+				.filter((result) => !!result)
+				.find(
+					(result) =>
+						result.value === ExecutionTerminationType.CaughtError ||
+						result.value ===
+							ExecutionTerminationType.UnhandledError ||
+						result.value === ExecutionTerminationType.Return ||
+						result.value === ExecutionTerminationType.Break ||
+						result.value === ExecutionTerminationType.Continue
+				);
+
+			if (terminationResult) {
+				return terminationResult;
+			}
+
+			agregateResults = [...agregateResults, ...groupResults];
+
+			// If there are no error calls, return the result
+			return result;
+		} else if (result.value === ExecutionTerminationType.UnhandledError) {
+			// Abort the execution of the test
+			this.executing.forEach((entity) => {
+				// this.removeFromExecutingList(entity);
+				this.skip(entity);
+			});
+
+			// Unschedule all entities that were scheduled
+			// And skip them
+			this.scheduled.forEach((entity) => {
+				this.skip(entity);
+			});
+
+			if (CALLER_TYPES.includes(result.entity.type)) {
+				flattenElementCalls(result.entity as CallerEntityState).forEach(
+					(call) => {
+						this.skip(call);
+					}
+				);
+			}
+
+			return result;
+		} else if (result.value === ExecutionTerminationType.Return) {
+			return result;
+		} else if (result.value === ExecutionTerminationType.Break) {
+			return result;
+		} else if (result.value === ExecutionTerminationType.Continue) {
+			return result;
+		}
+
+		return result;
+	}
+
+	/*
+		Execute the chain of entities, starting with the entry point
+		And sorting any branching by dependency order so all values are fulfilled before their entity is executed
+		Explore each branch by checking if it is part of the test, then execute it
+		Revert to next sibling branch if it isn't.
+
+		If two branches aren't dependent, we can execute them in parallel
+	*/
+	async execute(
+		client: IExecutionClient = {},
+		// A set of external values which take the place of internally resolved ones,
+		// Good for exernally executing a logic chain with specific arguments
+		values: IDynamicValue[] = []
+	): Promise<IExecutionResult> {
+		console.log(
+			`%cexecute -> [Execution] initialExternalValues:\n   ${values
+				.map(
+					(d) =>
+						`${d.valueOwner?.type} (${d.valueOwner?.id}) "${resolveEntityName(
+							d.valueOwner as any,
+							this.project
+						)}": ${JSON.stringify(d.value?.value, null, 2)}`
+				)
+				.join('\n   ')}\n`,
+			'color: #3b82f6; font-weight: bold;'
+		);
+		const clientWithDefaults: IExecutionClient = {
+			...EXECUTION_CLIENT_DEFAULTS,
+			...client
+		};
+
+		this.state = ExecutionState.Running;
+
+		const originalActiveExecution = (this.project as any).activeExecution;
+		(this.project as any).activeExecution = this;
+
+		try {
+			const finalResult = await this.executeBranch(
+				this.entryPoint,
+				clientWithDefaults,
+				values
+			);
+
+			this.state = ExecutionState.FinishedSuccess;
+
+			return finalResult as IExecutionResult;
+		} finally {
+			(this.project as any).activeExecution = originalActiveExecution;
+		}
+	}
+
+	getExecutionLevels(): string {
+		const levels: string[] = [];
+		let current: Execution | null = this;
+		while (current) {
+			const ep = current.entryPoint;
+			const name = ep ? resolveEntityName(ep, this.project) : 'Unknown';
+			const type = ep ? ep.type : 'unknown';
+			levels.unshift(`${type} "${name}"`);
+			current = current.parentExecution;
+		}
+		return levels.join(' -> ');
+	}
+
+	logBeforeExecution(
+		methodName: string,
+		entity: EntityState,
+		inputs: IDynamicValue[]
+	) {
+		const levels = this.getExecutionLevels();
+		const scopeOwner = getScopeOwner(entity, this.project);
+		const scopeOwnerName = scopeOwner
+			? resolveEntityName(scopeOwner as any, this.project)
+			: 'Project';
+		const scopeOwnerType = scopeOwner
+			? (scopeOwner as any).type
+			: 'Project';
+		const entityName = resolveEntityName(entity, this.project);
+
+		console.log(
+			`%c[Execution: ${levels}] %c[Scope: ${scopeOwnerType} "${scopeOwnerName}"]`,
+			'color: #3b82f6; font-weight: bold;',
+			'color: #10b981; font-weight: bold;'
+		);
+
+		console.log(
+			`%c${methodName} (${entity.type}) -> [${entityName}]%c Inputs:`,
+			'font-weight: bold; color: #224370ff;',
+			'color: #9ca3af;'
+		);
+
+		if (inputs.length) {
+			inputs.forEach((d) => {
+				const ownerName = resolveEntityName(
+					d.valueOwner as any,
+					this.project
+				);
+				console.log(
+					`   %c${d.valueOwner?.type}%c (${d.valueOwner?.id}) %c"${ownerName}"%c:`,
+					'color: #8b5cf6; font-weight: bold;',
+					'color: #9ca3af;',
+					'color: #10b981; font-weight: bold;',
+					'color: #667a9bff;',
+					d.value?.value
+				);
+			});
+		} else {
+			console.log('   (none)');
+		}
+
+		if (
+			entity.type === EntityType.VariableInstance ||
+			entity.type === EntityType.VariableDeclaration
+		) {
+			const varDeclaration = getDeclaration(entity as VariableState);
+			const varValue = resolveValue(
+				varDeclaration,
+				this.valueResolutionContext as any
+			);
+			console.log(
+				`   %cExisting Value%c of [${resolveEntityName(varDeclaration, this.project)}]:`,
+				'color: #ec4899; font-weight: bold;',
+				'color: #667a9bff;',
+				varValue?.value?.value
+			);
+		}
+
+		if (entity.type === EntityType.InternalCall) {
+			const parentVar = (entity as InternalCallState).parent;
+			if (parentVar) {
+				const parentVarValue = resolveValue(
+					parentVar,
+					this.valueResolutionContext as any
+				);
+				console.log(
+					`   %cParent Variable%c [${resolveEntityName(parentVar, this.project)}] Value:`,
+					'color: #f59e0b; font-weight: bold;',
+					'color: #667a9bff;',
+					parentVarValue?.value?.value
+				);
+			}
+		}
+	}
+
+	addEntity(entity: TestableEntityState) {
+		if (!this.entities.includes(entity)) {
+			this.entities.push(entity);
+			this.onAddEntityCallback?.(entity, {});
+		}
+	}
+
+	async addEntityAsync(
+		entity: TestableEntityState,
+		options: YieldOptions & {
+			skipValidate?: boolean;
+			skipRender?: boolean;
+			skipNotify?: boolean;
+		} = {}
+	) {
+		if (!this.entities.includes(entity)) {
+			this.entities.push(entity);
+			await this.onAddEntityCallback?.(entity, options);
+		}
+	}
+
+	addEntities(entities: TestableEntityState[]) {
+		entities.forEach((entity) => this.addEntity(entity));
+	}
+
+	async addEntitiesAsync(
+		entities: TestableEntityState[],
+		options: YieldOptions & {
+			skipValidate?: boolean;
+			skipRender?: boolean;
+			skipNotify?: boolean;
+		} = {}
+	) {
+		const tracker = YieldTracker.from(options);
+
+		const promises: Promise<void>[] = [];
+
+		for (const entity of entities) {
+			promises.push(this.addEntityAsync(entity, options));
+
+			await tracker.tick();
+		}
+
+		await Promise.all(promises);
+	}
+
+	// Remove entity if it isn't the entry point
+	removeEntity(entity: TestableEntityState) {
+		if (entity !== this.entryPoint) {
+			const index = this.entities.indexOf(entity);
+			if (index > -1) {
+				this.entities.splice(index, 1);
+				this.onRemoveEntityCallback?.(entity, {});
+			}
+		}
+	}
+
+	hasEntity(entity: EntityState): boolean {
+		if (this.entities.includes(entity as TestableEntityState)) {
+			return true;
+		}
+
+		if (
+			(entity as any).parent &&
+			(entity as any).parent?.id !== entity?.id
+		) {
+			return this.hasEntity((entity as any).parent as any);
+		}
+
+		return false;
+	}
+
+	removeScheduled(entity: TestableEntityState) {
+		const index = this.scheduled.indexOf(entity);
+		if (index > -1) {
+			this.scheduled.splice(index, 1);
+		}
+	}
+
+	hasScheduled(entity: TestableEntityState): boolean {
+		if (this.scheduled.includes(entity)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	hasSkipped(entity: TestableEntityState): boolean {
+		if (this.skipped.includes(entity)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	hasExecuted(entity: TestableEntityState): boolean {
+		if (this.executed.includes(entity)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	hasEntityWithId(id: string): boolean {
+		const entity = this.project.get(id);
+
+		return !!entity ? this.hasEntity(entity) : false;
+	}
+
+	onAddToSkippedList(
+		callback: (
+			entity: TestableEntityState,
+			options?: YieldOptions & {
+				skipValidate?: boolean;
+				skipRender?: boolean;
+				skipNotify?: boolean;
+			}
+		) => Promise<void> | void
+	) {
+		this.onAddToSkippedListCallback = callback;
+	}
+
+	onAbortExecution(
+		callback: (
+			entity: TestableEntityState,
+			options?: YieldOptions & {
+				skipValidate?: boolean;
+				skipRender?: boolean;
+				skipNotify?: boolean;
+			}
+		) => Promise<void> | void
+	) {
+		this.onAbortExecutionCallback = callback;
+	}
+
+	onAddEntity(
+		callback: (
+			entity: TestableEntityState,
+			options?: YieldOptions & {
+				skipValidate?: boolean;
+				skipRender?: boolean;
+				skipNotify?: boolean;
+			}
+		) => Promise<void> | void
+	) {
+		this.onAddEntityCallback = callback;
+	}
+
+	onRemoveFromSkippedList(
+		callback: (
+			entity: TestableEntityState,
+			options?: YieldOptions & {
+				skipValidate?: boolean;
+				skipRender?: boolean;
+				skipNotify?: boolean;
+			}
+		) => Promise<void> | void
+	) {
+		this.onRemoveFromSkippedListCallback = callback;
+	}
+
+	onRemoveEntity(
+		callback: (
+			entity: TestableEntityState,
+			options?: YieldOptions & {
+				skipValidate?: boolean;
+				skipRender?: boolean;
+				skipNotify?: boolean;
+			}
+		) => Promise<void> | void
+	) {
+		this.onRemoveEntityCallback = callback;
+	}
+
+	addToExecutingList(entity: TestableEntityState) {
+		if (!this.executing.includes(entity)) {
+			this.executing.push(entity);
+		}
+	}
+
+	addToScheduledList(entity: TestableEntityState) {
+		if (!this.scheduled.includes(entity)) {
+			this.scheduled.push(entity);
+		}
+	}
+
+	removeFromScheduledList(entity: TestableEntityState) {
+		const index = this.scheduled.indexOf(entity);
+		if (index > -1) {
+			this.scheduled.splice(index, 1);
+		}
+	}
+
+	removeFromExecutingList(entity: TestableEntityState) {
+		const index = this.executing.indexOf(entity);
+		if (index > -1) {
+			this.executing.splice(index, 1);
+			this.onAbortExecutionCallback?.(entity, {});
+		}
+	}
+
+	removeFromAlreadyExecutedList(entity: TestableEntityState) {
+		const index = this.executed.indexOf(entity);
+		if (index > -1) {
+			this.executed.splice(index, 1);
+		}
+	}
+
+	removeFromSkippedList(entity: TestableEntityState) {
+		const index = this.skipped.indexOf(entity);
+		if (index > -1) {
+			this.skipped.splice(index, 1);
+			this.onRemoveFromSkippedListCallback?.(entity, {});
+		}
+	}
+
+	addToAlreadyExecutedList(entity: TestableEntityState) {
+		if (!this.executed.includes(entity)) {
+			this.executed.push(entity);
+		}
+	}
+
+	addToSkippedList(entity: TestableEntityState) {
+		if (!this.skipped.includes(entity)) {
+			this.skipped.push(entity);
+			this.onAddToSkippedListCallback?.(entity, {});
+		}
+	}
+
+	getValueTypePreference(
+		valueOwnerId: EntityId
+	): DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null {
+		// Check local storage for preference
+		const storedPreference =
+			this.parentContext.getValueTypePreference(valueOwnerId);
+
+		return (
+			(storedPreference as
+				| DynamicValueTypes.DefaultValue
+				| DynamicValueTypes.Testing) || null
+		);
+	}
+
+	setValueTypePreference(
+		valueOwnerId: EntityId,
+		valueTypePreference:
+			| DynamicValueTypes.DefaultValue
+			| DynamicValueTypes.Testing
+			| null
+	) {
+		// Store preference in local storage
+		this.parentContext.setValueTypePreference(
+			valueOwnerId,
+			valueTypePreference
+		);
+
+		// Emit event
+		this.emit(valueOwnerId, {});
+	}
+}