@lionweb/class-core 0.8.0-beta.6 → 0.8.0-beta.7

package/src/base-types.ts

@@ -48,7 +48,7 @@ import {
 
 /**
  * Encodes how a {@link INodeBase} is contained by a parent.
- * If the {@code containingFeature} is {@code null}, the {@link INodeBase} is an annotation
+ * If the `containingFeature` is `null`, the {@link INodeBase} is an annotation
  * and effectively contained by the {@link INodeBase.annotations} property.
  */
 export type Parentage = [ parent: INodeBase, containingFeature: Containment | null ];
@@ -66,7 +66,7 @@ export interface INodeBase extends Node {
 
     /**
      * The parent of this node object,
-     * or {@code undefined} if it's either a root (in which case it {@code this.classifier} should be a {@link Concept} which is a partition)
+     * or `undefined` if it's either a root (in which case it `this.classifier` should be a {@link Concept} which is a partition)
      *  or (currently/temporarily) an orphan.
      */
     parent: INodeBase | undefined;
@@ -107,7 +107,7 @@ export interface INodeBase extends Node {
      * @return the value manager for the given {@link Reference reference} feature.
      * @throws if this node('s {@link Classifier classifier}) doesn't have that reference.
      */
-    getReferenceValueManager(reference: Reference): ReferenceValueManager<INodeBase>;
+    getReferenceValueManager(reference: Reference): ReferenceValueManager<Node>;
 
     /**
      * @return the value manager for the given {@link Feature feature}.
@@ -247,7 +247,7 @@ export abstract class NodeBase implements INodeBase {
         throw new Error(`containment (feature) "${containment.name}" (with key=${containment.key}) doesn't exist on ${this.locationMessage}`);
     }
 
-    getReferenceValueManager(reference: Reference): ReferenceValueManager<INodeBase> {
+    getReferenceValueManager(reference: Reference): ReferenceValueManager<Node> {
         throw new Error(`reference (feature) "${reference.name}" (with key=${reference.key}) doesn't exist on ${this.locationMessage}`);
     }
 

package/src/deltas/appliers.ts

@@ -32,7 +32,6 @@ import {
     ChildMovedFromOtherContainmentInSameParentDelta,
     ChildMovedInSameContainmentDelta,
     ChildReplacedDelta,
-    CompositeDelta,
     NoOpDelta,
     PartitionAddedDelta,
     PartitionDeletedDelta,
@@ -51,7 +50,7 @@ import {
 } from "../value-managers/index.js"
 import { INodeBase } from "../base-types.js"
 import { IdMapping } from "../id-mapping.js"
-import { isUnresolvedReference, referenceToSet, SingleRef } from "@lionweb/core"
+import { isUnresolvedReference, Node, referenceToSet, SingleRef } from "@lionweb/core"
 import { IDelta } from "./base.js"
 
 
@@ -70,24 +69,21 @@ const deltaApplier = (idMapping?: IdMapping, updatablePartitions?: () => INodeBa
             if (idMapping === undefined) {
                 return node
             }
-            const lookup = idMapping.fromId(node.id);
-            if (lookup === undefined) {
-                throw new Error(`look up of node with id=${node.id} failed: node doesn't exist in ID mapping`);
-            }
+            const lookup = idMapping.nodeBaseFromId(node.id);
             if (node.classifier !== lookup.classifier) {
                 throw new Error(`look up of node with id=${node.id} failed: looked-up node has a different classifier than the original one`);
             }
             return lookup;
         };
 
-        const lookupNodeRefFrom = <T extends INodeBase>(nodeRef: SingleRef<T>): SingleRef<T> => {
+        const lookupNodeRefFrom = <T extends Node>(nodeRef: SingleRef<T>): SingleRef<T> => {
             if (idMapping === undefined) {
                 return nodeRef
             }
             if (isUnresolvedReference(nodeRef)) {
                 return referenceToSet()
             }
-            return lookupNodeFrom(nodeRef) as SingleRef<T>
+            return idMapping.fromRefId(nodeRef.id) as SingleRef<T>;
         }
 
         const applyDelta = (delta: IDelta): void => {
@@ -313,38 +309,39 @@ const deltaApplier = (idMapping?: IdMapping, updatablePartitions?: () => INodeBa
             }
             if (delta instanceof ReferenceAddedDelta) {
                 const valueManager = lookupNodeFrom(delta.parent).getReferenceValueManager(delta.reference);
-                const newTarget = lookupNodeRefFrom(delta.newTarget);
+                const newTarget = lookupNodeRefFrom(delta.newReference);
                 if (delta.reference.multiple) {
-                    (valueManager as MultiReferenceValueManager<INodeBase>).insertAtIndexDirectly(newTarget, delta.index);
+                    (valueManager as MultiReferenceValueManager<Node>).insertAtIndexDirectly(newTarget, delta.index);
                 } else {
-                    (valueManager as SingleReferenceValueManager<INodeBase>).setDirectly(newTarget);
+                    (valueManager as SingleReferenceValueManager<Node>).setDirectly(newTarget);
                 }
                 return;
             }
             if (delta instanceof ReferenceDeletedDelta) {
                 const valueManager = lookupNodeFrom(delta.parent).getReferenceValueManager(delta.reference);
                 if (delta.reference.multiple) {
-                    (valueManager as MultiReferenceValueManager<INodeBase>).removeAtIndexDirectly(delta.index); // should be delta.deletedTarget
+                    const multiValueManager = valueManager as MultiReferenceValueManager<Node>;
+                    if (multiValueManager.getDirectly()[delta.index] !== delta.deletedReference) {
+                        throw new Error(`index ${delta.index} doesn’t match deleted reference`)
+                    }
+                    multiValueManager.removeAtIndexDirectly(delta.index);
                 } else {
-                    (valueManager as SingleReferenceValueManager<INodeBase>).setDirectly(undefined);
+                    (valueManager as SingleReferenceValueManager<Node>).setDirectly(undefined);
                 }
                 return;
             }
             if (delta instanceof ReferenceChangedDelta) {
                 const valueManager = lookupNodeFrom(delta.parent).getReferenceValueManager(delta.reference);
-                const newTarget = lookupNodeRefFrom(delta.newTarget);
+                const newTarget = lookupNodeRefFrom(delta.newReference);
                 if (delta.reference.multiple) {
-                    const multiValueManager = valueManager as MultiReferenceValueManager<INodeBase>;
+                    const multiValueManager = valueManager as MultiReferenceValueManager<Node>;
                     multiValueManager.removeAtIndexDirectly(delta.index); // should be delta.oldTarget
                     multiValueManager.insertAtIndexDirectly(newTarget, delta.index);
                 } else {
-                    (valueManager as SingleReferenceValueManager<INodeBase>).setDirectly(newTarget);
+                    (valueManager as SingleReferenceValueManager<Node>).setDirectly(newTarget);
                 }
                 return;
             }
-            if (delta instanceof CompositeDelta) {
-                delta.parts.forEach(applyDelta);
-            }
             if (delta instanceof NoOpDelta) {
                 return;
             }

package/src/deltas/index.ts

@@ -17,7 +17,6 @@
 
 export * from "./appliers.js";
 export * from "./base.js";
-export * from "./compositor.js";
 export * from "./inverters.js";
 export * from "./receivers.js";
 export * from "./types.g.js";

package/src/deltas/inverters.ts

@@ -32,7 +32,6 @@ import {
     ChildMovedFromOtherContainmentInSameParentDelta,
     ChildMovedInSameContainmentDelta,
     ChildReplacedDelta,
-    CompositeDelta,
     NoOpDelta,
     PartitionAddedDelta,
     PartitionDeletedDelta,
@@ -50,99 +49,96 @@ import { IDelta } from "./base.js"
  * @return the inverted version of the given {@link IDelta delta}
  * in the sense that it undoes that delta after it has been applied.
  */
-export const invertDelta = (delta: IDelta): IDelta => {
+export const invertDelta = (delta: IDelta): IDelta[] => {
     if (delta instanceof PartitionAddedDelta) {
-        return new PartitionDeletedDelta(delta.newPartition);
+        return [new PartitionDeletedDelta(delta.newPartition)];
     }
     if (delta instanceof PartitionDeletedDelta) {
-        return new PartitionAddedDelta(delta.deletedPartition);
+        return [new PartitionAddedDelta(delta.deletedPartition)];
     }
     if (delta instanceof PropertyAddedDelta) {
-        return new PropertyDeletedDelta(delta.node, delta.property, delta.value);
+        return [new PropertyDeletedDelta(delta.node, delta.property, delta.value)];
     }
     if (delta instanceof PropertyDeletedDelta) {
-        return new PropertyAddedDelta(delta.node, delta.property, delta.oldValue);
+        return [new PropertyAddedDelta(delta.node, delta.property, delta.oldValue)];
     }
     if (delta instanceof PropertyChangedDelta) {
-        return new PropertyChangedDelta(delta.node, delta.property, delta.newValue, delta.oldValue);
+        return [new PropertyChangedDelta(delta.node, delta.property, delta.newValue, delta.oldValue)];
     }
     if (delta instanceof ChildAddedDelta) {
-        return new ChildDeletedDelta(delta.parent, delta.containment, delta.index, delta.newChild);
+        return [new ChildDeletedDelta(delta.parent, delta.containment, delta.index, delta.newChild)];
     }
     if (delta instanceof ChildDeletedDelta) {
-        return new ChildAddedDelta(delta.parent, delta.containment, delta.index, delta.deletedChild);
+        return [new ChildAddedDelta(delta.parent, delta.containment, delta.index, delta.deletedChild)];
     }
     if (delta instanceof ChildReplacedDelta) {
-        return new ChildReplacedDelta(delta.parent, delta.containment, delta.index, delta.newChild, delta.replacedChild);
+        return [new ChildReplacedDelta(delta.parent, delta.containment, delta.index, delta.newChild, delta.replacedChild)];
     }
     if (delta instanceof ChildMovedFromOtherContainmentDelta) {
-        return new ChildMovedFromOtherContainmentDelta(delta.newParent, delta.newContainment, delta.newIndex, delta.oldParent, delta.oldContainment, delta.oldIndex, delta.movedChild);
+        return [new ChildMovedFromOtherContainmentDelta(delta.newParent, delta.newContainment, delta.newIndex, delta.oldParent, delta.oldContainment, delta.oldIndex, delta.movedChild)];
     }
     if (delta instanceof ChildMovedFromOtherContainmentInSameParentDelta) {
-        return new ChildMovedFromOtherContainmentInSameParentDelta(delta.parent, delta.newContainment, delta.newIndex, delta.movedChild, delta.oldContainment, delta.oldIndex);
+        return [new ChildMovedFromOtherContainmentInSameParentDelta(delta.parent, delta.newContainment, delta.newIndex, delta.movedChild, delta.oldContainment, delta.oldIndex)];
     }
     if (delta instanceof ChildMovedInSameContainmentDelta) {
-        return new ChildMovedInSameContainmentDelta(delta.parent, delta.containment, delta.newIndex, delta.oldIndex, delta.movedChild);
+        return [new ChildMovedInSameContainmentDelta(delta.parent, delta.containment, delta.newIndex, delta.oldIndex, delta.movedChild)];
     }
     if (delta instanceof ChildMovedAndReplacedFromOtherContainmentDelta) {
-        return new CompositeDelta([
+        return [
             new ChildMovedFromOtherContainmentDelta(delta.newParent, delta.newContainment, delta.newIndex, delta.oldParent, delta.oldContainment, delta.oldIndex, delta.movedChild),
             new ChildAddedDelta(delta.newParent, delta.newContainment, delta.newIndex, delta.replacedChild)
-        ]);
+        ];
     }
     if (delta instanceof ChildMovedAndReplacedFromOtherContainmentInSameParentDelta) {
-        return new CompositeDelta([
+        return [
             new ChildMovedFromOtherContainmentInSameParentDelta(delta.parent, delta.newContainment, delta.newIndex, delta.movedChild, delta.oldContainment, delta.oldIndex),
             new ChildAddedDelta(delta.parent, delta.newContainment, delta.newIndex, delta.replacedChild)
-        ]);
+        ];
     }
     if (delta instanceof ChildMovedAndReplacedInSameContainmentDelta) {
-        return new CompositeDelta([
+        return [
             new ChildMovedInSameContainmentDelta(delta.parent, delta.containment, delta.newIndex, delta.oldIndex, delta.movedChild),
             new ChildAddedDelta(delta.parent, delta.containment, delta.newIndex, delta.replacedChild)
-        ]);
+        ];
     }
     if (delta instanceof AnnotationAddedDelta) {
-        return new AnnotationDeletedDelta(delta.parent, delta.index, delta.newAnnotation);
+        return [new AnnotationDeletedDelta(delta.parent, delta.index, delta.newAnnotation)];
     }
     if (delta instanceof AnnotationDeletedDelta) {
-        return new AnnotationAddedDelta(delta.parent, delta.index, delta.deletedAnnotation);
+        return [new AnnotationAddedDelta(delta.parent, delta.index, delta.deletedAnnotation)];
     }
     if (delta instanceof AnnotationReplacedDelta) {
-        return new AnnotationReplacedDelta(delta.parent, delta.index, delta.newAnnotation, delta.replacedAnnotation);
+        return [new AnnotationReplacedDelta(delta.parent, delta.index, delta.newAnnotation, delta.replacedAnnotation)];
     }
     if (delta instanceof AnnotationMovedFromOtherParentDelta) {
-        return new AnnotationMovedFromOtherParentDelta(delta.newParent, delta.newIndex, delta.oldParent, delta.oldIndex, delta.movedAnnotation);
+        return [new AnnotationMovedFromOtherParentDelta(delta.newParent, delta.newIndex, delta.oldParent, delta.oldIndex, delta.movedAnnotation)];
     }
     if (delta instanceof AnnotationMovedInSameParentDelta) {
-        return new AnnotationMovedInSameParentDelta(delta.parent, delta.newIndex, delta.oldIndex, delta.movedAnnotation);
+        return [new AnnotationMovedInSameParentDelta(delta.parent, delta.newIndex, delta.oldIndex, delta.movedAnnotation)];
     }
     if (delta instanceof AnnotationMovedAndReplacedFromOtherParentDelta) {
-        return new CompositeDelta([
+        return [
             new AnnotationMovedFromOtherParentDelta(delta.newParent, delta.newIndex, delta.oldParent, delta.oldIndex, delta.movedAnnotation),
             new AnnotationAddedDelta(delta.newParent, delta.newIndex, delta.replacedAnnotation)
-        ]);
+        ];
     }
     if (delta instanceof AnnotationMovedAndReplacedInSameParentDelta) {
-        return new CompositeDelta([
+        return [
             new AnnotationMovedInSameParentDelta(delta.parent, delta.newIndex, delta.oldIndex, delta.movedAnnotation),
             new AnnotationAddedDelta(delta.parent, delta.newIndex, delta.replacedAnnotation)
-        ]);
+        ];
     }
     if (delta instanceof ReferenceAddedDelta) {
-        return new ReferenceDeletedDelta(delta.parent, delta.reference, delta.index, delta.newTarget);
+        return [new ReferenceDeletedDelta(delta.parent, delta.reference, delta.index, delta.newReference)];
     }
     if (delta instanceof ReferenceDeletedDelta) {
-        return new ReferenceAddedDelta(delta.parent, delta.reference, delta.index, delta.deletedTarget);
+        return [new ReferenceAddedDelta(delta.parent, delta.reference, delta.index, delta.deletedReference)];
     }
     if (delta instanceof ReferenceChangedDelta) {
-        return new ReferenceChangedDelta(delta.parent, delta.reference, delta.index, delta.oldTarget, delta.newTarget);
-    }
-    if (delta instanceof CompositeDelta) {
-        return new CompositeDelta(delta.parts.map(invertDelta));
+        return [new ReferenceChangedDelta(delta.parent, delta.reference, delta.index, delta.oldReference, delta.newReference)];
     }
     if (delta instanceof NoOpDelta) {
-        return delta;
+        return [delta];
     }
 
     throw new Error(`inversion of delta of class ${delta.constructor.name} not implemented`);

package/src/deltas/serialization/base.ts

@@ -15,7 +15,7 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { defaultLionWebVersion } from "@lionweb/core"
+import { LionWebVersions } from "@lionweb/core"
 import { IDelta } from "../base.js"
 import { SerializedDelta } from "./types.g.js"
 import { propertyValueSerializerWith } from "../../serializer.js"
@@ -32,5 +32,5 @@ export type DeltaDeserializer = (delta: SerializedDelta) => IDelta;
  * using the same {@link PropertyValueSerializer} instance as the {@link serializeNodeBases} function,
  * and the same treatment of enumeration values.
  */
-export const defaultPropertyValueSerializer = propertyValueSerializerWith({ primitiveValueSerializer: defaultLionWebVersion.builtinsFacade.propertyValueSerializer })
+export const defaultPropertyValueSerializer = propertyValueSerializerWith({ primitiveValueSerializer: LionWebVersions.v2023_1.builtinsFacade.propertyValueSerializer })
 

package/src/deltas/serialization/deserializer.g.ts

@@ -41,7 +41,6 @@ import {
     ChildMovedFromOtherContainmentInSameParentDelta,
     ChildMovedInSameContainmentDelta,
     ChildReplacedDelta,
-    CompositeDelta,
     NoOpDelta,
     PartitionAddedDelta,
     PartitionDeletedDelta,
@@ -59,187 +58,183 @@ export const deltaDeserializer = (languageBases: ILanguageBase[], idMapping: IdM
     const deserializedDelta = (delta: SerializedDelta): IDelta => {
         switch (delta.kind) {
             case "PartitionAdded": {
-                const newPartition = idMapping.fromId(delta.newPartition);
+                const newPartition = idMapping.nodeBaseFromId(delta.newPartition);
                 return new PartitionAddedDelta(newPartition);
             }
             case "PartitionDeleted": {
-                const deletedPartition = idMapping.fromId(delta.deletedPartition);
+                const deletedPartition = idMapping.nodeBaseFromId(delta.deletedPartition);
                 return new PartitionDeletedDelta(deletedPartition);
             }
             case "PropertyAdded": {
-                const node = idMapping.fromId(delta.node);
+                const node = idMapping.nodeBaseFromId(delta.node);
                 const property = resolvedPropertyFrom(delta.property, node.classifier);
                 const value = delta.value;
                 return new PropertyAddedDelta(node, property, value);
             }
             case "PropertyDeleted": {
-                const node = idMapping.fromId(delta.node);
+                const node = idMapping.nodeBaseFromId(delta.node);
                 const property = resolvedPropertyFrom(delta.property, node.classifier);
                 const oldValue = delta.oldValue;
                 return new PropertyDeletedDelta(node, property, oldValue);
             }
             case "PropertyChanged": {
-                const node = idMapping.fromId(delta.node);
+                const node = idMapping.nodeBaseFromId(delta.node);
                 const property = resolvedPropertyFrom(delta.property, node.classifier);
                 const oldValue = delta.oldValue;
                 const newValue = delta.newValue;
                 return new PropertyChangedDelta(node, property, oldValue, newValue);
             }
             case "ChildAdded": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const containment = resolvedContainmentFrom(delta.containment, parent.classifier);
                 const index = delta.index;
-                const newChild = idMapping.fromId(delta.newChild);
+                const newChild = idMapping.nodeBaseFromId(delta.newChild);
                 return new ChildAddedDelta(parent, containment, index, newChild);
             }
             case "ChildDeleted": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const containment = resolvedContainmentFrom(delta.containment, parent.classifier);
                 const index = delta.index;
-                const deletedChild = idMapping.fromId(delta.deletedChild);
+                const deletedChild = idMapping.nodeBaseFromId(delta.deletedChild);
                 return new ChildDeletedDelta(parent, containment, index, deletedChild);
             }
             case "ChildReplaced": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const containment = resolvedContainmentFrom(delta.containment, parent.classifier);
                 const index = delta.index;
-                const replacedChild = idMapping.fromId(delta.replacedChild);
-                const newChild = idMapping.fromId(delta.newChild);
+                const replacedChild = idMapping.nodeBaseFromId(delta.replacedChild);
+                const newChild = idMapping.nodeBaseFromId(delta.newChild);
                 return new ChildReplacedDelta(parent, containment, index, replacedChild, newChild);
             }
             case "ChildMovedFromOtherContainment": {
-                const oldParent = idMapping.fromId(delta.oldParent);
+                const oldParent = idMapping.nodeBaseFromId(delta.oldParent);
                 const oldContainment = resolvedContainmentFrom(delta.oldContainment, oldParent.classifier);
                 const oldIndex = delta.oldIndex;
-                const newParent = idMapping.fromId(delta.newParent);
+                const newParent = idMapping.nodeBaseFromId(delta.newParent);
                 const newContainment = resolvedContainmentFrom(delta.newContainment, newParent.classifier);
                 const newIndex = delta.newIndex;
-                const movedChild = idMapping.fromId(delta.movedChild);
+                const movedChild = idMapping.nodeBaseFromId(delta.movedChild);
                 return new ChildMovedFromOtherContainmentDelta(oldParent, oldContainment, oldIndex, newParent, newContainment, newIndex, movedChild);
             }
             case "ChildMovedFromOtherContainmentInSameParent": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const oldContainment = resolvedContainmentFrom(delta.oldContainment, parent.classifier);
                 const oldIndex = delta.oldIndex;
-                const movedChild = idMapping.fromId(delta.movedChild);
+                const movedChild = idMapping.nodeBaseFromId(delta.movedChild);
                 const newContainment = resolvedContainmentFrom(delta.newContainment, parent.classifier);
                 const newIndex = delta.newIndex;
                 return new ChildMovedFromOtherContainmentInSameParentDelta(parent, oldContainment, oldIndex, movedChild, newContainment, newIndex);
             }
             case "ChildMovedInSameContainment": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const containment = resolvedContainmentFrom(delta.containment, parent.classifier);
                 const oldIndex = delta.oldIndex;
                 const newIndex = delta.newIndex;
-                const movedChild = idMapping.fromId(delta.movedChild);
+                const movedChild = idMapping.nodeBaseFromId(delta.movedChild);
                 return new ChildMovedInSameContainmentDelta(parent, containment, oldIndex, newIndex, movedChild);
             }
             case "ChildMovedAndReplacedFromOtherContainment": {
-                const newParent = idMapping.fromId(delta.newParent);
+                const newParent = idMapping.nodeBaseFromId(delta.newParent);
                 const newContainment = resolvedContainmentFrom(delta.newContainment, newParent.classifier);
                 const newIndex = delta.newIndex;
-                const movedChild = idMapping.fromId(delta.movedChild);
-                const oldParent = idMapping.fromId(delta.oldParent);
+                const movedChild = idMapping.nodeBaseFromId(delta.movedChild);
+                const oldParent = idMapping.nodeBaseFromId(delta.oldParent);
                 const oldContainment = resolvedContainmentFrom(delta.oldContainment, oldParent.classifier);
                 const oldIndex = delta.oldIndex;
-                const replacedChild = idMapping.fromId(delta.replacedChild);
+                const replacedChild = idMapping.nodeBaseFromId(delta.replacedChild);
                 return new ChildMovedAndReplacedFromOtherContainmentDelta(newParent, newContainment, newIndex, movedChild, oldParent, oldContainment, oldIndex, replacedChild);
             }
             case "ChildMovedAndReplacedFromOtherContainmentInSameParent": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const oldContainment = resolvedContainmentFrom(delta.oldContainment, parent.classifier);
                 const oldIndex = delta.oldIndex;
                 const newContainment = resolvedContainmentFrom(delta.newContainment, parent.classifier);
                 const newIndex = delta.newIndex;
-                const movedChild = idMapping.fromId(delta.movedChild);
-                const replacedChild = idMapping.fromId(delta.replacedChild);
+                const movedChild = idMapping.nodeBaseFromId(delta.movedChild);
+                const replacedChild = idMapping.nodeBaseFromId(delta.replacedChild);
                 return new ChildMovedAndReplacedFromOtherContainmentInSameParentDelta(parent, oldContainment, oldIndex, newContainment, newIndex, movedChild, replacedChild);
             }
             case "ChildMovedAndReplacedInSameContainment": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const containment = resolvedContainmentFrom(delta.containment, parent.classifier);
                 const oldIndex = delta.oldIndex;
                 const newIndex = delta.newIndex;
-                const movedChild = idMapping.fromId(delta.movedChild);
-                const replacedChild = idMapping.fromId(delta.replacedChild);
+                const movedChild = idMapping.nodeBaseFromId(delta.movedChild);
+                const replacedChild = idMapping.nodeBaseFromId(delta.replacedChild);
                 return new ChildMovedAndReplacedInSameContainmentDelta(parent, containment, oldIndex, newIndex, movedChild, replacedChild);
             }
             case "AnnotationAdded": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const index = delta.index;
-                const newAnnotation = idMapping.fromId(delta.newAnnotation);
+                const newAnnotation = idMapping.nodeBaseFromId(delta.newAnnotation);
                 return new AnnotationAddedDelta(parent, index, newAnnotation);
             }
             case "AnnotationDeleted": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const index = delta.index;
-                const deletedAnnotation = idMapping.fromId(delta.deletedAnnotation);
+                const deletedAnnotation = idMapping.nodeBaseFromId(delta.deletedAnnotation);
                 return new AnnotationDeletedDelta(parent, index, deletedAnnotation);
             }
             case "AnnotationReplaced": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const index = delta.index;
-                const replacedAnnotation = idMapping.fromId(delta.replacedAnnotation);
-                const newAnnotation = idMapping.fromId(delta.newAnnotation);
+                const replacedAnnotation = idMapping.nodeBaseFromId(delta.replacedAnnotation);
+                const newAnnotation = idMapping.nodeBaseFromId(delta.newAnnotation);
                 return new AnnotationReplacedDelta(parent, index, replacedAnnotation, newAnnotation);
             }
             case "AnnotationMovedFromOtherParent": {
-                const oldParent = idMapping.fromId(delta.oldParent);
+                const oldParent = idMapping.nodeBaseFromId(delta.oldParent);
                 const oldIndex = delta.oldIndex;
-                const newParent = idMapping.fromId(delta.newParent);
+                const newParent = idMapping.nodeBaseFromId(delta.newParent);
                 const newIndex = delta.newIndex;
-                const movedAnnotation = idMapping.fromId(delta.movedAnnotation);
+                const movedAnnotation = idMapping.nodeBaseFromId(delta.movedAnnotation);
                 return new AnnotationMovedFromOtherParentDelta(oldParent, oldIndex, newParent, newIndex, movedAnnotation);
             }
             case "AnnotationMovedInSameParent": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const oldIndex = delta.oldIndex;
                 const newIndex = delta.newIndex;
-                const movedAnnotation = idMapping.fromId(delta.movedAnnotation);
+                const movedAnnotation = idMapping.nodeBaseFromId(delta.movedAnnotation);
                 return new AnnotationMovedInSameParentDelta(parent, oldIndex, newIndex, movedAnnotation);
             }
             case "AnnotationMovedAndReplacedFromOtherParent": {
-                const oldParent = idMapping.fromId(delta.oldParent);
+                const oldParent = idMapping.nodeBaseFromId(delta.oldParent);
                 const oldIndex = delta.oldIndex;
-                const replacedAnnotation = idMapping.fromId(delta.replacedAnnotation);
-                const newParent = idMapping.fromId(delta.newParent);
+                const replacedAnnotation = idMapping.nodeBaseFromId(delta.replacedAnnotation);
+                const newParent = idMapping.nodeBaseFromId(delta.newParent);
                 const newIndex = delta.newIndex;
-                const movedAnnotation = idMapping.fromId(delta.movedAnnotation);
+                const movedAnnotation = idMapping.nodeBaseFromId(delta.movedAnnotation);
                 return new AnnotationMovedAndReplacedFromOtherParentDelta(oldParent, oldIndex, replacedAnnotation, newParent, newIndex, movedAnnotation);
             }
             case "AnnotationMovedAndReplacedInSameParent": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const oldIndex = delta.oldIndex;
                 const newIndex = delta.newIndex;
-                const replacedAnnotation = idMapping.fromId(delta.replacedAnnotation);
-                const movedAnnotation = idMapping.fromId(delta.movedAnnotation);
+                const replacedAnnotation = idMapping.nodeBaseFromId(delta.replacedAnnotation);
+                const movedAnnotation = idMapping.nodeBaseFromId(delta.movedAnnotation);
                 return new AnnotationMovedAndReplacedInSameParentDelta(parent, oldIndex, newIndex, replacedAnnotation, movedAnnotation);
             }
             case "ReferenceAdded": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const reference = resolvedReferenceFrom(delta.reference, parent.classifier);
                 const index = delta.index;
-                const newTarget = idMapping.fromRefId(delta.newTarget);
-                return new ReferenceAddedDelta(parent, reference, index, newTarget);
+                const newReference = idMapping.fromRefId(delta.newReference);
+                return new ReferenceAddedDelta(parent, reference, index, newReference);
             }
             case "ReferenceDeleted": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const reference = resolvedReferenceFrom(delta.reference, parent.classifier);
                 const index = delta.index;
-                const deletedTarget = idMapping.fromRefId(delta.deletedTarget);
-                return new ReferenceDeletedDelta(parent, reference, index, deletedTarget);
+                const deletedReference = idMapping.fromRefId(delta.deletedReference);
+                return new ReferenceDeletedDelta(parent, reference, index, deletedReference);
             }
             case "ReferenceChanged": {
-                const parent = idMapping.fromId(delta.parent);
+                const parent = idMapping.nodeBaseFromId(delta.parent);
                 const reference = resolvedReferenceFrom(delta.reference, parent.classifier);
                 const index = delta.index;
-                const newTarget = idMapping.fromRefId(delta.newTarget);
-                const oldTarget = idMapping.fromRefId(delta.oldTarget);
-                return new ReferenceChangedDelta(parent, reference, index, newTarget, oldTarget);
-            }
-            case "Composite": {
-                const parts = delta.parts.map(deserializedDelta);
-                return new CompositeDelta(parts);
+                const newReference = idMapping.fromRefId(delta.newReference);
+                const oldReference = idMapping.fromRefId(delta.oldReference);
+                return new ReferenceChangedDelta(parent, reference, index, newReference, oldReference);
             }
             case "NoOp": {
                 return new NoOpDelta();

package/src/deltas/serialization/serializer.g.ts

@@ -37,7 +37,6 @@ import {
     ChildMovedFromOtherContainmentInSameParentDelta,
     ChildMovedInSameContainmentDelta,
     ChildReplacedDelta,
-    CompositeDelta,
     NoOpDelta,
     PartitionAddedDelta,
     PartitionDeletedDelta,
@@ -65,7 +64,6 @@ import {
     ChildMovedFromOtherContainmentSerializedDelta,
     ChildMovedInSameContainmentSerializedDelta,
     ChildReplacedSerializedDelta,
-    CompositeSerializedDelta,
     NoOpSerializedDelta,
     PartitionAddedSerializedDelta,
     PartitionDeletedSerializedDelta,
@@ -323,7 +321,7 @@ export const serializeDelta = (delta: IDelta): SerializedDelta => {
             parent: delta.parent.id,
             reference: metaPointerFor(delta.reference),
             index: delta.index,
-            newTarget: idFrom(delta.newTarget)
+            newReference: idFrom(delta.newReference)
         } as ReferenceAddedSerializedDelta;
     }
 
@@ -333,7 +331,7 @@ export const serializeDelta = (delta: IDelta): SerializedDelta => {
             parent: delta.parent.id,
             reference: metaPointerFor(delta.reference),
             index: delta.index,
-            deletedTarget: idFrom(delta.deletedTarget)
+            deletedReference: idFrom(delta.deletedReference)
         } as ReferenceDeletedSerializedDelta;
     }
 
@@ -343,18 +341,11 @@ export const serializeDelta = (delta: IDelta): SerializedDelta => {
             parent: delta.parent.id,
             reference: metaPointerFor(delta.reference),
             index: delta.index,
-            newTarget: idFrom(delta.newTarget),
-            oldTarget: idFrom(delta.oldTarget)
+            newReference: idFrom(delta.newReference),
+            oldReference: idFrom(delta.oldReference)
         } as ReferenceChangedSerializedDelta;
     }
 
-    if (delta instanceof CompositeDelta) {
-        return {
-            kind: "Composite",
-            parts: delta.parts.map(serializeDelta)
-        } as CompositeSerializedDelta;
-    }
-
     if (delta instanceof NoOpDelta) {
         return {
             kind: "NoOp"