@fluidframework/tree 2.90.0-378676 → 2.91.0

package/dist/feature-libraries/optional-field/requiredField.js.map

@@ -1 +1 @@
-{"version":3,"file":"requiredField.js","sourceRoot":"","sources":["../../../src/feature-libraries/optional-field/requiredField.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kDAA8F;AAC9F,wEAA2F;AAC3F,yDAKoC;AAEpC,yDAI4B;AAuBf,QAAA,mBAAmB,GAAwB;IACvD,GAAG,sCAAmB;IACtB,GAAG,EAAE,CAAC,GAAiD,EAAqB,EAAE,CAC7E,sCAAmB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC;CACpC,CAAC;AAEF,SAAgB,sBAAsB,CACrC,MAAyB,EACzB,cAAuB;IAEvB,OAAO,IAAA,mDAAgC,EAAC,KAAK,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;AACxE,CAAC;AALD,wDAKC;AAEY,QAAA,0BAA0B,GAGnC;IACH,GAAG,wCAAqB;IACxB,SAAS,EAAE,sBAAsB;IACjC,MAAM,EAAE,2BAAmB;CAC3B,CAAC;AAKF;;GAEG;AACU,QAAA,QAAQ,GAAa,IAAI,wBAAa,CAAC,4CAAkB,EAAE,uBAAY,CAAC,MAAM,EAAE;IAC5F,aAAa,EAAE,kCAA0B;IACzC,yBAAyB,EAAE,IAAI,GAAG,CAAC,CAAC,mDAAyB,CAAC,CAAC;CAC/D,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { type ChangeAtomId, type DeltaFieldChanges, Multiplicity } from \"../../core/index.js\";\nimport { requiredIdentifier, identifierFieldIdentifier } from \"../fieldKindIdentifiers.js\";\nimport {\n\ttype FieldEditor,\n\ttype FieldChangeHandler,\n\tFlexFieldKind,\n\ttype ToDelta,\n} from \"../modular-schema/index.js\";\n\nimport {\n\toptionalChangeHandler,\n\toptionalFieldEditor,\n\toptionalOrRequiredFieldIntoDelta,\n} from \"./optionalField.js\";\nimport type { OptionalChangeset } from \"./optionalFieldChangeTypes.js\";\n\n// Required fields are a restricted version of optional fields that must always contain a value.\n// Because of this, the implementation of required fields lives here, inside optional.\n// This avoids having to export optional field implementation details which are only used by required.\n\n/**\n * {@link FieldEditor} for required fields (always contain exactly 1 child).\n * @remarks\n * This shares code with optional fields, since they are the same edit wise except setting to empty is not allowed,\n * and the content is always assumed to not be empty.\n * This means the actual edits implemented for optional fields are sufficient to support required fields\n * which is why this is defined and implemented in terms of optional fields.\n */\nexport interface RequiredFieldEditor extends FieldEditor<OptionalChangeset> {\n\t/**\n\t * Creates a change which replaces the current value of the field with `newValue`.\n\t * @param ids - The ids for the fill and detach fields.\n\t */\n\tset(ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset;\n}\n\nexport const requiredFieldEditor: RequiredFieldEditor = {\n\t...optionalFieldEditor,\n\tset: (ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset =>\n\t\toptionalFieldEditor.set(false, ids),\n};\n\nexport function requiredFieldIntoDelta(\n\tchange: OptionalChangeset,\n\tdeltaFromChild: ToDelta,\n): DeltaFieldChanges {\n\treturn optionalOrRequiredFieldIntoDelta(false, change, deltaFromChild);\n}\n\nexport const requiredFieldChangeHandler: FieldChangeHandler<\n\tOptionalChangeset,\n\tRequiredFieldEditor\n> = {\n\t...optionalChangeHandler,\n\tintoDelta: requiredFieldIntoDelta,\n\teditor: requiredFieldEditor,\n};\n\ninterface Required\n\textends FlexFieldKind<RequiredFieldEditor, typeof requiredIdentifier, Multiplicity.Single> {}\n\n/**\n * Exactly one item.\n */\nexport const required: Required = new FlexFieldKind(requiredIdentifier, Multiplicity.Single, {\n\tchangeHandler: requiredFieldChangeHandler,\n\tallowMonotonicUpgradeFrom: new Set([identifierFieldIdentifier]),\n});\n"]}
+{"version":3,"file":"requiredField.js","sourceRoot":"","sources":["../../../src/feature-libraries/optional-field/requiredField.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kDAAsE;AACtE,wEAA2F;AAC3F,yDAIoC;AAEpC,yDAAgF;AAuBnE,QAAA,mBAAmB,GAAwB;IACvD,GAAG,sCAAmB;IACtB,GAAG,EAAE,CAAC,GAAiD,EAAqB,EAAE,CAC7E,sCAAmB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC;CACpC,CAAC;AAEW,QAAA,0BAA0B,GAGnC;IACH,GAAG,wCAAqB;IACxB,MAAM,EAAE,2BAAmB;CAC3B,CAAC;AAKF;;GAEG;AACU,QAAA,QAAQ,GAAa,IAAI,wBAAa,CAAC,4CAAkB,EAAE,uBAAY,CAAC,MAAM,EAAE;IAC5F,aAAa,EAAE,kCAA0B;IACzC,yBAAyB,EAAE,IAAI,GAAG,CAAC,CAAC,mDAAyB,CAAC,CAAC;CAC/D,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { type ChangeAtomId, Multiplicity } from \"../../core/index.js\";\nimport { requiredIdentifier, identifierFieldIdentifier } from \"../fieldKindIdentifiers.js\";\nimport {\n\ttype FieldEditor,\n\ttype FieldChangeHandler,\n\tFlexFieldKind,\n} from \"../modular-schema/index.js\";\n\nimport { optionalChangeHandler, optionalFieldEditor } from \"./optionalField.js\";\nimport type { OptionalChangeset } from \"./optionalFieldChangeTypes.js\";\n\n// Required fields are a restricted version of optional fields that must always contain a value.\n// Because of this, the implementation of required fields lives here, inside optional.\n// This avoids having to export optional field implementation details which are only used by required.\n\n/**\n * {@link FieldEditor} for required fields (always contain exactly 1 child).\n * @remarks\n * This shares code with optional fields, since they are the same edit wise except setting to empty is not allowed,\n * and the content is always assumed to not be empty.\n * This means the actual edits implemented for optional fields are sufficient to support required fields\n * which is why this is defined and implemented in terms of optional fields.\n */\nexport interface RequiredFieldEditor extends FieldEditor<OptionalChangeset> {\n\t/**\n\t * Creates a change which replaces the current value of the field with `newValue`.\n\t * @param ids - The ids for the fill and detach fields.\n\t */\n\tset(ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset;\n}\n\nexport const requiredFieldEditor: RequiredFieldEditor = {\n\t...optionalFieldEditor,\n\tset: (ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset =>\n\t\toptionalFieldEditor.set(false, ids),\n};\n\nexport const requiredFieldChangeHandler: FieldChangeHandler<\n\tOptionalChangeset,\n\tRequiredFieldEditor\n> = {\n\t...optionalChangeHandler,\n\teditor: requiredFieldEditor,\n};\n\ninterface Required\n\textends FlexFieldKind<RequiredFieldEditor, typeof requiredIdentifier, Multiplicity.Single> {}\n\n/**\n * Exactly one item.\n */\nexport const required: Required = new FlexFieldKind(requiredIdentifier, Multiplicity.Single, {\n\tchangeHandler: requiredFieldChangeHandler,\n\tallowMonotonicUpgradeFrom: new Set([identifierFieldIdentifier]),\n});\n"]}

package/dist/feature-libraries/sequence-field/compose.d.ts

@@ -4,8 +4,9 @@
  */
 import { type RevisionMetadataSource } from "../../core/index.js";
 import type { IdAllocator } from "../../util/index.js";
-import type { ComposeNodeManager, NodeChangeComposer } from "../modular-schema/index.js";
-import type { Changeset, Mark } from "./types.js";
+import { type CrossFieldManager, type NodeChangeComposer } from "../modular-schema/index.js";
+import { type MoveEffectTable } from "./moveEffectTable.js";
+import { type Changeset, type Mark } from "./types.js";
 /**
  * Composes a sequence of changesets into a single changeset.
  * @param changes - The changesets to be applied.
@@ -18,7 +19,7 @@ import type { Changeset, Mark } from "./types.js";
  * - Support for moves is not implemented.
  * - Support for slices is not implemented.
  */
-export declare function compose(change1: Changeset, change2: Changeset, composeChild: NodeChangeComposer, _genId: IdAllocator, manager: ComposeNodeManager, revisionMetadata: RevisionMetadataSource): Changeset;
+export declare function compose(change1: Changeset, change2: Changeset, composeChild: NodeChangeComposer, _genId: IdAllocator, manager: CrossFieldManager, revisionMetadata: RevisionMetadataSource): Changeset;
 export declare class ComposeQueue {
     private readonly moveEffects;
     private readonly revisionMetadata;
@@ -26,7 +27,7 @@ export declare class ComposeQueue {
     private readonly newMarks;
     private readonly baseMarksCellSources;
     private readonly newMarksCellSources;
-    constructor(baseMarks: Changeset, newMarks: Changeset, moveEffects: ComposeNodeManager, revisionMetadata: RevisionMetadataSource);
+    constructor(baseMarks: Changeset, newMarks: Changeset, moveEffects: MoveEffectTable, revisionMetadata: RevisionMetadataSource);
     isEmpty(): boolean;
     pop(): ComposeMarks;
     private dequeueBase;
@@ -35,8 +36,8 @@ export declare class ComposeQueue {
     private peekMinLength;
 }
 interface ComposeMarks {
-    baseMark: Mark;
-    newMark: Mark;
+    baseMark?: Mark;
+    newMark?: Mark;
 }
 export {};
 //# sourceMappingURL=compose.d.ts.map

package/dist/feature-libraries/sequence-field/compose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/compose.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAIN,KAAK,sBAAsB,EAE3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EACX,kBAAkB,EAClB,kBAAkB,EAElB,MAAM,4BAA4B,CAAC;AAKpC,OAAO,KAAK,EAEX,SAAS,EAET,IAAI,EAIJ,MAAM,YAAY,CAAC;AA2BpB;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACtB,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,SAAS,EAClB,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,kBAAkB,EAC3B,gBAAgB,EAAE,sBAAsB,GACtC,SAAS,CAEX;AAoND,qBAAa,YAAY;IASvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IATlC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAY;IACrC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAuC;IAC5E,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAuC;gBAG1E,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,SAAS,EACF,WAAW,EAAE,kBAAkB,EAC/B,gBAAgB,EAAE,sBAAsB;IAanD,OAAO,IAAI,OAAO;IAIlB,GAAG,IAAI,YAAY;IAyD1B,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,aAAa;CAUrB;AAED,UAAU,YAAY;IACrB,QAAQ,EAAE,IAAI,CAAC;IACf,OAAO,EAAE,IAAI,CAAC;CACd"}
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/compose.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAEN,KAAK,sBAAsB,EAG3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EACN,KAAK,iBAAiB,EAEtB,KAAK,kBAAkB,EAEvB,MAAM,4BAA4B,CAAC;AAKpC,OAAO,EAEN,KAAK,eAAe,EAQpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAGN,KAAK,SAAS,EAEd,KAAK,IAAI,EAMT,MAAM,YAAY,CAAC;AA6BpB;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACtB,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,SAAS,EAClB,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,iBAAiB,EAC1B,gBAAgB,EAAE,sBAAsB,GACtC,SAAS,CAQX;AAuZD,qBAAa,YAAY;IASvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IATlC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAY;IACrC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAuC;IAC5E,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAuC;gBAG1E,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,SAAS,EACF,WAAW,EAAE,eAAe,EAC5B,gBAAgB,EAAE,sBAAsB;IAQnD,OAAO,IAAI,OAAO;IAIlB,GAAG,IAAI,YAAY;IAyD1B,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,aAAa;CAUrB;AAED,UAAU,YAAY;IACrB,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,OAAO,CAAC,EAAE,IAAI,CAAC;CACf"}

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

@@ -7,8 +7,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComposeQueue = exports.compose = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../core/index.js");
+const index_js_2 = require("../modular-schema/index.js");
 const markListFactory_js_1 = require("./markListFactory.js");
 const markQueue_js_1 = require("./markQueue.js");
+const moveEffectTable_js_1 = require("./moveEffectTable.js");
+const types_js_1 = require("./types.js");
 const utils_js_1 = require("./utils.js");
 /**
  * Composes a sequence of changesets into a single changeset.
@@ -31,8 +34,26 @@ function composeMarkLists(baseMarkList, newMarkList, composeChild, moveEffects,
     const queue = new ComposeQueue(baseMarkList, newMarkList, moveEffects, revisionMetadata);
     while (!queue.isEmpty()) {
         const { baseMark, newMark } = queue.pop();
-        const composedMark = composeMarks(baseMark, newMark, composeChild, moveEffects);
-        factory.push(composedMark);
+        if (newMark === undefined) {
+            (0, internal_1.assert)(baseMark !== undefined, 0x4db /* Non-empty queue should not return two undefined marks */);
+            factory.push(composeMark(baseMark, moveEffects, (node) => composeChildChanges(node, undefined, composeChild)));
+        }
+        else {
+            // We only compose changesets that will not be further rebased.
+            // It is therefore safe to remove any intentions that have no impact in the context they apply to.
+            const settledNewMark = (0, utils_js_1.settleMark)(newMark);
+            if (baseMark === undefined) {
+                factory.push(composeMark(settledNewMark, moveEffects, (node) => composeChildChanges(undefined, node, composeChild)));
+            }
+            else {
+                // Past this point, we are guaranteed that `settledNewMark` and `baseMark` have the same length and
+                // start at the same location in the revision after the base changes.
+                // They therefore refer to the same range for that revision.
+                const settledBaseMark = (0, utils_js_1.settleMark)(baseMark);
+                const composedMark = composeMarks(settledBaseMark, settledNewMark, composeChild, moveEffects);
+                factory.push(composedMark);
+            }
+        }
     }
     return factory.list;
 }
@@ -47,64 +68,128 @@ function composeMarkLists(baseMarkList, newMarkList, composeChild, moveEffects,
  */
 function composeMarks(baseMark, newMark, composeChild, moveEffects) {
     const nodeChange = handleNodeChanges(baseMark, newMark, composeChild, moveEffects);
-    return (0, utils_js_1.withNodeChange)(composeMarksIgnoreChild(baseMark, newMark, moveEffects), nodeChange);
+    return withUpdatedEndpoint((0, utils_js_1.withNodeChange)(composeMarksIgnoreChild(baseMark, newMark, moveEffects), nodeChange), baseMark.count, moveEffects);
 }
 function composeMarksIgnoreChild(baseMark, newMark, moveEffects) {
     if ((0, utils_js_1.isNoopMark)(baseMark)) {
         return newMark;
     }
     else if ((0, utils_js_1.isNoopMark)(newMark)) {
-        return updateBaseMarkId(moveEffects, baseMark);
+        return baseMark;
     }
     if ((0, utils_js_1.isRename)(baseMark) && (0, utils_js_1.isRename)(newMark)) {
-        if ((0, index_js_1.areEqualChangeAtomIdOpts)(baseMark.cellId, newMark.idOverride)) {
-            return createNoopMark(baseMark.count, undefined, baseMark.cellId);
-        }
         return { ...baseMark, idOverride: newMark.idOverride };
     }
     else if ((0, utils_js_1.isRename)(baseMark)) {
-        (0, internal_1.assert)((0, utils_js_1.isAttach)(newMark), 0x9f1 /* Unexpected mark type */);
-        (0, internal_1.assert)(baseMark.cellId !== undefined && newMark.cellId !== undefined, "Expected marks to target an empty cell");
+        (0, internal_1.assert)((0, utils_js_1.isAttach)(newMark) || (0, utils_js_1.isAttachAndDetachEffect)(newMark), 0x9f1 /* Unexpected mark type */);
         return { ...newMark, cellId: baseMark.cellId };
     }
     else if ((0, utils_js_1.isRename)(newMark)) {
-        (0, internal_1.assert)((0, utils_js_1.isDetach)(baseMark), 0x9f2 /* Unexpected mark type */);
-        return updateBaseMarkId(moveEffects, { ...baseMark, cellRename: newMark.idOverride });
-    }
-    if (!(0, utils_js_1.markHasCellEffect)(baseMark)) {
-        (0, internal_1.assert)(baseMark.type === "Attach", "Expected baseMark to be a pin");
-        // `newMark` can be either a remove or another pin.
-        // A pin is treated as a detach and attach, so we call `composeAttachDetach` in either case.
-        moveEffects.composeAttachDetach((0, utils_js_1.getAttachedRootId)(baseMark), {
-            revision: newMark.revision,
-            localId: newMark.id,
-        }, baseMark.count);
-        const pinId = (0, utils_js_1.getAttachedRootId)(baseMark);
-        return newMark.type === "Detach"
-            ? {
-                ...newMark,
-                detachCellId: baseMark.detachCellId ?? pinId,
-                cellRename: (0, utils_js_1.getDetachOutputCellId)(newMark),
+        (0, internal_1.assert)((0, utils_js_1.isDetach)(baseMark) || (0, utils_js_1.isAttachAndDetachEffect)(baseMark), 0x9f2 /* Unexpected mark type */);
+        return (0, utils_js_1.isDetach)(baseMark)
+            ? { ...baseMark, idOverride: newMark.idOverride }
+            : { ...baseMark, detach: { ...baseMark.detach, idOverride: newMark.idOverride } };
+    }
+    if ((0, utils_js_1.isImpactfulCellRename)(newMark)) {
+        const newAttachAndDetach = (0, utils_js_1.asAttachAndDetach)(newMark);
+        (0, internal_1.assert)(newAttachAndDetach.cellId !== undefined, 0x9f3 /* Impactful cell rename must target empty cell */);
+        const newDetachRevision = newAttachAndDetach.detach.revision;
+        if ((0, utils_js_1.markEmptiesCells)(baseMark)) {
+            // baseMark is a detach which cancels with the attach portion of the AttachAndDetach,
+            // so we are just left with the detach portion of the AttachAndDetach.
+            const newDetach = {
+                ...newAttachAndDetach.detach,
+                count: baseMark.count,
+            };
+            if ((0, moveEffectTable_js_1.isMoveIn)(newAttachAndDetach.attach) && (0, moveEffectTable_js_1.isMoveOut)(newAttachAndDetach.detach)) {
+                (0, internal_1.assert)((0, moveEffectTable_js_1.isMoveOut)(baseMark), 0x808 /* Unexpected mark type */);
+                // The base changeset and new changeset both move these nodes.
+                // Call the original position of the nodes A, the position after the base changeset is applied B,
+                // and the position after the new changeset is applied C.
+                // The new changeset moves the nodes from B, temporarily returns them to A, and then moves them to C.
+                // The composition of the base and new changesets will be a move directly from A to C,
+                // since the move from A to B cancels out with the return from B to A.
+                // This if-block is handling marks at A.
+                // When we compose the marks at B we will link the start of the base move (A to B)
+                // with the end of the new move (B to C).
+                // Because we are replacing the mark representing the start of the move with the new changeset's
+                // move-out from A, we update the base move-in at B to consider that its start point.
+                const newDetachId = {
+                    revision: newDetachRevision,
+                    localId: newAttachAndDetach.detach.id,
+                };
+                setTruncatedEndpointForInner(moveEffects, index_js_2.CrossFieldTarget.Destination, (0, utils_js_1.getEndpoint)(baseMark), baseMark.count, newDetachId);
+                const newEndpoint = getComposedEndpoint(moveEffects, index_js_2.CrossFieldTarget.Source, baseMark.revision, baseMark.id, baseMark.count);
+                if (newEndpoint !== undefined) {
+                    changeFinalEndpoint(newDetach, newEndpoint);
+                    setTruncatedEndpoint(moveEffects, index_js_2.CrossFieldTarget.Destination, newEndpoint, baseMark.count, newDetachId);
+                }
+            }
+            return newDetach;
+        }
+        if ((0, utils_js_1.isImpactfulCellRename)(baseMark)) {
+            (0, internal_1.assert)(baseMark.cellId !== undefined, 0x9f4 /* Impactful cell rename must target empty cell */);
+            const baseAttachAndDetach = (0, utils_js_1.asAttachAndDetach)(baseMark);
+            const newOutputId = (0, utils_js_1.getOutputCellId)(newAttachAndDetach);
+            const originalAttach = { ...baseAttachAndDetach.attach };
+            const finalDetach = { ...newAttachAndDetach.detach };
+            handleMovePivot(baseMark.count, originalAttach, finalDetach, moveEffects);
+            if ((0, utils_js_1.areEqualCellIds)(newOutputId, baseAttachAndDetach.cellId)) {
+                return { count: baseAttachAndDetach.count, cellId: baseAttachAndDetach.cellId };
             }
-            : newMark;
+            // `newMark`'s attach portion cancels with `baseMark`'s detach portion.
+            const detachRevision = finalDetach.revision;
+            if (detachRevision !== undefined) {
+                finalDetach.revision = detachRevision;
+            }
+            return (0, utils_js_1.normalizeCellRename)(baseMark.cellId, baseMark.count, originalAttach, finalDetach);
+        }
+        return (0, utils_js_1.normalizeCellRename)(newAttachAndDetach.cellId, newAttachAndDetach.count, newAttachAndDetach.attach, newAttachAndDetach.detach);
     }
-    else if (!(0, utils_js_1.markHasCellEffect)(newMark)) {
-        if ((0, utils_js_1.isAttach)(newMark) && (0, utils_js_1.isAttach)(baseMark)) {
-            // When composing two inserts, the second insert (which is a pin) should take precedence.
-            // We treat the pin as a detach and reattach.
-            moveEffects.composeAttachDetach((0, utils_js_1.getAttachedRootId)(baseMark), (0, utils_js_1.getAttachedRootId)(newMark), baseMark.count);
-            const composed = { cellId: baseMark.cellId, ...newMark };
-            delete composed.detachCellId;
-            return composed;
+    if ((0, utils_js_1.isImpactfulCellRename)(baseMark)) {
+        const baseAttachAndDetach = (0, utils_js_1.asAttachAndDetach)(baseMark);
+        if ((0, utils_js_1.markFillsCells)(newMark)) {
+            const originalAttach = (0, utils_js_1.withRevision)({
+                ...baseAttachAndDetach.attach,
+                cellId: baseAttachAndDetach.cellId,
+                count: baseAttachAndDetach.count,
+            }, baseAttachAndDetach.attach.revision);
+            if ((0, moveEffectTable_js_1.isMoveIn)(baseAttachAndDetach.attach) && (0, moveEffectTable_js_1.isMoveOut)(baseAttachAndDetach.detach)) {
+                (0, internal_1.assert)((0, moveEffectTable_js_1.isMoveIn)(newMark), 0x809 /* Unexpected mark type */);
+                const originalAttachId = {
+                    revision: baseAttachAndDetach.attach.revision,
+                    localId: baseAttachAndDetach.attach.id,
+                };
+                setTruncatedEndpointForInner(moveEffects, index_js_2.CrossFieldTarget.Source, (0, utils_js_1.getEndpoint)(newMark), baseAttachAndDetach.count, originalAttachId);
+                const newEndpoint = getComposedEndpoint(moveEffects, index_js_2.CrossFieldTarget.Destination, newMark.revision, newMark.id, newMark.count);
+                if (newEndpoint !== undefined) {
+                    changeFinalEndpoint(originalAttach, newEndpoint);
+                    setTruncatedEndpoint(moveEffects, index_js_2.CrossFieldTarget.Source, newEndpoint, baseMark.count, originalAttachId);
+                }
+            }
+            return originalAttach;
+        }
+        else {
+            // Other mark types have been handled by previous conditional branches.
+            (0, internal_1.assert)(newMark.type === types_js_1.NoopMarkType, 0x80a /* Unexpected mark type */);
+            return baseMark;
         }
-        return updateBaseMarkId(moveEffects, baseMark);
+    }
+    if (!(0, utils_js_1.markHasCellEffect)(baseMark) && !(0, utils_js_1.markHasCellEffect)(newMark)) {
+        return createNoopMark(newMark.count, undefined, (0, utils_js_1.getInputCellId)(baseMark));
+    }
+    else if (!(0, utils_js_1.markHasCellEffect)(baseMark)) {
+        return newMark;
+    }
+    else if (!(0, utils_js_1.markHasCellEffect)(newMark)) {
+        return baseMark;
     }
     else if ((0, utils_js_1.areInputCellsEmpty)(baseMark)) {
         (0, internal_1.assert)((0, utils_js_1.isDetach)(newMark), 0x71c /* Unexpected mark type */);
         (0, internal_1.assert)((0, utils_js_1.isAttach)(baseMark), 0x71d /* Expected generative mark */);
         const attach = (0, utils_js_1.extractMarkEffect)(baseMark);
         const detach = (0, utils_js_1.extractMarkEffect)(newMark);
-        moveEffects.composeAttachDetach((0, utils_js_1.getAttachedRootId)(baseMark), (0, utils_js_1.getDetachedRootId)(newMark), baseMark.count);
+        handleMovePivot(baseMark.count, attach, detach, moveEffects);
         if ((0, utils_js_1.areEqualCellIds)((0, utils_js_1.getOutputCellId)(newMark), baseMark.cellId)) {
             // The output and input cell IDs are the same, so this mark has no effect.
             return { count: baseMark.count, cellId: baseMark.cellId };
@@ -112,36 +197,37 @@ function composeMarksIgnoreChild(baseMark, newMark, moveEffects) {
         return (0, utils_js_1.normalizeCellRename)(baseMark.cellId, baseMark.count, attach, detach);
     }
     else {
-        (0, internal_1.assert)(baseMark.type === "Detach", "Unexpected mark type");
-        (0, internal_1.assert)(newMark.type === "Attach", "Unexpected mark type");
-        const detachId = (0, utils_js_1.getDetachedRootId)(baseMark);
-        const attachId = (0, utils_js_1.getAttachedRootId)(newMark);
-        moveEffects.composeDetachAttach(detachId, attachId, baseMark.count, true);
-        // The composition has no net effect but we preserve the second change's intention to pin the nodes here.
-        const composedMark = { ...newMark };
-        delete composedMark.cellId;
-        const baseDetachCellId = baseMark.detachCellId ?? detachId;
-        if (!(0, index_js_1.areEqualChangeAtomIds)(baseDetachCellId, attachId)) {
-            composedMark.detachCellId = baseDetachCellId;
-        }
-        return composedMark;
+        const length = baseMark.count;
+        return createNoopMark(length, undefined);
     }
 }
-function updateBaseMarkId(moveEffects, baseMark) {
-    if ((0, utils_js_1.isDetach)(baseMark)) {
-        const baseDetachId = (0, utils_js_1.getDetachedRootId)(baseMark);
-        const updatedDetachId = getUpdatedDetachId(moveEffects, baseMark);
-        if (updatedDetachId !== undefined &&
-            !(0, index_js_1.areEqualChangeAtomIds)(updatedDetachId, baseDetachId)) {
-            return {
-                ...baseMark,
-                revision: updatedDetachId.revision,
-                id: updatedDetachId.localId,
-                detachCellId: baseMark.detachCellId ?? baseDetachId,
-            };
+/**
+ * Checks if `baseAttach` and `newDetach` are both moves, and if so updates their move endpoints as appropriate,
+ * and removes their `finalEndpoint` endpoint fields. Note that can mutate `baseAttach` and `newDetach`.
+ * If the effects are not both moves this function does nothing.
+ * @param count - The number of cells targeted
+ * @param baseAttach - The base attach effect at this location
+ * @param newDetach - The new detach effect at this location
+ */
+function handleMovePivot(count, baseAttach, newDetach, moveEffects) {
+    if ((0, moveEffectTable_js_1.isMoveIn)(baseAttach) && (0, moveEffectTable_js_1.isMoveOut)(newDetach)) {
+        const finalSource = (0, utils_js_1.getEndpoint)(baseAttach);
+        const finalDest = (0, utils_js_1.getEndpoint)(newDetach);
+        setEndpoint(moveEffects, index_js_2.CrossFieldTarget.Source, finalSource, count, finalDest);
+        const truncatedEndpoint1 = getTruncatedEndpointForInner(moveEffects, index_js_2.CrossFieldTarget.Destination, baseAttach.revision, baseAttach.id, count);
+        if (truncatedEndpoint1 !== undefined) {
+            setTruncatedEndpoint(moveEffects, index_js_2.CrossFieldTarget.Destination, finalDest, count, truncatedEndpoint1);
         }
+        setEndpoint(moveEffects, index_js_2.CrossFieldTarget.Destination, finalDest, count, finalSource);
+        const truncatedEndpoint2 = getTruncatedEndpointForInner(moveEffects, index_js_2.CrossFieldTarget.Source, newDetach.revision, newDetach.id, count);
+        if (truncatedEndpoint2 !== undefined) {
+            setTruncatedEndpoint(moveEffects, index_js_2.CrossFieldTarget.Source, finalSource, count, truncatedEndpoint2);
+        }
+        // The `finalEndpoint` field of AttachAndDetach move effect pairs is not used,
+        // so we remove it as a normalization.
+        delete baseAttach.finalEndpoint;
+        delete newDetach.finalEndpoint;
     }
-    return baseMark;
 }
 function createNoopMark(length, nodeChange, cellId) {
     const mark = { count: length };
@@ -155,13 +241,14 @@ function createNoopMark(length, nodeChange, cellId) {
     return mark;
 }
 function handleNodeChanges(baseMark, newMark, composeChild, moveEffects) {
-    if (newMark.changes !== undefined &&
-        baseMark.type === "Attach" &&
-        baseMark.cellId !== undefined) {
-        moveEffects.sendNewChangesToBaseSourceLocation((0, utils_js_1.getAttachedRootId)(baseMark), newMark.changes);
-        return undefined;
+    if (newMark.changes !== undefined) {
+        const baseSource = (0, moveEffectTable_js_1.getMoveIn)(baseMark);
+        // TODO: Make sure composeChild is not called twice on the node changes.
+        if (baseSource !== undefined) {
+            setModifyAfter(moveEffects, (0, utils_js_1.getEndpoint)(baseSource), newMark.changes);
+            return undefined;
+        }
     }
-    // TODO: Make sure composeChild is not called twice on the node changes.
     return composeChildChanges(baseMark.changes, newMark.changes, composeChild);
 }
 function composeChildChanges(baseChange, newChange, composeChild) {
@@ -170,15 +257,17 @@ function composeChildChanges(baseChange, newChange, composeChild) {
     }
     return composeChild(baseChange, newChange);
 }
+function composeMark(mark, moveEffects, composeChild) {
+    const nodeChanges = mark.changes === undefined ? undefined : composeChild(mark.changes);
+    const updatedMark = withUpdatedEndpoint(mark, mark.count, moveEffects);
+    return (0, utils_js_1.withNodeChange)(updatedMark, nodeChanges);
+}
 class ComposeQueue {
     constructor(baseMarks, newMarks, moveEffects, revisionMetadata) {
         this.moveEffects = moveEffects;
         this.revisionMetadata = revisionMetadata;
-        const queryFunc = (mark) => (0, utils_js_1.isDetach)(mark) || (0, utils_js_1.isPin)(mark)
-            ? moveEffects.getNewChangesForBaseDetach((0, utils_js_1.getMovedNodeId)(mark), mark.count).length
-            : mark.count;
-        this.baseMarks = new markQueue_js_1.MarkQueue(baseMarks, queryFunc);
-        this.newMarks = new markQueue_js_1.MarkQueue(newMarks, (mark) => mark.count);
+        this.baseMarks = new markQueue_js_1.MarkQueue(baseMarks, moveEffects);
+        this.newMarks = new markQueue_js_1.MarkQueue(newMarks, moveEffects);
         this.baseMarksCellSources = (0, utils_js_1.cellSourcesFromMarks)(baseMarks, utils_js_1.getOutputCellId);
         this.newMarksCellSources = (0, utils_js_1.cellSourcesFromMarks)(newMarks, utils_js_1.getInputCellId);
     }
@@ -189,7 +278,7 @@ class ComposeQueue {
         const baseMark = this.baseMarks.peek();
         const newMark = this.newMarks.peek();
         if (baseMark === undefined && newMark === undefined) {
-            (0, internal_1.fail)("Should not pop when queue is empty");
+            return {};
         }
         else if (baseMark === undefined) {
             return this.dequeueNew();
@@ -238,6 +327,9 @@ class ComposeQueue {
     dequeueBase(length = Number.POSITIVE_INFINITY) {
         const baseMark = this.baseMarks.dequeueUpTo(length);
         const movedChanges = getMovedChangesFromMark(this.moveEffects, baseMark);
+        if (movedChanges !== undefined) {
+            this.moveEffects.onMoveIn(movedChanges);
+        }
         const newMark = createNoopMark(baseMark.count, movedChanges, (0, utils_js_1.getOutputCellId)(baseMark));
         return { baseMark, newMark };
     }
@@ -272,14 +364,100 @@ class ComposeQueue {
 }
 exports.ComposeQueue = ComposeQueue;
 function getMovedChangesFromMark(moveEffects, markEffect) {
-    if (!(0, utils_js_1.isDetach)(markEffect)) {
+    if ((0, utils_js_1.isAttachAndDetachEffect)(markEffect)) {
+        return getMovedChangesFromMark(moveEffects, markEffect.detach);
+    }
+    if (!(0, moveEffectTable_js_1.isMoveOut)(markEffect)) {
         return undefined;
     }
-    return moveEffects.getNewChangesForBaseDetach((0, utils_js_1.getDetachedRootId)(markEffect), 1).value
-        ?.nodeChange;
+    return getModifyAfter(moveEffects, markEffect.revision, markEffect.id);
+}
+// 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 getModifyAfter(moveEffects, revision, id) {
+    const target = index_js_2.CrossFieldTarget.Source;
+    const effect = (0, moveEffectTable_js_1.getMoveEffect)(moveEffects, target, revision, id, 1);
+    if (effect.value?.modifyAfter !== undefined) {
+        return effect.value.modifyAfter;
+    }
+    return undefined;
+}
+// TODO: Reduce the duplication between this and other MoveEffect helpers
+function setModifyAfter(moveEffects, { revision, localId: id }, modifyAfter) {
+    const target = index_js_2.CrossFieldTarget.Source;
+    const count = 1;
+    const effect = (0, moveEffectTable_js_1.getMoveEffect)(moveEffects, target, revision, id, count, false);
+    const newEffect = effect.value === undefined ? { modifyAfter } : { ...effect.value, modifyAfter };
+    (0, moveEffectTable_js_1.setMoveEffect)(moveEffects, target, revision, id, count, newEffect);
+}
+function setEndpoint(moveEffects, target, id, count, endpoint) {
+    const effect = (0, moveEffectTable_js_1.getMoveEffect)(moveEffects, target, id.revision, id.localId, count, false);
+    const newEffect = effect.value === undefined ? { endpoint } : { ...effect.value, endpoint };
+    (0, moveEffectTable_js_1.setMoveEffect)(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
+    const remainingCount = count - effect.length;
+    if (remainingCount > 0) {
+        setEndpoint(moveEffects, target, (0, index_js_1.offsetChangeAtomId)(id, effect.length), remainingCount, (0, index_js_1.offsetChangeAtomId)(endpoint, effect.length));
+    }
+}
+function setTruncatedEndpoint(moveEffects, target, id, count, truncatedEndpoint) {
+    const effect = (0, moveEffectTable_js_1.getMoveEffect)(moveEffects, target, id.revision, id.localId, count);
+    const newEffect = effect.value === undefined
+        ? { truncatedEndpoint }
+        : { ...effect.value, truncatedEndpoint };
+    (0, moveEffectTable_js_1.setMoveEffect)(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
+    const remainingCount = count - effect.length;
+    if (remainingCount > 0) {
+        setTruncatedEndpoint(moveEffects, target, (0, index_js_1.offsetChangeAtomId)(id, effect.length), remainingCount, (0, index_js_1.offsetChangeAtomId)(truncatedEndpoint, effect.length));
+    }
+}
+function setTruncatedEndpointForInner(moveEffects, target, id, count, truncatedEndpointForInner) {
+    const effect = (0, moveEffectTable_js_1.getMoveEffect)(moveEffects, target, id.revision, id.localId, count);
+    const newEffect = effect.value === undefined
+        ? { truncatedEndpointForInner }
+        : { ...effect.value, truncatedEndpointForInner };
+    (0, moveEffectTable_js_1.setMoveEffect)(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
+    const remainingCount = count - effect.length;
+    if (remainingCount > 0) {
+        setTruncatedEndpointForInner(moveEffects, target, (0, index_js_1.offsetChangeAtomId)(id, effect.length), remainingCount, (0, index_js_1.offsetChangeAtomId)(truncatedEndpointForInner, effect.length));
+    }
+}
+function withUpdatedEndpoint(mark, count, effects) {
+    if ((0, utils_js_1.isAttachAndDetachEffect)(mark)) {
+        return {
+            ...mark,
+            attach: withUpdatedEndpoint(mark.attach, count, effects),
+            detach: withUpdatedEndpoint(mark.detach, count, effects),
+        };
+    }
+    if (!(0, moveEffectTable_js_1.isMoveMark)(mark)) {
+        return mark;
+    }
+    const finalDest = getComposedEndpoint(effects, (0, moveEffectTable_js_1.getCrossFieldTargetFromMove)(mark), mark.revision, mark.id, count);
+    if (finalDest === undefined) {
+        return mark;
+    }
+    const output = { ...mark };
+    changeFinalEndpoint(output, finalDest);
+    return output;
+}
+function changeFinalEndpoint(mark, endpoint) {
+    if ((0, utils_js_1.areEqualCellIds)(endpoint, { revision: mark.revision, localId: mark.id })) {
+        delete mark.finalEndpoint;
+    }
+    else {
+        mark.finalEndpoint = endpoint;
+    }
+}
+function getComposedEndpoint(moveEffects, target, revision, id, count) {
+    const effect = (0, moveEffectTable_js_1.getMoveEffect)(moveEffects, target, revision, id, count);
+    (0, internal_1.assert)(effect.length === count, 0x815 /* Expected effect to cover entire mark */);
+    return effect.value?.truncatedEndpoint ?? effect.value?.endpoint;
 }
-function getUpdatedDetachId(manager, mark) {
-    return manager.getNewChangesForBaseDetach((0, utils_js_1.getDetachedRootId)(mark), mark.count).value
-        ?.detachId;
+function getTruncatedEndpointForInner(moveEffects, target, revision, id, count) {
+    const effect = (0, moveEffectTable_js_1.getMoveEffect)(moveEffects, target, revision, id, count);
+    (0, internal_1.assert)(effect.length === count, 0x934 /* Expected effect to cover entire mark */);
+    return effect.value?.truncatedEndpointForInner;
 }
 //# sourceMappingURL=compose.js.map