@fluidframework/tree 2.74.0-370705 → 2.80.0

package/lib/feature-libraries/sequence-field/moveEffectTable.js

@@ -2,20 +2,100 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { isAttach, isDetach, splitMark } from "./utils.js";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { brand } from "../../util/index.js";
+import { CrossFieldTarget, } from "../modular-schema/index.js";
+import { isAttachAndDetachEffect, splitMark, splitMarkEffect } from "./utils.js";
+export var MoveEnd;
+(function (MoveEnd) {
+    MoveEnd[MoveEnd["Source"] = 0] = "Source";
+    MoveEnd[MoveEnd["Dest"] = 1] = "Dest";
+})(MoveEnd || (MoveEnd = {}));
+export function setMoveEffect(moveEffects, target, revision, id, count, effect, invalidate = true) {
+    effect.basis = id;
+    moveEffects.set(target, revision, id, count, effect, invalidate);
+}
+export function getMoveEffect(moveEffects, target, revision, id, count, addDependency = true) {
+    const result = moveEffects.get(target, revision, id, count, addDependency);
+    return result.value === undefined
+        ? result
+        : { ...result, value: adjustMoveEffectBasis(result.value, id) };
+}
 export function isMoveMark(effect) {
-    return isAttach(effect) || isDetach(effect);
+    return isMoveOut(effect) || isMoveIn(effect);
+}
+export function isMoveOut(effect) {
+    return effect.type === "MoveOut";
+}
+export function isMoveIn(effect) {
+    return effect.type === "MoveIn";
 }
-export function getAttach(effect) {
+export function getMoveIn(effect) {
     switch (effect.type) {
-        case "Insert":
+        case "MoveIn": {
             return effect;
-        default:
+        }
+        case "AttachAndDetach": {
+            return getMoveIn(effect.attach);
+        }
+        default: {
             return undefined;
+        }
+    }
+}
+function adjustMoveEffectBasis(effect, newBasis) {
+    if (effect.basis === newBasis) {
+        return effect;
+    }
+    const adjusted = { ...effect, basis: newBasis };
+    const basisShift = newBasis - effect.basis;
+    assert(basisShift > 0, 0x812 /* Expected basis shift to be positive */);
+    if (effect.endpoint !== undefined) {
+        adjusted.endpoint = adjustChangeAtomId(effect.endpoint, basisShift);
+    }
+    if (effect.truncatedEndpoint !== undefined) {
+        adjusted.truncatedEndpoint = adjustChangeAtomId(effect.truncatedEndpoint, basisShift);
     }
+    if (effect.truncatedEndpointForInner !== undefined) {
+        adjusted.truncatedEndpointForInner = adjustChangeAtomId(effect.truncatedEndpointForInner, basisShift);
+    }
+    if (effect.movedEffect !== undefined) {
+        const [_mark1, mark2] = splitMarkEffect(effect.movedEffect, basisShift);
+        adjusted.movedEffect = mark2;
+    }
+    return adjusted;
 }
-export function splitMarkForMoveEffects(mark, getLength) {
-    const length = getLength(mark);
+export function splitMarkForMoveEffects(mark, effects) {
+    const length = getFirstMoveEffectLength(mark, mark.count, effects);
     return length < mark.count ? splitMark(mark, length) : [mark];
 }
+function getFirstMoveEffectLength(markEffect, count, effects) {
+    if (isMoveMark(markEffect)) {
+        return getMoveEffect(effects, getCrossFieldTargetFromMove(markEffect), markEffect.revision, markEffect.id, count).length;
+    }
+    else if (isAttachAndDetachEffect(markEffect)) {
+        return Math.min(getFirstMoveEffectLength(markEffect.attach, count, effects), getFirstMoveEffectLength(markEffect.detach, count, effects));
+    }
+    return count;
+}
+export function getCrossFieldTargetFromMove(mark) {
+    const type = mark.type;
+    switch (type) {
+        case "MoveIn": {
+            return CrossFieldTarget.Destination;
+        }
+        case "MoveOut": {
+            return CrossFieldTarget.Source;
+        }
+        default: {
+            unreachableCase(type);
+        }
+    }
+}
+function adjustChangeAtomId(id, shift) {
+    return {
+        ...id,
+        localId: brand(id.localId + shift),
+    };
+}
 //# sourceMappingURL=moveEffectTable.js.map

package/lib/feature-libraries/sequence-field/moveEffectTable.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveEffectTable.js","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/moveEffectTable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI3D,MAAM,UAAU,UAAU,CAAC,MAAkB;IAC5C,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,MAAkB;IAC3C,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACrB,KAAK,QAAQ;YACZ,OAAO,MAAM,CAAC;QACf;YACC,OAAO,SAAS,CAAC;IACnB,CAAC;AACF,CAAC;AAID,MAAM,UAAU,uBAAuB,CAAC,IAAU,EAAE,SAA6B;IAChF,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC/D,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { MoveMarkEffect } from \"./helperTypes.js\";\nimport type { Attach, CellMark, Mark, MarkEffect } from \"./types.js\";\nimport { isAttach, isDetach, splitMark } from \"./utils.js\";\n\nexport type MoveMark = CellMark<MoveMarkEffect>;\n\nexport function isMoveMark(effect: MarkEffect): effect is MoveMarkEffect {\n\treturn isAttach(effect) || isDetach(effect);\n}\n\nexport function getAttach(effect: MarkEffect): Attach | undefined {\n\tswitch (effect.type) {\n\t\tcase \"Insert\":\n\t\t\treturn effect;\n\t\tdefault:\n\t\t\treturn undefined;\n\t}\n}\n\nexport type NodeRangeQueryFunc = (mark: Mark) => number;\n\nexport function splitMarkForMoveEffects(mark: Mark, getLength: NodeRangeQueryFunc): Mark[] {\n\tconst length = getLength(mark);\n\treturn length < mark.count ? splitMark(mark, length) : [mark];\n}\n"]}
+{"version":3,"file":"moveEffectTable.js","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/moveEffectTable.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, unreachableCase } from \"@fluidframework/core-utils/internal\";\n\nimport type { ChangeAtomId, RevisionTag, TaggedChange } from \"../../core/index.js\";\nimport { type RangeQueryResult, brand } from \"../../util/index.js\";\nimport {\n\ttype CrossFieldManager,\n\tCrossFieldTarget,\n\ttype NodeId,\n} from \"../modular-schema/index.js\";\n\nimport type { MoveMarkEffect } from \"./helperTypes.js\";\nimport type { CellMark, Detach, Mark, MarkEffect, MoveId, MoveIn, MoveOut } from \"./types.js\";\nimport { isAttachAndDetachEffect, splitMark, splitMarkEffect } from \"./utils.js\";\n\nexport type MoveEffectTable = CrossFieldManager<MoveEffect>;\n\n/**\n * Changes to be applied to a move mark.\n */\nexport interface MoveEffect {\n\t/**\n\t * Node changes which should be applied to this mark.\n\t * If this mark already has node changes, `modifyAfter` should be composed as later changes.\n\t */\n\tmodifyAfter?: NodeId;\n\n\t/**\n\t * Only used during rebasing.\n\t * An effect from changeset being rebased which should be moved to the same position as this mark.\n\t */\n\tmovedEffect?: Detach;\n\n\t/**\n\t * Rebased changes for a node which has been moved to the position of this mark.\n\t */\n\trebasedChanges?: NodeId;\n\n\t/**\n\t * The ID of the other outer endpoint.\n\t * Used when this is the outer endpoint in a move chain which is being composed with another move chain.\n\t */\n\tendpoint?: ChangeAtomId;\n\n\t/**\n\t * The ID of the truncated endpoint.\n\t * Used when this mark is the outer endpoint of a chain being composed with a redundant move chain.\n\t */\n\ttruncatedEndpoint?: ChangeAtomId;\n\n\t/**\n\t * The ID of the truncated endpoint.\n\t * Used when this mark is the inner endpoint of a redundant move chain.\n\t */\n\ttruncatedEndpointForInner?: ChangeAtomId;\n}\n\ninterface MoveEffectWithBasis extends MoveEffect {\n\t/**\n\t * The ID for the start of the range this MoveEffect was created for.\n\t * This is used, for example, to correctly interpret `MoveEffect.endpoint` field.\n\t */\n\tbasis: MoveId;\n}\n\nexport enum MoveEnd {\n\tSource,\n\tDest,\n}\n\nexport interface MovePartition {\n\tid: MoveId;\n\n\t// Undefined means the partition is the same size as the input.\n\tcount?: number;\n\treplaceWith?: Mark[];\n\tmodifyAfter?: TaggedChange<NodeId>;\n}\n\nexport function setMoveEffect(\n\tmoveEffects: MoveEffectTable,\n\ttarget: CrossFieldTarget,\n\trevision: RevisionTag | undefined,\n\tid: MoveId,\n\tcount: number,\n\teffect: MoveEffect,\n\tinvalidate: boolean = true,\n): void {\n\t(effect as MoveEffectWithBasis).basis = id;\n\tmoveEffects.set(target, revision, id, count, effect, invalidate);\n}\n\nexport function getMoveEffect(\n\tmoveEffects: MoveEffectTable,\n\ttarget: CrossFieldTarget,\n\trevision: RevisionTag | undefined,\n\tid: MoveId,\n\tcount: number,\n\taddDependency: boolean = true,\n): RangeQueryResult<ChangeAtomId, MoveEffect> {\n\tconst result = moveEffects.get(target, revision, id, count, addDependency);\n\treturn result.value === undefined\n\t\t? result\n\t\t: { ...result, value: adjustMoveEffectBasis(result.value as MoveEffectWithBasis, id) };\n}\n\nexport type MoveMark = CellMark<MoveMarkEffect>;\n\nexport function isMoveMark(effect: MarkEffect): effect is MoveMarkEffect {\n\treturn isMoveOut(effect) || isMoveIn(effect);\n}\n\nexport function isMoveOut(effect: MarkEffect): effect is MoveOut {\n\treturn effect.type === \"MoveOut\";\n}\n\nexport function isMoveIn(effect: MarkEffect): effect is MoveIn {\n\treturn effect.type === \"MoveIn\";\n}\n\nexport function getMoveIn(effect: MarkEffect): MoveIn | undefined {\n\tswitch (effect.type) {\n\t\tcase \"MoveIn\": {\n\t\t\treturn effect;\n\t\t}\n\t\tcase \"AttachAndDetach\": {\n\t\t\treturn getMoveIn(effect.attach);\n\t\t}\n\t\tdefault: {\n\t\t\treturn undefined;\n\t\t}\n\t}\n}\n\nfunction adjustMoveEffectBasis(effect: MoveEffectWithBasis, newBasis: MoveId): MoveEffect {\n\tif (effect.basis === newBasis) {\n\t\treturn effect;\n\t}\n\n\tconst adjusted = { ...effect, basis: newBasis };\n\tconst basisShift = newBasis - effect.basis;\n\tassert(basisShift > 0, 0x812 /* Expected basis shift to be positive */);\n\n\tif (effect.endpoint !== undefined) {\n\t\tadjusted.endpoint = adjustChangeAtomId(effect.endpoint, basisShift);\n\t}\n\n\tif (effect.truncatedEndpoint !== undefined) {\n\t\tadjusted.truncatedEndpoint = adjustChangeAtomId(effect.truncatedEndpoint, basisShift);\n\t}\n\n\tif (effect.truncatedEndpointForInner !== undefined) {\n\t\tadjusted.truncatedEndpointForInner = adjustChangeAtomId(\n\t\t\teffect.truncatedEndpointForInner,\n\t\t\tbasisShift,\n\t\t);\n\t}\n\n\tif (effect.movedEffect !== undefined) {\n\t\tconst [_mark1, mark2] = splitMarkEffect(effect.movedEffect, basisShift);\n\t\tadjusted.movedEffect = mark2;\n\t}\n\n\treturn adjusted;\n}\n\nexport function splitMarkForMoveEffects(mark: Mark, effects: MoveEffectTable): Mark[] {\n\tconst length = getFirstMoveEffectLength(mark, mark.count, effects);\n\treturn length < mark.count ? splitMark(mark, length) : [mark];\n}\n\nfunction getFirstMoveEffectLength(\n\tmarkEffect: MarkEffect,\n\tcount: number,\n\teffects: MoveEffectTable,\n): number {\n\tif (isMoveMark(markEffect)) {\n\t\treturn getMoveEffect(\n\t\t\teffects,\n\t\t\tgetCrossFieldTargetFromMove(markEffect),\n\t\t\tmarkEffect.revision,\n\t\t\tmarkEffect.id,\n\t\t\tcount,\n\t\t).length;\n\t} else if (isAttachAndDetachEffect(markEffect)) {\n\t\treturn Math.min(\n\t\t\tgetFirstMoveEffectLength(markEffect.attach, count, effects),\n\t\t\tgetFirstMoveEffectLength(markEffect.detach, count, effects),\n\t\t);\n\t}\n\n\treturn count;\n}\n\nexport function getCrossFieldTargetFromMove(mark: MoveMarkEffect): CrossFieldTarget {\n\tconst type = mark.type;\n\tswitch (type) {\n\t\tcase \"MoveIn\": {\n\t\t\treturn CrossFieldTarget.Destination;\n\t\t}\n\t\tcase \"MoveOut\": {\n\t\t\treturn CrossFieldTarget.Source;\n\t\t}\n\t\tdefault: {\n\t\t\tunreachableCase(type);\n\t\t}\n\t}\n}\n\nfunction adjustChangeAtomId(id: ChangeAtomId, shift: number): ChangeAtomId {\n\treturn {\n\t\t...id,\n\t\tlocalId: brand(id.localId + shift),\n\t};\n}\n"]}

package/lib/feature-libraries/sequence-field/rebase.d.ts

@@ -2,8 +2,8 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { IdAllocator } from "../../util/index.js";
-import { type RebaseNodeManager, type NodeChangeRebaser, type RebaseRevisionMetadata } from "../modular-schema/index.js";
+import { type IdAllocator } from "../../util/index.js";
+import { type CrossFieldManager, type NodeChangeRebaser, type RebaseRevisionMetadata } from "../modular-schema/index.js";
 import { type Changeset } from "./types.js";
 /**
  * Rebases `change` over `base` assuming they both apply to the same initial state.
@@ -11,5 +11,5 @@ import { type Changeset } from "./types.js";
  * @param base - The changeset to rebase over.
  * @returns A changeset that performs the changes in `change` but does so assuming `base` has been applied first.
  */
-export declare function rebase(change: Changeset, base: Changeset, rebaseChild: NodeChangeRebaser, genId: IdAllocator, manager: RebaseNodeManager, revisionMetadata: RebaseRevisionMetadata): Changeset;
+export declare function rebase(change: Changeset, base: Changeset, rebaseChild: NodeChangeRebaser, genId: IdAllocator, manager: CrossFieldManager, revisionMetadata: RebaseRevisionMetadata): Changeset;
 //# sourceMappingURL=rebase.d.ts.map

package/lib/feature-libraries/sequence-field/rebase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rebase.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/rebase.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,KAAK,EAAE,WAAW,EAAW,MAAM,qBAAqB,CAAC;AAChE,OAAO,EACN,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAGtB,KAAK,sBAAsB,EAC3B,MAAM,4BAA4B,CAAC;AAKpC,OAAO,EAIN,KAAK,SAAS,EAQd,MAAM,YAAY,CAAC;AAwBpB;;;;;GAKG;AACH,wBAAgB,MAAM,CACrB,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,iBAAiB,EAC9B,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,iBAAiB,EAC1B,gBAAgB,EAAE,sBAAsB,GACtC,SAAS,CAEX"}
+{"version":3,"file":"rebase.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/rebase.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EACN,KAAK,iBAAiB,EAEtB,KAAK,iBAAiB,EAGtB,KAAK,sBAAsB,EAC3B,MAAM,4BAA4B,CAAC;AAapC,OAAO,EAGN,KAAK,SAAS,EAUd,MAAM,YAAY,CAAC;AAuBpB;;;;;GAKG;AACH,wBAAgB,MAAM,CACrB,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,iBAAiB,EAC9B,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,iBAAiB,EAC1B,gBAAgB,EAAE,sBAAsB,GACtC,SAAS,CASX"}

package/lib/feature-libraries/sequence-field/rebase.js

@@ -3,12 +3,13 @@
  * Licensed under the MIT License.
  */
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import { areEqualChangeAtomIds, } from "../../core/index.js";
-import { NodeAttachState, } from "../modular-schema/index.js";
+import { brand } from "../../util/index.js";
+import { CrossFieldTarget, NodeAttachState, } from "../modular-schema/index.js";
 import { MarkListFactory } from "./markListFactory.js";
 import { MarkQueue } from "./markQueue.js";
+import { getMoveEffect, isMoveIn, isMoveMark, isMoveOut, setMoveEffect, } from "./moveEffectTable.js";
 import { NoopMarkType, } from "./types.js";
-import { CellOrder, areInputCellsEmpty, cellSourcesFromMarks, cloneCellId, cloneMark, compareCellPositionsUsingTombstones, extractMarkEffect, getAttachedRootId, getDetachOutputCellId, getDetachedRootId, getInputCellId, getOutputCellId, isAttach, isDetach, isNewAttach, isRename, isTombstone, markEmptiesCells, markFillsCells, withNodeChange, } from "./utils.js";
+import { CellOrder, areInputCellsEmpty, cellSourcesFromMarks, cloneCellId, cloneMark, compareCellPositionsUsingTombstones, extractMarkEffect, getDetachOutputCellId, getEndpoint, getInputCellId, isAttachAndDetachEffect, isDetach, isNewAttach, isRename, isTombstone, markEmptiesCells, markFillsCells, splitMarkEffect, withNodeChange, } from "./utils.js";
 /**
  * Rebases `change` over `base` assuming they both apply to the same initial state.
  * @param change - The changeset to rebase.
@@ -43,24 +44,8 @@ class RebaseQueue {
     constructor(baseMarks, newMarks, metadata, moveEffects) {
         this.metadata = metadata;
         this.moveEffects = moveEffects;
-        const queryFunc = (mark) => {
-            if (isAttach(mark)) {
-                return moveEffects.getNewChangesForBaseAttach(getAttachedRootId(mark), mark.count)
-                    .length;
-            }
-            else if (isDetach(mark)) {
-                return moveEffects.doesBaseAttachNodes(getDetachedRootId(mark), mark.count).length;
-            }
-            let count = mark.count;
-            if (mark.type === "Rename") {
-                count = moveEffects.getNewRenameForBaseRename(mark.idOverride, count).length;
-            }
-            return mark.cellId !== undefined
-                ? moveEffects.doesBaseAttachNodes(mark.cellId, count).length
-                : count;
-        };
-        this.baseMarks = new MarkQueue(baseMarks, queryFunc);
-        this.newMarks = new MarkQueue(newMarks, (mark) => mark.count);
+        this.baseMarks = new MarkQueue(baseMarks, moveEffects);
+        this.newMarks = new MarkQueue(newMarks, moveEffects);
         this.baseMarksCellSources = cellSourcesFromMarks(baseMarks, getInputCellId);
         this.newMarksCellSources = cellSourcesFromMarks(newMarks, getInputCellId);
     }
@@ -87,14 +72,18 @@ class RebaseQueue {
             assert(baseId !== undefined && newId !== undefined, 0x89f /* Both marks should have cell IDs */);
             const comparison = compareCellPositionsUsingTombstones(baseId, newId, this.baseMarksCellSources, this.newMarksCellSources, this.metadata);
             switch (comparison) {
-                case CellOrder.SameCell:
+                case CellOrder.SameCell: {
                     return this.dequeueBoth();
-                case CellOrder.OldThenNew:
+                }
+                case CellOrder.OldThenNew: {
                     return this.dequeueBase();
-                case CellOrder.NewThenOld:
+                }
+                case CellOrder.NewThenOld: {
                     return this.dequeueNew();
-                default:
+                }
+                default: {
                     unreachableCase(comparison);
+                }
             }
         }
         else if (areInputCellsEmpty(newMark)) {
@@ -108,7 +97,7 @@ class RebaseQueue {
         }
     }
     dequeueBase(length) {
-        const baseMark = length !== undefined ? this.baseMarks.dequeueUpTo(length) : this.baseMarks.dequeue();
+        const baseMark = length === undefined ? this.baseMarks.dequeue() : this.baseMarks.dequeueUpTo(length);
         let newMark = generateNoOpWithCellId(baseMark);
         const movedEffect = getMovedEffectFromBaseMark(this.moveEffects, baseMark);
         if (movedEffect !== undefined) {
@@ -144,15 +133,14 @@ class RebaseQueue {
  * @returns a mark which has the composite effect of `mark` and `effect`.
  */
 function addMovedMarkEffect(mark, effect) {
-    if (isAttach(mark) && isDetach(effect)) {
+    if (isMoveIn(mark) && isMoveOut(effect)) {
         return { ...mark, type: "Insert" };
     }
-    else if (isRename(mark) && isDetach(effect)) {
-        const result = { ...effect, count: mark.count };
-        if (!areEqualChangeAtomIds(mark.idOverride, getDetachedRootId(effect))) {
-            result.detachCellId = mark.idOverride;
-        }
-        return result;
+    else if (isRename(mark) && isMoveOut(effect)) {
+        return { ...effect, count: mark.count, idOverride: mark.idOverride };
+    }
+    else if (isAttachAndDetachEffect(mark) && isMoveIn(mark.attach) && isMoveOut(effect)) {
+        return { ...mark.detach, count: mark.count };
     }
     else if (isTombstone(mark)) {
         return { ...mark, ...effect };
@@ -165,6 +153,7 @@ function rebaseMark(currMark, baseMark, rebaseChild, moveEffects) {
     if (movedNodeChanges !== undefined) {
         assert(rebasedMark.changes === undefined, 0x8dc /* Unexpected collision of new node changes */);
         rebasedMark.changes = movedNodeChanges;
+        moveEffects.onMoveIn(movedNodeChanges);
     }
     return rebaseMarkIgnoreChild(rebasedMark, baseMark, moveEffects);
 }
@@ -177,83 +166,80 @@ function rebaseMarkIgnoreChild(currMark, baseMark, moveEffects) {
         }
         assert(!isNewAttach(currMark), 0x69d /* A new attach should not be rebased over its cell being emptied */);
         const baseCellId = getDetachOutputCellId(baseMark);
-        const baseDetachId = getDetachedRootId(baseMark);
-        const { remains, follows } = separateEffectsForMove(extractMarkEffect(currMark), baseMark, moveEffects);
-        moveRebasedChanges(moveEffects, baseDetachId, baseMark.count, currMark.changes, follows);
-        rebasedMark = { ...(remains ?? {}), count: baseMark.count };
-        return makeDetachedMark(rebasedMark, cloneCellId(baseCellId));
+        if (isMoveOut(baseMark)) {
+            assert(isMoveMark(baseMark), 0x6f0 /* Only move marks have move IDs */);
+            assert(!isNewAttach(currMark), 0x819 /* New attaches should not be rebased over moves */);
+            const { remains, follows } = separateEffectsForMove(extractMarkEffect(currMark));
+            if (follows !== undefined) {
+                sendEffectToDest(follows, moveEffects, getEndpoint(baseMark), baseMark.count);
+            }
+            if (currMark.changes !== undefined) {
+                moveRebasedChanges(currMark.changes, moveEffects, getEndpoint(baseMark));
+            }
+            rebasedMark = { ...(remains ?? {}), count: baseMark.count };
+        }
+        else {
+            rebasedMark = currMark;
+        }
+        rebasedMark = makeDetachedMark(rebasedMark, cloneCellId(baseCellId));
     }
     else if (markFillsCells(baseMark)) {
-        return withCellId(currMark, undefined);
+        rebasedMark = isAttachAndDetachEffect(currMark)
+            ? withNodeChange({ ...currMark.detach, count: currMark.count }, currMark.changes)
+            : withCellId(currMark, undefined);
+    }
+    else if (isAttachAndDetachEffect(baseMark)) {
+        assert(baseMark.cellId !== undefined, 0x81a /* AttachAndDetach mark should target an empty cell */);
+        const halfRebasedMark = rebaseMarkIgnoreChild(currMark, { ...baseMark.attach, cellId: cloneCellId(baseMark.cellId), count: baseMark.count }, moveEffects);
+        rebasedMark = rebaseMarkIgnoreChild(halfRebasedMark, { ...baseMark.detach, count: baseMark.count }, moveEffects);
     }
     else if (isRename(baseMark)) {
-        if (currMark.type === "Rename") {
-            const doesBaseMoveAndAttach = moveEffects.doesBaseAttachNodes(baseMark.idOverride, baseMark.count).value;
-            assert(baseMark.cellId !== undefined, "Rename should target empty cells");
-            const baseRootRename = moveEffects.getBaseRename(baseMark.cellId, baseMark.count).value;
-            const doesBaseMoveAndDetach = baseRootRename !== undefined &&
-                !areEqualChangeAtomIds(baseRootRename, baseMark.idOverride);
-            if (doesBaseMoveAndAttach || doesBaseMoveAndDetach) {
-                // `newMark` represents a node-targeting rename.
-                // The base changeset has moved the node which was last detached from the cell,
-                // so we should remove the rename from this location.
-                return { cellId: baseMark.idOverride, count: baseMark.count };
-            }
-        }
-        const newRenameId = moveEffects.getNewRenameForBaseRename(baseMark.idOverride, baseMark.count).value;
-        if (newRenameId !== undefined && currMark.type !== "Insert") {
-            return {
-                type: "Rename",
-                cellId: baseMark.idOverride,
-                count: baseMark.count,
-                idOverride: newRenameId,
-            };
-        }
-        return withCellId(currMark, getOutputCellId(baseMark));
+        return withCellId(currMark, getDetachOutputCellId(baseMark));
     }
     else {
-        return currMark;
+        rebasedMark = currMark;
     }
+    return rebasedMark;
 }
 /**
  * Returns a pair of marks that represent the effects which should remain in place in the face of concurrent move,
  * and the effects that should be sent to the move destination.
  */
-function separateEffectsForMove(mark, baseMark, nodeManager) {
+function separateEffectsForMove(mark) {
     const type = mark.type;
     switch (type) {
-        case NoopMarkType:
-            return {};
-        case "Remove": {
-            if (mark.cellRename !== undefined) {
-                return { remains: { type: "Rename", idOverride: mark.cellRename }, follows: mark };
+        case "Remove":
+        case "MoveOut": {
+            // There are two scenarios that lead to a Detach mark having an idOverride:
+            // 1. The detach is a rollback (the idOverride the original id that the cell had in the input context of the attach being rolled back).
+            // 2. The detach has been composed with a Rename (the idOverride is the cell id in the output context of the rename).
+            // Since rollbacks are never rebased, we can safely assume that the idOverride is due to a Rename (scenario #2).
+            // While the detach must follow the node that it targets, the rename must remain in place because it targets the cell.
+            if (mark.idOverride !== undefined) {
+                const remains = { type: "Rename", idOverride: mark.idOverride };
+                const follows = { ...mark };
+                delete follows.idOverride;
+                return { remains, follows };
             }
-            const baseDetachId = getDetachedRootId(baseMark);
-            const outputCellId = getDetachOutputCellId(baseMark);
-            const doesBaseMoveNodes = !areEqualChangeAtomIds(outputCellId, baseDetachId) ||
-                nodeManager.doesBaseAttachNodes(baseDetachId, baseMark.count).value;
-            // We should rename these cells unless the nodes are reattached elsewhere,
-            // in which case we will rename those cells instead.
-            const remains = doesBaseMoveNodes
-                ? {}
-                : {
-                    type: "Rename",
-                    idOverride: getDetachOutputCellId(mark),
-                };
-            return { remains, follows: mark };
+            return { follows: mark };
+        }
+        case "AttachAndDetach": {
+            return { follows: mark.detach, remains: mark.attach };
         }
-        case "Rename":
+        case "MoveIn":
+        case "Rename": {
             return { remains: mark };
+        }
+        case NoopMarkType: {
+            return {};
+        }
         case "Insert": {
             const follows = {
-                type: "Remove",
+                type: "MoveOut",
                 id: mark.id,
             };
-            if (mark.detachCellId !== undefined) {
-                follows.detachCellId = mark.detachCellId;
-            }
             const remains = {
-                type: "Insert",
+                type: "MoveIn",
                 id: mark.id,
             };
             if (mark.revision !== undefined) {
@@ -262,14 +248,35 @@ function separateEffectsForMove(mark, baseMark, nodeManager) {
             }
             return { remains, follows };
         }
-        default:
+        default: {
             unreachableCase(type);
+        }
+    }
+}
+// TODO: Reduce the duplication between this and other MoveEffect helpers
+function sendEffectToDest(markEffect, moveEffects, { revision, localId: id }, count) {
+    const effect = getMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count, false);
+    if (effect.length < count) {
+        const [markEffect1, markEffect2] = splitMarkEffect(markEffect, effect.length);
+        const newEffect = effect.value === undefined
+            ? { movedMark: markEffect1 }
+            : { ...effect.value, movedMark: markEffect1 };
+        setMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, effect.length, newEffect);
+        sendEffectToDest(markEffect2, moveEffects, { revision, localId: brand(id + effect.length) }, count - effect.length);
+    }
+    else {
+        const newEffect = effect.value === undefined
+            ? { movedEffect: markEffect }
+            : { ...effect.value, movedEffect: markEffect };
+        setMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count, newEffect);
     }
 }
-function moveRebasedChanges(moveEffects, baseId, count, nodeChange, newDetach) {
-    const newId = newDetach !== undefined ? getDetachedRootId(newDetach) : undefined;
-    const detachCellId = newDetach?.detachCellId;
-    moveEffects.rebaseOverDetach(baseId, count, newId, nodeChange, detachCellId);
+function moveRebasedChanges(nodeChange, moveEffects, { revision, localId: id }) {
+    const effect = getMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, 1, false).value;
+    const newEffect = effect === undefined
+        ? { rebasedChanges: nodeChange }
+        : { ...effect, rebasedChanges: nodeChange };
+    setMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, 1, newEffect);
 }
 function rebaseNodeChange(currMark, baseMark, nodeRebaser) {
     const baseChange = baseMark.changes;
@@ -303,38 +310,45 @@ function withCellId(mark, cellId) {
     return newMark;
 }
 function getMovedEffectFromBaseMark(moveEffects, baseMark) {
-    return isAttach(baseMark)
-        ? getMovedEffect(moveEffects, baseMark.revision, baseMark.id, baseMark.count)
-        : undefined;
+    if (isMoveIn(baseMark)) {
+        return getMovedEffect(moveEffects, baseMark.revision, baseMark.id, baseMark.count);
+    }
+    else if (isAttachAndDetachEffect(baseMark) && isMoveIn(baseMark.attach)) {
+        return getMovedEffect(moveEffects, baseMark.attach.revision, baseMark.attach.id, baseMark.count);
+    }
+    else {
+        return undefined;
+    }
 }
 // It is expected that the range from `id` to `id + count - 1` has the same move effect.
 // The call sites to this function are making queries about a mark which has already been split by a `MarkQueue`
 // to match the ranges in `moveEffects`.
 // TODO: Reduce the duplication between this and other MoveEffect helpers
-function getMovedEffect(moveEffects, revision, localId, count) {
-    const entry = moveEffects.getNewChangesForBaseAttach({ revision, localId }, count);
-    assert(entry.length === count, 0x6f3 /* Expected effect to cover entire mark */);
-    const detachId = entry.value?.detachId;
-    if (detachId === undefined) {
-        assert(entry.value?.cellRename === undefined, "Cell detach should be accompanied by node detach");
+function getMovedEffect(moveEffects, revision, id, count) {
+    const effect = getMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count);
+    assert(effect.length === count, 0x6f3 /* Expected effect to cover entire mark */);
+    const movedEffect = effect.value?.movedEffect;
+    if (movedEffect === undefined) {
         return undefined;
     }
-    const detach = {
-        type: "Remove",
-        revision: detachId.revision,
-        id: detachId.localId,
-    };
-    if (entry.value?.cellRename !== undefined) {
-        detach.detachCellId = entry.value.cellRename;
+    if (isMoveOut(movedEffect)) {
+        moveEffects.moveKey(CrossFieldTarget.Source, movedEffect.revision, movedEffect.id, count);
     }
-    return detach;
+    return movedEffect;
 }
 function getMovedChangesFromBaseMark(moveEffects, baseMark) {
-    return isAttach(baseMark)
-        ? getMovedNodeChanges(moveEffects, baseMark.revision, baseMark.id)
-        : undefined;
+    if (isMoveIn(baseMark)) {
+        return getMovedNodeChanges(moveEffects, baseMark.revision, baseMark.id, baseMark.count);
+    }
+    else if (isAttachAndDetachEffect(baseMark) && isMoveIn(baseMark.attach)) {
+        return getMovedNodeChanges(moveEffects, baseMark.attach.revision, baseMark.attach.id, baseMark.count);
+    }
+    else {
+        return undefined;
+    }
 }
-function getMovedNodeChanges(moveEffects, revision, localId) {
-    return moveEffects.getNewChangesForBaseAttach({ revision, localId }, 1).value?.nodeChange;
+function getMovedNodeChanges(moveEffects, revision, id, count) {
+    return getMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count).value
+        ?.rebasedChanges;
 }
 //# sourceMappingURL=rebase.js.map