@elyx-code/project-logic-tree 0.0.6161 → 0.0.6162

package/dist/tree/built-in/operations/definition-entity/validate-data.d.ts

@@ -1,4 +1,4 @@
-import { ActionDescriptorState, DefinitionEntityState, DataTypeState, InputMapState, OperationState, OutputMapState, ProjectState } from '../../../state';
+import { ActionDescriptorState, DefinitionEntityState, DataTypeState, InputMapState, OperationState, OutputMapState, ProjectState, IChangeSet, ChangeSet } from '../../../state';
 
 export declare class ValidateDataOperation extends ActionDescriptorState {
     readonly autoexecutable = true;
@@ -7,10 +7,10 @@ export declare class ValidateDataOperation extends ActionDescriptorState {
     getDataToValidateInputMap(operation: OperationState): InputMapState | null;
     getOutputDataOutputMap(operation: OperationState): OutputMapState | null;
     getEntityToMatch(entityToMatchInputMap: InputMapState): DefinitionEntityState | null;
-    syncOperationInstance(operation: OperationState): OperationState;
-    syncEntityToMatchInputMapDataType(inputMap: InputMapState): DataTypeState | null;
-    syncDataToValidateInputMapDataType(inputMap: InputMapState): DataTypeState | null;
-    syncOutputDataOutputMapDataType(outputMap: OutputMapState): DataTypeState | null;
-    inferInputMapDataType(inputMap: InputMapState): DataTypeState | null;
-    inferOutputMapDataType(outputMap: OutputMapState): DataTypeState | null;
+    syncOperationInstance(operation: OperationState, changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    syncEntityToMatchInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    syncDataToValidateInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    syncOutputDataOutputMapDataType(outputMap: OutputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    inferInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    inferOutputMapDataType(outputMap: OutputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
 }

package/dist/tree/state/action-descriptor/action-descriptor.d.ts

@@ -1,6 +1,6 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IActionDescriptor, IActionDescriptorGenerationTarget, IActionDescriptorReference, IActionDescriptorShallowTransfer, IActionDescriptorTransfer, IFunctionDeclarationTransfer, ActionDescriptorTypesUnion, EntityVersion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
+import { BaseState, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { ProjectState } from '../project/project';
 import { DataTypeState } from '../data-type';
 import { ValueDescriptorState } from '../value-descriptor';
@@ -8,13 +8,14 @@ import { DefinitionEntityState } from '../definition-entity';
 import { PrimitiveEntityState } from '../primitive-entity';
 import { BuiltInBaseEntityState } from '../built-in-base-entity';
 import { EntityError, EntityGenerationError } from '../error';
-import { EntityState, EntityWithLogicScopeState, IChangeSet } from '../types';
+import { EntityState, EntityWithLogicScopeState, UserManagedEntityState } from '../types';
 import { LoopState } from '../loop';
 import { OperationState } from '../operation';
 import { ConditionState } from '../condition';
 import { InputMapState } from '../input-map';
 import { OutputMapState } from '../output-map';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
 export declare enum ExecutionTerminationType {
     Success = "success",
@@ -28,7 +29,7 @@ export interface IPrimitiveExecutionResult {
     results: any[];
     error: any | null;
 }
-export declare class ActionDescriptorState extends VersionedState implements IActionDescriptor, UserManagedEntityStateFunctionality, BaseState, ChildEntityState {
+export declare class ActionDescriptorState extends VersionedState implements IActionDescriptor, UserManagedEntityStateTemplate, BaseState, ChildEntityState {
     initialData: IActionDescriptorTransfer | IActionDescriptor;
     readonly id: EntityId;
     name: string;
@@ -41,9 +42,14 @@ export declare class ActionDescriptorState extends VersionedState implements IAc
     parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState | null;
     errors: EntityError[];
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, ActionDescriptorState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     autoexecutable: boolean;
     constructor(initialData: IActionDescriptor | IActionDescriptorTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -68,43 +74,43 @@ export declare class ActionDescriptorState extends VersionedState implements IAc
         errors: EntityGenerationError[];
         modifiedData: IActionDescriptorGenerationTarget;
     };
-    syncOperationInstance(operation: OperationState): OperationState;
-    inferInputMapDataType(inputMap: InputMapState): DataTypeState | null;
-    inferOutputMapDataType(outputMap: OutputMapState): DataTypeState | null;
+    syncOperationInstance(operation: OperationState, _changeSet: ChangeSet | null): IChangeSet<OperationState>;
+    inferInputMapDataType(inputMap: InputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
+    inferOutputMapDataType(outputMap: OutputMapState, changeSet?: ChangeSet | null): IChangeSet<DataTypeState | null>;
     validateGeneratedUpdate(data: Partial<IActionDescriptorGenerationTarget>): {
         errors: EntityGenerationError[];
         modifiedData: Partial<IActionDescriptorGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): ActionDescriptorState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ActionDescriptorState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ActionDescriptorState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ActionDescriptorState>>;
     hydrateAncestors(): IChangeSet<ActionDescriptorState>;
-    afterAllChildrenInitialized(): IChangeSet<ActionDescriptorState>;
-    addSelfToProject(): IChangeSet<ActionDescriptorState>;
-    setParent(parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState): ActionDescriptorState;
-    initChildren(): ActionDescriptorState;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ActionDescriptorState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ActionDescriptorState>;
+    setParent(parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState | DataTypeState, changeSet?: ChangeSet | null): ActionDescriptorState;
+    initChildren(changeSet?: ChangeSet | null): ActionDescriptorState;
     subscribe(): ActionDescriptorState;
     unsubscribe(): ActionDescriptorState;
-    sync(data: Partial<IActionDescriptor | IActionDescriptorTransfer | IActionDescriptorShallowTransfer>): ActionDescriptorState;
+    metaSync(data: Partial<IActionDescriptor | IActionDescriptorTransfer | IActionDescriptorShallowTransfer>, changeSet?: ChangeSet | null): ActionDescriptorState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ActionDescriptorState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IActionDescriptorShallowTransfer | null>;
-    remove({ ignoreUpstream: _, seenEntities, }?: {
+    remove({ ignoreUpstream: _ }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: ActionDescriptorState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<ActionDescriptorState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IActionDescriptorTransfer | IActionDescriptorReference;

package/dist/tree/state/argument-declaration/argument-declaration.d.ts

@@ -1,15 +1,20 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IArgumentDeclaration, IArgumentDeclarationGenerationTarget, IArgumentDeclarationReference, IArgumentDeclarationShallowTransfer, IArgumentDeclarationTransfer, ArgumentDeclarationTypesUnion, EntityVersion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, EntityWithValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, ValueWritingEntityClass, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
-import { EntityState, EntryPointEntityState, IChangeSet, ValueReadingEntityState } from '../types';
+import { BaseState, ChildEntityState, EntityWithValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, ValueWritingEntityClass, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
+import { EntityState, EntryPointEntityState, UserManagedEntityState, ValueReadingEntityState } from '../types';
 import { DataTypeState } from '../data-type';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { LiteralValueState } from '../literal-value';
 import { ValueDescriptorState } from '../value-descriptor';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class ArgumentDeclarationState extends VersionedState implements IArgumentDeclaration, UserManagedEntityStateFunctionality, ValueWritingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
+export declare enum ArgumentDeclarationDependencyField {
+    DataTypeEntity = "data-type-entity",
+    Implements = "implements"
+}
+export declare class ArgumentDeclarationState extends VersionedState implements IArgumentDeclaration, UserManagedEntityStateTemplate, ValueWritingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
     initialData: IArgumentDeclaration | IArgumentDeclarationTransfer;
     readonly id: EntityId;
     name: string;
@@ -25,9 +30,14 @@ export declare class ArgumentDeclarationState extends VersionedState implements
     project: ProjectState;
     errors: EntityError[];
     parent: EntryPointEntityState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, ArgumentDeclarationState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IArgumentDeclaration | IArgumentDeclarationTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -56,39 +66,39 @@ export declare class ArgumentDeclarationState extends VersionedState implements
         errors: EntityGenerationError[];
         modifiedData: Partial<IArgumentDeclarationGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): ArgumentDeclarationState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ArgumentDeclarationState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ArgumentDeclarationState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ArgumentDeclarationState>>;
     hydrateAncestors(): IChangeSet<ArgumentDeclarationState>;
-    afterAllChildrenInitialized(): IChangeSet<ArgumentDeclarationState>;
-    addSelfToProject(): IChangeSet<ArgumentDeclarationState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ArgumentDeclarationState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ArgumentDeclarationState>;
     addValueReader(entity: ValueReadingEntityState): ArgumentDeclarationState;
     removeValueReader(valueReader: ValueReadingEntityState): ArgumentDeclarationState;
-    setParent(parent: EntryPointEntityState): ArgumentDeclarationState;
-    setImplements(implementsEntity: ValueDescriptorState): ArgumentDeclarationState;
-    initChildren(): ArgumentDeclarationState;
+    setParent(parent: EntryPointEntityState, changeSet?: ChangeSet | null): ArgumentDeclarationState;
+    setImplements(implementsEntity: ValueDescriptorState | null, changeSet?: ChangeSet | null): ArgumentDeclarationState;
+    initChildren(changeSet?: ChangeSet | null): ArgumentDeclarationState;
     subscribe(): ArgumentDeclarationState;
     unsubscribe(): ArgumentDeclarationState;
-    sync(data: Partial<IArgumentDeclaration | IArgumentDeclarationTransfer | IArgumentDeclarationShallowTransfer>): ArgumentDeclarationState;
+    metaSync(data: Partial<IArgumentDeclaration | IArgumentDeclarationTransfer | IArgumentDeclarationShallowTransfer>, changeSet?: ChangeSet | null): ArgumentDeclarationState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ArgumentDeclarationState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ArgumentDeclarationState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ArgumentDeclarationState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ArgumentDeclarationState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ArgumentDeclarationState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IArgumentDeclarationShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: ArgumentDeclarationState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<ArgumentDeclarationState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IArgumentDeclarationTransfer | IArgumentDeclarationReference;

package/dist/tree/state/argument-declaration/validation/validation-schema.d.ts

@@ -428,8 +428,6 @@ export declare function getArgumentDeclarationSchema(): z.ZodObject<z.objectUtil
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     dataType: Record<string, any> | {
         type: EntityType.DataType;
     } | null;
@@ -442,6 +440,8 @@ export declare function getArgumentDeclarationSchema(): z.ZodObject<z.objectUtil
     } | {
         type: EntityType.VariableInstance;
     })[];
+    x: number;
+    y: number;
 }, {
     id: string;
     type: EntityType.ArgumentDeclaration;
@@ -472,8 +472,6 @@ export declare function getArgumentDeclarationSchema(): z.ZodObject<z.objectUtil
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     dataType: Record<string, any> | {
         type: EntityType.DataType;
     } | null;
@@ -486,4 +484,6 @@ export declare function getArgumentDeclarationSchema(): z.ZodObject<z.objectUtil
     } | {
         type: EntityType.VariableInstance;
     })[];
+    x: number;
+    y: number;
 }>;

package/dist/tree/state/base.d.ts

@@ -1,6 +1,6 @@
 import { EntityId, EntityType, EntityVersion, IGenericBase, Element, ElementTransfer, IGenericReference, ElementShallowTransfer, ElementGenerationTarget, Reference } from '../../definitions';
 import { ZodError } from 'zod';
-import { CallableEntityState, CallerEntityState, CanvasEntityState, EntityState, IChangeSet, InputMapState, UserManagedEntityState, ValueReadingEntityState, ValueWritingEntityState } from '.';
+import { CallableEntityState, CallerEntityState, CanvasEntityState, ChangeSet, EntityState, IChangeSet, InputMapState, UserManagedEntityState, ValueReadingEntityState, ValueWritingEntityState } from '.';
 import { ProjectState } from './project/project';
 import { EntityError } from './error';
 import { LiteralValueState } from './literal-value';
@@ -54,16 +54,21 @@ export interface IEditableEntityPersistanceRepository extends IReadOnlyEntityPer
 }
 export declare const READ_ONLY_ENTITY_PERSISTANCE_REPOSITORY: IReadOnlyEntityPersistanceRepository;
 export declare const EDITABLE_PERSISTANCE_REPOSITORY_DEFAULTS: IEditableEntityPersistanceRepository;
-export declare abstract class UserManagedEntityStateFunctionality {
+export declare abstract class UserManagedEntityStateTemplate {
+    abstract detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     abstract knownVersions: Map<EntityVersion, EntityState> | null;
     abstract activeVersion: boolean;
-    abstract captureVersion(): UserManagedEntityStateFunctionality;
-    abstract recursiveCaptureUpstreamVersions(): IChangeSet<UserManagedEntityState>;
+    abstract captureVersion(): UserManagedEntityStateTemplate;
+    abstract increaseVersion(sharedTimestamp: null | string): UserManagedEntityStateTemplate;
+    abstract recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<UserManagedEntityState>;
     abstract restoreVersion(version: EntityVersion): Promise<IChangeSet<UserManagedEntityState>>;
     abstract hydrateAncestors(): IChangeSet<UserManagedEntityState>;
-    abstract addSelfToProject(): IChangeSet<UserManagedEntityState>;
-    abstract afterAllChildrenInitialized(): IChangeSet<UserManagedEntityState>;
-    abstract sync(data: Partial<Element | ElementTransfer | ElementShallowTransfer>): SharedStateFunctionality;
+    abstract addSelfToProject(changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    abstract afterAllChildrenInitialized(changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    abstract metaSync(data: Partial<Element | ElementTransfer | ElementShallowTransfer>, changeSet: ChangeSet | null): SharedStateFunctionality;
     abstract APICreate(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
     abstract APIUpdate(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
     abstract APIDelete(options: IEntityPersistanceOptions): Promise<SharedStateFunctionality>;
@@ -71,19 +76,24 @@ export declare abstract class UserManagedEntityStateFunctionality {
     abstract APILoadVersion(options: IEntityPersistanceOptions, versionIdOrBeforeEqualDate: EntityVersion | Date): Promise<ElementShallowTransfer | null>;
     abstract remove(options: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
+    }, changeSet: ChangeSet | null): {
+        updated: EntityState[];
         removed: EntityState[];
     };
-    abstract restore(options: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
+    abstract restore(options: {}, changeSet: ChangeSet | null): {
+        updated: EntityState[];
         self: EntityState;
     };
     abstract toJSONClone(options?: IEntityJSONCloneOptions): ElementTransfer | Reference;
     abstract clone(parent?: EntityState | null, newId?: string | null, subscribe?: boolean): SharedStateFunctionality;
+    abstract subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    abstract subscribeToDependencies(): UserManagedEntityState;
+    abstract syncDependents(): IChangeSet<UserManagedEntityState>;
+    abstract onDetachedDependencyRemoved(dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    abstract onDetachedDependencyRestored(dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
 }
 export declare abstract class BaseState extends SharedStateFunctionality implements IGenericBase {
     abstract id: EntityId;
@@ -100,9 +110,10 @@ export declare abstract class BaseCanvasDraggableState {
 }
 export declare abstract class ChildEntityState {
     abstract parent: EntityState | null;
+    abstract startedInitialization: boolean;
     abstract initialized: boolean;
     abstract setParent(parent: EntityState): ChildEntityState;
-    abstract initChildren(): ChildEntityState;
+    abstract initChildren(changeSet: ChangeSet | null): ChildEntityState;
 }
 export declare abstract class CallableEntityClass {
     abstract calledBy: CallerEntityState[];

package/dist/tree/state/break-statement/break-statement.d.ts

@@ -1,14 +1,18 @@
 import { BreakStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IBreakStatement, IBreakStatementGenerationTarget, IBreakStatementReference, IBreakStatementShallowTransfer, IBreakStatementTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
-import { CallerEntityState, EntityState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
+import { CallerEntityState, EntityState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState } from '../types';
 import { ProjectState } from '../project/project';
 import { LoopState } from '../loop';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class BreakStatementState extends VersionedState implements IBreakStatement, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
+export declare enum BreakStatementDependencyField {
+    Parent = "parent"
+}
+export declare class BreakStatementState extends VersionedState implements IBreakStatement, UserManagedEntityStateTemplate, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
     initialData: IBreakStatement | IBreakStatementTransfer;
     readonly id: EntityId;
     x: number;
@@ -22,9 +26,14 @@ export declare class BreakStatementState extends VersionedState implements IBrea
     project: ProjectState;
     errors: EntityError[];
     parent: LoopState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IBreakStatement | IBreakStatementTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -53,43 +62,43 @@ export declare class BreakStatementState extends VersionedState implements IBrea
         errors: EntityGenerationError[];
         modifiedData: Partial<IBreakStatementGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): BreakStatementState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<BreakStatementState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<BreakStatementState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<BreakStatementState>>;
     hydrateAncestors(): IChangeSet<BreakStatementState>;
-    afterAllChildrenInitialized(): IChangeSet<BreakStatementState>;
-    addSelfToProject(): IChangeSet<BreakStatementState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<BreakStatementState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<BreakStatementState>;
     get calledBy(): CallerEntityState[];
-    addSuccessCaller(caller: PassThroughCallableEntityState): BreakStatementState;
-    addErrorCaller(caller: PassThroughCallableEntityState): BreakStatementState;
-    addEntryCaller(caller: EntryPointEntityState): BreakStatementState;
-    removeCaller(caller: CallerEntityState): BreakStatementState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): BreakStatementState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): BreakStatementState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): BreakStatementState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): BreakStatementState;
     addOutputDeclaration(output: ReturnDeclarationState): BreakStatementState;
     removeOutputDeclaration(output: ReturnDeclarationState): BreakStatementState;
-    setParent(parent: LoopState): BreakStatementState;
-    initChildren(): BreakStatementState;
+    setParent(parent: LoopState, changeSet?: ChangeSet | null): BreakStatementState;
+    initChildren(changeSet?: ChangeSet | null): BreakStatementState;
     subscribe(): BreakStatementState;
     unsubscribe(): BreakStatementState;
-    sync(data: Partial<IBreakStatement | IBreakStatementTransfer | IBreakStatementShallowTransfer>): BreakStatementState;
+    metaSync(data: Partial<IBreakStatement | IBreakStatementTransfer | IBreakStatementShallowTransfer>, changeSet?: ChangeSet | null): BreakStatementState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BreakStatementState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IBreakStatementShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: EntityState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<EntityState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IBreakStatementTransfer | IBreakStatementReference;

package/dist/tree/state/break-statement/validation/validation-schema.d.ts

@@ -995,11 +995,11 @@ export declare function getBreakStatementSchema(): z.ZodObject<z.objectUtil.exte
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     outputs: (Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     })[];
+    x: number;
+    y: number;
     throws?: Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     } | undefined;
@@ -1106,11 +1106,11 @@ export declare function getBreakStatementSchema(): z.ZodObject<z.objectUtil.exte
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     outputs: (Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     })[];
+    x: number;
+    y: number;
     throws?: Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     } | undefined;

package/dist/tree/state/built-in-base-entity/built-in-base-entity.d.ts

@@ -10,6 +10,7 @@ import { EntityError, EntityGenerationError } from '../../state/error';
 import { EntityState } from '../types';
 import { DefinitionEntityState } from '../definition-entity';
 import { VersionedState } from '../version';
+import { ChangeSet } from '../change-set';
 
 export declare class BuiltInBaseEntityState extends VersionedState implements BaseState, IBuiltInBaseEntity {
     initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
@@ -37,19 +38,6 @@ export declare class BuiltInBaseEntityState extends VersionedState implements Ba
     subscribe(): BuiltInBaseEntityState;
     unsubscribe(): BuiltInBaseEntityState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<BuiltInBaseEntityState>;
-    remove(_?: {
-        ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities: _ }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: BuiltInBaseEntityState;
-    };
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IBuiltInBaseEntityTransfer | IBuiltInBaseEntityReference;
@@ -66,7 +54,7 @@ export declare class BuiltInBaseEntityState extends VersionedState implements Ba
     };
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
-    implement(newEntityName: string, newId?: string): {
+    implement(newEntityName: string, changeSet?: ChangeSet | null, newId?: string): {
         errors: [];
         implemented: DefinitionEntityState;
         entitiesChanges: {

package/dist/tree/state/change-set.d.ts

@@ -0,0 +1,71 @@
+import { EntityId, EntityType, UserManagedElementShallowTransfer } from '../../definitions';
+import { UserManagedEntityState } from './types';
+import { ProjectState } from './project';
+
+export interface IChangeSet<TSelf extends {
+    id: string;
+    type: EntityType;
+} | null = UserManagedEntityState, TGeneric extends {
+    id: string;
+    type: EntityType;
+} = UserManagedEntityState> {
+    added: TGeneric[];
+    updated: TGeneric[];
+    removed: TGeneric[];
+    affected: TGeneric[];
+    self: TSelf;
+}
+export interface IRecordChangeSet<TSelf extends {
+    id: string;
+    type: EntityType;
+} | null = UserManagedEntityState, TGeneric extends {
+    id: string;
+    type: EntityType;
+} = UserManagedEntityState> {
+    added: Record<EntityId, TGeneric>;
+    updated: Record<EntityId, TGeneric>;
+    removed: Set<EntityId>;
+    affected: Set<EntityId>;
+    self: TSelf;
+    seenEntities: EntityId[];
+}
+export declare enum ChangeSetChangeCaptureType {
+    Manual = "manual",
+    Automatic = "automatic"
+}
+export declare enum ChangeSetEntityChangeType {
+    Added = "added",
+    Updated = "updated",
+    Removed = "removed",
+    Affected = "affected"
+}
+export declare class ChangeSet {
+    id: string;
+    seenEntities: EntityId[];
+    added: Record<EntityId, UserManagedEntityState>;
+    updated: Record<EntityId, UserManagedEntityState>;
+    removed: Record<EntityId, UserManagedEntityState>;
+    affected: Record<EntityId, UserManagedEntityState>;
+    self: UserManagedEntityState | null;
+    author: string;
+    timestamp: string;
+    open: boolean;
+    dirty: boolean;
+    type: ChangeSetChangeCaptureType;
+    autoclose: boolean;
+    autoCloseActionName: string;
+    project: ProjectState;
+    constructor(project: ProjectState, author: string, timestamp: string, // ISO 8601 format
+    self: UserManagedEntityState | null, autoclose?: boolean, autoCloseActionName?: string);
+    get isEmpty(): boolean;
+    get isValid(): boolean;
+    attemptAutoclose(knownAutoCloseActionName: string, closingEntityId: EntityId): ChangeSet;
+    close(): ChangeSet;
+    add(entity: UserManagedEntityState, changeType: ChangeSetEntityChangeType): ChangeSet;
+    toJSON(): IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer>;
+    has(entityId: EntityId): boolean;
+    hasAdded(entityId: EntityId): boolean;
+    hasUpdated(entityId: EntityId): boolean;
+    hasRemoved(entityId: EntityId): boolean;
+    hasAffected(entityId: EntityId): boolean;
+}

package/dist/tree/state/change-set.test.d.ts

@@ -0,0 +1 @@
+export {};