@fluidframework/tree 2.90.0-378676 → 2.91.0

package/lib/feature-libraries/optional-field/optionalField.js

@@ -3,354 +3,542 @@
  * Licensed under the MIT License.
  */
 import { assert } from "@fluidframework/core-utils/internal";
-import { Multiplicity, areEqualChangeAtomIdOpts, forbiddenFieldKindIdentifier, makeChangeAtomId, } from "../../core/index.js";
+import { Multiplicity, areEqualChangeAtomIds, forbiddenFieldKindIdentifier, makeChangeAtomId, taggedAtomId, } from "../../core/index.js";
+import { SizedNestedMap, deleteFromNestedMap, setInNestedMap, tryGetFromNestedMap, } from "../../util/index.js";
 import { nodeIdFromChangeAtom } from "../deltaUtils.js";
 import { optionalIdentifier, identifierFieldIdentifier, requiredIdentifier, } from "../fieldKindIdentifiers.js";
-import { NodeMoveType, FlexFieldKind, } from "../modular-schema/index.js";
+import { NodeAttachState, FlexFieldKind, } from "../modular-schema/index.js";
 import { makeOptionalFieldCodecFamily } from "./optionalFieldCodecs.js";
-export const optionalChangeRebaser = {
-    compose,
-    invert: (change, isRollback, genId, revision, nodeManager) => {
-        const inverted = {};
-        const detachId = getEffectiveDetachId(change);
-        if (detachId !== undefined) {
-            const attachIdForInverse = isRollback
-                ? detachId
-                : makeChangeAtomId(detachId.localId, revision);
-            nodeManager.invertDetach(detachId, 1, change.childChange, attachIdForInverse);
-            inverted.valueReplace = {
-                isEmpty: change.valueReplace?.src === undefined,
-                dst: makeChangeAtomId(genId.allocate(), revision),
-                src: attachIdForInverse,
-            };
+export class RegisterMap {
+    constructor() {
+        this.nestedMapData = new SizedNestedMap();
+    }
+    clone() {
+        const clone = new RegisterMap();
+        for (const [id, t] of this.entries()) {
+            clone.set(id, t);
+        }
+        return clone;
+    }
+    set(id, childChange) {
+        if (id === "self") {
+            this.nestedMapData.set("self", undefined, childChange);
+        }
+        else {
+            this.nestedMapData.set(id.localId, id.revision, childChange);
+        }
+    }
+    get(id) {
+        return id === "self"
+            ? this.nestedMapData.tryGet(id, undefined)
+            : this.nestedMapData.tryGet(id.localId, id.revision);
+    }
+    has(id) {
+        return this.get(id) !== undefined;
+    }
+    delete(id) {
+        return id === "self"
+            ? this.nestedMapData.delete("self", undefined)
+            : this.nestedMapData.delete(id.localId, id.revision);
+    }
+    keys() {
+        const changeIds = [];
+        for (const [localId, nestedMap] of this.nestedMapData) {
+            if (localId === "self") {
+                changeIds.push("self");
+            }
+            else {
+                for (const [revisionTag, _] of nestedMap) {
+                    changeIds.push(revisionTag === undefined ? { localId } : { localId, revision: revisionTag });
+                }
+            }
         }
-        if (change.valueReplace?.src !== undefined) {
-            const attachEntry = nodeManager.invertAttach(change.valueReplace.src, 1);
-            const detachIdForInverse = invertAttachId(change.valueReplace.src, revision, isRollback, attachEntry.value?.detachId);
-            if (attachEntry.value?.nodeChange !== undefined) {
-                inverted.childChange = attachEntry.value.nodeChange;
+        return changeIds;
+    }
+    values() {
+        return this.nestedMapData.values();
+    }
+    entries() {
+        const entries = [];
+        for (const changeId of this.keys()) {
+            if (changeId === "self") {
+                const entry = this.nestedMapData.tryGet("self", undefined);
+                assert(entry !== undefined, 0x770 /* Entry should not be undefined when iterating keys. */);
+                entries.push(["self", entry]);
             }
-            // TODO: Always use nodeDetach instead of valueReplace if not supporting older client versions.
-            if (isPin(change)) {
-                inverted.nodeDetach = detachIdForInverse;
+            else {
+                const entry = this.nestedMapData.tryGet(changeId.localId, changeId.revision);
+                assert(entry !== undefined, 0x771 /* Entry should not be undefined when iterating keys. */);
+                entries.push([changeId, entry]);
             }
-            else if (inverted.valueReplace === undefined) {
-                inverted.valueReplace = { isEmpty: false, dst: detachIdForInverse };
+        }
+        return entries;
+    }
+    get size() {
+        return this.nestedMapData.size;
+    }
+}
+export const optionalChangeRebaser = {
+    compose: (change1, change2, composeChild) => {
+        const { srcToDst, dstToSrc } = getBidirectionalMaps(change1.moves);
+        const change1FieldSrc = change1.valueReplace?.src;
+        const change1FieldDst = getEffectfulDst(change1.valueReplace);
+        const change2FieldSrc = change2.valueReplace?.src;
+        let composedFieldSrc;
+        if (change2FieldSrc !== undefined) {
+            if (change2FieldSrc === "self") {
+                composedFieldSrc = change1FieldSrc ?? change2FieldSrc;
+            }
+            else if (change1FieldDst !== undefined &&
+                areEqualRegisterIds(change1FieldDst, change2FieldSrc)) {
+                composedFieldSrc = "self";
             }
             else {
-                inverted.valueReplace.dst = detachIdForInverse;
+                composedFieldSrc =
+                    tryGetFromNestedMap(dstToSrc, change2FieldSrc.revision, change2FieldSrc.localId) ??
+                        change2FieldSrc;
             }
         }
-        else if (detachId === undefined && change.childChange !== undefined) {
-            // This change does not affect which node is in the field, so its child change should remain here.
-            inverted.childChange = change.childChange;
+        else if (change1FieldSrc !== undefined && change2.valueReplace === undefined) {
+            composedFieldSrc = change1FieldSrc;
         }
-        return inverted;
+        const childChanges2ByOriginalId = new RegisterMap();
+        for (const [id, change] of change2.childChanges) {
+            if (id === "self") {
+                if (change1FieldSrc === undefined) {
+                    childChanges2ByOriginalId.set("self", change);
+                }
+                else {
+                    childChanges2ByOriginalId.set(change1FieldSrc, change);
+                }
+            }
+            else {
+                if (change1FieldDst !== undefined && areEqualChangeAtomIds(change1FieldDst, id)) {
+                    childChanges2ByOriginalId.set("self", change);
+                }
+                else {
+                    const originalId = tryGetFromNestedMap(dstToSrc, id.revision, id.localId);
+                    childChanges2ByOriginalId.set(originalId ?? id, change);
+                }
+            }
+        }
+        const composedMoves = [];
+        const composedChildChanges = [];
+        const composed = {
+            moves: composedMoves,
+            childChanges: composedChildChanges,
+        };
+        for (const [id, childChange1] of change1.childChanges) {
+            const childChange2 = childChanges2ByOriginalId.get(id);
+            composedChildChanges.push([id, composeChild(childChange1, childChange2)]);
+            childChanges2ByOriginalId.delete(id);
+        }
+        for (const [id, childChange2] of childChanges2ByOriginalId.entries()) {
+            composedChildChanges.push([id, composeChild(undefined, childChange2)]);
+        }
+        for (const [leg2Src, leg2Dst] of change2.moves) {
+            const leg1Src = tryGetFromNestedMap(dstToSrc, leg2Src.revision, leg2Src.localId);
+            if (leg1Src !== undefined) {
+                composedMoves.push([leg1Src, leg2Dst]);
+                deleteFromNestedMap(srcToDst, leg1Src.revision, leg1Src.localId);
+                deleteFromNestedMap(dstToSrc, leg2Src.revision, leg2Src.localId);
+            }
+            else if (change1FieldDst === undefined ||
+                !areEqualChangeAtomIds(change1FieldDst, leg2Src)) {
+                composedMoves.push([leg2Src, leg2Dst]);
+            }
+        }
+        for (const [revision, innerMap] of srcToDst.entries()) {
+            for (const [localId, dst] of innerMap.entries()) {
+                const src = makeChangeAtomId(localId, revision);
+                if (composedFieldSrc === undefined || !areEqualRegisterIds(src, composedFieldSrc)) {
+                    composedMoves.push([src, dst]);
+                }
+            }
+        }
+        if (change1FieldSrc !== undefined &&
+            change1FieldSrc !== "self" &&
+            change2.valueReplace !== undefined) {
+            const change2FieldDst = change2.valueReplace.dst;
+            if (isReplaceEffectful(change2.valueReplace) &&
+                !areEqualChangeAtomIds(change1FieldSrc, change2FieldDst)) {
+                composedMoves.push([change1FieldSrc, change2FieldDst]);
+            }
+        }
+        const firstChange = change1.valueReplace ?? change2.valueReplace;
+        if (firstChange === undefined) {
+            return composed;
+        }
+        const replace = {
+            isEmpty: firstChange.isEmpty,
+            dst: getComposedReplaceDst(change1.valueReplace, change2),
+        };
+        if (composedFieldSrc !== undefined) {
+            replace.src = composedFieldSrc;
+        }
+        composed.valueReplace = replace;
+        return composed;
     },
-    rebase: (newChange, overChange, rebaseChild, _genId, nodeManager, _metadata, rebaseVersion) => {
-        const rebased = {};
-        const rebasedChild = rebaseChild(newChange.childChange, overChange.childChange);
-        const overDetach = getEffectiveDetachId(overChange);
-        // Note that composition ignores rebase version, and so will create node detaches even when we are supporting collaboration with older clients.
-        // Therefore, in rebase version 1 we must rebase node detach as if it were a clear, matching the behavior of older clients.
-        const hasNodeDetachTreatedAsClear = newChange.nodeDetach !== undefined && rebaseVersion < 2 && !isPin(newChange);
-        if (overDetach !== undefined) {
-            const nodeDetach = hasNodeDetachTreatedAsClear ? undefined : newChange.nodeDetach;
-            nodeManager.rebaseOverDetach(overDetach, 1, nodeDetach, rebasedChild);
-        }
-        const overAttach = overChange.valueReplace?.src;
-        if (overAttach !== undefined) {
-            const movedChangeEntry = nodeManager.getNewChangesForBaseAttach(overAttach, 1).value;
-            if (movedChangeEntry?.nodeChange !== undefined) {
-                rebased.childChange = movedChangeEntry.nodeChange;
+    invert: (change, isRollback, genId, revision) => {
+        const { moves, childChanges, valueReplace } = change;
+        const invertIdMap = new RegisterMap();
+        const invertedMoves = [];
+        for (const [src, dst] of moves) {
+            invertIdMap.set(src, dst);
+            invertedMoves.push([dst, src]);
+        }
+        if (valueReplace !== undefined) {
+            const effectfulDst = getEffectfulDst(valueReplace);
+            if (effectfulDst !== undefined) {
+                invertIdMap.set("self", valueReplace.dst);
             }
-            if (movedChangeEntry?.detachId !== undefined) {
-                rebased.nodeDetach = movedChangeEntry.detachId;
-                if (newChange.valueReplace !== undefined) {
-                    // Now that the rebased change has a node detach,
-                    // the detach from the value replace no longer takes effect.
-                    nodeManager.removeDetach(newChange.valueReplace.dst, 1);
+            if (valueReplace.src !== undefined) {
+                invertIdMap.set(valueReplace.src, "self");
+            }
+        }
+        const inverted = {
+            moves: invertedMoves,
+            childChanges: childChanges.map(([id, childChange]) => {
+                return [invertIdMap.get(id) ?? id, childChange];
+            }),
+        };
+        if (valueReplace !== undefined) {
+            if (isReplaceEffectful(valueReplace)) {
+                const replace = valueReplace.src === undefined
+                    ? {
+                        isEmpty: true,
+                        dst: makeChangeAtomId(genId.allocate(), revision),
+                    }
+                    : {
+                        isEmpty: false,
+                        dst: isRollback
+                            ? valueReplace.src
+                            : makeChangeAtomId(genId.allocate(), revision),
+                    };
+                if (valueReplace.isEmpty === false) {
+                    replace.src = valueReplace.dst;
                 }
+                inverted.valueReplace = replace;
+            }
+            else if (!isRollback && valueReplace.src === "self") {
+                inverted.valueReplace = {
+                    isEmpty: false,
+                    src: "self",
+                    dst: makeChangeAtomId(genId.allocate(), revision),
+                };
             }
         }
-        else if (overDetach === undefined) {
-            // `overChange` did not change which node is in the field.
-            if (rebasedChild !== undefined) {
-                rebased.childChange = rebasedChild;
+        return inverted;
+    },
+    rebase: (change, overChange, rebaseChild) => {
+        const { moves, childChanges, valueReplace: field } = change;
+        // TODO: avoid computing the dstToSrc map if it's not needed.
+        // TODO: de-dupe overSrcToDst and forwardMap
+        const { srcToDst: overSrcToDst } = getBidirectionalMaps(overChange.moves);
+        const forwardMap = new RegisterMap();
+        for (const [src, dst] of overChange.moves) {
+            forwardMap.set(src, dst);
+        }
+        if (overChange.valueReplace !== undefined) {
+            const effectfulDst = getEffectfulDst(overChange.valueReplace);
+            if (effectfulDst !== undefined) {
+                forwardMap.set("self", overChange.valueReplace.dst);
             }
-            if (newChange.nodeDetach !== undefined) {
-                rebased.nodeDetach = newChange.nodeDetach;
+            if (overChange.valueReplace.src !== undefined) {
+                forwardMap.set(overChange.valueReplace.src, "self");
             }
         }
-        if (hasNodeDetachTreatedAsClear && overDetach !== undefined) {
-            // In order to emulate the rebasing behavior of older clients,
-            // we convert the node detach to a clear.
-            const valueReplace = {
-                dst: newChange.nodeDetach,
-                isEmpty: overAttach === undefined,
-            };
-            if (newChange.valueReplace?.src !== undefined) {
-                valueReplace.src = newChange.valueReplace.src;
+        const rebasedMoves = [];
+        for (const [src, dst] of moves) {
+            const newDst = tryGetFromNestedMap(overSrcToDst, src.revision, src.localId);
+            rebasedMoves.push([src, newDst ?? dst]);
+        }
+        const overChildChangesBySrc = new RegisterMap();
+        for (const [id, childChange] of overChange.childChanges) {
+            overChildChangesBySrc.set(id, childChange);
+        }
+        const rebasedChildChanges = [];
+        for (const [id, childChange] of childChanges) {
+            const overChildChange = overChildChangesBySrc.get(id);
+            if (overChildChange !== undefined) {
+                overChildChangesBySrc.delete(id);
             }
-            rebased.valueReplace = valueReplace;
-        }
-        else if (newChange.valueReplace !== undefined) {
-            const isEmpty = overDetach !== undefined || overAttach !== undefined
-                ? overAttach === undefined
-                : newChange.valueReplace.isEmpty;
-            rebased.valueReplace = { ...newChange.valueReplace, isEmpty };
-        }
-        const detachId = getEffectiveDetachId(newChange);
-        const rebasedDetachId = getEffectiveDetachId(rebased);
-        if (!areEqualChangeAtomIdOpts(detachId, rebasedDetachId)) {
-            if (detachId !== undefined) {
-                nodeManager.removeDetach(detachId, 1);
+            const rebasedId = forwardMap.get(id) ?? id;
+            const rebasedChildChange = rebaseChild(childChange, overChildChange, rebasedId === "self" ? NodeAttachState.Attached : NodeAttachState.Detached);
+            if (rebasedChildChange !== undefined) {
+                rebasedChildChanges.push([rebasedId, rebasedChildChange]);
             }
-            if (rebasedDetachId !== undefined) {
-                nodeManager.addDetach(rebasedDetachId, 1);
+        }
+        for (const [id, overChildChange] of overChildChangesBySrc.entries()) {
+            const rebasedId = forwardMap.get(id) ?? id;
+            const rebasedChildChange = rebaseChild(undefined, overChildChange, rebasedId === "self" ? NodeAttachState.Attached : NodeAttachState.Detached);
+            if (rebasedChildChange !== undefined) {
+                rebasedChildChanges.push([rebasedId, rebasedChildChange]);
             }
         }
+        const rebased = {
+            moves: rebasedMoves,
+            childChanges: rebasedChildChanges,
+        };
+        if (field !== undefined) {
+            const replace = {
+                isEmpty: overChange.valueReplace === undefined
+                    ? field.isEmpty
+                    : overChange.valueReplace.src === undefined,
+                dst: field.dst,
+            };
+            if (field.src !== undefined) {
+                replace.src = forwardMap.get(field.src) ?? field.src;
+            }
+            rebased.valueReplace = replace;
+        }
         return rebased;
     },
     prune: (change, pruneChild) => {
-        const prunedChange = { ...change };
-        delete prunedChange.childChange;
-        if (change.childChange !== undefined) {
-            const childChange = pruneChild(change.childChange);
-            if (childChange !== undefined) {
-                prunedChange.childChange = childChange;
+        const childChanges = [];
+        const prunedChange = {
+            moves: change.moves,
+            childChanges,
+        };
+        if (change.valueReplace !== undefined) {
+            prunedChange.valueReplace = change.valueReplace;
+        }
+        for (const [id, childChange] of change.childChanges) {
+            const prunedChildChange = pruneChild(childChange);
+            if (prunedChildChange !== undefined) {
+                childChanges.push([id, prunedChildChange]);
             }
         }
         return prunedChange;
     },
     replaceRevisions: (change, replacer) => {
-        const updated = {};
         const valueReplace = replaceReplaceRevisions(change.valueReplace, replacer);
-        if (change.childChange !== undefined) {
-            updated.childChange = replacer.getUpdatedAtomId(change.childChange);
+        const childChanges = [];
+        for (const [id, childChange] of change.childChanges) {
+            childChanges.push([
+                replaceRegisterRevisions(id, replacer),
+                replacer.getUpdatedAtomId(childChange),
+            ]);
+        }
+        const moves = [];
+        for (const [src, dst] of change.moves) {
+            moves.push([replacer.getUpdatedAtomId(src), replacer.getUpdatedAtomId(dst)]);
         }
+        const updated = { childChanges, moves };
         if (valueReplace !== undefined) {
             updated.valueReplace = valueReplace;
         }
-        if (change.nodeDetach !== undefined) {
-            updated.nodeDetach = replacer.getUpdatedAtomId(change.nodeDetach);
-        }
         return updated;
     },
     mute: (change) => {
-        return { childChange: change.childChange };
+        return { childChanges: change.childChanges, moves: [] };
     },
 };
-function compose(change1, change2, composeChild, _genId, nodeManager) {
-    const detachId2 = getEffectiveDetachId(change2);
-    if (change1.valueReplace?.src !== undefined && detachId2 !== undefined) {
-        nodeManager.composeAttachDetach(change1.valueReplace.src, detachId2, 1);
+function replaceReplaceRevisions(replace, replacer) {
+    if (replace === undefined) {
+        return undefined;
     }
-    const composedDetach = composeNodeDetaches(change1, change2, nodeManager);
-    const composedReplace = composeReplaces(change1, change2);
-    const composedChildChange = getComposedChildChanges(change1, change2, nodeManager, composeChild);
-    sendNewChildChanges(change1, change2, nodeManager);
-    if (change1.nodeDetach !== undefined &&
-        areEqualChangeAtomIdOpts(change1.nodeDetach, change2.valueReplace?.src)) {
-        nodeManager.composeDetachAttach(change1.nodeDetach, change1.nodeDetach, 1, true);
+    const updated = {
+        ...replace,
+        dst: replacer.getUpdatedAtomId(replace.dst),
+    };
+    if (replace.src !== undefined) {
+        updated.src = replaceRegisterRevisions(replace.src, replacer);
     }
-    return makeChangeset(composedReplace, composedDetach, composedChildChange);
+    return updated;
 }
-function composeNodeDetaches(change1, change2, nodeManager) {
-    const detach1 = getEffectiveDetachId(change1);
-    if (detach1 !== undefined) {
-        const newDetachId = nodeManager.getNewChangesForBaseDetach(detach1, 1).value?.detachId;
-        if (newDetachId !== undefined) {
-            // change2 either renames or detaches this node (the latter case implying that change1 reattaches/moves it).
-            // In either case, the composition ends with the node detached by `newDetachId`.
-            // Note that even if change2 detaches the node with a location-targeting detach (e.g. an optional field clear),
-            // the composition should still have a node-targeting detach.
-            // This is because change1 must attach the node in the location targeted by the detach,
-            // and rebasing does not affect attaches, although that could change if slice moves are implemented.
-            return newDetachId;
-        }
-    }
-    if (change1.nodeDetach !== undefined) {
-        return change1.nodeDetach;
-    }
-    return change1.valueReplace === undefined ? change2.nodeDetach : undefined;
+function replaceRegisterRevisions(register, replacer) {
+    return register === "self" ? register : replacer.getUpdatedAtomId(register);
 }
-function composeReplaces(change1, change2) {
-    const firstReplace = change1.valueReplace ?? change2.valueReplace;
-    if (firstReplace === undefined) {
-        return undefined;
+function getComposedReplaceDst(change1, change2) {
+    const dst1 = change1?.dst;
+    if (change2.valueReplace === undefined) {
+        assert(dst1 !== undefined, 0x8ce /* Both replace replaces should not be undefined */);
+        return getIdAfterMoves(dst1, change2.moves);
     }
-    const isEmpty = change1.nodeDetach === undefined ? firstReplace.isEmpty : false;
-    const replace = { isEmpty, dst: firstReplace.dst };
-    if (change2.valueReplace?.src !== undefined) {
-        replace.src = change2.valueReplace.src;
+    if (dst1 === undefined ||
+        change1?.src === "self" ||
+        (change2.valueReplace.src !== undefined &&
+            areEqualRegisterIds(change2.valueReplace.src, dst1))) {
+        assert(change2.valueReplace !== undefined, 0x8cf /* Both replace replaces should not be undefined */);
+        return change2.valueReplace.dst;
     }
-    else if (getEffectiveDetachId(change2) === undefined &&
-        change1.valueReplace?.src !== undefined) {
-        replace.src = change1.valueReplace.src;
+    else {
+        return getIdAfterMoves(dst1, change2.moves);
     }
-    return replace;
 }
-/**
- * Informs the node manager of any child changes in `change2` that may need to be represented somewhere else in the input context of the composed changeset.
- * See {@link ComposeNodeManager.sendNewChangesToBaseSourceLocation} for motivation.
- * @param change1 - The first change to compose. Conceptually applies before `change2`.
- * @param change2 - The second change to compose. Conceptually applies after `change1`.
- * @param nodeManager - The node manager that needs to be informed of the child changes.
- */
-function sendNewChildChanges(change1, change2, nodeManager) {
-    if (change2.childChange !== undefined && change1.valueReplace?.src !== undefined) {
-        // The presence of new child implies that there is some node present in the field in the input context of change2.
-        // The fact that the change1 has a shallow effect implies that this node was attached by change1.
-        nodeManager.sendNewChangesToBaseSourceLocation(change1.valueReplace.src, change2.childChange);
+function getIdAfterMoves(id, moves) {
+    for (const [src, dst] of moves) {
+        if (areEqualChangeAtomIds(id, src)) {
+            return dst;
+        }
     }
+    return id;
 }
-/**
- * Computes the child changes that should be included in the composed changeset.
- * @param change1 - The first change to compose. Conceptually applies before `change2`.
- * @param change2 - The second change to compose. Conceptually applies after `change1`.
- * @param nodeManager - The node manager. Provides information about potential child changes from `change2`.
- * @param composeChild - The delegate to compose child changes.
- * @returns The composed child changes (if any) for the node (if any) present in the field in the input context of `change1`.
- */
-function getComposedChildChanges(change1, change2, nodeManager, composeChild) {
-    const detachId1 = getEffectiveDetachId(change1);
-    // We need to determine what the child changes are in change2 for the node (if any) that resides in the field in the input context of change1.
-    const childChangesFromChange2 = 
-    // If such a node did exist, the changes for it in change2 would come from wherever change1 sends that node.
-    // Note: in both branches of this ternary, we are leveraging the fact querying for changes of a non-existent node safely yields undefined
-    detachId1 === undefined
-        ? change1.valueReplace?.src === undefined
-            ? change2.childChange
-            : undefined
-        : nodeManager.getNewChangesForBaseDetach(detachId1, 1).value?.nodeChange;
-    let composedChildChange;
-    if (change1.childChange !== undefined || childChangesFromChange2 !== undefined) {
-        composedChildChange = composeChild(change1.childChange, childChangesFromChange2);
-    }
-    return composedChildChange;
+function areEqualRegisterIds(id1, id2) {
+    return id1 === "self" || id2 === "self" ? id1 === id2 : areEqualChangeAtomIds(id1, id2);
 }
-function makeChangeset(replace, nodeDetach, childChange) {
-    const changeset = {};
-    if (replace !== undefined) {
-        changeset.valueReplace = replace;
-    }
-    if (nodeDetach !== undefined) {
-        changeset.nodeDetach = nodeDetach;
-    }
-    if (childChange !== undefined) {
-        changeset.childChange = childChange;
+function areEqualRegisterIdsOpt(id1, id2) {
+    if (id1 === undefined || id2 === undefined) {
+        return id1 === id2;
     }
-    return changeset;
+    return areEqualRegisterIds(id1, id2);
 }
-function replaceReplaceRevisions(replace, replacer) {
-    if (replace === undefined) {
-        return undefined;
+function getBidirectionalMaps(moves) {
+    const srcToDst = new Map();
+    const dstToSrc = new Map();
+    for (const [src, dst] of moves) {
+        setInNestedMap(srcToDst, src.revision, src.localId, dst);
+        setInNestedMap(dstToSrc, dst.revision, dst.localId, src);
     }
-    const updated = {
-        ...replace,
-        dst: replacer.getUpdatedAtomId(replace.dst),
-    };
-    if (replace.src !== undefined) {
-        updated.src = replacer.getUpdatedAtomId(replace.src);
+    return { srcToDst, dstToSrc };
+}
+function isReplaceEffectful(replace) {
+    if (replace.src === "self") {
+        return false;
     }
-    return updated;
+    return !replace.isEmpty || replace.src !== undefined;
+}
+function getEffectfulDst(replace) {
+    return replace === undefined || replace.isEmpty || replace.src === "self"
+        ? undefined
+        : replace.dst;
 }
-function getEffectiveDetachId(change) {
-    if (change.nodeDetach !== undefined) {
-        return change.nodeDetach;
+export function taggedRegister(id, revision) {
+    if (id === "self") {
+        return id;
     }
-    return change.valueReplace?.isEmpty === false ? change.valueReplace.dst : undefined;
+    return taggedAtomId(id, revision);
 }
 export const optionalFieldEditor = {
-    set: (isEmpty, ids) => ({
+    set: (wasEmpty, ids) => ({
+        moves: [],
+        childChanges: [],
         valueReplace: {
-            isEmpty,
+            isEmpty: wasEmpty,
             src: ids.fill,
             dst: ids.detach,
         },
     }),
-    clear: (isEmpty, detachId) => ({
+    clear: (wasEmpty, detachId) => ({
+        moves: [],
+        childChanges: [],
         valueReplace: {
-            isEmpty,
+            isEmpty: wasEmpty,
             dst: detachId,
         },
     }),
     buildChildChanges: (changes) => {
-        const childChanges = Array.from(changes, ([index, child]) => {
+        const childChanges = Array.from(changes, ([index, childChange]) => {
             assert(index === 0, 0x404 /* Optional fields only support a single child node */);
-            return child;
+            return ["self", childChange];
         });
         assert(childChanges.length <= 1, 0xabd /* Optional fields only support a single child node */);
-        const childChange = childChanges[0];
-        return childChange === undefined ? {} : { childChange };
+        return {
+            moves: [],
+            childChanges,
+        };
     },
 };
 export function optionalFieldIntoDelta(change, deltaFromChild) {
-    return optionalOrRequiredFieldIntoDelta(true, change, deltaFromChild);
-}
-export function optionalOrRequiredFieldIntoDelta(allowReattach, change, deltaFromChild) {
+    const delta = {};
     let markIsANoop = true;
     const mark = { count: 1 };
-    const detachId = getEffectiveDetachId(change);
-    const attachId = change.valueReplace?.src;
-    if (!areEqualChangeAtomIdOpts(detachId, attachId)) {
+    if (change.valueReplace !== undefined && isReplaceEffectful(change.valueReplace)) {
+        if (!change.valueReplace.isEmpty) {
+            mark.detach = nodeIdFromChangeAtom(change.valueReplace.dst);
+        }
+        if (change.valueReplace.src !== undefined) {
+            mark.attach = nodeIdFromChangeAtom(change.valueReplace.src);
+        }
         markIsANoop = false;
-        if (detachId !== undefined) {
-            mark.detach = nodeIdFromChangeAtom(detachId);
+    }
+    if (change.moves.length > 0) {
+        delta.rename = change.moves.map(([src, dst]) => ({
+            count: 1,
+            oldId: nodeIdFromChangeAtom(src),
+            newId: nodeIdFromChangeAtom(dst),
+        }));
+    }
+    if (change.childChanges.length > 0) {
+        const globals = [];
+        for (const [id, childChange] of change.childChanges) {
+            const childDelta = deltaFromChild(childChange);
+            if (id === "self") {
+                mark.fields = childDelta;
+                markIsANoop = false;
+            }
+            else {
+                const fields = childDelta;
+                globals.push({
+                    id: { major: id.revision, minor: id.localId },
+                    fields,
+                });
+            }
         }
-        if (attachId !== undefined) {
-            mark.attach = nodeIdFromChangeAtom(attachId);
+        if (globals.length > 0) {
+            delta.global = globals;
         }
     }
-    if (change.childChange !== undefined) {
-        mark.fields = deltaFromChild(change.childChange);
-        markIsANoop = false;
+    if (!markIsANoop) {
+        delta.local = { marks: [mark] };
     }
-    return { marks: markIsANoop ? [] : [mark], allowReattach };
+    return delta;
 }
 export const optionalChangeHandler = {
     rebaser: optionalChangeRebaser,
     codecsFactory: makeOptionalFieldCodecFamily,
     editor: optionalFieldEditor,
     intoDelta: optionalFieldIntoDelta,
-    isEmpty: (change) => change.childChange === undefined &&
-        change.valueReplace === undefined &&
-        change.nodeDetach === undefined,
+    relevantRemovedRoots,
+    isEmpty: (change) => change.childChanges.length === 0 &&
+        change.moves.length === 0 &&
+        change.valueReplace === undefined,
     getNestedChanges,
-    createEmpty: () => ({}),
-    getCrossFieldKeys,
-    getDetachCellIds: (_change) => [],
+    createEmpty: () => ({ moves: [], childChanges: [] }),
+    getCrossFieldKeys: (_change) => [],
 };
-function getCrossFieldKeys(change) {
-    const keys = [];
-    if (change.valueReplace?.src !== undefined) {
-        keys.push({
-            key: { ...change.valueReplace.src, target: NodeMoveType.Attach },
-            count: 1,
-        });
-    }
-    const detachId = getEffectiveDetachId(change);
-    if (detachId !== undefined) {
-        keys.push({ key: { ...detachId, target: NodeMoveType.Detach }, count: 1 });
-    }
-    return keys;
-}
 function getNestedChanges(change) {
-    if (change.childChange === undefined) {
-        return [];
-    }
-    return [[change.childChange, 0]];
+    // True iff the content of the field changes in some way
+    const isFieldContentChanged = change.valueReplace !== undefined && change.valueReplace.src !== "self";
+    // The node that is moved into the field (if any).
+    const nodeMovedIntoField = change.valueReplace?.src;
+    return change.childChanges.map(([register, nodeId]) => {
+        // The node is removed in the input context iif register is not self.
+        const inputIndex = register === "self" ? 0 : undefined;
+        const outputIndex = register === "self"
+            ? // If the node starts out as not-removed, it is removed in the output context iff the field content is changed
+                isFieldContentChanged
+                    ? undefined
+                    : 0
+            : // If the node starts out as removed, then it remains removed in the output context iff it is not the node that is moved into the field
+                areEqualRegisterIdsOpt(register, nodeMovedIntoField)
+                    ? 0
+                    : undefined;
+        return [nodeId, inputIndex, outputIndex];
+    });
 }
-function invertAttachId(attachId, revision, isRollback, detachId) {
-    if (!isRollback) {
-        return makeChangeAtomId(attachId.localId, revision);
+function* relevantRemovedRoots(change, relevantRemovedRootsFromChild) {
+    const alreadyYielded = new RegisterMap();
+    for (const [src] of change.moves) {
+        if (!alreadyYielded.has(src)) {
+            alreadyYielded.set(src, true);
+            yield nodeIdFromChangeAtom(src);
+        }
+    }
+    for (const [id, childChange] of change.childChanges) {
+        // Child changes make the tree they apply to relevant unless that tree existed in the starting context of
+        // of this change.
+        if (id !== "self" && !alreadyYielded.has(id)) {
+            alreadyYielded.set(id, true);
+            yield nodeIdFromChangeAtom(id);
+        }
+        yield* relevantRemovedRootsFromChild(childChange);
+    }
+    const selfSrc = change.valueReplace?.src;
+    if (selfSrc !== undefined && selfSrc !== "self" && !alreadyYielded.has(selfSrc)) {
+        yield nodeIdFromChangeAtom(selfSrc);
     }
-    return detachId ?? attachId;
-}
-function isPin(change) {
-    return (change.nodeDetach !== undefined &&
-        areEqualChangeAtomIdOpts(change.nodeDetach, change.valueReplace?.src));
 }
 /**
  * 0 or 1 items.