@fluidframework/tree 2.90.0-378676 → 2.91.0

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

@@ -4,19 +4,101 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryGetEncodedCellRename = exports.encodeRevisionWithContext = exports.encodeSequenceChangeset = exports.makeV2Codec = exports.decodeSequenceChangeset = exports.makeV2CodecHelpers = void 0;
+exports.makeV2Codec = exports.makeV2CodecHelpers = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../codec/index.js");
-const index_js_2 = require("../../core/index.js");
-const index_js_3 = require("../../util/index.js");
-const changeAtomIdBTree_js_1 = require("../changeAtomIdBTree.js");
+const index_js_2 = require("../../util/index.js");
 const changeAtomIdCodec_js_1 = require("../changeAtomIdCodec.js");
-const index_js_4 = require("../modular-schema/index.js");
+const index_js_3 = require("../modular-schema/index.js");
 const formatV2_js_1 = require("./formatV2.js");
 const types_js_1 = require("./types.js");
 const utils_js_1 = require("./utils.js");
 function makeV2CodecHelpers(revisionTagCodec) {
     const changeAtomIdCodec = (0, changeAtomIdCodec_js_1.makeChangeAtomIdCodec)(revisionTagCodec);
+    const markEffectCodec = {
+        encode(effect, context) {
+            function encodeRevision(revision) {
+                if (revision === undefined || revision === context.revision) {
+                    return undefined;
+                }
+                return revisionTagCodec.encode(revision, context);
+            }
+            const type = effect.type;
+            switch (type) {
+                case "MoveIn": {
+                    return {
+                        moveIn: {
+                            revision: encodeRevision(effect.revision),
+                            finalEndpoint: effect.finalEndpoint === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.finalEndpoint, context),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "Insert": {
+                    return {
+                        insert: {
+                            revision: encodeRevision(effect.revision),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "Remove": {
+                    return {
+                        remove: {
+                            revision: encodeRevision(effect.revision),
+                            idOverride: effect.idOverride === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.idOverride, context),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "MoveOut": {
+                    return {
+                        moveOut: {
+                            revision: encodeRevision(effect.revision),
+                            finalEndpoint: effect.finalEndpoint === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.finalEndpoint, context),
+                            idOverride: effect.idOverride === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.idOverride, context),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "AttachAndDetach": {
+                    return {
+                        attachAndDetach: {
+                            attach: markEffectCodec.encode(effect.attach, context),
+                            detach: markEffectCodec.encode(effect.detach, context),
+                        },
+                    };
+                }
+                case "Rename": {
+                    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
+                    // renames are encoded as AttachAndDetach with a special id.
+                    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
+                    return markEffectCodec.encode({
+                        type: "AttachAndDetach",
+                        attach: { type: "MoveIn", id: renameLocalId },
+                        detach: { type: "MoveOut", id: renameLocalId, idOverride: effect.idOverride },
+                    }, context);
+                }
+                case types_js_1.NoopMarkType: {
+                    (0, internal_1.fail)(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
+                }
+                default: {
+                    (0, internal_1.unreachableCase)(type);
+                }
+            }
+        },
+        decode(encoded, context) {
+            return decoderDispatcher.dispatch(encoded, context);
+        },
+    };
     function decodeRevision(encodedRevision, context) {
         if (encodedRevision === undefined) {
             (0, internal_1.assert)(context.revision !== undefined, 0x996 /* Implicit revision should be provided */);
@@ -24,423 +106,140 @@ function makeV2CodecHelpers(revisionTagCodec) {
         }
         return revisionTagCodec.decode(encodedRevision, context);
     }
-    const decoderLibrary = makeMarkEffectDecoder(changeAtomIdCodec, decodeRevision);
-    const decoderDispatcher = new index_js_1.DiscriminatedUnionDispatcher(decoderLibrary);
-    return {
-        changeAtomIdCodec,
-        decoderLibrary,
-        encodeMarkEffect(mark, context) {
-            return encodeMarkEffectV2(mark, context, (revision) => encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec), changeAtomIdCodec);
-        },
-        decodeRevision: (encoded, context) => encoded === undefined
-            ? (context.revision ?? (0, internal_1.fail)("Expected a default revision"))
-            : revisionTagCodec.decode(encoded, context),
-        decodeMarkEffect: (encoded, count, cellId, context) => {
-            return decoderDispatcher.dispatch(encoded, count, cellId, context);
-        },
-    };
-}
-exports.makeV2CodecHelpers = makeV2CodecHelpers;
-function decodeSequenceChangeset(changeset, context, changeAtomIdCodec, decodeMarkEffect) {
-    const marks = [];
-    for (const mark of changeset) {
-        const decodedMark = {
-            count: mark.count,
-        };
-        if (mark.cellId !== undefined) {
-            decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
-        }
-        if (mark.effect !== undefined) {
-            Object.assign(decodedMark, decodeMarkEffect(mark.effect, mark.count, decodedMark.cellId, context));
-        }
-        if (mark.changes !== undefined) {
-            if (decodedMark.cellId === undefined) {
-                decodedMark.changes = context.decodeNode(mark.changes);
-            }
-            else {
-                context.decodeRootNodeChange(decodedMark.cellId, mark.changes);
-            }
-        }
-        marks.push(decodedMark);
-    }
-    return marks;
-}
-exports.decodeSequenceChangeset = decodeSequenceChangeset;
-function makeMarkEffectDecoder(changeAtomIdCodec, decodeRevision) {
-    function decodeMoveIn(encoded, context) {
-        const { id, revision } = encoded;
-        const mark = {
-            type: "Attach",
-            id,
-            revision: decodeRevision(revision, context.baseContext),
-        };
-        return mark;
-    }
     const decoderLibrary = {
-        moveIn(encoded, count, cellId, context) {
-            return decodeMoveIn(encoded, context);
+        moveIn(encoded, context) {
+            const { id, finalEndpoint, revision } = encoded;
+            const mark = {
+                type: "MoveIn",
+                id,
+            };
+            mark.revision = decodeRevision(revision, context);
+            if (finalEndpoint !== undefined) {
+                mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
+            }
+            return mark;
         },
-        insert(encoded, count, cellId, context) {
+        insert(encoded, context) {
             const { id, revision } = encoded;
             const mark = {
-                type: "Attach",
+                type: "Insert",
                 id,
             };
-            mark.revision = decodeRevision(revision, context.baseContext);
-            const attachId = (0, utils_js_1.getAttachedRootId)(mark);
-            if (cellId !== undefined && !(0, index_js_2.areEqualChangeAtomIds)(cellId, attachId)) {
-                context.decodeRootRename(cellId, attachId, count);
-            }
+            mark.revision = decodeRevision(revision, context);
             return mark;
         },
-        remove(encoded, count, cellId, context) {
+        remove(encoded, context) {
             const { id, revision, idOverride } = encoded;
-            const cellRename = idOverride === undefined
-                ? undefined
-                : changeAtomIdCodec.decode(idOverride, context.baseContext);
-            return decodeDetach(cellId, count, decodeRevision(revision, context.baseContext), id, cellRename, undefined, context);
+            const mark = {
+                type: "Remove",
+                id,
+            };
+            mark.revision = decodeRevision(revision, context);
+            if (idOverride !== undefined) {
+                mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
+            }
+            return mark;
         },
-        moveOut(encoded, count, cellId, context) {
-            const { id, idOverride, revision, finalEndpoint } = encoded;
-            const cellRename = idOverride === undefined
-                ? undefined
-                : changeAtomIdCodec.decode(idOverride, context.baseContext);
-            const decodedRevision = decodeRevision(revision, context.baseContext);
+        moveOut(encoded, context) {
+            const { id, finalEndpoint, idOverride, revision } = encoded;
+            const mark = {
+                type: "MoveOut",
+                id,
+            };
+            mark.revision = decodeRevision(revision, context);
             if (finalEndpoint !== undefined) {
-                const decodedEndpoint = changeAtomIdCodec.decode(finalEndpoint, context.baseContext);
-                return decodeDetach(cellId, count, decodedEndpoint.revision ?? (0, internal_1.fail)("Revision should be defined"), decodedEndpoint.localId, cellRename, { revision: decodedRevision, localId: id }, context);
+                mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
+            }
+            if (idOverride !== undefined) {
+                mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
             }
-            return decodeDetach(cellId, count, decodedRevision, id, cellRename, undefined, context);
+            return mark;
         },
-        attachAndDetach(encoded, count, cellId, context) {
+        attachAndDetach(encoded, context) {
+            const attach = decoderDispatcher.dispatch(encoded.attach, context);
+            const detach = decoderDispatcher.dispatch(encoded.detach, context);
             // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
             // renames are encoded as AttachAndDetach with a special id.
             // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-            const encodedRenameId = tryGetEncodedCellRenameFromAttachAndDetach(encoded);
-            if (encodedRenameId !== undefined) {
+            if (attach.id === renameLocalId) {
+                (0, internal_1.assert)(detach.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
                 return {
                     type: "Rename",
-                    idOverride: changeAtomIdCodec.decode(encodedRenameId, context.baseContext),
+                    idOverride: detach.idOverride,
                 };
             }
-            (0, internal_1.assert)(encoded.detach.remove !== undefined, "Attach and detach should always contains a remove");
-            const detachId = encoded.detach.remove.idOverride === undefined
-                ? {
-                    revision: decodeRevision(encoded.detach.remove.revision, context.baseContext),
-                    localId: encoded.detach.remove.id,
-                }
-                : changeAtomIdCodec.decode(encoded.detach.remove.idOverride, context.baseContext);
-            (0, internal_1.assert)(cellId !== undefined, "Attach and detach should target an empty cell");
-            if (encoded.attach.moveIn === undefined) {
-                context.decodeRootRename(cellId, detachId, count);
-            }
-            else {
-                context.decodeMoveAndDetach(detachId, count);
-            }
             return {
-                type: "Rename",
-                idOverride: detachId,
+                type: "AttachAndDetach",
+                attach,
+                detach,
             };
         },
     };
-    return decoderLibrary;
-}
-function decodeDetach(cellId, count, revision, localId, cellRename, detachCellId, context) {
-    const detachId = { revision, localId };
-    if (cellId !== undefined) {
-        context.decodeRootRename(cellId, detachId, count);
-        return {
-            type: "Rename",
-            idOverride: cellRename ?? detachCellId ?? detachId,
-        };
-    }
-    const mark = {
-        type: "Detach",
-        revision,
-        id: localId,
-    };
-    if (cellRename !== undefined) {
-        mark.cellRename = cellRename;
-    }
-    if (detachCellId !== undefined) {
-        mark.detachCellId = detachCellId;
-    }
-    return mark;
-}
-function makeV2Codec(revisionTagCodec) {
-    const { decodeMarkEffect, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
+    const decoderDispatcher = new index_js_1.DiscriminatedUnionDispatcher(decoderLibrary);
     return {
-        encode: (changeset, context) => encodeSequenceChangeset(changeset, context, (revision) => encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec), changeAtomIdCodec, encodeMarkEffectV2),
-        decode: (changeset, context) => decodeSequenceChangeset(changeset, context, changeAtomIdCodec, decodeMarkEffect),
-        encodedSchema: (0, formatV2_js_1.Changeset)(index_js_4.EncodedNodeChangeset),
+        changeAtomIdCodec,
+        markEffectCodec,
+        decoderLibrary,
+        decodeRevision,
     };
 }
-exports.makeV2Codec = makeV2Codec;
-function encodeSequenceChangeset(changeset, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
-    const jsonMarks = [];
-    for (const mark of changeset) {
-        jsonMarks.push(...encodeMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect));
-    }
-    return jsonMarks;
-}
-exports.encodeSequenceChangeset = encodeSequenceChangeset;
-function encodeMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
-    const splitLength = getLengthToSplitMark(mark, context);
-    if (splitLength < mark.count) {
-        const [mark1, mark2] = (0, utils_js_1.splitMark)(mark, splitLength);
-        return [
-            encodeSplitMark(mark1, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
-            ...encodeMark(mark2, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
-        ];
-    }
-    return [encodeSplitMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect)];
-}
-function encodeRename(mark, context, changeAtomIdCodec, encodeRevision) {
-    (0, internal_1.assert)(mark.cellId !== undefined, "Rename should target empty cell");
-    const inputDetachId = context.getInputRootId(mark.idOverride, mark.count).value;
-    const isMoveInAndDetach = !context.isAttachId(mark.idOverride, mark.count).value &&
-        (context.isDetachId(mark.idOverride, mark.count).value ||
-            (inputDetachId !== undefined && !(0, index_js_2.areEqualChangeAtomIds)(inputDetachId, mark.cellId)));
-    if (isMoveInAndDetach) {
-        // These cells are the final detach location of moved nodes.
-        const encodedRevision = encodeRevision(mark.idOverride.revision);
-        const endpoint = context.getCellIdForMove(mark.idOverride, mark.count).value;
-        const encodedEndpoint = endpoint === undefined
-            ? undefined
-            : changeAtomIdCodec.encode(endpoint, context.baseContext);
-        return {
-            attachAndDetach: {
-                attach: {
-                    moveIn: {
-                        revision: encodedRevision,
-                        id: mark.idOverride.localId,
-                        finalEndpoint: encodedEndpoint,
-                    },
-                },
-                detach: {
-                    remove: {
-                        revision: encodedRevision,
-                        id: mark.idOverride.localId,
-                    },
-                },
-            },
-        };
-    }
-    const renamedRootId = context.rootRenames.getFirst(mark.cellId, mark.count).value;
-    const isMoveOutAndAttach = renamedRootId !== undefined && context.isAttachId(renamedRootId, mark.count).value;
-    const isRenameOfRoot = renamedRootId !== undefined;
-    // If we are renaming a root, but the output ID is not `mark.idOverride`,
-    // then we must be moving the node to another cell.
-    // If it were left in this cell, the root's output ID would not match the cell's output ID.
-    const isMoveOutAndDetach = isRenameOfRoot && !(0, index_js_2.areEqualChangeAtomIds)(renamedRootId, mark.idOverride);
-    if (isMoveOutAndAttach || isMoveOutAndDetach) {
-        // This mark represents a move of a node which was detached from this cell.
-        // The root will be either be reattached with `moveId`,
-        // or left detached in another cell, with `moveId` as its output root ID.
-        // In the latter case, the other endpoint will be encoded as
-        // attach and detach (move-in and remove), where both the move-in and the remove
-        // use `moveId` as their ID.
-        // In either of these cases, we need this mark's `finalEndpoint` to be `moveId`.
-        // We can omit the final endpoint if it is the same as the move-out ID.
-        const encodedEndpoint = (0, index_js_2.areEqualChangeAtomIds)(mark.idOverride, renamedRootId)
-            ? undefined
-            : changeAtomIdCodec.encode(renamedRootId, context.baseContext);
-        return {
-            moveOut: {
-                revision: encodeRevision(mark.idOverride.revision),
-                id: mark.idOverride.localId,
-                finalEndpoint: encodedEndpoint,
-            },
-        };
-    }
-    if (renamedRootId !== undefined) {
-        return {
-            remove: {
-                revision: encodeRevision(renamedRootId.revision),
-                id: renamedRootId.localId,
-            },
-        };
-    }
-    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-    // renames are encoded as AttachAndDetach with a special id.
-    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
+exports.makeV2CodecHelpers = makeV2CodecHelpers;
+function makeV2Codec(revisionTagCodec) {
+    const { markEffectCodec, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
     return {
-        attachAndDetach: {
-            attach: { insert: { id: renameLocalId } },
-            detach: {
-                remove: {
-                    id: renameLocalId,
-                    idOverride: changeAtomIdCodec.encode(mark.idOverride, context.baseContext),
-                },
-            },
-        },
-    };
-}
-function getLengthToSplitMark(mark, context) {
-    let count = mark.cellId === undefined
-        ? mark.count
-        : (0, changeAtomIdBTree_js_1.rangeQueryChangeAtomIdMap)(context.rootNodeChanges, mark.cellId, mark.count).length;
-    if (mark.cellId !== undefined) {
-        count = context.getInputRootId(mark.cellId, count).length;
-    }
-    switch (mark.type) {
-        case "Attach": {
-            const attachId = (0, utils_js_1.getAttachedRootId)(mark);
-            count = context.isDetachId(attachId, count).length;
-            count = context.getCellIdForMove(attachId, count).length;
-            break;
-        }
-        case "Detach": {
-            count = context.isAttachId((0, utils_js_1.getDetachedRootId)(mark), count).length;
-            break;
-        }
-        case "Rename": {
-            count = context.getInputRootId(mark.idOverride, count).length;
-            count = context.isAttachId(mark.idOverride, count).length;
-            count = context.isDetachId(mark.idOverride, count).length;
-            count = context.getCellIdForMove(mark.idOverride, count).length;
-            const cellId = mark.cellId ?? (0, internal_1.fail)("Rename should have cell ID");
-            const renameEntry = context.rootRenames.getFirst(cellId, count);
-            count = renameEntry.length;
-            count = context.isAttachId(renameEntry.value ?? cellId, count).length;
-            break;
-        }
-        default: {
-            break;
-        }
-    }
-    return count;
-}
-function encodeSplitMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
-    const encodedMark = {
-        count: mark.count,
-    };
-    if (!(0, utils_js_1.isNoopMark)(mark)) {
-        encodedMark.effect = encodeMarkEffect(mark, context, encodeRevision, changeAtomIdCodec);
-    }
-    if (mark.cellId !== undefined) {
-        (0, internal_1.assert)(mark.changes === undefined, "Empty cells should not have node changes");
-        encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
-        const nodeId = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(context.rootNodeChanges, mark.cellId);
-        if (nodeId !== undefined) {
-            encodedMark.changes = context.encodeNode(nodeId);
-        }
-    }
-    else if (mark.changes !== undefined) {
-        encodedMark.changes = context.encodeNode(mark.changes);
-    }
-    return encodedMark;
-}
-function encodeMarkEffectV2(mark, context, encodeRevision, changeAtomIdCodec) {
-    const type = mark.type;
-    switch (type) {
-        case "Attach": {
-            const attachId = (0, utils_js_1.getAttachedRootId)(mark);
-            const isMove = context.isDetachId(attachId, 1).value;
-            // If the input context ID for these nodes is not the cell ID,
-            // then these nodes are being moved from the location at which they were last detached.
-            const inputId = context.getInputRootId(attachId, mark.count).value ?? attachId;
-            const isInitialAttachLocation = mark.cellId === undefined || (0, index_js_2.areEqualChangeAtomIds)(mark.cellId, inputId);
-            if (!isMove && isInitialAttachLocation) {
-                return {
-                    insert: {
-                        revision: encodeRevision(mark.revision),
-                        id: mark.id,
-                    },
+        encode: (changeset, context) => {
+            const jsonMarks = [];
+            for (const mark of changeset) {
+                const encodedMark = {
+                    count: mark.count,
                 };
+                if (!(0, utils_js_1.isNoopMark)(mark)) {
+                    encodedMark.effect = markEffectCodec.encode(mark, context.baseContext);
+                }
+                if (mark.cellId !== undefined) {
+                    encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
+                }
+                if (mark.changes !== undefined) {
+                    encodedMark.changes = context.encodeNode(mark.changes);
+                }
+                jsonMarks.push(encodedMark);
             }
-            const detachCellId = context.getCellIdForMove(attachId, mark.count).value;
-            const encodedEndpoint = detachCellId === undefined
-                ? undefined
-                : changeAtomIdCodec.encode(detachCellId, context.baseContext);
-            return {
-                moveIn: {
-                    revision: encodeRevision(mark.revision),
-                    id: mark.id,
-                    finalEndpoint: encodedEndpoint,
-                },
-            };
-        }
-        case "Detach": {
-            const encodedIdOverride = mark.cellRename === undefined
-                ? undefined
-                : changeAtomIdCodec.encode(mark.cellRename, context.baseContext);
-            const detachId = (0, utils_js_1.getDetachedRootId)(mark);
-            const isMove = context.isAttachId(detachId, 1).value;
-            const outputCellId = mark.cellRename ?? mark.detachCellId ?? detachId;
-            // If the final detach location for the nodes were here,
-            // then the output cell ID would be the same as the detach ID.
-            // So if the cell ID is different from the detach ID, the nodes must have been moved.
-            const isFinalDetachLocation = (0, index_js_2.areEqualChangeAtomIds)(detachId, outputCellId);
-            const isMoveOrDetachedMove = isMove || !isFinalDetachLocation;
-            if (mark.detachCellId !== undefined) {
-                (0, internal_1.assert)(isMoveOrDetachedMove, "Only detaches representing a move out should specify a detach cell ID");
-                return {
-                    moveOut: {
-                        revision: encodeRevision(mark.detachCellId.revision),
-                        id: mark.detachCellId.localId,
-                        idOverride: encodedIdOverride,
-                        finalEndpoint: changeAtomIdCodec.encode({ revision: mark.revision, localId: mark.id }, context.baseContext),
-                    },
+            return jsonMarks;
+        },
+        decode: (changeset, context) => {
+            const marks = [];
+            for (const mark of changeset) {
+                const decodedMark = {
+                    count: mark.count,
                 };
-            }
-            const encodedRevision = encodeRevision(mark.revision);
-            return isMoveOrDetachedMove
-                ? {
-                    moveOut: {
-                        revision: encodedRevision,
-                        id: mark.id,
-                        idOverride: encodedIdOverride,
-                    },
+                if (mark.effect !== undefined) {
+                    Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context.baseContext));
                 }
-                : {
-                    remove: {
-                        revision: encodedRevision,
-                        idOverride: encodedIdOverride,
-                        id: mark.id,
-                    },
-                };
-        }
-        case "Rename": {
-            return encodeRename(mark, context, changeAtomIdCodec, encodeRevision);
-        }
-        case types_js_1.NoopMarkType: {
-            (0, internal_1.fail)(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
-        }
-        default: {
-            (0, internal_1.unreachableCase)(type);
-        }
-    }
-}
-function encodeRevisionWithContext(revision, context, revisionTagCodec) {
-    return revision === undefined || revision === context.revision
-        ? undefined
-        : revisionTagCodec.encode(revision, context);
+                if (mark.cellId !== undefined) {
+                    decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
+                }
+                // Type deduction wrongly narrows the type of `decodedMark` to `NoopMark & HasMarkFields`.
+                // We declare a new casted copy of `decodedMark` to recover the correct type.
+                let decodedMark2 = decodedMark;
+                if (decodedMark2.cellId !== undefined && decodedMark2.type === "AttachAndDetach") {
+                    // In documents generated by clients on release <=2.1 (i.e., not running the code from the PR that added this comment),
+                    // rename-like AttachAndDetach marks are not normalized to Rename marks thus requiring this normalization step.
+                    // This ensures backward compatibility with documents generated by clients on release <=2.1.
+                    decodedMark2 = (0, utils_js_1.normalizeCellRename)(decodedMark2.cellId, decodedMark2.count, decodedMark2.attach, decodedMark2.detach);
+                }
+                if (mark.changes !== undefined) {
+                    decodedMark2.changes = context.decodeNode(mark.changes);
+                }
+                marks.push(decodedMark2);
+            }
+            return marks;
+        },
+        encodedSchema: (0, formatV2_js_1.Changeset)(index_js_3.EncodedNodeChangeset),
+    };
 }
-exports.encodeRevisionWithContext = encodeRevisionWithContext;
+exports.makeV2Codec = makeV2Codec;
 /**
  * Arbitrary ID that is used to indicate a Rename effect.
  */
-const renameLocalId = (0, index_js_3.brand)(-1);
-/**
- * If the encoded mark effect represents a simple cell rename (with no effect on root nodes),
- * returns the encoded form of the ID the cell is being renamed to,
- * and otherwise returns undefined.
- */
-function tryGetEncodedCellRename(encoded) {
-    const attachAndDetach = encoded.attachAndDetach;
-    if (attachAndDetach === undefined) {
-        return undefined;
-    }
-}
-exports.tryGetEncodedCellRename = tryGetEncodedCellRename;
-function tryGetEncodedCellRenameFromAttachAndDetach(encoded) {
-    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-    // renames are encoded as AttachAndDetach with a special id.
-    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-    if (encoded.attach.insert?.id === renameLocalId) {
-        (0, internal_1.assert)(encoded.detach.remove?.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
-        return encoded.detach.remove.idOverride;
-    }
-}
+const renameLocalId = (0, index_js_2.brand)(-1);
 //# sourceMappingURL=sequenceFieldCodecV2.js.map