@fluidframework/tree 2.83.0 → 2.90.0-378676

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

@@ -3,542 +3,354 @@
  * Licensed under the MIT License.
  */
 import { assert } from "@fluidframework/core-utils/internal";
-import { Multiplicity, areEqualChangeAtomIds, forbiddenFieldKindIdentifier, makeChangeAtomId, taggedAtomId, } from "../../core/index.js";
-import { SizedNestedMap, deleteFromNestedMap, setInNestedMap, tryGetFromNestedMap, } from "../../util/index.js";
+import { Multiplicity, areEqualChangeAtomIdOpts, forbiddenFieldKindIdentifier, makeChangeAtomId, } from "../../core/index.js";
 import { nodeIdFromChangeAtom } from "../deltaUtils.js";
 import { optionalIdentifier, identifierFieldIdentifier, requiredIdentifier, } from "../fieldKindIdentifiers.js";
-import { NodeAttachState, FlexFieldKind, } from "../modular-schema/index.js";
+import { NodeMoveType, FlexFieldKind, } from "../modular-schema/index.js";
 import { makeOptionalFieldCodecFamily } from "./optionalFieldCodecs.js";
-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 });
-                }
-            }
-        }
-        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]);
-            }
-            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]);
-            }
-        }
-        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 {
-                composedFieldSrc =
-                    tryGetFromNestedMap(dstToSrc, change2FieldSrc.revision, change2FieldSrc.localId) ??
-                        change2FieldSrc;
-            }
-        }
-        else if (change1FieldSrc !== undefined && change2.valueReplace === undefined) {
-            composedFieldSrc = change1FieldSrc;
-        }
-        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)]);
+    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,
+            };
         }
-        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);
+        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;
             }
-            else if (change1FieldDst === undefined ||
-                !areEqualChangeAtomIds(change1FieldDst, leg2Src)) {
-                composedMoves.push([leg2Src, leg2Dst]);
+            // TODO: Always use nodeDetach instead of valueReplace if not supporting older client versions.
+            if (isPin(change)) {
+                inverted.nodeDetach = detachIdForInverse;
             }
-        }
-        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]);
-                }
+            else if (inverted.valueReplace === undefined) {
+                inverted.valueReplace = { isEmpty: false, dst: detachIdForInverse };
             }
-        }
-        if (change1FieldSrc !== undefined &&
-            change1FieldSrc !== "self" &&
-            change2.valueReplace !== undefined) {
-            const change2FieldDst = change2.valueReplace.dst;
-            if (isReplaceEffectful(change2.valueReplace) &&
-                !areEqualChangeAtomIds(change1FieldSrc, change2FieldDst)) {
-                composedMoves.push([change1FieldSrc, change2FieldDst]);
+            else {
+                inverted.valueReplace.dst = detachIdForInverse;
             }
         }
-        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;
+        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;
         }
-        composed.valueReplace = replace;
-        return composed;
+        return inverted;
     },
-    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);
+    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;
             }
-            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;
+            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);
                 }
-                inverted.valueReplace = replace;
-            }
-            else if (!isRollback && valueReplace.src === "self") {
-                inverted.valueReplace = {
-                    isEmpty: false,
-                    src: "self",
-                    dst: makeChangeAtomId(genId.allocate(), revision),
-                };
             }
         }
-        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);
+        else if (overDetach === undefined) {
+            // `overChange` did not change which node is in the field.
+            if (rebasedChild !== undefined) {
+                rebased.childChange = rebasedChild;
             }
-            if (overChange.valueReplace.src !== undefined) {
-                forwardMap.set(overChange.valueReplace.src, "self");
+            if (newChange.nodeDetach !== undefined) {
+                rebased.nodeDetach = newChange.nodeDetach;
             }
         }
-        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);
+        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 rebasedId = forwardMap.get(id) ?? id;
-            const rebasedChildChange = rebaseChild(childChange, overChildChange, rebasedId === "self" ? NodeAttachState.Attached : NodeAttachState.Detached);
-            if (rebasedChildChange !== undefined) {
-                rebasedChildChanges.push([rebasedId, rebasedChildChange]);
+            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);
             }
-        }
-        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]);
+            if (rebasedDetachId !== undefined) {
+                nodeManager.addDetach(rebasedDetachId, 1);
             }
         }
-        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 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]);
+        const prunedChange = { ...change };
+        delete prunedChange.childChange;
+        if (change.childChange !== undefined) {
+            const childChange = pruneChild(change.childChange);
+            if (childChange !== undefined) {
+                prunedChange.childChange = childChange;
             }
         }
         return prunedChange;
     },
     replaceRevisions: (change, replacer) => {
+        const updated = {};
         const valueReplace = replaceReplaceRevisions(change.valueReplace, replacer);
-        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)]);
+        if (change.childChange !== undefined) {
+            updated.childChange = replacer.getUpdatedAtomId(change.childChange);
         }
-        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 { childChanges: change.childChanges, moves: [] };
+        return { childChange: change.childChange };
     },
 };
-function replaceReplaceRevisions(replace, replacer) {
-    if (replace === undefined) {
-        return undefined;
+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);
     }
-    const updated = {
-        ...replace,
-        dst: replacer.getUpdatedAtomId(replace.dst),
-    };
-    if (replace.src !== undefined) {
-        updated.src = replaceRegisterRevisions(replace.src, replacer);
+    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);
     }
-    return updated;
+    return makeChangeset(composedReplace, composedDetach, composedChildChange);
 }
-function replaceRegisterRevisions(register, replacer) {
-    return register === "self" ? register : replacer.getUpdatedAtomId(register);
+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 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);
+function composeReplaces(change1, change2) {
+    const firstReplace = change1.valueReplace ?? change2.valueReplace;
+    if (firstReplace === undefined) {
+        return undefined;
     }
-    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;
+    const isEmpty = change1.nodeDetach === undefined ? firstReplace.isEmpty : false;
+    const replace = { isEmpty, dst: firstReplace.dst };
+    if (change2.valueReplace?.src !== undefined) {
+        replace.src = change2.valueReplace.src;
     }
-    else {
-        return getIdAfterMoves(dst1, change2.moves);
+    else if (getEffectiveDetachId(change2) === undefined &&
+        change1.valueReplace?.src !== undefined) {
+        replace.src = change1.valueReplace.src;
     }
+    return replace;
 }
-function getIdAfterMoves(id, moves) {
-    for (const [src, dst] of moves) {
-        if (areEqualChangeAtomIds(id, src)) {
-            return dst;
-        }
+/**
+ * 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);
     }
-    return id;
-}
-function areEqualRegisterIds(id1, id2) {
-    return id1 === "self" || id2 === "self" ? id1 === id2 : areEqualChangeAtomIds(id1, id2);
 }
-function areEqualRegisterIdsOpt(id1, id2) {
-    if (id1 === undefined || id2 === undefined) {
-        return id1 === id2;
+/**
+ * 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 areEqualRegisterIds(id1, id2);
+    return composedChildChange;
 }
-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);
+function makeChangeset(replace, nodeDetach, childChange) {
+    const changeset = {};
+    if (replace !== undefined) {
+        changeset.valueReplace = replace;
     }
-    return { srcToDst, dstToSrc };
-}
-function isReplaceEffectful(replace) {
-    if (replace.src === "self") {
-        return false;
+    if (nodeDetach !== undefined) {
+        changeset.nodeDetach = nodeDetach;
+    }
+    if (childChange !== undefined) {
+        changeset.childChange = childChange;
     }
-    return !replace.isEmpty || replace.src !== undefined;
+    return changeset;
 }
-function getEffectfulDst(replace) {
-    return replace === undefined || replace.isEmpty || replace.src === "self"
-        ? undefined
-        : replace.dst;
+function replaceReplaceRevisions(replace, replacer) {
+    if (replace === undefined) {
+        return undefined;
+    }
+    const updated = {
+        ...replace,
+        dst: replacer.getUpdatedAtomId(replace.dst),
+    };
+    if (replace.src !== undefined) {
+        updated.src = replacer.getUpdatedAtomId(replace.src);
+    }
+    return updated;
 }
-export function taggedRegister(id, revision) {
-    if (id === "self") {
-        return id;
+function getEffectiveDetachId(change) {
+    if (change.nodeDetach !== undefined) {
+        return change.nodeDetach;
     }
-    return taggedAtomId(id, revision);
+    return change.valueReplace?.isEmpty === false ? change.valueReplace.dst : undefined;
 }
 export const optionalFieldEditor = {
-    set: (wasEmpty, ids) => ({
-        moves: [],
-        childChanges: [],
+    set: (isEmpty, ids) => ({
         valueReplace: {
-            isEmpty: wasEmpty,
+            isEmpty,
             src: ids.fill,
             dst: ids.detach,
         },
     }),
-    clear: (wasEmpty, detachId) => ({
-        moves: [],
-        childChanges: [],
+    clear: (isEmpty, detachId) => ({
         valueReplace: {
-            isEmpty: wasEmpty,
+            isEmpty,
             dst: detachId,
         },
     }),
     buildChildChanges: (changes) => {
-        const childChanges = Array.from(changes, ([index, childChange]) => {
+        const childChanges = Array.from(changes, ([index, child]) => {
             assert(index === 0, 0x404 /* Optional fields only support a single child node */);
-            return ["self", childChange];
+            return child;
         });
         assert(childChanges.length <= 1, 0xabd /* Optional fields only support a single child node */);
-        return {
-            moves: [],
-            childChanges,
-        };
+        const childChange = childChanges[0];
+        return childChange === undefined ? {} : { childChange };
     },
 };
 export function optionalFieldIntoDelta(change, deltaFromChild) {
-    const delta = {};
+    return optionalOrRequiredFieldIntoDelta(true, change, deltaFromChild);
+}
+export function optionalOrRequiredFieldIntoDelta(allowReattach, change, deltaFromChild) {
     let markIsANoop = true;
     const mark = { count: 1 };
-    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);
-        }
+    const detachId = getEffectiveDetachId(change);
+    const attachId = change.valueReplace?.src;
+    if (!areEqualChangeAtomIdOpts(detachId, attachId)) {
         markIsANoop = false;
-    }
-    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 (detachId !== undefined) {
+            mark.detach = nodeIdFromChangeAtom(detachId);
         }
-        if (globals.length > 0) {
-            delta.global = globals;
+        if (attachId !== undefined) {
+            mark.attach = nodeIdFromChangeAtom(attachId);
         }
     }
-    if (!markIsANoop) {
-        delta.local = { marks: [mark] };
+    if (change.childChange !== undefined) {
+        mark.fields = deltaFromChild(change.childChange);
+        markIsANoop = false;
     }
-    return delta;
+    return { marks: markIsANoop ? [] : [mark], allowReattach };
 }
 export const optionalChangeHandler = {
     rebaser: optionalChangeRebaser,
     codecsFactory: makeOptionalFieldCodecFamily,
     editor: optionalFieldEditor,
     intoDelta: optionalFieldIntoDelta,
-    relevantRemovedRoots,
-    isEmpty: (change) => change.childChanges.length === 0 &&
-        change.moves.length === 0 &&
-        change.valueReplace === undefined,
+    isEmpty: (change) => change.childChange === undefined &&
+        change.valueReplace === undefined &&
+        change.nodeDetach === undefined,
     getNestedChanges,
-    createEmpty: () => ({ moves: [], childChanges: [] }),
-    getCrossFieldKeys: (_change) => [],
+    createEmpty: () => ({}),
+    getCrossFieldKeys,
+    getDetachCellIds: (_change) => [],
 };
-function getNestedChanges(change) {
-    // 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* relevantRemovedRoots(change, relevantRemovedRootsFromChild) {
-    const alreadyYielded = new RegisterMap();
-    for (const [src] of change.moves) {
-        if (!alreadyYielded.has(src)) {
-            alreadyYielded.set(src, true);
-            yield nodeIdFromChangeAtom(src);
-        }
+function getCrossFieldKeys(change) {
+    const keys = [];
+    if (change.valueReplace?.src !== undefined) {
+        keys.push({
+            key: { ...change.valueReplace.src, target: NodeMoveType.Attach },
+            count: 1,
+        });
     }
-    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 detachId = getEffectiveDetachId(change);
+    if (detachId !== undefined) {
+        keys.push({ key: { ...detachId, target: NodeMoveType.Detach }, count: 1 });
     }
-    const selfSrc = change.valueReplace?.src;
-    if (selfSrc !== undefined && selfSrc !== "self" && !alreadyYielded.has(selfSrc)) {
-        yield nodeIdFromChangeAtom(selfSrc);
+    return keys;
+}
+function getNestedChanges(change) {
+    if (change.childChange === undefined) {
+        return [];
     }
+    return [[change.childChange, 0]];
+}
+function invertAttachId(attachId, revision, isRollback, detachId) {
+    if (!isRollback) {
+        return makeChangeAtomId(attachId.localId, revision);
+    }
+    return detachId ?? attachId;
+}
+function isPin(change) {
+    return (change.nodeDetach !== undefined &&
+        areEqualChangeAtomIdOpts(change.nodeDetach, change.valueReplace?.src));
 }
 /**
  * 0 or 1 items.