@fluidframework/tree 2.74.0-370705 → 2.80.0

package/dist/feature-libraries/sequence-field/utils.js

@@ -4,7 +4,8 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCrossFieldKeys = exports.withRevision = exports.withNodeChange = exports.omitMarkEffect = exports.extractMarkEffect = exports.splitMarkEffect = exports.splitMark = exports.tryMergeMarks = exports.areMergeableChangeAtoms = exports.isRemoveMark = exports.isPin = exports.isDetach = exports.compareCellsFromSameRevision = exports.areOverlappingIdRanges = exports.isNoopMark = exports.isTombstone = exports.isImpactful = exports.areOutputCellsEmpty = exports.areInputCellsEmpty = exports.markHasCellEffect = exports.markFillsCells = exports.markEmptiesCells = exports.getInputLength = exports.getOutputLength = exports.cloneCellId = exports.cloneMarkEffect = exports.cloneMark = exports.normalizeCellRename = exports.getMovedNodeId = exports.getDetachedRootId = exports.getAttachedRootId = exports.getDetachOutputCellId = exports.compareCellPositionsUsingTombstones = exports.CellOrder = exports.cellSourcesFromMarks = exports.getOutputCellId = exports.getInputCellId = exports.areEqualCellIds = exports.isActiveReattach = exports.isReattachEffect = exports.isReattach = exports.isAttach = exports.isInsert = exports.isRename = exports.isNewAttachEffect = exports.isNewAttach = exports.getNestedChanges = exports.createEmpty = exports.isEmpty = void 0;
+exports.getEndpoint = exports.withRevision = exports.withNodeChange = exports.omitMarkEffect = exports.extractMarkEffect = exports.splitMarkEffect = exports.splitMark = exports.tryMergeMarks = exports.isRemoveMark = exports.isDetach = exports.compareCellsFromSameRevision = exports.areOverlappingIdRanges = exports.isNoopMark = exports.isTombstone = exports.isImpactful = exports.settleMark = exports.areOutputCellsEmpty = exports.areInputCellsEmpty = exports.isImpactfulCellRename = exports.isDetachOfRemovedNodes = exports.isAttachAndDetachEffect = exports.markHasCellEffect = exports.markFillsCells = exports.markEmptiesCells = exports.getInputLength = exports.getOutputLength = exports.cloneCellId = exports.cloneMarkEffect = exports.cloneMark = exports.asAttachAndDetach = exports.normalizeCellRename = exports.getDetachedNodeId = exports.getDetachOutputCellId = exports.compareCellPositionsUsingTombstones = exports.CellOrder = exports.cellSourcesFromMarks = exports.getOutputCellId = exports.getInputCellId = exports.areEqualCellIds = exports.isActiveReattach = exports.isReattachEffect = exports.isReattach = exports.isAttach = exports.isInsert = exports.isRename = exports.isNewAttachEffect = exports.isNewAttach = exports.getNestedChanges = exports.createEmpty = exports.isEmpty = void 0;
+exports.getCrossFieldKeys = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../core/index.js");
 const index_js_2 = require("../../util/index.js");
@@ -26,14 +27,22 @@ exports.createEmpty = createEmpty;
 function getNestedChanges(change) {
     const output = [];
     let inputIndex = 0;
+    let outputIndex = 0;
     for (const mark of change) {
         const { changes, count } = mark;
         if (changes !== undefined) {
-            output.push([changes, inputIndex]);
+            output.push([
+                changes,
+                areInputCellsEmpty(mark) ? undefined : inputIndex /* inputIndex */,
+                areOutputCellsEmpty(mark) ? undefined : outputIndex /* outputIndex */,
+            ]);
         }
         if (!areInputCellsEmpty(mark)) {
             inputIndex += count;
         }
+        if (!areOutputCellsEmpty(mark)) {
+            outputIndex += count;
+        }
     }
     return output;
 }
@@ -43,9 +52,10 @@ function isNewAttach(mark, revision) {
 }
 exports.isNewAttach = isNewAttach;
 function isNewAttachEffect(effect, cellId, revision) {
-    return (isAttach(effect) &&
+    return ((isAttach(effect) &&
         cellId !== undefined &&
-        (effect.revision ?? revision) === (cellId.revision ?? revision));
+        (effect.revision ?? revision) === (cellId.revision ?? revision)) ||
+        (isAttachAndDetachEffect(effect) && isNewAttachEffect(effect.attach, cellId, revision)));
 }
 exports.isNewAttachEffect = isNewAttachEffect;
 function isRename(mark) {
@@ -57,7 +67,7 @@ function isInsert(mark) {
 }
 exports.isInsert = isInsert;
 function isAttach(effect) {
-    return effect.type === "Insert";
+    return effect.type === "Insert" || effect.type === "MoveIn";
 }
 exports.isAttach = isAttach;
 function isReattach(mark) {
@@ -81,19 +91,16 @@ function getInputCellId(mark) {
 }
 exports.getInputCellId = getInputCellId;
 function getOutputCellId(mark) {
-    const type = mark.type;
-    switch (type) {
-        case types_js_1.NoopMarkType:
-            return getInputCellId(mark);
-        case "Insert":
-            return undefined;
-        case "Remove":
-            return getDetachOutputCellId(mark);
-        case "Rename":
-            return mark.idOverride;
-        default:
-            (0, internal_1.unreachableCase)(type);
+    if (isDetach(mark) || isRename(mark)) {
+        return getDetachOutputCellId(mark);
     }
+    else if (markFillsCells(mark)) {
+        return undefined;
+    }
+    else if (isAttachAndDetachEffect(mark)) {
+        return getDetachOutputCellId(mark.detach);
+    }
+    return getInputCellId(mark);
 }
 exports.getOutputCellId = getOutputCellId;
 function cellSourcesFromMarks(marks, contextGetter) {
@@ -146,9 +153,9 @@ function compareCellPositionsUsingTombstones(oldMarkCell, newMarkCell, oldChange
         // If both changesets know of both cells, but we've been asked to compare different cells,
         // Then either the changesets they originate from do not represent the same context,
         // or the ordering of their cells in inconsistent.
-        // The only exception to this is when we're composing anonymous changesets in a transaction.
-        (0, internal_1.assert)(oldMarkCell.revision === undefined && newMarkCell.revision === undefined, 0x8a0 /* Inconsistent cell ordering */);
-        // We are composing anonymous changesets in a transaction. The new changeset is creating a cell in a gap
+        // The only exception to this is when we're composing changesets in a transaction since they have the same revision but different sets of cells.
+        (0, internal_1.assert)(oldMarkCell.revision === newMarkCell.revision, 0x8a0 /* Inconsistent cell ordering */);
+        // We are composing changesets in a transaction. The new changeset is creating a cell in a gap
         // where the old changeset knows of some now empty cell. We order the new cell relative to the old cell in a
         // way that is consistent with its tie-breaking behavior should the old cell be concurrently re-filled.
         // Since only tie-break left is supported at the moment, the new cell comes first.
@@ -178,33 +185,42 @@ function compareCellPositionsUsingTombstones(oldMarkCell, newMarkCell, oldChange
         (0, internal_1.assert)(oldMarkCell.revision !== undefined, 0x8a1 /* Old mark cell should have a revision */);
         // Note that these indices are for ordering the revisions in which the cells were named, not the revisions
         // of the changesets in which the marks targeting these cells appear.
-        const revisionComparison = metadata.compareRevisions(oldMarkCell.revision, newMarkCell.revision);
+        const oldCellRevisionIndex = metadata.getIndex(oldMarkCell.revision);
+        const newCellRevisionIndex = metadata.getIndex(newMarkCell.revision);
         // If the metadata defines an ordering for the revisions then the cell from the newer revision comes first.
-        if (revisionComparison !== 0) {
-            return revisionComparison > 0 ? CellOrder.NewThenOld : CellOrder.OldThenNew;
-        }
-        // While it is possible for both marks to refer to cells that were named in revisions that are outside
-        // the scope of the metadata, such a scenario should be handled above due to the fact that one of the two
-        // changesets should have tombstones or marks for both cells.
-        //
-        // To see this in the context of rebase, we must consider the lowest common ancestor (LCA) of each change's
-        // original (i.e., unrebased) edit with the head of the branch they will both reside on after the rebase.
-        // ...─(Ti)─...─(Tj)─...─(old')─(new') <- branch both change will reside on after rebase
-        //        |        └─...─(new)
-        //        └─...─(old)
-        // In the diagram above we can see that by the time `new` is being rebased over `old`, both changesets have
-        // been rebased over, and therefore have cell information for, changes `Tj` onwards. This means that one of
-        // The two changesets (the `old` one in the diagram above) will have tombstones or marks for any cells that
-        // `new` refers to so long as those cells were not created on `new`'s branch.
-        // Note that the change that contains the superset of cells (again, ignoring cells created on the other
-        // change's branch) is not always the older change. Consider the following scenario:
-        // ...─(Ti)─...─(Tj)─...─(old')─(new')
-        //        |        └─...─(old)
-        //        └─...─(new)
-        //
-        // The same scenario can arise in the context of compose (just consider composing `old'` and `new'` from
-        // the examples above) with the same resolution.
-        (0, internal_1.assert)(false, 0x8a2 /* Invalid cell ordering scenario */);
+        if (newCellRevisionIndex !== undefined && oldCellRevisionIndex !== undefined) {
+            return newCellRevisionIndex > oldCellRevisionIndex
+                ? CellOrder.NewThenOld
+                : CellOrder.OldThenNew;
+        }
+        if (newCellRevisionIndex === undefined && oldCellRevisionIndex === undefined) {
+            // While it is possible for both marks to refer to cells that were named in revisions that are outside
+            // the scope of the metadata, such a scenario should be handled above due to the fact that one of the two
+            // changesets should have tombstones or marks for both cells.
+            //
+            // To see this in the context of rebase, we must consider the lowest common ancestor (LCA) of each change's
+            // original (i.e., unrebased) edit with the head of the branch they will both reside on after the rebase.
+            // ...─(Ti)─...─(Tj)─...─(old')─(new') <- branch both change will reside on after rebase
+            //        |        └─...─(new)
+            //        └─...─(old)
+            // In the diagram above we can see that by the time `new` is being rebased over `old`, both changesets have
+            // been rebased over, and therefore have cell information for, changes `Tj` onwards. This means that one of
+            // The two changesets (the `old` one in the diagram above) will have tombstones or marks for any cells that
+            // `new` refers to so long as those cells were not created on `new`'s branch.
+            // Note that the change that contains the superset of cells (again, ignoring cells created on the other
+            // change's branch) is not always the older change. Consider the following scenario:
+            // ...─(Ti)─...─(Tj)─...─(old')─(new')
+            //        |        └─...─(old)
+            //        └─...─(new)
+            //
+            // The same scenario can arise in the context of compose (just consider composing `old'` and `new'` from
+            // the examples above) with the same resolution.
+            (0, internal_1.assert)(false, 0x8a2 /* Invalid cell ordering scenario */);
+        }
+        // The absence of metadata for a cell with a defined revision means that the cell is from a revision that
+        // predates the edits that are within the scope of the metadata. Such a cell is therefore older than the one
+        // for which we do have metadata.
+        return oldCellRevisionIndex === undefined ? CellOrder.NewThenOld : CellOrder.OldThenNew;
     }
 }
 exports.compareCellPositionsUsingTombstones = compareCellPositionsUsingTombstones;
@@ -212,50 +228,100 @@ exports.compareCellPositionsUsingTombstones = compareCellPositionsUsingTombstone
  * Gets the ID of the cell in the output context of the given detach `mark`.
  */
 function getDetachOutputCellId(mark) {
-    if (mark.cellRename !== undefined) {
-        return mark.cellRename;
+    if (isRename(mark)) {
+        return mark.idOverride;
     }
-    if (mark.detachCellId !== undefined) {
-        return mark.detachCellId;
+    if (mark.idOverride !== undefined) {
+        return mark.idOverride;
     }
-    return getDetachedRootId(mark);
+    return mark.revision === undefined
+        ? { localId: mark.id }
+        : { revision: mark.revision, localId: mark.id };
 }
 exports.getDetachOutputCellId = getDetachOutputCellId;
-/**
- * Gets the ID of the node to be attached in the input context of the given detach `mark`.
- */
-function getAttachedRootId(mark) {
-    return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
-}
-exports.getAttachedRootId = getAttachedRootId;
 /**
  * Gets the ID of the detached node in the output context of the given detach `mark`.
  */
-function getDetachedRootId(mark) {
-    return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
-}
-exports.getDetachedRootId = getDetachedRootId;
-function getMovedNodeId(mark) {
-    return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
+function getDetachedNodeId(mark) {
+    switch (mark.type) {
+        case "Rename":
+        case "Remove": {
+            return getDetachOutputCellId(mark);
+        }
+        case "MoveOut": {
+            return (0, index_js_1.makeChangeAtomId)(mark.id, mark.revision);
+        }
+        default: {
+            (0, internal_1.unreachableCase)(mark);
+        }
+    }
 }
-exports.getMovedNodeId = getMovedNodeId;
+exports.getDetachedNodeId = getDetachedNodeId;
 /**
  * Preserves the semantics of the given `mark` but repackages it into a `DetachOfRemovedNodes` when possible.
  */
 function normalizeCellRename(cellId, count, attach, detach) {
-    const outputId = getDetachOutputCellId(detach);
-    // Note that the output ID may be the same as the cellId. In such a scenario,
-    // we output an (impact-less) Rename mark anyway (as opposed to a Skip)
-    // because the resulting Rename may be rebased over other changes that rename the input cell,
-    // eventually leading to an impactful rename.
+    if (attach.type === "MoveIn") {
+        if (detach.type === "MoveOut") {
+            const outputId = getDetachOutputCellId(detach);
+            // Note that the output ID may be the same as the cellId. In such a scenario,
+            // we output an (impact-less) Rename mark anyway (as opposed to a Skip)
+            // because the resulting Rename may be rebased over other changes that rename the input cell,
+            // eventually leading to an impactful rename.
+            return {
+                type: "Rename",
+                count,
+                cellId,
+                idOverride: outputId,
+            };
+        }
+    }
+    else {
+        // Normalization: when the attach is an insert/revive, we rely on the implicit reviving semantics of the
+        // detach instead of using an explicit revive effect in an AttachAndDetach
+        return {
+            ...detach,
+            count,
+            cellId,
+        };
+    }
     return {
-        type: "Rename",
+        type: "AttachAndDetach",
+        attach,
+        detach,
         count,
         cellId,
-        idOverride: outputId,
     };
 }
 exports.normalizeCellRename = normalizeCellRename;
+/**
+ * Preserves the semantics of the given `mark` but repackages it into an `AttachAndDetach` mark if it is not already one.
+ */
+function asAttachAndDetach(mark) {
+    if (mark.type === "AttachAndDetach") {
+        return mark;
+    }
+    const { cellId, count, changes, revision, ...effect } = mark;
+    const attachAndDetach = {
+        type: "AttachAndDetach",
+        count,
+        cellId,
+        attach: {
+            type: "Insert",
+            id: mark.id,
+        },
+        detach: effect,
+    };
+    if (changes !== undefined) {
+        attachAndDetach.changes = changes;
+    }
+    if (revision !== undefined) {
+        attachAndDetach.attach.revision = revision;
+        attachAndDetach.detach.revision = revision;
+    }
+    return attachAndDetach;
+}
+exports.asAttachAndDetach = asAttachAndDetach;
 function cloneMark(mark) {
     const clone = { ...cloneMarkEffect(mark), count: mark.count };
     if (mark.cellId !== undefined) {
@@ -266,6 +332,10 @@ function cloneMark(mark) {
 exports.cloneMark = cloneMark;
 function cloneMarkEffect(effect) {
     const clone = { ...effect };
+    if (clone.type === "AttachAndDetach") {
+        clone.attach = cloneMarkEffect(clone.attach);
+        clone.detach = cloneMarkEffect(clone.detach);
+    }
     return clone;
 }
 exports.cloneMarkEffect = cloneMarkEffect;
@@ -304,6 +374,18 @@ function markHasCellEffect(mark) {
     return areInputCellsEmpty(mark) !== areOutputCellsEmpty(mark);
 }
 exports.markHasCellEffect = markHasCellEffect;
+function isAttachAndDetachEffect(effect) {
+    return effect.type === "AttachAndDetach";
+}
+exports.isAttachAndDetachEffect = isAttachAndDetachEffect;
+function isDetachOfRemovedNodes(mark) {
+    return isDetach(mark) && mark.cellId !== undefined;
+}
+exports.isDetachOfRemovedNodes = isDetachOfRemovedNodes;
+function isImpactfulCellRename(mark) {
+    return (isAttachAndDetachEffect(mark) || isDetachOfRemovedNodes(mark)) && isImpactful(mark);
+}
+exports.isImpactfulCellRename = isImpactfulCellRename;
 function areInputCellsEmpty(mark) {
     return mark.cellId !== undefined;
 }
@@ -311,18 +393,39 @@ exports.areInputCellsEmpty = areInputCellsEmpty;
 function areOutputCellsEmpty(mark) {
     const type = mark.type;
     switch (type) {
-        case types_js_1.NoopMarkType:
+        case types_js_1.NoopMarkType: {
             return mark.cellId !== undefined;
+        }
         case "Remove":
         case "Rename":
+        case "MoveOut":
+        case "AttachAndDetach": {
             return true;
-        case "Insert":
+        }
+        case "MoveIn":
+        case "Insert": {
             return false;
-        default:
+        }
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
 }
 exports.areOutputCellsEmpty = areOutputCellsEmpty;
+/**
+ * Creates a mark that is equivalent to the given `mark` but with effects removed if those have no impact in the input
+ * context of that mark.
+ *
+ * @param mark - The mark to settle. Never mutated.
+ * @returns either the original mark or a shallow clone of it with effects stripped out.
+ */
+function settleMark(mark) {
+    if (isImpactful(mark)) {
+        return mark;
+    }
+    return omitMarkEffect(mark);
+}
+exports.settleMark = settleMark;
 /**
  * Returns true if and only iff the given `mark` would have impact on the field when applied.
  *
@@ -333,10 +436,12 @@ exports.areOutputCellsEmpty = areOutputCellsEmpty;
 function isImpactful(mark) {
     const type = mark.type;
     switch (type) {
-        case types_js_1.NoopMarkType:
+        case types_js_1.NoopMarkType: {
             return false;
-        case "Rename":
+        }
+        case "Rename": {
             return true;
+        }
         case "Remove": {
             const inputId = getInputCellId(mark);
             if (inputId === undefined) {
@@ -346,11 +451,22 @@ function isImpactful(mark) {
             (0, internal_1.assert)(outputId !== undefined, 0x824 /* Remove marks must have an output cell ID */);
             return !(0, index_js_1.areEqualChangeAtomIds)(inputId, outputId);
         }
-        case "Insert":
+        case "AttachAndDetach":
+        case "MoveOut": {
+            return true;
+        }
+        case "MoveIn": {
+            // MoveIn marks always target an empty cell.
+            (0, internal_1.assert)(mark.cellId !== undefined, 0x825 /* MoveIn marks should target empty cells */);
+            return true;
+        }
+        case "Insert": {
             // A Revive has no impact if the nodes are already in the document.
             return mark.cellId !== undefined;
-        default:
+        }
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
 }
 exports.isImpactful = isImpactful;
@@ -378,13 +494,9 @@ function compareCellsFromSameRevision(cell1, count1, cell2, count2) {
 exports.compareCellsFromSameRevision = compareCellsFromSameRevision;
 function isDetach(mark) {
     const type = mark?.type;
-    return type === "Remove";
+    return type === "Remove" || type === "MoveOut";
 }
 exports.isDetach = isDetach;
-function isPin(mark) {
-    return mark?.type === "Insert" && mark.cellId === undefined;
-}
-exports.isPin = isPin;
 function isRemoveMark(mark) {
     return mark?.type === "Remove";
 }
@@ -393,10 +505,17 @@ function areMergeableChangeAtoms(lhs, lhsCount, rhs) {
     if (lhs === undefined || rhs === undefined) {
         return lhs === undefined && rhs === undefined;
     }
-    return (lhs.revision === rhs.revision &&
-        (0, index_js_2.areAdjacentIntegerRanges)(lhs.localId, lhsCount, rhs.localId));
+    return (lhs.revision === rhs.revision && areAdjacentIdRanges(lhs.localId, lhsCount, rhs.localId));
+}
+function areAdjacentIdRanges(firstStart, firstLength, secondStart) {
+    return firstStart + firstLength === secondStart;
+}
+function haveMergeableIdOverrides(lhs, lhsCount, rhs) {
+    if (lhs.idOverride !== undefined && rhs.idOverride !== undefined) {
+        return areMergeableCellIds(lhs.idOverride, lhsCount, rhs.idOverride);
+    }
+    return (lhs.idOverride === undefined) === (rhs.idOverride === undefined);
 }
-exports.areMergeableChangeAtoms = areMergeableChangeAtoms;
 function areMergeableCellIds(lhs, lhsCount, rhs) {
     return areMergeableChangeAtoms(lhs, lhsCount, rhs);
 }
@@ -431,42 +550,66 @@ function tryMergeEffects(lhs, rhs, lhsCount) {
     if (rhs.type === types_js_1.NoopMarkType) {
         return lhs;
     }
+    if (rhs.type === "AttachAndDetach") {
+        const lhsAttachAndDetach = lhs;
+        const attach = tryMergeEffects(lhsAttachAndDetach.attach, rhs.attach, lhsCount);
+        const detach = tryMergeEffects(lhsAttachAndDetach.detach, rhs.detach, lhsCount);
+        if (attach === undefined || detach === undefined) {
+            return undefined;
+        }
+        (0, internal_1.assert)(isAttach(attach) && isDetach(detach), 0x826 /* Merged marks should be same type as input marks */);
+        return { ...lhsAttachAndDetach, attach, detach };
+    }
     if (lhs.revision !== rhs.revision) {
         return undefined;
     }
-    if (isDetach(lhs) &&
-        isDetach(rhs) &&
-        !areMergeableChangeAtoms(lhs.cellRename, lhsCount, rhs.cellRename)) {
+    if (isDetach(lhs) && isDetach(rhs) && !haveMergeableIdOverrides(lhs, lhsCount, rhs)) {
         return undefined;
     }
     const type = rhs.type;
     switch (type) {
+        case "MoveIn": {
+            const lhsMoveIn = lhs;
+            if (lhsMoveIn.id + lhsCount === rhs.id &&
+                areMergeableChangeAtoms(lhsMoveIn.finalEndpoint, lhsCount, rhs.finalEndpoint)) {
+                return lhsMoveIn;
+            }
+            break;
+        }
         case "Remove": {
             const lhsDetach = lhs;
             if (lhsDetach.id + lhsCount === rhs.id &&
-                areMergeableChangeAtoms(lhsDetach.cellRename, lhsCount, rhs.cellRename) &&
-                areMergeableChangeAtoms(lhsDetach.detachCellId, lhsCount, rhs.detachCellId)) {
+                haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
                 return lhsDetach;
             }
             break;
         }
         case "Rename": {
             const lhsDetach = lhs;
-            if (areMergeableChangeAtoms(lhsDetach.idOverride, lhsCount, rhs.idOverride)) {
+            if (haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
                 return lhsDetach;
             }
             break;
         }
+        case "MoveOut": {
+            const lhsMoveOut = lhs;
+            if (lhsMoveOut.id + lhsCount === rhs.id &&
+                haveMergeableIdOverrides(lhsMoveOut, lhsCount, rhs) &&
+                areMergeableChangeAtoms(lhsMoveOut.finalEndpoint, lhsCount, rhs.finalEndpoint)) {
+                return lhsMoveOut;
+            }
+            break;
+        }
         case "Insert": {
             const lhsInsert = lhs;
-            if (lhsInsert.id + lhsCount === rhs.id &&
-                areMergeableChangeAtoms(lhsInsert.detachCellId, lhsCount, rhs.detachCellId)) {
+            if (lhsInsert.id + lhsCount === rhs.id) {
                 return lhsInsert;
             }
             break;
         }
-        default:
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
     return undefined;
 }
@@ -500,8 +643,9 @@ exports.splitMark = splitMark;
 function splitMarkEffect(effect, length) {
     const type = effect.type;
     switch (type) {
-        case types_js_1.NoopMarkType:
+        case types_js_1.NoopMarkType: {
             return [effect, effect];
+        }
         case "Insert": {
             const effect1 = {
                 ...effect,
@@ -510,21 +654,23 @@ function splitMarkEffect(effect, length) {
                 ...effect,
                 id: effect.id + length,
             };
-            if (effect.detachCellId !== undefined) {
-                effect2.detachCellId = splitDetachEvent(effect.detachCellId, length);
-            }
             return [effect1, effect2];
         }
+        case "MoveIn": {
+            const effect2 = { ...effect, id: effect.id + length };
+            const move2 = effect2;
+            if (move2.finalEndpoint !== undefined) {
+                move2.finalEndpoint = splitDetachEvent(move2.finalEndpoint, length);
+            }
+            return [effect, effect2];
+        }
         case "Remove": {
             const effect1 = { ...effect };
             const id2 = (0, index_js_2.brand)(effect.id + length);
             const effect2 = { ...effect, id: id2 };
             const effect2Remove = effect2;
-            if (effect2Remove.cellRename !== undefined) {
-                effect2Remove.cellRename = splitDetachEvent(effect2Remove.cellRename, length);
-            }
-            if (effect2Remove.detachCellId !== undefined) {
-                effect2Remove.detachCellId = splitDetachEvent(effect2Remove.detachCellId, length);
+            if (effect2Remove.idOverride !== undefined) {
+                effect2Remove.idOverride = splitDetachEvent(effect2Remove.idOverride, length);
             }
             return [effect1, effect2];
         }
@@ -537,8 +683,38 @@ function splitMarkEffect(effect, length) {
             }
             return [effect1, effect2];
         }
-        default:
+        case "MoveOut": {
+            const effect2 = {
+                ...effect,
+                id: effect.id + length,
+            };
+            const return2 = effect2;
+            if (return2.idOverride !== undefined) {
+                return2.idOverride = splitDetachEvent(return2.idOverride, length);
+            }
+            if (return2.finalEndpoint !== undefined) {
+                return2.finalEndpoint = splitDetachEvent(return2.finalEndpoint, length);
+            }
+            return [effect, effect2];
+        }
+        case "AttachAndDetach": {
+            const [attach1, attach2] = splitMarkEffect(effect.attach, length);
+            const [detach1, detach2] = splitMarkEffect(effect.detach, length);
+            const effect1 = {
+                ...effect,
+                attach: attach1,
+                detach: detach1,
+            };
+            const effect2 = {
+                ...effect,
+                attach: attach2,
+                detach: detach2,
+            };
+            return [effect1, effect2];
+        }
+        default: {
             (0, internal_1.unreachableCase)(type);
+        }
     }
 }
 exports.splitMarkEffect = splitMarkEffect;
@@ -566,11 +742,11 @@ function omitMarkEffect(mark) {
 exports.omitMarkEffect = omitMarkEffect;
 function withNodeChange(mark, changes) {
     const newMark = { ...mark };
-    if (changes !== undefined) {
-        newMark.changes = changes;
+    if (changes === undefined) {
+        delete newMark.changes;
     }
     else {
-        delete newMark.changes;
+        newMark.changes = changes;
     }
     return newMark;
 }
@@ -593,52 +769,83 @@ function addRevision(effect, revision) {
     if (effect.type === types_js_1.NoopMarkType || isRename(effect)) {
         return;
     }
+    if (effect.type === "AttachAndDetach") {
+        addRevision(effect.attach, revision);
+        addRevision(effect.detach, revision);
+        return;
+    }
     (0, internal_1.assert)(effect.revision === undefined || effect.revision === revision, 0x829 /* Should not overwrite mark revision */);
     effect.revision = revision;
 }
+function getEndpoint(effect) {
+    return effect.finalEndpoint ?? { revision: effect.revision, localId: effect.id };
+}
+exports.getEndpoint = getEndpoint;
 function getCrossFieldKeys(change) {
     const keys = [];
     for (const mark of change) {
-        keys.push(...getCrossFieldKeysForMark(mark, mark.count));
+        keys.push(...getCrossFieldKeysForMarkEffect(mark, mark.count));
     }
     return keys;
 }
 exports.getCrossFieldKeys = getCrossFieldKeys;
-function getCrossFieldKeysForMark(mark, count) {
-    switch (mark.type) {
+function getCrossFieldKeysForMarkEffect(effect, count) {
+    switch (effect.type) {
         case "Insert": {
-            const keys = [
+            // An insert behaves like a move where the source and destination are at the same location.
+            // An insert can become a move when after rebasing.
+            return [
+                {
+                    key: {
+                        target: index_js_3.CrossFieldTarget.Source,
+                        revision: effect.revision,
+                        localId: effect.id,
+                    },
+                    count,
+                },
                 {
                     key: {
-                        revision: mark.revision,
-                        localId: mark.id,
                         target: index_js_3.CrossFieldTarget.Destination,
+                        revision: effect.revision,
+                        localId: effect.id,
                     },
                     count,
                 },
             ];
-            if (mark.cellId === undefined) {
-                // This is a pin, which is treated as a detach and attach.
-                keys.push({
-                    key: { revision: mark.revision, localId: mark.id, target: index_js_3.CrossFieldTarget.Source },
-                    count,
-                });
-            }
-            return keys;
         }
-        case "Remove":
+        case "MoveOut": {
             return [
                 {
                     key: {
-                        revision: mark.revision,
-                        localId: mark.id,
                         target: index_js_3.CrossFieldTarget.Source,
+                        revision: effect.revision,
+                        localId: effect.id,
+                    },
+                    count,
+                },
+            ];
+        }
+        case "MoveIn": {
+            return [
+                {
+                    key: {
+                        target: index_js_3.CrossFieldTarget.Destination,
+                        revision: effect.revision,
+                        localId: effect.id,
                     },
                     count,
                 },
             ];
-        default:
+        }
+        case "AttachAndDetach": {
+            return [
+                ...getCrossFieldKeysForMarkEffect(effect.attach, count),
+                ...getCrossFieldKeysForMarkEffect(effect.detach, count),
+            ];
+        }
+        default: {
             return [];
+        }
     }
 }
 //# sourceMappingURL=utils.js.map