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

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

@@ -1,9 +1,9 @@
 import { ZodError } from 'zod';
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, ILoop, ILoopGenerationTarget, ILoopReference, ILoopShallowTransfer, ILoopTransfer, LoopTypesUnion } from '../../../definitions';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, EntityWithLogicScopeClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, EntityWithLogicScopeClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate } from '../base';
 import { ActionInputMapState } from '../input-map';
 import { ActionOutputMapState } from '../output-map';
-import { CallableEntityState, CallerEntityState, CanvasEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
+import { CallableEntityState, CallerEntityState, CanvasEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState } from '../types';
 import { ProjectState } from '../project/project';
 import { BreakStatementState } from '../break-statement';
 import { ContinueStatementState } from '../continue-statement';
@@ -16,8 +16,12 @@ import { ValueDescriptorState } from '../value-descriptor';
 import { ReturnDeclarationState } from '../return-declaration';
 import { ArgumentDeclarationState } from '../argument-declaration';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class LoopState extends VersionedState implements ILoop, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, EntityWithLogicScopeClass, PassThroughCallableEntityClass {
+export declare enum LoopDependencyField {
+    Parent = "parent"
+}
+export declare class LoopState extends VersionedState implements ILoop, BaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, EntityWithLogicScopeClass, PassThroughCallableEntityClass {
     initialData: ILoop | ILoopTransfer;
     readonly id: EntityId;
     x: number;
@@ -30,8 +34,6 @@ export declare class LoopState extends VersionedState implements ILoop, BaseStat
     successCalls: CallableEntityState[];
     errorCalls: CallableEntityState[];
     error: ActionOutputMapState | null;
-    breakStatements: BreakStatementState[];
-    continueStatements: ContinueStatementState[];
     outputsDeclarations: ValueDescriptorState[];
     body: FunctionDeclarationState;
     calledBySuccess: PassThroughCallableEntityState[];
@@ -43,9 +45,14 @@ export declare class LoopState extends VersionedState implements ILoop, BaseStat
     currentValueArgumentDeclaration: ArgumentDeclarationState | null;
     errors: EntityError[];
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: ILoop | ILoopTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.Loop;
@@ -77,16 +84,27 @@ export declare class LoopState extends VersionedState implements ILoop, BaseStat
     static fromLoopOutputDeclarationToReturnDeclarationName(outputDeclaration: ValueDescriptorState): string;
     static fromLoopOutputDeclarationToBodyArgumentDeclarationName(outputDeclaration: ValueDescriptorState): string;
     static fromBodyArgumentDeclarationToLoopOutputDeclarationName(argumentDeclaration: ArgumentDeclarationState): string;
+    get continueStatements(): ContinueStatementState[];
+    get breakStatements(): BreakStatementState[];
     validateGeneratedUpdate(data: Partial<ILoopGenerationTarget>): {
         errors: EntityGenerationError[];
         modifiedData: Partial<ILoopGenerationTarget>;
     };
+    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(): LoopState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<LoopState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<LoopState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<LoopState>>;
     hydrateAncestors(): IChangeSet<LoopState>;
-    afterAllChildrenInitialized(): IChangeSet<LoopState>;
-    addSelfToProject(): IChangeSet<LoopState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
     get calledBy(): CallerEntityState[];
     removeInput(input: ActionInputMapState): LoopState;
     addInput(input: ActionInputMapState): LoopState;
@@ -95,40 +113,31 @@ export declare class LoopState extends VersionedState implements ILoop, BaseStat
     addOutput(output: ActionOutputMapState): LoopState;
     removeOutput(output: ActionOutputMapState): LoopState;
     setBody(body: FunctionDeclarationState): LoopState;
-    addSuccessCaller(caller: PassThroughCallableEntityState): LoopState;
-    addErrorCaller(caller: PassThroughCallableEntityState): LoopState;
-    addEntryCaller(caller: EntryPointEntityState): LoopState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): LoopState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): LoopState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): LoopState;
     addErrorCall(call: CallableEntityState): LoopState;
     addSuccessCall(call: CallableEntityState): LoopState;
     removeCall(call: CallableEntityState): LoopState;
-    removeCaller(caller: CallerEntityState): LoopState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): LoopState;
     replaceDetachedChild(existingChild: CanvasEntityState, newChild: CanvasEntityState): LoopState;
     subscribeDetachedChild(child: CanvasEntityState): LoopState;
-    setParent(parent: EntityWithLogicScopeState | ProjectState): LoopState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): LoopState;
     setDeclaration(declaration: ActionDescriptorState): LoopState;
-    initChildren(): LoopState;
+    initChildren(changeSet?: ChangeSet | null): LoopState;
     subscribe(): LoopState;
     unsubscribe(): LoopState;
-    sync(data: Partial<ILoop | ILoopTransfer | ILoopShallowTransfer>): LoopState;
+    metaSync(data: Partial<ILoop | ILoopTransfer | ILoopShallowTransfer>, changeSet?: ChangeSet | null): LoopState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LoopState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LoopState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LoopState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LoopState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<LoopState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<ILoopShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: LoopState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<LoopState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): ILoopTransfer | ILoopReference;
@@ -155,19 +164,19 @@ export declare class LoopState extends VersionedState implements ILoop, BaseStat
     addContinueStatement(statement: ContinueStatementState): LoopState;
     removeContinueStatement(statement: ContinueStatementState): LoopState;
     getUniqueReturnDeclarations(): ReturnDeclarationState[];
-    syncTerminationStatements(): IChangeSet<LoopState>;
-    syncBodyInputIndexes(): IChangeSet<LoopState>;
-    syncBodyArgumentsDeclarations(): IChangeSet<LoopState>;
-    syncOutputsDeclarations(): IChangeSet<LoopState>;
-    syncOutputMaps(): IChangeSet<LoopState>;
-    createCurrentIterationNumberArgumentDeclaration(): IChangeSet<LoopState>;
-    removeExtraBodyArgumentDeclarations(): IChangeSet<LoopState>;
-    createCurrentValueInputBasedOnInputMap(): IChangeSet<LoopState>;
-    syncFixedBodyArgumentDeclarations(): IChangeSet<LoopState>;
-    syncInputMaps(): IChangeSet<LoopState>;
+    syncTerminationStatements(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    syncBodyInputIndexes(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    syncBodyArgumentsDeclarations(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    syncOutputsDeclarations(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    syncOutputMaps(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    createCurrentIterationNumberArgumentDeclaration(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    removeExtraBodyArgumentDeclarations(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    createCurrentValueInputBasedOnInputMap(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    syncFixedBodyArgumentDeclarations(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    syncInputMaps(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
     getCurrentValueBuiltInValueDescriptor(): ValueDescriptorState | null;
     getCurrentIterationNumberBuiltInValueDescriptor(): ValueDescriptorState;
-    syncBody(): IChangeSet<LoopState>;
-    syncChildren(): IChangeSet<LoopState>;
+    syncBody(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
+    syncChildren(changeSet?: ChangeSet | null): IChangeSet<LoopState>;
 }
 export type LoopPayloadUnion = LoopState | LoopTypesUnion;

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

@@ -2158,8 +2158,6 @@ export declare function getLoopSchema(): z.ZodObject<z.objectUtil.extendShape<z.
         type: EntityType.OutputMap;
     };
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2278,6 +2276,8 @@ export declare function getLoopSchema(): z.ZodObject<z.objectUtil.extendShape<z.
         entityType: EntityType.ContinueStatement;
         entityId: string;
     })[];
+    x: number;
+    y: number;
     outputsDeclarations: ({
         type: EntityType.ValueDescriptor;
     } | Record<string, any>)[];
@@ -2414,8 +2414,6 @@ export declare function getLoopSchema(): z.ZodObject<z.objectUtil.extendShape<z.
         type: EntityType.OutputMap;
     };
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2534,6 +2532,8 @@ export declare function getLoopSchema(): z.ZodObject<z.objectUtil.extendShape<z.
         entityType: EntityType.ContinueStatement;
         entityId: string;
     })[];
+    x: number;
+    y: number;
     outputsDeclarations: ({
         type: EntityType.ValueDescriptor;
     } | Record<string, any>)[];

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

@@ -1,15 +1,19 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IOperation, IOperationGenerationTarget, IOperationReference, IOperationShallowTransfer, IOperationTransfer, OperationTypesUnion, EntityVersion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate } from '../base';
 import { ActionDescriptorState } from '../action-descriptor/action-descriptor';
 import { ActionInputMapState } from '../input-map';
 import { ActionOutputMapState } from '../output-map';
-import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState, ValueReadingEntityState } from '../types';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueReadingEntityState } 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 OperationState extends VersionedState implements IOperation, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare enum OperationDependencyField {
+    Parent = "parent"
+}
+export declare class OperationState extends VersionedState implements IOperation, BaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: IOperation | IOperationTransfer;
     readonly id: EntityId;
     x: number;
@@ -28,9 +32,14 @@ export declare class OperationState extends VersionedState implements IOperation
     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: IOperation | IOperationTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.Operation;
@@ -58,12 +67,21 @@ export declare class OperationState extends VersionedState implements IOperation
         errors: EntityGenerationError[];
         modifiedData: Partial<IOperationGenerationTarget>;
     };
+    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(): OperationState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<OperationState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<OperationState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<OperationState>>;
     hydrateAncestors(): IChangeSet<OperationState>;
-    afterAllChildrenInitialized(): IChangeSet<OperationState>;
-    addSelfToProject(): IChangeSet<OperationState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
     get calledBy(): CallerEntityState[];
     removeInput(input: ActionInputMapState): OperationState;
     addInput(input: ActionInputMapState): OperationState;
@@ -71,38 +89,29 @@ export declare class OperationState extends VersionedState implements IOperation
     removeOutput(output: ActionOutputMapState): OperationState;
     addValueReader(entity: ValueReadingEntityState): OperationState;
     removeValueReader(valueReader: ValueReadingEntityState): OperationState;
-    addSuccessCaller(caller: PassThroughCallableEntityState): OperationState;
-    addErrorCaller(caller: PassThroughCallableEntityState): OperationState;
-    addEntryCaller(caller: EntryPointEntityState): OperationState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): OperationState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): OperationState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): OperationState;
     addErrorCall(call: CallableEntityState): OperationState;
     addSuccessCall(call: CallableEntityState): OperationState;
     removeCall(call: CallableEntityState): OperationState;
-    removeCaller(caller: CallerEntityState): OperationState;
-    setParent(parent: EntityWithLogicScopeState | ProjectState): OperationState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): OperationState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): OperationState;
     setDeclaration(declaration: ActionDescriptorState): OperationState;
-    initChildren(): OperationState;
+    initChildren(changeSet?: ChangeSet | null): OperationState;
     subscribe(): OperationState;
     unsubscribe(): OperationState;
-    sync(data: Partial<IOperation | IOperationTransfer | IOperationShallowTransfer>): OperationState;
+    metaSync(data: Partial<IOperation | IOperationTransfer | IOperationShallowTransfer>, changeSet?: ChangeSet | null): OperationState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OperationState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IOperationShallowTransfer | 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>): IOperationTransfer | IOperationReference;
@@ -121,9 +130,9 @@ export declare class OperationState extends VersionedState implements IOperation
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
     clone(parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): OperationState;
-    removeUnrecognizedInputs(): IChangeSet<OperationState>;
-    removeUnrecognizedOutputs(): IChangeSet<OperationState>;
-    syncMissingFixedInputs(): IChangeSet<OperationState>;
-    syncMissingFixedOutputs(): IChangeSet<OperationState>;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    removeUnrecognizedOutputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    syncMissingFixedInputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
+    syncMissingFixedOutputs(changeSet?: ChangeSet | null): IChangeSet<OperationState>;
 }
 export type OperationPayloadUnion = OperationState | OperationTypesUnion;

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

@@ -2142,8 +2142,6 @@ export declare function getOperationSchema(): z.ZodObject<z.objectUtil.extendSha
         type: EntityType.OutputMap;
     })[];
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2271,6 +2269,8 @@ export declare function getOperationSchema(): z.ZodObject<z.objectUtil.extendSha
     } | {
         type: EntityType.VariableInstance;
     })[];
+    x: number;
+    y: number;
 }, {
     id: string;
     type: EntityType.Operation;
@@ -2395,8 +2395,6 @@ export declare function getOperationSchema(): z.ZodObject<z.objectUtil.extendSha
         type: EntityType.OutputMap;
     })[];
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2524,4 +2522,6 @@ export declare function getOperationSchema(): z.ZodObject<z.objectUtil.extendSha
     } | {
         type: EntityType.VariableInstance;
     })[];
+    x: number;
+    y: number;
 }>;

package/dist/tree/state/output-map/output-map.d.ts

@@ -1,8 +1,8 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IActionOutputMap, IActionOutputMapTransfer, IOutputMap, IOutputMapGenerationTarget, IOutputMapReference, IOutputMapShallowTransfer, IOutputMapTransfer, IVariableOutputMap, IVariableOutputMapTransfer, OutputMapParentChildRelation, OutputMapTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, EntityWithValueClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality, ValueWritingEntityClass } from '../base';
+import { BaseState, ChildEntityState, EntityWithValueClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate, ValueWritingEntityClass } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
-import { EntityState, IChangeSet, PassThroughCallableEntityWithOutputsState, ValueReadingEntityState } from '../types';
+import { EntityState, PassThroughCallableEntityWithOutputsState, UserManagedEntityState, ValueReadingEntityState } from '../types';
 import { ProjectState } from '../project/project';
 import { VariableDeclarationState } from '../variable-declaration';
 import { VariableInstanceState } from '../variable-instance';
@@ -12,8 +12,13 @@ import { LiteralValueState } from '../literal-value';
 import { DataTypeState } from '../data-type';
 import { ValueDescriptorState } from '../value-descriptor';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class OutputMapState extends VersionedState implements IOutputMap, UserManagedEntityStateFunctionality, ValueWritingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
+export declare enum OutputMapDependencyField {
+    Declaration = "declaration",
+    DataTypeEntity = "data-type-entity"
+}
+export declare class OutputMapState extends VersionedState implements IOutputMap, UserManagedEntityStateTemplate, ValueWritingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
     initialData: IOutputMap | IOutputMapTransfer;
     readonly id: EntityId;
     index: number;
@@ -26,9 +31,14 @@ export declare class OutputMapState extends VersionedState implements IOutputMap
     project: ProjectState;
     errors: EntityError[];
     parent: PassThroughCallableEntityWithOutputsState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IOutputMap | IOutputMapTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -57,41 +67,41 @@ export declare class OutputMapState extends VersionedState implements IOutputMap
         errors: EntityGenerationError[];
         modifiedData: Partial<IOutputMapGenerationTarget>;
     };
+    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(): OutputMapState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<OutputMapState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<OutputMapState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<OutputMapState>>;
     hydrateAncestors(): IChangeSet<OutputMapState>;
-    afterAllChildrenInitialized(): IChangeSet<OutputMapState>;
-    addSelfToProject(): IChangeSet<OutputMapState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<OutputMapState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<OutputMapState>;
     addValueReader(entity: ValueReadingEntityState): OutputMapState;
     removeValueReader(valueReader: ValueReadingEntityState): OutputMapState;
-    setParent(parent: PassThroughCallableEntityWithOutputsState): OutputMapState;
+    setParent(parent: PassThroughCallableEntityWithOutputsState, changeSet?: ChangeSet | null): OutputMapState;
     setDataType(dataType: DataTypeState): OutputMapState;
     removeDataType(): OutputMapState;
     setDeclaration(declaration: ReturnDeclarationState | PropertyState | ValueDescriptorState): OutputMapState;
-    initChildren(): OutputMapState;
+    initChildren(changeSet?: ChangeSet | null): OutputMapState;
     subscribe(): OutputMapState;
     unsubscribe(): OutputMapState;
-    sync(data: Partial<IOutputMap | IOutputMapTransfer | IOutputMapShallowTransfer>): OutputMapState;
+    metaSync(data: Partial<IOutputMap | IOutputMapTransfer | IOutputMapShallowTransfer>, changeSet?: ChangeSet | null): OutputMapState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<OutputMapState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IOutputMapShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: OutputMapState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<OutputMapState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IOutputMapTransfer | IOutputMapReference;

package/dist/tree/state/primitive-entity/primitive-entity.d.ts

@@ -34,19 +34,6 @@ export declare class PrimitiveEntityState extends VersionedState implements Base
     subscribe(): PrimitiveEntityState;
     unsubscribe(): PrimitiveEntityState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<PrimitiveEntityState>;
-    remove({ ignoreUpstream: _, seenEntities: _1, }?: {
-        ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities: _ }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: PrimitiveEntityState;
-    };
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IPrimitiveEntityTransfer | IPrimitiveEntityReference;

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

@@ -1,6 +1,6 @@
 import { EntityId, EntityType, IProject, IDefinitionEntity, IFunctionDeclaration, IGlobalEvent, Element, IProjectTransfer, IGenericReference, ElementTransfer, Reference, IProjectReference, IFunctionCallTransfer, IDefinitionEntityTransfer, IFunctionDeclarationTransfer, IInstalledProjectTransfer, IVariableDeclarationTransfer, IProjectShallowTransfer, ElementShallowTransfer, ElementGenerationTarget, IProjectGenerationTarget, IConditionTransfer, IOperationTransfer, ProjectTypesUnion, EntityVersion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
+import { BaseState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { FunctionDeclarationState } from '../function-declaration';
 import { GlobalEventState } from '../global-event';
 import { DefinitionEntityState } from '../definition-entity';
@@ -9,7 +9,7 @@ import { VariableDeclarationState } from '../variable-declaration';
 import { ConditionState } from '../condition';
 import { FunctionCallState } from '../function-call';
 import { OperationState } from '../operation';
-import { DataTypeState, EntityState, EntryPointEntityState, PrimitiveEntityState, VariableState } from '..';
+import { ChangeSet, DataTypeState, EntityState, EntryPointEntityState, IChangeSet, PrimitiveEntityState, VariableState } from '..';
 import { LoopState } from '../loop';
 import { SearchState } from '../search';
 import { VariableInstanceState } from '../variable-instance';
@@ -17,7 +17,7 @@ import { BuiltInBaseEntityState } from '../built-in-base-entity';
 import { EntityError, EntityGenerationError } from '../error';
 import { ActionDescriptorState } from '../action-descriptor';
 import { ValueDescriptorState } from '../value-descriptor';
-import { IChangeSet, IModuleInjection } from '../types';
+import { IModuleInjection, UserManagedEntityState } from '../types';
 import { VersionedState } from '../version';
 
 export interface UUIDModule {
@@ -25,7 +25,7 @@ export interface UUIDModule {
     uuid: () => string;
     fromUUID: (uuid: string) => string;
 }
-export declare class ProjectState extends VersionedState implements IProject, UserManagedEntityStateFunctionality, BaseState {
+export declare class ProjectState extends VersionedState implements IProject, UserManagedEntityStateTemplate, BaseState {
     initialData: IProject | IProjectTransfer;
     readonly id: EntityId;
     type: EntityType.Project;
@@ -55,17 +55,26 @@ export declare class ProjectState extends VersionedState implements IProject, Us
     dataTypes: DataTypeState[];
     project: ProjectState;
     instances: {
-        [id: string]: EntityState;
+        [id: EntityId]: EntityState;
     };
     builtInInstances: {
-        [id: string]: EntityState;
+        [id: EntityId]: EntityState;
+    };
+    deletedInstances: {
+        [id: EntityId]: EntityState;
     };
     errors: EntityError[];
     references: IGenericReference[];
-    history: Record<EntityId, EntityVersion>;
+    history: ChangeSet[];
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
+    onCloseChangeSetCallback: ((changeSet: ChangeSet | null) => void) | null;
     constructor(initialData: IProject | IProjectTransfer);
     static UUID: UUIDModule;
     static injectUUIDModule(module: UUIDModule): void;
@@ -90,6 +99,10 @@ export declare class ProjectState extends VersionedState implements IProject, Us
         errors: EntityGenerationError[];
         modifiedData: IProjectGenerationTarget;
     };
+    onCloseChangeSet(callback: (changeSet: ChangeSet | null) => void): void;
+    closeChangeSet(changeSet: ChangeSet | null): void;
+    addChangeSet(changeSet: ChangeSet): ChangeSet;
+    discardChangeSet(changeSet: ChangeSet | null): ProjectState;
     undo(): IChangeSet<ProjectState>;
     redo(): IChangeSet<ProjectState>;
     inject(...injectedModules: IModuleInjection[]): Promise<ProjectState>;
@@ -97,31 +110,41 @@ export declare class ProjectState extends VersionedState implements IProject, Us
         errors: EntityGenerationError[];
         modifiedData: Partial<IProjectGenerationTarget>;
     };
+    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(): ProjectState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ProjectState>;
+    recursiveCaptureUpstreamVersions(_sharedTimestamp: null | string): IChangeSet<ProjectState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ProjectState>>;
     hydrateAncestors(): IChangeSet<ProjectState>;
-    afterAllChildrenInitialized(): IChangeSet<ProjectState>;
-    addSelfToProject(): IChangeSet<ProjectState>;
+    afterAllChildrenInitialized(_changeSet?: ChangeSet | null): IChangeSet<ProjectState>;
+    addSelfToProject(_changeSet: ChangeSet | null): IChangeSet<ProjectState>;
     get instancesList(): EntityState[];
     isOperationDeclaration(entity: ActionDescriptorState): boolean;
     isGlobalEventActionDescriptor(entity: ActionDescriptorState): boolean;
     isLoopDeclaration(entity: ActionDescriptorState): boolean;
     isConditionDeclaration(entity: ActionDescriptorState): boolean;
-    initChildren(): ProjectState;
+    initChildren(changeSet?: ChangeSet | null): ProjectState;
     subscribeInstance(instance: EntityState): ProjectState;
+    subscribeDeletedInstance(instance: EntityState): ProjectState;
     subscribeBuiltInInstance(instance: EntityState): ProjectState;
     subscribe(): ProjectState;
     unsubscribe(): ProjectState;
     unsubscribeInstance(entity: EntityState): ProjectState;
-    findSubscribedInstance(entity: Element | ElementTransfer): EntityState | null;
+    unsubscribeDeletedInstance(entity: EntityState): ProjectState;
     findSubscribedBuiltInInstance(entity: Element | ElementTransfer): EntityState | null;
     get(entityId: EntityId): EntityState | null;
     getManaged(entityId: EntityId): EntityState | null;
     getBuiltIn(entityId: EntityId): EntityState | null;
     findSubscribedInstanceFromReference(entity: Reference): EntityState | null;
     findSubscribedBuiltInInstanceFromReference(entity: Reference): EntityState | null;
-    sync(data: Partial<(IProject & {
+    metaSync(data: Partial<(IProject & {
         x: number;
         y: number;
     }) | (IProjectTransfer & {
@@ -130,7 +153,7 @@ export declare class ProjectState extends VersionedState implements IProject, Us
     }) | (IProjectShallowTransfer & {
         x: number;
         y: number;
-    })>): ProjectState;
+    })>, changeSet?: ChangeSet | null): ProjectState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
@@ -139,16 +162,8 @@ export declare class ProjectState extends VersionedState implements IProject, Us
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IProjectShallowTransfer | null>;
     remove({ ignoreUpstream: _ }?: {
         ignoreUpstream: boolean;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities: _ }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: EntityState;
-    };
+    }, _changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, _changeSet?: ChangeSet | null): IChangeSet<ProjectState>;
     getAllBuiltInIds(): EntityId[];
     getAllBuiltIn(): EntityState[];
     toFlat(seenEntities?: Set<EntityId>): EntityState[];