@fluidframework/tree 2.82.0 → 2.90.0-378676

package/dist/feature-libraries/modular-schema/modularChangeCodecV1.js

@@ -4,40 +4,67 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeModularChangeCodecV1 = exports.getFieldChangesetCodecs = exports.decodeChange = exports.encodeChange = exports.decodeRevisionInfos = exports.encodeRevisionInfos = exports.decodeDetachedNodes = exports.encodeDetachedNodes = exports.decodeNodeChangesetFromJson = exports.decodeFieldChangesFromJson = exports.encodeNodeChangesForJson = exports.encodeFieldChangesForJsonI = exports.encodeFieldChangesForJson = exports.getFieldChangesetCodec = void 0;
+exports.decodeChange = exports.getMoveIdToCellId = exports.encodeDetachedNodes = exports.encodeRevisionInfos = exports.encodeChange = exports.makeModularChangeCodecV1 = exports.decodeRevisionInfos = exports.decodeDetachedNodes = exports.getFieldChangesetCodecs = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../codec/index.js");
-const index_js_2 = require("../../util/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_3 = require("../chunked-forest/index.js");
+const index_js_4 = require("../chunked-forest/index.js");
 const treeCompressionUtils_js_1 = require("../treeCompressionUtils.js");
 const genericFieldKind_js_1 = require("./genericFieldKind.js");
+const modularChangeFamily_js_1 = require("./modularChangeFamily.js");
 const modularChangeFormatV1_js_1 = require("./modularChangeFormatV1.js");
 const modularChangeTypes_js_1 = require("./modularChangeTypes.js");
-function getFieldChangesetCodec(fieldKind, fieldChangesetCodecs) {
-    const entry = fieldChangesetCodecs.get(fieldKind);
-    (0, internal_1.assert)(entry !== undefined, 0x5ea /* Tried to encode unsupported fieldKind */);
-    return entry;
-}
-exports.getFieldChangesetCodec = getFieldChangesetCodec;
-function encodeFieldChangesForJson(change, context, nodeChanges, fieldChangesetCodecs) {
-    const fieldContext = {
-        baseContext: context,
-        encodeNode: (nodeId) => {
-            const node = nodeChanges.get([nodeId.revision, nodeId.localId]);
-            (0, internal_1.assert)(node !== undefined, 0x92e /* Unknown node ID */);
-            return encodeNodeChangesForJson(node, fieldContext, fieldChangesetCodecs);
-        },
-        decodeNode: () => (0, internal_1.fail)(0xb1e /* Should not decode nodes during field encoding */),
+function getFieldChangesetCodecs(fieldKinds, revisionTagCodec, codecOptions) {
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    const getMapEntry = ({ kind, formatVersion }) => {
+        const codec = kind.changeHandler.codecsFactory(revisionTagCodec).resolve(formatVersion);
+        return {
+            codec,
+            compiledSchema: codec.encodedSchema
+                ? (0, index_js_1.extractJsonValidator)(codecOptions.jsonValidator).compile(codec.encodedSchema)
+                : undefined,
+        };
     };
-    return encodeFieldChangesForJsonI(change, fieldContext, fieldChangesetCodecs);
+    /**
+     * The codec version for the generic field kind.
+     */
+    const genericFieldKindFormatVersion = 1;
+    const fieldChangesetCodecs = new Map([
+        [
+            genericFieldKind_js_1.genericFieldKind.identifier,
+            getMapEntry({ kind: genericFieldKind_js_1.genericFieldKind, formatVersion: genericFieldKindFormatVersion }),
+        ],
+    ]);
+    // eslint-disable-next-line unicorn/no-array-for-each -- Map.forEach with (value, key) signature; codec initialization
+    fieldKinds.forEach((entry, identifier) => {
+        fieldChangesetCodecs.set(identifier, getMapEntry(entry));
+    });
+    return fieldChangesetCodecs;
 }
-exports.encodeFieldChangesForJson = encodeFieldChangesForJson;
-function encodeFieldChangesForJsonI(change, context, fieldChangesetCodecs) {
+exports.getFieldChangesetCodecs = getFieldChangesetCodecs;
+function encodeFieldChangesForJson(change, parentId, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId, getCellIdForMove, fieldChangesetCodecs) {
     const encodedFields = [];
     for (const [field, fieldChange] of change) {
         const { codec, compiledSchema } = getFieldChangesetCodec(fieldChange.fieldKind, fieldChangesetCodecs);
-        const encodedChange = codec.json.encode(fieldChange.change, context);
+        const rootChanges = fieldToRoots.get([parentId?.revision, parentId?.localId, field]);
+        const fieldContext = {
+            baseContext: context,
+            rootNodeChanges: rootChanges?.nodeChanges ?? (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
+            rootRenames: rootChanges?.renames ?? (0, index_js_2.newChangeAtomIdTransform)(),
+            encodeNode,
+            getInputRootId,
+            isAttachId,
+            isDetachId,
+            getCellIdForMove,
+            decodeNode: () => (0, internal_1.fail)(0xb1e /* Should not decode nodes during field encoding */),
+            decodeRootNodeChange: () => (0, internal_1.fail)("Should not be called during encoding"),
+            decodeRootRename: () => (0, internal_1.fail)("Should not be called during encoding"),
+            decodeMoveAndDetach: () => (0, internal_1.fail)("Should not be called during encoding"),
+            generateId: () => (0, internal_1.fail)("Should not be called during encoding"),
+        };
+        const encodedChange = codec.encode(fieldChange.change, fieldContext);
         if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
             (0, internal_1.fail)(0xb1f /* Encoded change didn't pass schema validation. */);
         }
@@ -51,21 +78,24 @@ function encodeFieldChangesForJsonI(change, context, fieldChangesetCodecs) {
     }
     return encodedFields;
 }
-exports.encodeFieldChangesForJsonI = encodeFieldChangesForJsonI;
-function encodeNodeChangesForJson(change, context, fieldChangesetCodecs) {
+function encodeNodeChangesForJson(change, id, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId, getCellIdForMove, fieldChangesetCodecs) {
     const encodedChange = {};
     // Note: revert constraints are ignored for now because they would only be needed if we supported reverting changes made by peers.
     const { fieldChanges, nodeExistsConstraint } = change;
     if (fieldChanges !== undefined) {
-        encodedChange.fieldChanges = encodeFieldChangesForJsonI(fieldChanges, context, fieldChangesetCodecs);
+        encodedChange.fieldChanges = encodeFieldChangesForJson(fieldChanges, id, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId, getCellIdForMove, fieldChangesetCodecs);
     }
     if (nodeExistsConstraint !== undefined) {
         encodedChange.nodeExistsConstraint = nodeExistsConstraint;
     }
     return encodedChange;
 }
-exports.encodeNodeChangesForJson = encodeNodeChangesForJson;
-function decodeFieldChangesFromJson(encodedChange, parentId, decoded, context, idAllocator, fieldKinds, fieldChangesetCodecs) {
+function getFieldChangesetCodec(fieldKind, fieldChangesetCodecs) {
+    const entry = fieldChangesetCodecs.get(fieldKind);
+    (0, internal_1.assert)(entry !== undefined, 0x5ea /* Tried to encode unsupported fieldKind */);
+    return entry;
+}
+function decodeFieldChangesFromJson(encodedChange, parentId, decodedCrossFieldKeys, decodedRootTable, context, decodeNode, idAllocator, fieldKinds, fieldChangesetCodecs) {
     const decodedFields = new Map();
     for (const field of encodedChange) {
         const { codec, compiledSchema } = getFieldChangesetCodec(field.fieldKind, fieldChangesetCodecs);
@@ -78,79 +108,55 @@ function decodeFieldChangesFromJson(encodedChange, parentId, decoded, context, i
         };
         const fieldContext = {
             baseContext: context,
+            rootNodeChanges: (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
+            rootRenames: (0, index_js_2.newChangeAtomIdTransform)(),
             encodeNode: () => (0, internal_1.fail)(0xb21 /* Should not encode nodes during field decoding */),
+            getInputRootId: () => (0, internal_1.fail)("Should not query during decoding"),
+            isAttachId: () => (0, internal_1.fail)("Should not query during decoding"),
+            isDetachId: () => (0, internal_1.fail)("Should not query during decoding"),
+            getCellIdForMove: () => (0, internal_1.fail)("Should not query during decoding"),
             decodeNode: (encodedNode) => {
-                const nodeId = {
-                    revision: context.revision,
-                    localId: (0, index_js_2.brand)(idAllocator.allocate()),
-                };
-                const node = decodeNodeChangesetFromJson(encodedNode, nodeId, decoded, context, idAllocator, fieldKinds, fieldChangesetCodecs);
-                decoded.nodeChanges.set([nodeId.revision, nodeId.localId], node);
-                decoded.nodeToParent.set([nodeId.revision, nodeId.localId], fieldId);
-                return nodeId;
+                return decodeNode(encodedNode, { field: fieldId });
+            },
+            decodeRootNodeChange: (detachId, encodedNode) => {
+                (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(decodedRootTable.nodeChanges, detachId, decodeNode(encodedNode, { root: detachId }));
+                decodedRootTable.detachLocations.set(detachId, 1, fieldId);
+            },
+            decodeRootRename: (oldId, newId, count) => {
+                (0, modularChangeFamily_js_1.addNodeRename)(decodedRootTable, oldId, newId, count, fieldId);
+            },
+            decodeMoveAndDetach: (detachId, count) => {
+                decodedRootTable.outputDetachLocations.set(detachId, count, fieldId);
             },
+            generateId: () => ({
+                revision: context.revision,
+                localId: (0, index_js_3.brand)(idAllocator.allocate()),
+            }),
         };
-        const fieldChangeset = codec.json.decode(field.change, fieldContext);
+        const fieldChangeset = codec.decode(field.change, fieldContext);
         const crossFieldKeys = getChangeHandler(fieldKinds, field.fieldKind).getCrossFieldKeys(fieldChangeset);
         for (const { key, count } of crossFieldKeys) {
-            decoded.crossFieldKeys.set(key, count, fieldId);
+            decodedCrossFieldKeys.set(key, count, fieldId);
         }
-        const fieldKey = (0, index_js_2.brand)(field.fieldKey);
+        const fieldKey = (0, index_js_3.brand)(field.fieldKey);
         decodedFields.set(fieldKey, {
             fieldKind: field.fieldKind,
-            change: (0, index_js_2.brand)(fieldChangeset),
+            change: (0, index_js_3.brand)(fieldChangeset),
         });
     }
     return decodedFields;
 }
-exports.decodeFieldChangesFromJson = decodeFieldChangesFromJson;
-function decodeNodeChangesetFromJson(encodedChange, id, decoded, context, idAllocator, fieldKinds, fieldChangesetCodecs) {
+function decodeNodeChangesetFromJson(encodedChange, id, decodedCrossFieldKeys, decodedRootTable, context, decodeNode, idAllocator, fieldKinds, fieldChangesetCodecs) {
     const decodedChange = {};
     const { fieldChanges, nodeExistsConstraint } = encodedChange;
     if (fieldChanges !== undefined) {
-        decodedChange.fieldChanges = decodeFieldChangesFromJson(fieldChanges, id, decoded, context, idAllocator, fieldKinds, fieldChangesetCodecs);
+        decodedChange.fieldChanges = decodeFieldChangesFromJson(fieldChanges, id, decodedCrossFieldKeys, decodedRootTable, context, decodeNode, idAllocator, fieldKinds, fieldChangesetCodecs);
     }
     if (nodeExistsConstraint !== undefined) {
         decodedChange.nodeExistsConstraint = nodeExistsConstraint;
     }
     return decodedChange;
 }
-exports.decodeNodeChangesetFromJson = decodeNodeChangesetFromJson;
-function encodeDetachedNodes(detachedNodes, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
-    if (detachedNodes === undefined) {
-        return undefined;
-    }
-    const treesToEncode = [];
-    const buildsArray = [];
-    let buildsForRevision;
-    for (const [[revision, id], chunk] of detachedNodes.entries()) {
-        const encodedRevision = encodeRevisionOpt(revisionTagCodec, revision, context);
-        if (buildsForRevision === undefined || buildsForRevision[1] !== encodedRevision) {
-            if (buildsForRevision !== undefined) {
-                buildsArray.push(buildsForRevision);
-            }
-            buildsForRevision = encodedRevision === undefined ? [[]] : [[], encodedRevision];
-        }
-        treesToEncode.push(chunk.cursor());
-        const treeIndexInBatch = treesToEncode.length - 1;
-        buildsForRevision?.[0].push([id, treeIndexInBatch]);
-    }
-    if (buildsForRevision !== undefined) {
-        buildsArray.push(buildsForRevision);
-    }
-    return buildsArray.length === 0
-        ? undefined
-        : {
-            builds: buildsArray,
-            trees: fieldsCodec.encode(treesToEncode, {
-                encodeType: chunkCompressionStrategy,
-                schema: context.schema,
-                originatorId: context.originatorId,
-                idCompressor: context.idCompressor,
-            }),
-        };
-}
-exports.encodeDetachedNodes = encodeDetachedNodes;
 function decodeDetachedNodes(encoded, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
     if (encoded === undefined || encoded.builds.length === 0) {
         return undefined;
@@ -162,8 +168,8 @@ function decodeDetachedNodes(encoded, context, revisionTagCodec, fieldsCodec, ch
     });
     const getChunk = (index) => {
         (0, internal_1.assert)(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
-        return (0, index_js_3.chunkFieldSingle)(chunks[index] ?? (0, internal_1.oob)(), {
-            policy: index_js_3.defaultChunkPolicy,
+        return (0, index_js_4.chunkFieldSingle)(chunks[index] ?? (0, internal_1.oob)(), {
+            policy: index_js_4.defaultChunkPolicy,
             idCompressor: context.idCompressor,
         });
     };
@@ -183,6 +189,70 @@ function decodeDetachedNodes(encoded, context, revisionTagCodec, fieldsCodec, ch
     return map;
 }
 exports.decodeDetachedNodes = decodeDetachedNodes;
+function decodeRevisionInfos(revisions, context, revisionTagCodec) {
+    if (revisions === undefined) {
+        return context.revision === undefined ? undefined : [{ revision: context.revision }];
+    }
+    const decodedRevisions = [];
+    for (const revision of revisions) {
+        const decodedRevision = {
+            revision: revisionTagCodec.decode(revision.revision, context),
+        };
+        if (revision.rollbackOf !== undefined) {
+            decodedRevision.rollbackOf = revisionTagCodec.decode(revision.rollbackOf, context);
+        }
+        decodedRevisions.push(decodedRevision);
+    }
+    return decodedRevisions;
+}
+exports.decodeRevisionInfos = decodeRevisionInfos;
+function makeModularChangeCodecV1(fieldKinds, revisionTagCodec, fieldsCodec, codecOptions, chunkCompressionStrategy = treeCompressionUtils_js_1.TreeCompressionStrategy.Compressed) {
+    const fieldChangesetCodecs = getFieldChangesetCodecs(fieldKinds, revisionTagCodec, codecOptions);
+    const modularChangeCodec = {
+        encode: (change, context) => encodeChange(change, context, fieldKinds, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
+        decode: (encodedChange, context) => decodeChange(encodedChange, context, fieldKinds, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
+    };
+    return (0, index_js_1.withSchemaValidation)(modularChangeFormatV1_js_1.EncodedModularChangesetV1, modularChangeCodec, codecOptions.jsonValidator);
+}
+exports.makeModularChangeCodecV1 = makeModularChangeCodecV1;
+function encodeChange(change, context, fieldKinds, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
+    const fieldToRoots = getFieldToRoots(change.rootNodes, change.nodeAliases);
+    const isAttachId = (id, count) => {
+        const attachEntry = (0, modularChangeFamily_js_1.getFirstAttachField)(change.crossFieldKeys, id, count);
+        return { ...attachEntry, value: attachEntry.value !== undefined };
+    };
+    const isDetachId = (id, count) => {
+        const detachEntry = (0, modularChangeFamily_js_1.getFirstDetachField)(change.crossFieldKeys, id, count);
+        const renameEntry = change.rootNodes.oldToNewId.getFirst(id, detachEntry.length);
+        const isDetach = (detachEntry.value ?? renameEntry.value) !== undefined;
+        return { start: id, value: isDetach, length: renameEntry.length };
+    };
+    const moveIdToCellId = getMoveIdToCellId(change, fieldKinds, fieldToRoots);
+    const getCellIdForMove = (id, count) => moveIdToCellId.getFirst(id, count);
+    const getInputRootId = (id, count) => {
+        return change.rootNodes.newToOldId.getFirst(id, count);
+    };
+    const encodeNode = (nodeId) => {
+        // TODO: Handle node aliasing.
+        const node = change.nodeChanges.get([nodeId.revision, nodeId.localId]);
+        (0, internal_1.assert)(node !== undefined, 0x92e /* Unknown node ID */);
+        return encodeNodeChangesForJson(node, nodeId, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId, getCellIdForMove, fieldChangesetCodecs);
+    };
+    // Destroys only exist in rollback changesets, which are never sent.
+    (0, internal_1.assert)(change.destroys === undefined, 0x899 /* Unexpected changeset with destroys */);
+    const encoded = {
+        maxId: change.maxId,
+        revisions: change.revisions === undefined
+            ? undefined
+            : encodeRevisionInfos(change.revisions, context, revisionTagCodec),
+        changes: encodeFieldChangesForJson(change.fieldChanges, undefined, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId, getCellIdForMove, fieldChangesetCodecs),
+        builds: encodeDetachedNodes(change.builds, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
+        refreshers: encodeDetachedNodes(change.refreshers, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
+        violations: change.constraintViolationCount,
+    };
+    return encoded;
+}
+exports.encodeChange = encodeChange;
 function encodeRevisionInfos(revisions, context, revisionTagCodec) {
     if (context.revision !== undefined) {
         (0, internal_1.assert)(
@@ -207,47 +277,137 @@ function encodeRevisionInfos(revisions, context, revisionTagCodec) {
     return encodedRevisions;
 }
 exports.encodeRevisionInfos = encodeRevisionInfos;
-function decodeRevisionInfos(revisions, context, revisionTagCodec) {
-    if (revisions === undefined) {
-        return context.revision === undefined ? undefined : [{ revision: context.revision }];
+function encodeDetachedNodes(detachedNodes, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
+    if (detachedNodes === undefined) {
+        return undefined;
     }
-    const decodedRevisions = [];
-    for (const revision of revisions) {
-        const decodedRevision = {
-            revision: revisionTagCodec.decode(revision.revision, context),
+    const treesToEncode = [];
+    const buildsArray = [];
+    let buildsForRevision;
+    for (const [[revision, id], chunk] of detachedNodes.entries()) {
+        const encodedRevision = encodeRevisionOpt(revisionTagCodec, revision, context);
+        if (buildsForRevision === undefined || buildsForRevision[1] !== encodedRevision) {
+            if (buildsForRevision !== undefined) {
+                buildsArray.push(buildsForRevision);
+            }
+            buildsForRevision = encodedRevision === undefined ? [[]] : [[], encodedRevision];
+        }
+        treesToEncode.push(chunk.cursor());
+        const treeIndexInBatch = treesToEncode.length - 1;
+        buildsForRevision?.[0].push([id, treeIndexInBatch]);
+    }
+    if (buildsForRevision !== undefined) {
+        buildsArray.push(buildsForRevision);
+    }
+    return buildsArray.length === 0
+        ? undefined
+        : {
+            builds: buildsArray,
+            trees: fieldsCodec.encode(treesToEncode, {
+                encodeType: chunkCompressionStrategy,
+                schema: context.schema,
+                originatorId: context.originatorId,
+                idCompressor: context.idCompressor,
+            }),
         };
-        if (revision.rollbackOf !== undefined) {
-            decodedRevision.rollbackOf = revisionTagCodec.decode(revision.rollbackOf, context);
+}
+exports.encodeDetachedNodes = encodeDetachedNodes;
+function getChangeHandler(fieldKinds, fieldKind) {
+    if (fieldKind === genericFieldKind_js_1.genericFieldKind.identifier) {
+        return genericFieldKind_js_1.genericFieldKind.changeHandler;
+    }
+    const handler = fieldKinds.get(fieldKind)?.kind.changeHandler;
+    (0, internal_1.assert)(handler !== undefined, 0x9c1 /* Unknown field kind */);
+    return handler;
+}
+function encodeRevisionOpt(revisionCodec, revision, context) {
+    if (revision === undefined) {
+        return undefined;
+    }
+    return revision === context.revision ? undefined : revisionCodec.encode(revision, context);
+}
+function getFieldToRoots(rootTable, aliases) {
+    const fieldToRoots = (0, modularChangeFamily_js_1.newFieldIdKeyBTree)();
+    for (const [[revision, localId], nodeId] of rootTable.nodeChanges.entries()) {
+        const detachId = { revision, localId };
+        const fieldId = rootTable.detachLocations.getFirst(detachId, 1).value;
+        if (fieldId === undefined) {
+            (0, internal_1.fail)("Untracked root change");
+        }
+        else {
+            (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(getOrAddInFieldRootMap(fieldToRoots, (0, modularChangeFamily_js_1.normalizeFieldId)(fieldId, aliases)).nodeChanges, detachId, nodeId);
         }
-        decodedRevisions.push(decodedRevision);
     }
-    return decodedRevisions;
+    for (const entry of rootTable.oldToNewId.entries()) {
+        const fieldId = rootTable.detachLocations.getFirst(entry.start, 1).value;
+        if (fieldId === undefined) {
+            (0, internal_1.fail)("Untracked root change");
+        }
+        else {
+            getOrAddInFieldRootMap(fieldToRoots, (0, modularChangeFamily_js_1.normalizeFieldId)(fieldId, aliases)).renames.set(entry.start, entry.length, entry.value);
+        }
+    }
+    return fieldToRoots;
 }
-exports.decodeRevisionInfos = decodeRevisionInfos;
-function encodeChange(change, context, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
-    // Destroys only exist in rollback changesets, which are never sent.
-    (0, internal_1.assert)(change.destroys === undefined, 0x899 /* Unexpected changeset with destroys */);
-    return {
-        maxId: change.maxId,
-        revisions: change.revisions === undefined
-            ? undefined
-            : encodeRevisionInfos(change.revisions, context, revisionTagCodec),
-        changes: encodeFieldChangesForJson(change.fieldChanges, context, change.nodeChanges, fieldChangesetCodecs),
-        builds: encodeDetachedNodes(change.builds, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
-        refreshers: encodeDetachedNodes(change.refreshers, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
-        violations: change.constraintViolationCount,
+function getOrAddInFieldRootMap(map, fieldId) {
+    const key = [fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field];
+    const rootChanges = map.get(key);
+    if (rootChanges !== undefined) {
+        return rootChanges;
+    }
+    const newRootChanges = {
+        nodeChanges: (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
+        renames: (0, index_js_2.newChangeAtomIdTransform)(),
     };
+    map.set(key, newRootChanges);
+    return newRootChanges;
+}
+function getMoveIdToCellId(change, fieldKinds, fieldToRoot) {
+    const map = (0, index_js_2.newChangeAtomIdTransform)();
+    getMoveIdToCellIdsForFieldChanges(change.fieldChanges, undefined, fieldKinds, fieldToRoot, map);
+    for (const [nodeId, nodeChange] of change.nodeChanges.entries()) {
+        if (nodeChange.fieldChanges !== undefined) {
+            getMoveIdToCellIdsForFieldChanges(nodeChange.fieldChanges, { revision: nodeId[0], localId: nodeId[1] }, fieldKinds, fieldToRoot, map);
+        }
+    }
+    return map;
+}
+exports.getMoveIdToCellId = getMoveIdToCellId;
+function getMoveIdToCellIdsForFieldChanges(changes, nodeId, fieldKinds, fieldToRoots, moveIdToCellId) {
+    for (const [fieldKey, field] of changes.entries()) {
+        for (const entry of getChangeHandler(fieldKinds, field.fieldKind).getDetachCellIds(field.change, fieldToRoots.get([nodeId?.revision, nodeId?.localId, fieldKey])?.renames ??
+            (0, index_js_2.newChangeAtomIdTransform)())) {
+            moveIdToCellId.set(entry.detachId, entry.count, entry.cellId);
+        }
+    }
 }
-exports.encodeChange = encodeChange;
 function decodeChange(encodedChange, context, fieldKinds, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
+    const idAllocator = (0, index_js_3.idAllocatorFromMaxId)(encodedChange.maxId);
+    const nodeChanges = (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)();
+    const nodeToParent = (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)();
+    const crossFieldKeys = (0, modularChangeTypes_js_1.newCrossFieldRangeTable)();
+    const rootNodes = (0, modularChangeFamily_js_1.newRootTable)();
+    const decodeNode = (encodedNode, fieldId) => {
+        const nodeId = {
+            revision: context.revision,
+            localId: (0, index_js_3.brand)(idAllocator.allocate()),
+        };
+        const node = decodeNodeChangesetFromJson(encodedNode, nodeId, crossFieldKeys, rootNodes, context, decodeNode, idAllocator, fieldKinds, fieldChangesetCodecs);
+        nodeChanges.set([nodeId.revision, nodeId.localId], node);
+        if (fieldId !== undefined) {
+            nodeToParent.set([nodeId.revision, nodeId.localId], fieldId);
+        }
+        return nodeId;
+    };
     const decoded = {
-        fieldChanges: new Map(),
-        nodeChanges: (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
-        nodeToParent: (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
+        rebaseVersion: 1,
+        fieldChanges: decodeFieldChangesFromJson(encodedChange.changes, undefined, crossFieldKeys, rootNodes, context, decodeNode, idAllocator, fieldKinds, fieldChangesetCodecs),
+        nodeChanges,
+        rootNodes,
+        nodeToParent,
         nodeAliases: (0, changeAtomIdBTree_js_1.newChangeAtomIdBTree)(),
-        crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+        crossFieldKeys,
     };
-    decoded.fieldChanges = decodeFieldChangesFromJson(encodedChange.changes, undefined, decoded, context, (0, index_js_2.idAllocatorFromMaxId)(encodedChange.maxId), fieldKinds, fieldChangesetCodecs);
     if (encodedChange.builds !== undefined) {
         decoded.builds = decodeDetachedNodes(encodedChange.builds, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy);
     }
@@ -264,58 +424,16 @@ function decodeChange(encodedChange, context, fieldKinds, fieldChangesetCodecs,
     if (encodedChange.maxId !== undefined) {
         decoded.maxId = encodedChange.maxId;
     }
+    // XXX: This is an expensive assert which should be removed before merging.
+    (0, modularChangeFamily_js_1.validateChangeset)(decoded, fieldKindsFromConfiguration(fieldKinds));
     return decoded;
 }
 exports.decodeChange = decodeChange;
-function getFieldChangesetCodecs(fieldKinds, revisionTagCodec, codecOptions) {
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    const getMapEntry = ({ kind, formatVersion }) => {
-        const codec = kind.changeHandler.codecsFactory(revisionTagCodec).resolve(formatVersion);
-        return {
-            codec,
-            compiledSchema: codec.json.encodedSchema
-                ? (0, index_js_1.extractJsonValidator)(codecOptions.jsonValidator).compile(codec.json.encodedSchema)
-                : undefined,
-        };
-    };
-    /**
-     * The codec version for the generic field kind.
-     */
-    const genericFieldKindFormatVersion = 1;
-    const fieldChangesetCodecs = new Map([
-        [
-            genericFieldKind_js_1.genericFieldKind.identifier,
-            getMapEntry({ kind: genericFieldKind_js_1.genericFieldKind, formatVersion: genericFieldKindFormatVersion }),
-        ],
-    ]);
-    // eslint-disable-next-line unicorn/no-array-for-each -- Map.forEach with (value, key) signature; codec initialization
-    fieldKinds.forEach((entry, identifier) => {
-        fieldChangesetCodecs.set(identifier, getMapEntry(entry));
-    });
-    return fieldChangesetCodecs;
-}
-exports.getFieldChangesetCodecs = getFieldChangesetCodecs;
-function makeModularChangeCodecV1(fieldKinds, revisionTagCodec, fieldsCodec, codecOptions, chunkCompressionStrategy = treeCompressionUtils_js_1.TreeCompressionStrategy.Compressed) {
-    const fieldChangesetCodecs = getFieldChangesetCodecs(fieldKinds, revisionTagCodec, codecOptions);
-    const modularChangeCodec = {
-        encode: (change, context) => encodeChange(change, context, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
-        decode: (encodedChange, context) => decodeChange(encodedChange, context, fieldKinds, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
-    };
-    return (0, index_js_1.withSchemaValidation)(modularChangeFormatV1_js_1.EncodedModularChangesetV1, modularChangeCodec, codecOptions.jsonValidator);
-}
-exports.makeModularChangeCodecV1 = makeModularChangeCodecV1;
-function getChangeHandler(fieldKinds, fieldKind) {
-    if (fieldKind === genericFieldKind_js_1.genericFieldKind.identifier) {
-        return genericFieldKind_js_1.genericFieldKind.changeHandler;
+function fieldKindsFromConfiguration(configuration) {
+    const map = new Map();
+    for (const [id, entry] of configuration.entries()) {
+        map.set(id, entry.kind);
     }
-    const handler = fieldKinds.get(fieldKind)?.kind.changeHandler;
-    (0, internal_1.assert)(handler !== undefined, 0x9c1 /* Unknown field kind */);
-    return handler;
-}
-function encodeRevisionOpt(revisionCodec, revision, context) {
-    if (revision === undefined) {
-        return undefined;
-    }
-    return revision === context.revision ? undefined : revisionCodec.encode(revision, context);
+    return map;
 }
 //# sourceMappingURL=modularChangeCodecV1.js.map