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

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

@@ -1,6 +1,6 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IProperty, IPropertyGenerationTarget, IPropertyReference, IPropertyShallowTransfer, IPropertyTransfer, PropertyTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, EntityWithValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
+import { BaseState, ChildEntityState, EntityWithValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { DataTypeState } from '../data-type';
 import { ProjectState } from '../project/project';
 import { PrimitiveEntityState } from '../primitive-entity';
@@ -8,10 +8,15 @@ import { DefinitionEntityState } from '../definition-entity';
 import { BuiltInBaseEntityState } from '../built-in-base-entity';
 import { EntityError, EntityGenerationError } from '../error';
 import { LiteralValueState } from '../literal-value';
-import { EntityState, IChangeSet } from '../types';
+import { EntityState, UserManagedEntityState } from '../types';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class PropertyState extends VersionedState implements IProperty, UserManagedEntityStateFunctionality, BaseState, ChildEntityState, EntityWithValueClass {
+export declare enum PropertyDependencyField {
+    Implements = "implements",
+    DataTypeEntity = "data-type-entity"
+}
+export declare class PropertyState extends VersionedState implements IProperty, UserManagedEntityStateTemplate, BaseState, ChildEntityState, EntityWithValueClass {
     initialData: IProperty | IPropertyTransfer;
     readonly id: EntityId;
     name: string;
@@ -30,9 +35,14 @@ export declare class PropertyState extends VersionedState implements IProperty,
     project: ProjectState;
     errors: EntityError[];
     parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IProperty | IPropertyTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -62,37 +72,37 @@ export declare class PropertyState extends VersionedState implements IProperty,
         errors: EntityGenerationError[];
         modifiedData: Partial<IPropertyGenerationTarget>;
     };
+    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(): PropertyState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<PropertyState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<PropertyState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<PropertyState>>;
     hydrateAncestors(): IChangeSet<PropertyState>;
-    afterAllChildrenInitialized(): IChangeSet<PropertyState>;
-    addSelfToProject(): IChangeSet<PropertyState>;
-    setParent(parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState): PropertyState;
-    setImplements(implementsEntity: PropertyState): PropertyState;
-    initChildren(): PropertyState;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
+    setParent(parent: DefinitionEntityState | PrimitiveEntityState | BuiltInBaseEntityState, changeSet?: ChangeSet | null): PropertyState;
+    setImplements(implementsEntity: PropertyState | null, changeSet?: ChangeSet | null): PropertyState;
+    initChildren(changeSet?: ChangeSet | null): PropertyState;
     subscribe(): PropertyState;
     unsubscribe(): PropertyState;
-    sync(data: Partial<IProperty | IPropertyTransfer | IPropertyShallowTransfer>): PropertyState;
+    metaSync(data: Partial<IProperty | IPropertyTransfer | IPropertyShallowTransfer>, changeSet?: ChangeSet | null): PropertyState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PropertyState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IPropertyShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: PropertyState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<PropertyState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IPropertyTransfer | IPropertyReference;

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

@@ -1,8 +1,8 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IReturnDeclaration, IReturnDeclarationGenerationTarget, IReturnDeclarationReference, IReturnDeclarationShallowTransfer, IReturnDeclarationTransfer, ReturnDeclarationTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, EntityWithValueClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality, ValueReadingEntityClass } from '../base';
+import { BaseState, ChildEntityState, EntityWithValueClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate, ValueReadingEntityClass } from '../base';
 import { DataTypeState } from '../data-type';
-import { EntityState, IChangeSet, ValueWritingEntityState } from '../types';
+import { EntityState, UserManagedEntityState, ValueWritingEntityState } from '../types';
 import { ProjectState } from '../project/project';
 import { ReturnStatementState } from '../return-statement';
 import { BreakStatementState } from '../break-statement';
@@ -11,8 +11,13 @@ 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 ReturnDeclarationState extends VersionedState implements IReturnDeclaration, UserManagedEntityStateFunctionality, ValueReadingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
+export declare enum ReturnDeclarationDependencyField {
+    Implements = "implements",
+    DataTypeEntity = "data-type-entity"
+}
+export declare class ReturnDeclarationState extends VersionedState implements IReturnDeclaration, UserManagedEntityStateTemplate, ValueReadingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
     initialData: IReturnDeclaration | IReturnDeclarationTransfer;
     readonly id: EntityId;
     name: string;
@@ -29,9 +34,14 @@ export declare class ReturnDeclarationState extends VersionedState implements IR
     project: ProjectState;
     errors: EntityError[];
     parent: ReturnStatementState | BreakStatementState | ContinueStatementState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IReturnDeclaration | IReturnDeclarationTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -60,40 +70,40 @@ export declare class ReturnDeclarationState extends VersionedState implements IR
         errors: EntityGenerationError[];
         modifiedData: Partial<IReturnDeclarationGenerationTarget>;
     };
+    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(): ReturnDeclarationState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ReturnDeclarationState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ReturnDeclarationState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ReturnDeclarationState>>;
     hydrateAncestors(): IChangeSet<ReturnDeclarationState>;
-    afterAllChildrenInitialized(): IChangeSet<ReturnDeclarationState>;
-    addSelfToProject(): IChangeSet<ReturnDeclarationState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ReturnDeclarationState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ReturnDeclarationState>;
     propagateChanges(): IChangeSet<ReturnDeclarationState>;
-    setParent(parent: ReturnStatementState | BreakStatementState | ContinueStatementState): ReturnDeclarationState;
-    setImplements(implementsEntity: ValueDescriptorState): ReturnDeclarationState;
-    initChildren(): ReturnDeclarationState;
+    setParent(parent: ReturnStatementState | BreakStatementState | ContinueStatementState, changeSet?: ChangeSet | null): ReturnDeclarationState;
+    setImplements(implementsEntity: ValueDescriptorState | null, changeSet?: ChangeSet | null): ReturnDeclarationState;
+    initChildren(changeSet?: ChangeSet | null): ReturnDeclarationState;
     setValueWriter(valueWriter: ValueWritingEntityState): ReturnDeclarationState;
     removeValueWriter(): ReturnDeclarationState;
     subscribe(): ReturnDeclarationState;
     unsubscribe(): ReturnDeclarationState;
-    sync(data: Partial<IReturnDeclaration | IReturnDeclarationTransfer | IReturnDeclarationShallowTransfer>): ReturnDeclarationState;
+    metaSync(data: Partial<IReturnDeclaration | IReturnDeclarationTransfer | IReturnDeclarationShallowTransfer>, changeSet?: ChangeSet | null): ReturnDeclarationState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnDeclarationState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnDeclarationState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnDeclarationState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnDeclarationState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnDeclarationState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IReturnDeclarationShallowTransfer | 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>): IReturnDeclarationTransfer | IReturnDeclarationReference;

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

@@ -1,13 +1,17 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IReturnStatement, IReturnStatementGenerationTarget, IReturnStatementReference, IReturnStatementShallowTransfer, IReturnStatementTransfer, ReturnStatementTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
-import { CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
+import { CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState } from '../types';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class ReturnStatementState extends VersionedState implements IReturnStatement, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
+export declare enum ReturnStatementDependencyField {
+    Parent = "parent"
+}
+export declare class ReturnStatementState extends VersionedState implements IReturnStatement, UserManagedEntityStateTemplate, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
     initialData: IReturnStatement | IReturnStatementTransfer;
     readonly id: EntityId;
     x: number;
@@ -21,9 +25,14 @@ export declare class ReturnStatementState extends VersionedState implements IRet
     project: ProjectState;
     errors: EntityError[];
     parent: EntityWithLogicScopeState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IReturnStatement | IReturnStatementTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -52,43 +61,43 @@ export declare class ReturnStatementState extends VersionedState implements IRet
         errors: EntityGenerationError[];
         modifiedData: Partial<IReturnStatementGenerationTarget>;
     };
+    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(): ReturnStatementState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ReturnStatementState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ReturnStatementState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ReturnStatementState>>;
     hydrateAncestors(): IChangeSet<ReturnStatementState>;
-    afterAllChildrenInitialized(): IChangeSet<ReturnStatementState>;
-    addSelfToProject(): IChangeSet<ReturnStatementState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ReturnStatementState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ReturnStatementState>;
     get calledBy(): CallerEntityState[];
-    addSuccessCaller(caller: PassThroughCallableEntityState): ReturnStatementState;
-    addErrorCaller(caller: PassThroughCallableEntityState): ReturnStatementState;
-    addEntryCaller(caller: EntryPointEntityState): ReturnStatementState;
-    removeCaller(caller: CallerEntityState): ReturnStatementState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): ReturnStatementState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): ReturnStatementState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): ReturnStatementState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): ReturnStatementState;
     addOutputDeclaration(output: ReturnDeclarationState): ReturnStatementState;
     removeOutputDeclaration(output: ReturnDeclarationState): ReturnStatementState;
-    setParent(parent: EntityWithLogicScopeState): ReturnStatementState;
-    initChildren(): ReturnStatementState;
+    setParent(parent: EntityWithLogicScopeState, changeSet?: ChangeSet | null): ReturnStatementState;
+    initChildren(changeSet?: ChangeSet | null): ReturnStatementState;
     subscribe(): ReturnStatementState;
     unsubscribe(): ReturnStatementState;
-    sync(data: Partial<IReturnStatement | IReturnStatementTransfer | IReturnStatementShallowTransfer>): ReturnStatementState;
+    metaSync(data: Partial<IReturnStatement | IReturnStatementTransfer | IReturnStatementShallowTransfer>, changeSet?: ChangeSet | null): ReturnStatementState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnStatementState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnStatementState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnStatementState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnStatementState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ReturnStatementState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IReturnStatementShallowTransfer | 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>): IReturnStatementTransfer | IReturnStatementReference;

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

@@ -1085,11 +1085,11 @@ export declare function getReturnStatementSchema(): z.ZodObject<z.objectUtil.ext
         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;
@@ -1206,11 +1206,11 @@ export declare function getReturnStatementSchema(): z.ZodObject<z.objectUtil.ext
         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/search/search.d.ts

@@ -1,15 +1,19 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, ISearch, ISearchGenerationTarget, ISearchReference, ISearchShallowTransfer, ISearchTransfer, SearchTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
-import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState } from '../types';
 import { ActionInputMapState } from '../input-map';
 import { ActionOutputMapState } from '../output-map';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { ValueDescriptorState } from '../value-descriptor';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class SearchState extends VersionedState implements ISearch, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare enum SearchDependencyField {
+    Parent = "parent"
+}
+export declare class SearchState extends VersionedState implements ISearch, BaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: ISearch | ISearchTransfer;
     readonly id: EntityId;
     name: string;
@@ -31,9 +35,14 @@ export declare class SearchState extends VersionedState implements ISearch, Base
     parent: EntityWithLogicScopeState | ProjectState;
     errors: EntityError[];
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: ISearch | ISearchTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.Search;
@@ -62,52 +71,52 @@ export declare class SearchState extends VersionedState implements ISearch, Base
         errors: EntityGenerationError[];
         modifiedData: Partial<ISearchGenerationTarget>;
     };
+    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(): SearchState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<SearchState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<SearchState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<SearchState>>;
     hydrateAncestors(): IChangeSet<SearchState>;
-    afterAllChildrenInitialized(): IChangeSet<SearchState>;
-    addSelfToProject(): IChangeSet<SearchState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
     get calledBy(): CallerEntityState[];
     removeInput(input: ActionInputMapState): SearchState;
     addInput(input: ActionInputMapState): SearchState;
-    addInputDeclaration(inputDeclaration: ValueDescriptorState): SearchState;
+    addInputDeclaration(inputDeclaration: ValueDescriptorState, changeSet?: ChangeSet | null): SearchState;
     removeInputDeclaration(inputDeclaration: ValueDescriptorState): SearchState;
     addOutputDeclaration(outputDeclaration: ValueDescriptorState): SearchState;
     removeOutputDeclaration(outputDeclaration: ValueDescriptorState): SearchState;
     addOutput(output: ActionOutputMapState): SearchState;
     removeOutput(output: ActionOutputMapState): SearchState;
-    addSuccessCaller(caller: PassThroughCallableEntityState): SearchState;
-    addErrorCaller(caller: PassThroughCallableEntityState): SearchState;
-    addEntryCaller(caller: EntryPointEntityState): SearchState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): SearchState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): SearchState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): SearchState;
     addErrorCall(call: CallableEntityState): SearchState;
     addSuccessCall(call: CallableEntityState): SearchState;
     removeCall(call: CallableEntityState): SearchState;
-    removeCaller(caller: CallerEntityState): SearchState;
-    setParent(parent: EntityWithLogicScopeState | ProjectState): SearchState;
-    initChildren(): SearchState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): SearchState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): SearchState;
+    initChildren(changeSet?: ChangeSet | null): SearchState;
     subscribe(): SearchState;
     unsubscribe(): SearchState;
-    sync(data: Partial<ISearch | ISearchTransfer | ISearchShallowTransfer>): SearchState;
+    metaSync(data: Partial<ISearch | ISearchTransfer | ISearchShallowTransfer>, changeSet?: ChangeSet | null): SearchState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<SearchState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<ISearchShallowTransfer | 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>): ISearchTransfer | ISearchReference;
@@ -126,6 +135,6 @@ export declare class SearchState extends VersionedState implements ISearch, Base
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
     clone(parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): SearchState;
-    syncInputMaps(): IChangeSet<SearchState>;
+    syncInputMaps(changeSet?: ChangeSet | null): IChangeSet<SearchState>;
 }
 export type SearchPayloadUnion = SearchState | SearchTypesUnion;

package/dist/tree/state/search/validation/validation-schema.d.ts

@@ -2113,8 +2113,6 @@ export declare function getSearchSchema(): z.ZodObject<z.objectUtil.extendShape<
         type: EntityType.OutputMap;
     } | null;
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2233,6 +2231,8 @@ export declare function getSearchSchema(): z.ZodObject<z.objectUtil.extendShape<
         entityType: EntityType.ContinueStatement;
         entityId: string;
     })[];
+    x: number;
+    y: number;
     outputsDeclarations: ({
         type: EntityType.ValueDescriptor;
     } | Record<string, any>)[];
@@ -2363,8 +2363,6 @@ export declare function getSearchSchema(): z.ZodObject<z.objectUtil.extendShape<
         type: EntityType.OutputMap;
     } | null;
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2483,6 +2481,8 @@ export declare function getSearchSchema(): z.ZodObject<z.objectUtil.extendShape<
         entityType: EntityType.ContinueStatement;
         entityId: string;
     })[];
+    x: number;
+    y: number;
     outputsDeclarations: ({
         type: EntityType.ValueDescriptor;
     } | Record<string, any>)[];

package/dist/tree/state/types/index.d.ts

@@ -1,6 +1,4 @@
-import { EntityId, EntityType } from '../../../definitions';
 import { ProjectState } from '../project';
-import { EntityState } from './state';
 
 export * from './state';
 export * from './validation';
@@ -8,30 +6,6 @@ export interface IModuleInjection {
     id: string;
     init(project: ProjectState): Promise<void> | void;
 }
-export interface IChangeSet<TSelf extends {
-    id: string;
-    type: EntityType;
-} | null = EntityState, TGeneric extends {
-    id: string;
-    type: EntityType;
-} = EntityState> {
-    added: TGeneric[];
-    updated: TGeneric[];
-    removed: TGeneric[];
-    self: TSelf;
-}
-export interface IRecordChangeSet<TSelf extends {
-    id: string;
-    type: EntityType;
-} | null = EntityState, TGeneric extends {
-    id: string;
-    type: EntityType;
-} = EntityState> {
-    added: Record<EntityId, TGeneric>;
-    updated: Record<EntityId, TGeneric>;
-    removed: Set<EntityId>;
-    self: TSelf;
-}
 export declare enum EntityAction {
     PersistChangeSet = "persist-change-set",
     CreateSingle = "create-single",

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

@@ -1,17 +1,21 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, ValueDescriptorParentChildRelation, IValueDescriptor, IValueDescriptorGenerationTarget, IValueDescriptorReference, IValueDescriptorShallowTransfer, IValueDescriptorTransfer, ValueDescriptorTypesUnion, EntityVersion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { DataTypeState } from '../data-type';
 import { ProjectState } from '../project/project';
 import { ActionDescriptorState } from '../action-descriptor';
 import { EntityError, EntityGenerationError } from '../error';
-import { EntityState, IChangeSet } from '../types';
+import { EntityState, UserManagedEntityState } from '../types';
 import { LiteralValueState } from '../literal-value';
 import { LoopState } from '../loop';
 import { SearchState } from '../search';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class ValueDescriptorState extends VersionedState implements IValueDescriptor, UserManagedEntityStateFunctionality, BaseState, ChildEntityState {
+export declare enum ValueDescriptorDependencyField {
+    DataTypeEntity = "data-type-entity"
+}
+export declare class ValueDescriptorState extends VersionedState implements IValueDescriptor, UserManagedEntityStateTemplate, BaseState, ChildEntityState {
     initialData: IValueDescriptor | IValueDescriptorTransfer;
     readonly id: EntityId;
     name: string;
@@ -25,9 +29,14 @@ export declare class ValueDescriptorState extends VersionedState implements IVal
     project: ProjectState;
     errors: EntityError[];
     parent: ActionDescriptorState | LoopState | SearchState | null;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: IValueDescriptor | IValueDescriptorTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.ValueDescriptor;
@@ -55,36 +64,36 @@ export declare class ValueDescriptorState extends VersionedState implements IVal
         errors: EntityGenerationError[];
         modifiedData: Partial<IValueDescriptorGenerationTarget>;
     };
+    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(): ValueDescriptorState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ValueDescriptorState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ValueDescriptorState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ValueDescriptorState>>;
     hydrateAncestors(): IChangeSet<ValueDescriptorState>;
-    afterAllChildrenInitialized(): IChangeSet<ValueDescriptorState>;
-    addSelfToProject(): IChangeSet<ValueDescriptorState>;
-    setParent(parent: ActionDescriptorState | LoopState | SearchState): ValueDescriptorState;
-    initChildren(): ValueDescriptorState;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ValueDescriptorState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ValueDescriptorState>;
+    setParent(parent: ActionDescriptorState | LoopState | SearchState, changeSet?: ChangeSet | null): ValueDescriptorState;
+    initChildren(changeSet?: ChangeSet | null): ValueDescriptorState;
     subscribe(): ValueDescriptorState;
     unsubscribe(): ValueDescriptorState;
-    sync(data: Partial<IValueDescriptor | IValueDescriptorTransfer | IValueDescriptorShallowTransfer>): ValueDescriptorState;
+    metaSync(data: Partial<IValueDescriptor | IValueDescriptorTransfer | IValueDescriptorShallowTransfer>, changeSet?: ChangeSet | null): ValueDescriptorState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ValueDescriptorState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IValueDescriptorShallowTransfer | 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>): IValueDescriptorTransfer | IValueDescriptorReference;