@elyx-code/project-logic-tree 0.0.6339 → 0.0.6340

package/dist/index.d.ts

@@ -171,6 +171,18 @@ export declare class ActionOutputMapState extends OutputMapState implements IAct
     toJSON(seenEntities?: Set<EntityId>): IActionOutputMap | IOutputMapReference;
 }
 
+export declare function afterLiteralValueAsTypeChangeSideEffects(newValue: ValueAsTypeState | ValueAsTypeState[] | null, entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function afterLiteralValueAsTypeDeleteSideEffects(entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function afterLiteralValueChangeSideEffects(newValue: LiteralValueType, entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function afterLiteralValueDeleteSideEffects(entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function aggregateVariableInputsNextValues(objectData: UntypedObjectValue, entity: VariableDeclarationState, context: IValueResolutionContext): UntypedObjectValue;
+
+export declare function aggregateVariableInputsValues(objectData: UntypedObjectValue, entity: VariableDeclarationState, context: IValueResolutionContext): UntypedObjectValue;
+
 declare class AggregationStatement implements ISearchNode {
     owner: SearchStatementState;
     dataSource: DataSource | null;
@@ -413,6 +425,10 @@ export { argumentDeclarationValidation }
 
 export declare function asGenerationActionExample(payload: Record<string, any> | string): string;
 
+export declare function assembleAndAddLiteralValueFromDataType(dataType: DataTypeState | null, valueOwner: EntityWithValueState | ValueDescriptorState | PropertyState, project: ProjectState, changeSet: ChangeSet | null): LiteralValueState;
+
+export declare function assembleStandaloneLiteralValueFromDataType(dataType: DataTypeState | null, valueOwner: EntityWithValueState | ValueDescriptorState | PropertyState, project: ProjectState): LiteralValueState | null;
+
 export declare type BaseActionImplementation = (...args: any[]) => any[] | Promise<any[]>;
 
 export declare abstract class BaseCanvasDraggableState {
@@ -1331,14 +1347,20 @@ export declare function checkIsDetachedBranch(entity: CanvasEntityState): boolea
 
 export declare function checkIsDetachedBranchShallow(entity: CanvasEntityState): boolean;
 
+export declare function checkIsEmptyValue(value: LiteralValueType): boolean;
+
 export declare function checkIsGloballyDeclared(entity: ConditionState | FunctionCallState | OperationState | VariableDeclarationState | VariableInstanceState | FunctionCallState | LoopState | SearchState): boolean;
 
 export declare function checkIsGlobalVariable(entity: VariableDeclarationState): boolean;
 
+export declare function checkIsLiteralValueEmpty(value: LiteralValueState): boolean;
+
 export declare function checkIsMethod(entity: EntityState): boolean;
 
 export declare function checkIsNestedScope(parent: EntityWithLogicScopeState | ProjectState, child: EntityWithLogicScopeState | ProjectState, project: ProjectState): boolean;
 
+export declare function checkIsRequiredValue(entity: EntityWithValueState | PropertyState | ValueDescriptorState): boolean;
+
 export declare function checkScopeCompatibility(entityA: EntityState | Element_2 | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, entityB: EntityState | Element_2 | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): ScopeCompatibility;
 
 export declare type ChildElement = IInstalledProject | IDefinitionEntity | IGlobalEvent | IFunctionDeclaration | IFunctionCall | IProperty | IVariableDeclaration | IVariableInstance | IOperation | ICondition | IArgumentDeclaration | IInputMap | IReturnDeclaration | IOutputMap | IDataType | IReturnStatement | IBreakStatement | IContinueStatement | ILoop | IActionDescriptor | ISearch | ILiteralValue | IValueDescriptor | IInternalCall;
@@ -2436,8 +2458,40 @@ export declare type DraggablePlayableEntityTransfer = DraggablePassThroughCallab
 
 export declare type DraggablePlayableEntityTypesUnion = DraggablePlayableEntity | DraggablePlayableEntityTransfer | DraggablePlayableEntityShallowTransfer | DraggablePlayableEntityGenerationTarget;
 
+export declare enum DynamicValueTypes {
+    Inherited = "inherited",
+    DefaultValue = "default-value",
+    Missing = "missing",
+    Empty = "empty",
+    AutoCalculated = "auto-calculated",
+    QueuedAutocalculation = "queued-autocalculation",
+    External = "external",
+    Testing = "testing",
+    ExecutionResult = "execution-result"
+}
+
 export declare const EDITABLE_PERSISTANCE_REPOSITORY_DEFAULTS: IEditableEntityPersistanceRepository;
 
+export declare class EfimeralValueStore implements IValueStoreClient {
+    initialized: boolean;
+    id: string;
+    project: ProjectState;
+    values: IValueStoreRecord;
+    onWriteCallback: (owner: EntityWithValueState, value: ILiteralValue) => void;
+    onRemoveCallback: (owner: EntityWithValueState) => void;
+    constructor(id: string, project: ProjectState);
+    onWrite(callback: (owner: EntityWithValueState, value: ILiteralValue) => void): void;
+    onRemove(callback: (owner: EntityWithValueState) => void): void;
+    init(): void;
+    toJSON(): {
+        [key: string]: ILiteralValueTransfer;
+    };
+    writeValue(owner: EntityWithValueState, value: LiteralValueState): void;
+    readValue(ownerId: string): LiteralValueState | null;
+    removeValue(ownerId: string): void;
+    clear(): void;
+}
+
 declare type Element_2 = IProject | IInstalledProject | IDefinitionEntity | IGlobalEvent | IFunctionDeclaration | IFunctionCall | IPrimitiveEntity | IProperty | IVariableDeclaration | IVariableInstance | IOperation | ICondition | IArgumentDeclaration | IInputMap | IReturnDeclaration | IOutputMap | IDataType | IReturnStatement | IBreakStatement | IContinueStatement | ILoop | IActionDescriptor | ISearch | ILiteralValue | IBuiltInBaseEntity | IValueDescriptor | IInternalCall;
 export { Element_2 as Element }
 
@@ -2922,6 +2976,78 @@ export declare type ExecutableEntityTransfer = CallableEntityTransfer | EntryPoi
 
 export declare type ExecutableEntityTypesUnion = ExecutableEntity | ExecutableEntityTransfer | ExecutableEntityShallowTransfer | ExecutableEntityGenerationTarget;
 
+export declare class Execution extends Events {
+    project: ProjectState;
+    entryPoint: DraggablePlayableEntityState;
+    state: ExecutionState;
+    events: Events;
+    entities: TestableEntityState[];
+    parentExecution: Execution | null;
+    executing: TestableEntityState[];
+    executed: TestableEntityState[];
+    skipped: TestableEntityState[];
+    localTestValues: EfimeralValueStore;
+    resolvedValues: EfimeralValueStore;
+    persistedExecutionResults: EfimeralValueStore;
+    lastExecutionResults: EfimeralValueStore;
+    onAddToSkippedListCallback: null | ((entity: TestableEntityState) => void);
+    onRemoveFromSkippedListCallback: null | ((entity: TestableEntityState) => void);
+    onAddEntityCallback: null | ((entity: TestableEntityState) => void);
+    onRemoveEntityCallback: null | ((entity: TestableEntityState) => void);
+    static searchImplementation: (entity: SearchState, inputs: IDynamicValue[]) => Promise<{
+        data: {
+            [columnName: string]: any;
+        } | null | {
+            [columnName: string]: any;
+        }[];
+        error: string | null;
+    }>;
+    constructor(project: ProjectState, entities: TestableEntityState[], entryPoint: DraggablePlayableEntityState, parentExecution?: Execution | null);
+    get valueResolutionContext(): IValueResolutionContext;
+    static injectSearchImplementation(implementation: (entity: SearchState, inputs: IDynamicValue[]) => Promise<{
+        data: {
+            [columnName: string]: any;
+        } | null | {
+            [columnName: string]: any;
+        }[];
+        error: string | null;
+    }>): void;
+    mergeExernalValuesWithInternalInputs(externalValues: IDynamicValue[], entity: EntityState): IDynamicValue[];
+    inheritValuesFromContext(context: IValueResolutionContext): void;
+    static executeOperation(operation: OperationState, inputs: IDynamicValue[], project: ProjectState): Promise<IExecutionResult>;
+    executeSearch(entity: SearchState, inputs: IDynamicValue[], project: ProjectState): Promise<IExecutionResult>;
+    executeLoop(loop: LoopState, inputs: IDynamicValue[], project: ProjectState, client?: IExecutionClient): Promise<IExecutionResult>;
+    executeFunctionCall(functionCall: FunctionCallState, inputs: IDynamicValue[], project: ProjectState, client?: IExecutionClient): Promise<IExecutionResult>;
+    static executeCondition(condition: ConditionState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    executeDetachedFullFunctionDeclarationLogic(functionDeclaration: FunctionDeclarationState, inputs: IDynamicValue[], project: ProjectState, client?: IExecutionClient): Promise<IExecutionResult>;
+    executeFullFunctionDeclarationLogic(functionDeclaration: FunctionDeclarationState, inputs: IDynamicValue[], client?: IExecutionClient): Promise<IExecutionResult>;
+    static executeEntryPointEntity(entryPointEntity: EntryPointEntityState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    static executeVariable(varDeclaration: VariableState, input: IDynamicValue): Promise<IExecutionResult>;
+    static executeReturnStatement(returnStatement: ReturnStatementState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    static executeContinueStatement(continueStatement: ContinueStatementState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    static executeBreakStatement(breakStatement: BreakStatementState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    mergeValues(inputs: IDynamicValue[], defaultValues: IDynamicValue[]): IDynamicValue[];
+    executeEntity(entity: DraggableExecutableEntityState | DraggableCallerEntityState | VariableDeclarationState, inputs?: IDynamicValue[], client?: IExecutionClient): Promise<IExecutionResult>;
+    storeLastExecutionValues(result: IExecutionResult): void;
+    executeBranch(localEntryPoint: DraggableExecutableEntityState | DraggableCallerEntityState | VariableDeclarationState, client?: IExecutionClient, values?: IDynamicValue[]): Promise<IExecutionResult | null>;
+    execute(client?: IExecutionClient, values?: IDynamicValue[]): Promise<IExecutionResult>;
+    addEntity(entity: TestableEntityState): void;
+    addEntities(entities: TestableEntityState[]): void;
+    removeEntity(entity: TestableEntityState): void;
+    hasEntity(entity: EntityState): boolean;
+    hasEntityWithId(id: string): boolean;
+    onAddToSkippedList(callback: (entity: TestableEntityState) => void): void;
+    onAddEntity(callback: (entity: TestableEntityState) => void): void;
+    onRemoveFromSkippedList(callback: (entity: TestableEntityState) => void): void;
+    onRemoveEntity(callback: (entity: TestableEntityState) => void): void;
+    addToExecutingList(entity: TestableEntityState): void;
+    removeFromExecutingList(entity: TestableEntityState): void;
+    removeFromAlreadyExecutedList(entity: TestableEntityState): void;
+    removeFromSkippedList(entity: TestableEntityState): void;
+    addToAlreadyExecutedList(entity: TestableEntityState): void;
+    addToSkippedList(entity: TestableEntityState): void;
+}
+
 export declare const EXECUTION_OPERATIONS: {
     [key: string]: IActionDescriptorTransfer;
 };
@@ -2938,6 +3064,15 @@ export declare enum ExecutionOperations {
     Wait = "wait"
 }
 
+export declare enum ExecutionState {
+    FinishedSuccess = "finished-success",
+    FinishedError = "finished-error",
+    Running = "running",
+    Paused = "paused",
+    Stopped = "stopped",
+    NotStarted = "not-started"
+}
+
 export declare enum ExecutionTerminationType {
     Success = "success",
     Error = "error",
@@ -3495,6 +3630,8 @@ export declare function generateRandomTextBefore(options: IAutogenerationRandomT
 
 export declare function generateRandomTextBetweenRange(options: IAutogenerationRandomTextBetween): string;
 
+export declare function generateStandaloneIfDefault(dynamicValue: IDynamicValue): IDynamicValue;
+
 export declare function generateUniqueUUID(): string;
 
 export declare const GET_PROJECT_OPTIONS_DEFAULTS: IGetProjectOptions;
@@ -5324,6 +5461,8 @@ export declare function getDraggablePlayableEntityTypeSchema(): z_2.ZodUnion<[z_
 
 export declare function getEntitiesCreatedSinceInitialization(projectState: ProjectState, preInitDate: string): UserManagedEntityState[];
 
+export declare function getEntitiesToPropagateValuesTo(entity: EntityWithValueState, project: ProjectState, seenInRecursion?: Set<EntityId>): EntityWithValueState[];
+
 export declare function getEntityArgumentDeclarations(entity: ExecutableEntityState): (ArgumentDeclarationState | ValueDescriptorState)[];
 
 export declare function getEntityInputMaps(entity: DraggablePassThroughCallableEntityState): InputMapState[];
@@ -6531,6 +6670,8 @@ declare function getLimitClauseFromSelectStatement(selectStatement: SelectStmt):
 
 export declare function getLinkedEntitiesFromArgumentDeclaration(argumentDeclaration: ArgumentDeclarationState): ValueReadingEntityState[];
 
+export declare function getLiteralValueNameFromDataType(dataType: DataTypeState | null): PrimitiveTypes;
+
 export declare function getLowestPersistedEntityImplementation(entity: DefinitionEntityState): DefinitionEntityState | null;
 
 declare function getMainSourceFromSelectStatement(selectStatement: SelectStmt): {
@@ -7560,6 +7701,14 @@ export declare function handleBeforeEntityImplementationSideEffects(self: Defini
     newEntities: EntityState[];
 };
 
+export declare function handleLiteralValueChange(newValue: LiteralValueType, entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function handleLiteralValueDelete(entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function handleValueAsTypeChange(newValue: ValueAsTypeState | ValueAsTypeState[] | null, entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function handleValueAsTypeDelete(entity: EntityWithValueState, project: ProjectState, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
 export declare const HTTP_OPERATIONS: {
     [key: string]: IActionDescriptorTransfer;
 };
@@ -7657,6 +7806,8 @@ export declare enum HTTPStatucCodeValidationErrorCodes {
 
 export declare function httpStatusCodeValueValidation(self: ActionDescriptorState, value: LiteralValueType): IValueValidationResult<LiteralValueType, HTTPStatucCodeValidationErrorCodes>;
 
+export declare function hydrateOrDiscardLiteralValue(value: LiteralValueState, _valueOwner: EntityWithValueState, _project: ProjectState): LiteralValueState | null;
+
 declare function hydrateSearchStatementState(ast: Program | SelectStmt, project: ProjectState, entity?: SearchState | null, debug?: boolean): {
     state: SearchStatementState | null;
     errors: {
@@ -7754,6 +7905,18 @@ export declare interface IActionOutputMapTransfer extends IOutputMapTransfer {
     parent: PassThroughCallableEntity | PassThroughCallableEntityReference;
 }
 
+export declare interface IActiveBranchHeadResult {
+    id: string;
+    headVersion: string;
+    userAuthor: string;
+    timestamp: string;
+    fromVersionId: string;
+    name: string;
+    identifier: string;
+    createdAt: string;
+    project: string;
+}
+
 export declare interface IArgumentDeclaration extends IArgumentDeclaration_meta, IBaseVariable, IChildEntity, IValueWritingEntity {
     type: EntityType.ArgumentDeclaration;
     constant: true;
@@ -8068,6 +8231,34 @@ export declare interface IBoolean extends IPrimitiveEntity {
     name: PrimitiveTypes.Boolean;
 }
 
+export declare interface IBranch {
+    id: string;
+    userAuthor: string;
+    project: string;
+    fromVersionId: string;
+    name: string;
+    identifier: string;
+    createdAt: string;
+}
+
+export declare interface IBranchHead {
+    id: string;
+    branch: string;
+    userAuthor: string;
+    versionId: string;
+    timestamp: string;
+}
+
+export declare interface IBranchMerge {
+    id: string;
+    branch: string;
+    userAuthor: string;
+    mergedIntoBranch: string | null;
+    mergedAsNewVersion: string | null;
+    mergedIntoVersion: string | null;
+    timestamp: string;
+}
+
 export declare interface IBreakStatement extends ITerminationStatement, IBreakStatement_meta {
     type: EntityType.BreakStatement;
     parent: ILoop;
@@ -8180,6 +8371,14 @@ export declare interface IChangeSet<TSelf extends {
     self: TSelf;
 }
 
+export declare interface IChannelConnections {
+    channel: string;
+    connections: {
+        connectionId: string;
+        userId: string;
+    }[];
+}
+
 export declare interface IChildEntity extends IChildEntityTransfer {
     parent: Element_2;
 }
@@ -8433,6 +8632,13 @@ export declare interface IDefinitionEntityTransfer extends IBaseCanvasDraggable,
     methods: (IFunctionDeclaration | IFunctionDeclarationTransfer)[];
 }
 
+export declare interface IDynamicValue {
+    value: LiteralValueState | null;
+    valueOwner: EntityWithValueState;
+    type: DynamicValueTypes;
+    inheritanceLink: IValueInheritanceLink | null;
+}
+
 export declare interface IEditableEntityPersistanceRepository extends IReadOnlyEntityPersistanceRepository {
     APICreate<T extends Array<any> = any[]>(entity: ElementShallowTransfer, ...otherArgs: T): Promise<ElementShallowTransfer>;
     APIUpdate<T extends Array<any> = any[]>(entity: ElementShallowTransfer, ...otherArgs: T): Promise<ElementShallowTransfer>;
@@ -8441,6 +8647,62 @@ export declare interface IEditableEntityPersistanceRepository extends IReadOnlyE
     APILoadVersion<T extends Array<any> = any[]>(entityId: EntityId, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: T): Promise<ElementShallowTransfer | null>;
 }
 
+export declare interface IEditor extends IUndoableInterface, IValueResolutionContext {
+    ready: boolean;
+    hasLoadedLogic: boolean;
+    destroyed: boolean;
+    logicLoadingPromise: Promise<void> | null;
+    logic: ProjectState | null;
+    branch: IActiveBranchHeadResult | null;
+    projectId: EntityId;
+    sessionId: string | null;
+    peerConnections: Record<string, IChannelConnections>;
+    test: ITest | null;
+    localTestValues: IValueStoreClient;
+    resolvedValues: IValueStoreClient;
+    persistedExecutionResults: IValueStoreClient;
+    socket: IWebsocketsClient;
+    events: Events;
+    onProjectHeadLoadedCallback: null | ((projectState: ProjectState) => void);
+    onLogicLoadingCompleteCallback: null | ((chunk: any) => void);
+    onRenderedCallback: null | (() => void);
+    onProjectSetupErrorCallback: null | ((error: any) => void);
+    constructor(projectId: EntityId, socket?: IWebsocketsClient | null, events?: Events): IEditor;
+    get execution(): Execution | null;
+    get project(): ProjectState;
+    get lastExecutionResults(): EfimeralValueStore;
+    get undoableStackValueIndex(): number;
+    set undoableStackValueIndex(value: number);
+    get PROJECT_NOTIFICATIONS_CHANNEL(): string;
+    onProjectHeadLoaded(callback: (projectState: ProjectState) => void): void;
+    onLogicLoadingComplete(callback: (chunk: any) => void): void;
+    onRendered(callback: () => void): void;
+    onProjectSetupError(callback: (error: any) => void): void;
+    removeValueByOwnerId(entityId: EntityId): void;
+    removeValue(dynamicValue: IDynamicValue): void;
+    handleNotificationChannelsMessage(message: IOutgoingWSMessage<string, {
+        data: {
+            channels: IChannelConnections[];
+            sessionId: string;
+        };
+    }>): void;
+    handlePersistChangeSetMessage(message: IOutgoingWSMessage<string, PersistChangeSetEntityActionRequestPayload>): void;
+    getLogic(options?: {
+        mockLogic?: ProjectState;
+    }): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    injectLocalImplementationOfSearchExecution(): void;
+    setup(options: {
+        mockLogic?: ProjectState;
+    }): Promise<void>;
+    destroy(): Promise<void>;
+    initTest(entryPoint: DraggablePlayableEntityState, autoExecute: boolean): Promise<ITest>;
+    removeTest(): Promise<void>;
+    copyEntities(entities: CanvasEntityState[]): Promise<ChangeSet>;
+    resolveInitialChildrenPositions(parent: CanvasEntityState | null, children: CanvasEntityState[], changeSet: ChangeSet | null): CanvasEntityState[];
+}
+
 export declare interface IEntityActionRequestPayload<P = EntityActionPayload> {
     action: EntityAction;
     author: string;
@@ -8455,6 +8717,12 @@ export declare interface IEntityActionResponsePayload {
     data: IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer>;
 }
 
+export declare interface IEntityComponentProps {
+    entity: DraggablePlayableEntityState | ReturnStatementState | ContinueStatementState | BreakStatementState;
+    project: IEditor;
+    disabled?: boolean;
+}
+
 export declare interface IEntityError<TCode = SharedEntityErrorCode | EntityInstanceErrorCode> {
     id: string;
     message: string;
@@ -8494,6 +8762,22 @@ export declare interface IEnum extends IPrimitiveEntity {
     options: string[];
 }
 
+export declare interface IExecutionCallbackContext {
+    detached: boolean;
+}
+
+export declare interface IExecutionClient {
+    onBeforeEntityExecution?: (entity: EntityState, inputs: IDynamicValue[], context: IExecutionCallbackContext) => Promise<any>;
+    onEntityExecuted?: (entity: EntityState, result: IExecutionResult, context: IExecutionCallbackContext) => Promise<any>;
+}
+
+export declare interface IExecutionResult {
+    value: ExecutionTerminationType;
+    entity: DraggableExecutableEntityState | DraggableCallerEntityState | ActionDescriptorState | VariableState;
+    error: IDynamicValue | null;
+    results: IDynamicValue[];
+}
+
 export declare interface IFile extends IPrimitiveEntity {
     name: PrimitiveTypes.File;
 }
@@ -8791,11 +9075,11 @@ export declare interface IJSON extends IPrimitiveEntity {
     name: PrimitiveTypes.KeyValue;
 }
 
-export declare interface ILiteralValue extends ILiteralValueTransfer, IChildEntity {
+export declare interface ILiteralValue extends ILiteralValueTransfer {
     valueAsTypeSingle: LiteralValueAsType | null;
     valueAsTypeList: LiteralValueAsType[] | null;
-    parent: IDataType | IInputMap | IVariableDeclaration | IVariableInstance | IArgumentDeclaration | IReturnDeclaration | IProperty | IValueDescriptor | IOutputMap;
-    standaloneParent?: EntityWithValue;
+    parent: null | IDataType | IInputMap | IVariableDeclaration | IVariableInstance | IArgumentDeclaration | IReturnDeclaration | IProperty | IValueDescriptor | IOutputMap;
+    standaloneParent: null | EntityWithValue;
 }
 
 export declare interface ILiteralValue_base {
@@ -8828,11 +9112,11 @@ export declare interface ILiteralValueShallowTransfer extends ILiteralValue_meta
     standaloneParent?: EntityWithValueReference;
 }
 
-export declare interface ILiteralValueTransfer extends ILiteralValue_meta, IChildEntityTransfer {
+export declare interface ILiteralValueTransfer extends ILiteralValue_meta {
     valueAsTypeSingle: LiteralValueAsTypeTransfer | null;
     valueAsTypeList: LiteralValueAsTypeTransfer[] | null;
-    parent: IDataType | IDataTypeReference | IInputMap | IInputMapReference | IVariableDeclaration | IVariableDeclarationReference | IVariableInstance | IVariableInstanceReference | IArgumentDeclaration | IArgumentDeclarationReference | IReturnDeclaration | IReturnDeclarationReference | IProperty | IPropertyReference | IValueDescriptor | IValueDescriptorReference | IOutputMap | IOutputMapReference;
-    standaloneParent?: EntityWithValue | EntityWithValueReference;
+    parent: null | IDataType | IDataTypeReference | IInputMap | IInputMapReference | IVariableDeclaration | IVariableDeclarationReference | IVariableInstance | IVariableInstanceReference | IArgumentDeclaration | IArgumentDeclarationReference | IReturnDeclaration | IReturnDeclarationReference | IProperty | IPropertyReference | IValueDescriptor | IValueDescriptorReference | IOutputMap | IOutputMapReference;
+    standaloneParent: null | EntityWithValue | EntityWithValueReference;
 }
 
 export declare interface ILoop extends ILoop_meta, IChildEntity, ICalledEntity, IBaseActionCall {
@@ -9363,6 +9647,12 @@ export declare interface IOperationTransfer extends IBaseActionCallTransfer, IOp
     parent: EntityWithLogicScope | EntityWithLogicScopeReference | IProject | IProjectReference;
 }
 
+export declare interface IOutgoingWSMessage<Type extends string = string, Payload = any> {
+    payload: Payload;
+    type: Type;
+    to?: string;
+}
+
 export declare interface IOutputMap extends IOutputMap_meta, IChildEntity, IValueWritingEntity {
     defaultValue: ILiteralValue | null;
     declaration: IReturnDeclaration | IValueDescriptor | IProperty;
@@ -10062,6 +10352,44 @@ export declare interface ITerminationStatementTransfer extends ITerminationState
     throws: IReturnDeclaration | IReturnDeclarationTransfer | null;
 }
 
+export declare interface ITest extends Execution {
+    editor: IEditor;
+    entitiesRelatedToExecution: TestableEntityState[];
+    validation: IDynamicValue[];
+    persistExecutionValues: boolean;
+    constructor(project: IEditor, entryPoint: DraggablePlayableEntityState): ITest;
+    initExecutionValueStores(): void;
+    pause(): Promise<void>;
+    stop(): Promise<void>;
+    resume(): Promise<void>;
+    restart(): Promise<void>;
+    onValueWritten(owner: EntityWithValueState, value: IDynamicValue): void;
+    onValueRemoved(owner: EntityWithValueState): void;
+    init(autoExecute: boolean): Promise<void>;
+    clear(): Promise<void>;
+    resolveIsContinuationOfSelectedLogic(entity: TestableEntityState): boolean;
+    recalculateEntitiesRelatedToTest(): void;
+    removeIfUnconnected(entity: TestableEntityState): boolean;
+    removeEntity(entity: TestableEntityState): void;
+    addEntity(entity: TestableEntityState): void;
+    getCanBeAddedToTest(entity: TestableEntityState): boolean;
+    removeFromCanBeAddedToTest(entity: TestableEntityState): void;
+    addToCanBeAddedToTest(entity: TestableEntityState): void;
+    getCanBeRemovedFromTest(entity: TestableEntityState): boolean;
+    validateLogic(): IDynamicValue[];
+    validate(): void;
+    onBeforeEntityExecution(entity: TestableEntityState, values: IDynamicValue[], context: IExecutionCallbackContext): Promise<void>;
+    onEntityExecuted(entity: TestableEntityState, result: IExecutionResult, context: IExecutionCallbackContext): Promise<void>;
+    start(): Promise<void>;
+    handleInvalidLogic(): Promise<void>;
+}
+
+export declare interface IUndoableInterface {
+    undo: () => void;
+    redo: () => void;
+    undoableStackValueIndex: number;
+}
+
 export declare interface IUUID extends IPrimitiveEntity {
     name: PrimitiveTypes.UUID;
 }
@@ -10112,6 +10440,11 @@ export declare interface IValueDescriptorTransfer extends IValueDescriptor_meta
     parent: IActionDescriptor | IActionDescriptorReference | ILoop | ILoopReference | ISearch | ISearchReference | null;
 }
 
+export declare interface IValueInheritanceLink {
+    sources: IDynamicValue[];
+    target: EntityWithValueState;
+}
+
 export declare interface IValueReadingEntity extends IValueReadingEntityTransfer {
     readsValue: ValueWritingEntity | null;
 }
@@ -10128,6 +10461,38 @@ export declare interface IValueReadingEntityTransfer {
     readsValue: ValueWritingEntity | ValueWritingEntityTransfer | ValueWritingEntityReference | null;
 }
 
+export declare interface IValueResolutionContext {
+    execution?: Execution | null;
+    project: ProjectState;
+    localTestValues: IValueStoreClient;
+    resolvedValues: IValueStoreClient;
+    persistedExecutionResults: IValueStoreClient;
+    lastExecutionResults: IValueStoreClient;
+}
+
+export declare interface IValueStoreClient {
+    initialized: boolean;
+    id: string;
+    project: ProjectState;
+    values: IValueStoreRecord;
+    onWriteCallback: (owner: EntityWithValueState, value: ILiteralValue) => void;
+    onRemoveCallback: (owner: EntityWithValueState) => void;
+    onWrite(callback: (owner: EntityWithValueState, value: ILiteralValue) => void): void;
+    onRemove(callback: (owner: EntityWithValueState) => void): void;
+    init(): void;
+    toJSON(): {
+        [key: string]: ILiteralValueTransfer;
+    };
+    writeValue(owner: EntityWithValueState, value: LiteralValueState): void;
+    readValue(ownerId: string): LiteralValueState | null;
+    removeValue(ownerId: string): void;
+    clear(): void;
+}
+
+export declare interface IValueStoreRecord {
+    [key: EntityId]: LiteralValueState;
+}
+
 export declare interface IValueValidationResult<T = LiteralValueType, TCode = SharedEntityErrorCode | EntityInstanceErrorCode> {
     errors: EntityError<TCode>[];
     override: T;
@@ -10315,6 +10680,47 @@ export declare interface IVersionMetadata {
     deleted: boolean;
 }
 
+/**
+ * The minimal subset of the Node‑ws and the browser WebSocket API
+ * that you actually use in your editor.
+ */
+export declare interface IWebSocketCommon {
+    /** readyState codes (both ws and browser expose these as static *and* instance props) */
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    readonly CLOSING: number;
+    readonly CLOSED: number;
+    /** The current state of the connection */
+    readonly readyState: number;
+    /** The URL used to establish the connection */
+    readonly url: string;
+    /** Subprotocol negotiated with the server, if any */
+    readonly protocol: string;
+    /** Bytes queued but not yet sent */
+    readonly bufferedAmount: number;
+    /** Send a message (string, binary, etc.) */
+    send(data: any): void;
+    /** Close the connection (code + reason both optional in both APIs) */
+    close(code?: number, reason?: string): void;
+    /**
+     * We only tap the four basic events in both environments.
+     * Node‑ws also implements addEventListener/removeEventListener,
+     * and the browser socket does too, so this matches both.
+     */
+    addEventListener(event: 'open' | 'message' | 'error' | 'close', listener: (ev: any) => void): void;
+    removeEventListener(event: 'open' | 'message' | 'error' | 'close', listener: (ev: any) => void): void;
+    /** Optional onX handlers on the instance */
+    onopen?: (ev: any) => void;
+    onmessage?: (ev: any) => void;
+    onerror?: (ev: any) => void;
+    onclose?: (ev: any) => void;
+}
+
+export declare interface IWebsocketsClient extends Events {
+    connection: IWebSocketCommon;
+    send(message: any): void;
+}
+
 export declare const joinListOperation: IActionDescriptorTransfer;
 
 export declare const joinListOperationError: IValueDescriptorTransfer;
@@ -11468,6 +11874,8 @@ export declare enum PersistedEntityMethods {
     AbortExecution = "base-abort-execution"
 }
 
+export declare const PLACEHOLDER_VALUE_STORE_CLIENT: IValueStoreClient;
+
 export declare type PlayableEntity = PassThroughCallableEntity | EntryPointEntity;
 
 export declare type PlayableEntity_meta = PassThroughCallableEntity_meta | EntryPointEntity_meta;
@@ -11820,6 +12228,14 @@ export declare enum ProjectStateEvents {
 
 export declare type ProjectTypesUnion = IProject | IProjectTransfer | IProjectShallowTransfer | IProjectGenerationTarget;
 
+export declare function propagateNewInputOrOutputMapValueAsTypeToParentVariable(entity: InputMapState | OutputMapState, project: ProjectState, newValue: ValueAsTypeState | ValueAsTypeState[] | null, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function propagateNewInputOrOutputMapValueToParentVariable(entity: InputMapState | OutputMapState, project: ProjectState, newValue: LiteralValueType, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function propagateNewStaticPropertyValueAsTypeToVariables(entity: PropertyState, project: ProjectState, newValue: ValueAsTypeState | ValueAsTypeState[] | null, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
+export declare function propagateNewStaticPropertyValueToVariables(entity: PropertyState, project: ProjectState, newValue: LiteralValueType, storage: ChangeSet | IValueStoreClient): ChangeSet | null;
+
 export declare const PROPERTY_NOT_VALUE_READER_WRITTER_EXPLANATION = "A property entity, is neither a value reading, or a value writting entity, but they are often confused with one.\nA 'property' can have a default value through its nested 'data-type' entity.\nThe 'property' entity only represents the data field in the declaration, and it can't write or read values.\nWhen a 'definition-entity' is instantiated as a variable, any writes or reads to its properties are done through 'input-map's and 'output-map's.";
 
 export declare enum PropertyDependencyField {
@@ -11972,6 +12388,8 @@ export { propertyValidation }
 
 export declare const READ_ONLY_ENTITY_PERSISTANCE_REPOSITORY: IReadOnlyEntityPersistanceRepository;
 
+export declare function readValueFromWritter(entity: ValueReadingEntityState, context: IValueResolutionContext): IDynamicValue | null;
+
 export declare type Reference = IGenericReference | IFunctionDeclarationReference | IInstalledProjectReference | IDataTypeReference | IVariableDeclarationReference | IVariableInstanceReference | IOperationReference | IDefinitionEntityReference | IPrimitiveEntityReference | IProjectReference | IGlobalEventReference | IFunctionDeclarationReference | IFunctionDeclarationReference | IPropertyReference | IFunctionCallReference | IArgumentDeclarationReference | IInputMapReference | IOutputMapReference | IReturnDeclarationReference | IConditionReference | IReturnStatementReference | IBreakStatementReference | IContinueStatementReference | ILoopReference | IActionDescriptorReference | ISearchReference | ILiteralValueReference | IBuiltInBaseEntityReference | IValueDescriptorReference | IInternalCallReference;
 
 export declare const relationalDatabaseBuiltInBaseEntity: IBuiltInBaseEntityTransfer;
@@ -12034,6 +12452,8 @@ export declare function resolveActionDescriptorName(actionDescriptor: ActionDesc
 
 declare function resolveAreThereConflictingColumnsInSelectAll(allColumnsSelector: AllColumnsSelector | null): boolean;
 
+export declare function resolveArgumentDeclarationValue(entity: ArgumentDeclarationState, context: IValueResolutionContext): IDynamicValue | null;
+
 export declare function resolveBaseEntityName(baseEntities: BaseEntityNames[]): string;
 
 export declare function resolveBuiltInBaseEntityDataTypeLabel(entity: BuiltInBaseEntityState): string;
@@ -12064,6 +12484,22 @@ export declare function resolveFirstCallsSecond(first: DraggableExecutableEntity
 
 export declare function resolveFirstWritesSecond(first: ValueWritingEntityState, second: ValueReadingEntityState): boolean;
 
+export declare function resolveInputMapNextStandaloneValue(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveInputMapNextValue(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveInputMapNextValueAsPropertyOfAnObject(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveInputMapStandaloneValue(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveInputMapValue(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveInputMapValueAsPropertyOfAnObject(entity: InputMapState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveNextValue(entity: ValueReadingEntityState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveOutputMapValue(entity: OutputMapState, context: IValueResolutionContext): IDynamicValue | null;
+
 export declare function resolvePersistedDefinitionEntityDatabaseEntity(entity: DefinitionEntityState): DefinitionEntityState | null;
 
 export declare function resolvePrimaryKeyProperty(entity: DefinitionEntityState): PropertyState | null;
@@ -12075,10 +12511,30 @@ export declare function resolvePrimitiveEntityName(primitiveEntity: {
     [key: string]: any;
 }): string;
 
+export declare function resolvePropertyValue(entity: PropertyState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveReturnDeclarationValue(entity: ReturnDeclarationState, context: IValueResolutionContext): IDynamicValue | null;
+
 export declare function resolveSearchName(search: SearchState): string;
 
+export declare function resolveValue(entity: EntityWithValueState | PropertyState | ValueDescriptorState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveValueDescriptorValue(entity: ValueDescriptorState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveVarDeclarationAggregateObjectValue(entity: VariableDeclarationState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveVarDeclarationNextAggregateObjectValue(entity: VariableDeclarationState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveVarDeclarationNextValue(entity: VariableDeclarationState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveVarDeclarationValue(entity: VariableDeclarationState, context: IValueResolutionContext): IDynamicValue | null;
+
 export declare function resolveVariableScope(variable: VariableState): 'global-declaration' | 'global-instance' | 'local-declaration' | 'local-instance';
 
+export declare function resolveVarInstanceNextValue(entity: VariableInstanceState, context: IValueResolutionContext): IDynamicValue | null;
+
+export declare function resolveVarInstanceValue(entity: VariableInstanceState, context: IValueResolutionContext): IDynamicValue | null;
+
 export declare const RETURN_STATEMENT_RETURN_DECLARATIONS_EXPLANATION = "Return statements need to be identical inside the same scope. For example if a 'return-statement' belongs to a function, with multiple branches of logic, leading to multiple 'return-statement' entities, all of them need to have the exact same amount of 'return-declaration' entities, sharing the same name and an equivalent 'data-type' entity.\nFurthermore, some 'function-declarations' and all 'global-events' might be implementing a base 'action-descriptor' entity, which defines exactly the shape and number of the return declarations.";
 
 export declare enum ReturnDeclarationDependencyField {
@@ -13039,6 +13495,8 @@ export declare type TerminationState = ReturnStatementState | BreakStatementStat
 
 export declare const test_primitive_entities_export = "test_primitive_entities_export";
 
+export declare type TestableEntityState = DraggableExecutableEntityState | DraggableCallerEntityState | VariableState | CallableEntityState;
+
 export declare function toCamelCase(str: string): string;
 
 export declare function toEntityState(entity: string | EntityState | IGenericReference | Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget, project: ProjectState): EntityState | null;
@@ -13276,6 +13734,8 @@ export declare const validateDataOperationOutputEntityDeclarationParentRef: IAct
 
 export declare function validateDefinitionEntityName(entity: DefinitionEntityState | IDefinitionEntityGenerationTarget | IDefinitionEntityShallowTransfer | IDefinitionEntityTransfer, project: ProjectState): EntityGenerationError[];
 
+export declare function validateEntityValues(entity: CanvasEntityState | CallableEntityState, context: IValueResolutionContext): IDynamicValue[];
+
 export declare function validateEntryCaller(data: ElementGenerationTarget, callerEntity: CallerEntityState): EntityGenerationError[];
 
 export declare function validateErrorCaller(data: ElementGenerationTarget, callerEntity: CallerEntityState): EntityGenerationError[];
@@ -13303,6 +13763,8 @@ declare function validateImplementation(self: PropertyState): EntityError[];
 
 declare function validateListLoop(self: LoopState): EntityError[];
 
+export declare function validateLogic(logic: (CanvasEntityState | CallableEntityState)[], context: IValueResolutionContext): IDynamicValue[];
+
 export declare function validateLoopEntityDeclaration(loopDeclarationId: EntityId, project: ProjectState): EntityGenerationError[];
 
 export declare function validateName(entity: ElementGenerationTarget | ElementShallowTransfer | ElementTransfer, project: ProjectState): EntityGenerationError[];