@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -2,17 +2,252 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert, fail, oob } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail } from "@fluidframework/core-utils/internal";
 import { extractJsonValidator, withSchemaValidation, } from "../../codec/index.js";
-import { newChangeAtomIdTransform, } from "../../core/index.js";
 import { brand, idAllocatorFromMaxId, newTupleBTree, } from "../../util/index.js";
 import { chunkFieldSingle, defaultChunkPolicy, } from "../chunked-forest/index.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
-import { addNodeRename, getFirstAttachField, getFirstDetachField, newRootTable, } from "./modularChangeFamily.js";
-import { newCrossFieldRangeTable, setInChangeAtomIdMap, } from "./modularChangeTypes.js";
-import { EncodedModularChangeset, } from "./modularChangeFormatV1.js";
 import { genericFieldKind } from "./genericFieldKind.js";
-export function makeModularChangeCodecV1(fieldKinds, revisionTagCodec, fieldsCodec, codecOptions, chunkCompressionStrategy = TreeCompressionStrategy.Compressed) {
+import { EncodedModularChangesetV1, } from "./modularChangeFormatV1.js";
+import { newCrossFieldKeyTable, } from "./modularChangeTypes.js";
+export function getFieldChangesetCodec(fieldKind, fieldChangesetCodecs) {
+    const entry = fieldChangesetCodecs.get(fieldKind);
+    assert(entry !== undefined, 0x5ea /* Tried to encode unsupported fieldKind */);
+    return entry;
+}
+export function encodeFieldChangesForJson(change, context, nodeChanges, fieldChangesetCodecs) {
+    const fieldContext = {
+        baseContext: context,
+        encodeNode: (nodeId) => {
+            const node = nodeChanges.get([nodeId.revision, nodeId.localId]);
+            assert(node !== undefined, 0x92e /* Unknown node ID */);
+            return encodeNodeChangesForJson(node, fieldContext, fieldChangesetCodecs);
+        },
+        decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
+    };
+    return encodeFieldChangesForJsonI(change, fieldContext, fieldChangesetCodecs);
+}
+export function encodeFieldChangesForJsonI(change, context, fieldChangesetCodecs) {
+    const encodedFields = [];
+    for (const [field, fieldChange] of change) {
+        const { codec, compiledSchema } = getFieldChangesetCodec(fieldChange.fieldKind, fieldChangesetCodecs);
+        const encodedChange = codec.json.encode(fieldChange.change, context);
+        if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
+            fail(0xb1f /* Encoded change didn't pass schema validation. */);
+        }
+        const fieldKey = field;
+        const encodedField = {
+            fieldKey,
+            fieldKind: fieldChange.fieldKind,
+            change: encodedChange,
+        };
+        encodedFields.push(encodedField);
+    }
+    return encodedFields;
+}
+export function encodeNodeChangesForJson(change, context, 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);
+    }
+    if (nodeExistsConstraint !== undefined) {
+        encodedChange.nodeExistsConstraint = nodeExistsConstraint;
+    }
+    return encodedChange;
+}
+export function decodeFieldChangesFromJson(encodedChange, parentId, decoded, context, idAllocator, fieldKinds, fieldChangesetCodecs) {
+    const decodedFields = new Map();
+    for (const field of encodedChange) {
+        const { codec, compiledSchema } = getFieldChangesetCodec(field.fieldKind, fieldChangesetCodecs);
+        if (compiledSchema !== undefined && !compiledSchema.check(field.change)) {
+            fail(0xb20 /* Encoded change didn't pass schema validation. */);
+        }
+        const fieldId = {
+            nodeId: parentId,
+            field: field.fieldKey,
+        };
+        const fieldContext = {
+            baseContext: context,
+            encodeNode: () => fail(0xb21 /* Should not encode nodes during field decoding */),
+            decodeNode: (encodedNode) => {
+                const nodeId = {
+                    revision: context.revision,
+                    localId: 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;
+            },
+        };
+        const fieldChangeset = codec.json.decode(field.change, fieldContext);
+        const crossFieldKeys = getChangeHandler(fieldKinds, field.fieldKind).getCrossFieldKeys(fieldChangeset);
+        for (const { key, count } of crossFieldKeys) {
+            decoded.crossFieldKeys.set(key, count, fieldId);
+        }
+        const fieldKey = brand(field.fieldKey);
+        decodedFields.set(fieldKey, {
+            fieldKind: field.fieldKind,
+            change: brand(fieldChangeset),
+        });
+    }
+    return decodedFields;
+}
+export function decodeNodeChangesetFromJson(encodedChange, id, decoded, context, idAllocator, fieldKinds, fieldChangesetCodecs) {
+    const decodedChange = {};
+    const { fieldChanges, nodeExistsConstraint } = encodedChange;
+    if (fieldChanges !== undefined) {
+        decodedChange.fieldChanges = decodeFieldChangesFromJson(fieldChanges, id, decoded, context, idAllocator, fieldKinds, fieldChangesetCodecs);
+    }
+    if (nodeExistsConstraint !== undefined) {
+        decodedChange.nodeExistsConstraint = nodeExistsConstraint;
+    }
+    return decodedChange;
+}
+export 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,
+            }),
+        };
+}
+export function decodeDetachedNodes(encoded, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
+    if (encoded === undefined || encoded.builds.length === 0) {
+        return undefined;
+    }
+    const chunks = fieldsCodec.decode(encoded.trees, {
+        encodeType: chunkCompressionStrategy,
+        originatorId: context.originatorId,
+        idCompressor: context.idCompressor,
+    });
+    const getChunk = (index) => {
+        assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
+        return chunkFieldSingle(chunks[index] ?? oob(), {
+            policy: defaultChunkPolicy,
+            idCompressor: context.idCompressor,
+        });
+    };
+    const map = newTupleBTree();
+    encoded.builds.forEach((build) => {
+        // EncodedRevisionTag cannot be an array so this ensures that we can isolate the tuple
+        const revision = build[1] === undefined ? context.revision : revisionTagCodec.decode(build[1], context);
+        const decodedChunks = build[0].map(([i, n]) => [
+            i,
+            getChunk(n),
+        ]);
+        for (const [id, chunk] of decodedChunks) {
+            map.set([revision, id], chunk);
+        }
+    });
+    return map;
+}
+export function encodeRevisionInfos(revisions, context, revisionTagCodec) {
+    if (context.revision !== undefined) {
+        assert(revisions.length === 1 &&
+            revisions[0] !== undefined &&
+            revisions[0].revision === context.revision &&
+            revisions[0].rollbackOf === undefined, 0x964 /* A tagged change should only contain the tagged revision */);
+        return undefined;
+    }
+    const encodedRevisions = [];
+    for (const revision of revisions) {
+        const encodedRevision = {
+            revision: revisionTagCodec.encode(revision.revision, context),
+        };
+        if (revision.rollbackOf !== undefined) {
+            encodedRevision.rollbackOf = revisionTagCodec.encode(revision.rollbackOf, context);
+        }
+        encodedRevisions.push(encodedRevision);
+    }
+    return encodedRevisions;
+}
+export 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;
+}
+export function encodeChange(change, context, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
+    // Destroys only exist in rollback changesets, which are never sent.
+    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,
+    };
+}
+export function decodeChange(encodedChange, context, fieldKinds, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy) {
+    const decoded = {
+        fieldChanges: new Map(),
+        nodeChanges: newTupleBTree(),
+        nodeToParent: newTupleBTree(),
+        nodeAliases: newTupleBTree(),
+        crossFieldKeys: newCrossFieldKeyTable(),
+    };
+    decoded.fieldChanges = decodeFieldChangesFromJson(encodedChange.changes, undefined, decoded, context, idAllocatorFromMaxId(encodedChange.maxId), fieldKinds, fieldChangesetCodecs);
+    if (encodedChange.builds !== undefined) {
+        decoded.builds = decodeDetachedNodes(encodedChange.builds, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy);
+    }
+    if (encodedChange.refreshers !== undefined) {
+        decoded.refreshers = decodeDetachedNodes(encodedChange.refreshers, context, revisionTagCodec, fieldsCodec, chunkCompressionStrategy);
+    }
+    if (encodedChange.violations !== undefined) {
+        decoded.constraintViolationCount = encodedChange.violations;
+    }
+    const decodedRevInfos = decodeRevisionInfos(encodedChange.revisions, context, revisionTagCodec);
+    if (decodedRevInfos !== undefined) {
+        decoded.revisions = decodedRevInfos;
+    }
+    if (encodedChange.maxId !== undefined) {
+        decoded.maxId = encodedChange.maxId;
+    }
+    return decoded;
+}
+export 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);
@@ -36,300 +271,15 @@ export function makeModularChangeCodecV1(fieldKinds, revisionTagCodec, fieldsCod
     fieldKinds.forEach((entry, identifier) => {
         fieldChangesetCodecs.set(identifier, getMapEntry(entry));
     });
-    const getFieldChangesetCodec = (fieldKind) => {
-        const entry = fieldChangesetCodecs.get(fieldKind);
-        assert(entry !== undefined, 0x5ea /* Tried to encode unsupported fieldKind */);
-        return entry;
-    };
-    function encodeFieldChangesForJson(change, parentId, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId) {
-        const encodedFields = [];
-        for (const [field, fieldChange] of change) {
-            const { codec, compiledSchema } = getFieldChangesetCodec(fieldChange.fieldKind);
-            const rootChanges = fieldToRoots.get([parentId?.revision, parentId?.localId, field]);
-            const fieldContext = {
-                baseContext: context,
-                rootNodeChanges: rootChanges?.nodeChanges ?? newTupleBTree(),
-                rootRenames: rootChanges?.renames ?? newChangeAtomIdTransform(),
-                encodeNode,
-                getInputRootId,
-                isAttachId,
-                isDetachId,
-                decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
-                decodeRootNodeChange: () => fail("Should not be called during encoding"),
-                decodeRootRename: () => fail("Should not be called during encoding"),
-                decodeMoveAndDetach: () => fail("Should not be called during encoding"),
-                generateId: () => fail("Should not be called during encoding"),
-            };
-            const encodedChange = codec.json.encode(fieldChange.change, fieldContext);
-            if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
-                fail(0xb1f /* Encoded change didn't pass schema validation. */);
-            }
-            const fieldKey = field;
-            const encodedField = {
-                fieldKey,
-                fieldKind: fieldChange.fieldKind,
-                change: encodedChange,
-            };
-            encodedFields.push(encodedField);
-        }
-        return encodedFields;
-    }
-    function encodeNodeChangesForJson(change, id, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId) {
-        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 = encodeFieldChangesForJson(fieldChanges, id, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId);
-        }
-        if (nodeExistsConstraint !== undefined) {
-            encodedChange.nodeExistsConstraint = nodeExistsConstraint;
-        }
-        return encodedChange;
-    }
-    function decodeFieldChangesFromJson(encodedChange, parentId, decodedCrossFieldKeys, decodedRootTable, context, decodeNode, idAllocator) {
-        const decodedFields = new Map();
-        for (const field of encodedChange) {
-            const { codec, compiledSchema } = getFieldChangesetCodec(field.fieldKind);
-            if (compiledSchema !== undefined && !compiledSchema.check(field.change)) {
-                fail(0xb20 /* Encoded change didn't pass schema validation. */);
-            }
-            const fieldId = {
-                nodeId: parentId,
-                field: field.fieldKey,
-            };
-            const fieldContext = {
-                baseContext: context,
-                rootNodeChanges: newTupleBTree(),
-                rootRenames: newChangeAtomIdTransform(),
-                encodeNode: () => fail(0xb21 /* Should not encode nodes during field decoding */),
-                getInputRootId: () => fail("Should not query during decoding"),
-                isAttachId: () => fail("Should not query during decoding"),
-                isDetachId: () => fail("Should not query during decoding"),
-                decodeNode: (encodedNode) => {
-                    return decodeNode(encodedNode, { field: fieldId });
-                },
-                decodeRootNodeChange: (detachId, encodedNode) => {
-                    setInChangeAtomIdMap(decodedRootTable.nodeChanges, detachId, decodeNode(encodedNode, { root: detachId }));
-                    decodedRootTable.detachLocations.set(detachId, 1, fieldId);
-                },
-                decodeRootRename: (oldId, newId, count) => {
-                    addNodeRename(decodedRootTable, oldId, newId, count, fieldId);
-                },
-                decodeMoveAndDetach: (detachId, count) => {
-                    decodedRootTable.outputDetachLocations.set(detachId, count, fieldId);
-                },
-                generateId: () => ({
-                    revision: context.revision,
-                    localId: brand(idAllocator.allocate()),
-                }),
-            };
-            const fieldChangeset = codec.json.decode(field.change, fieldContext);
-            const crossFieldKeys = getChangeHandler(fieldKinds, field.fieldKind).getCrossFieldKeys(fieldChangeset);
-            for (const { key, count } of crossFieldKeys) {
-                decodedCrossFieldKeys.set(key, count, fieldId);
-            }
-            const fieldKey = brand(field.fieldKey);
-            decodedFields.set(fieldKey, {
-                fieldKind: field.fieldKind,
-                change: brand(fieldChangeset),
-            });
-        }
-        return decodedFields;
-    }
-    function decodeNodeChangesetFromJson(encodedChange, id, decodedCrossFieldKeys, decodedRootTable, context, decodeNode, idAllocator) {
-        const decodedChange = {};
-        const { fieldChanges, nodeExistsConstraint } = encodedChange;
-        if (fieldChanges !== undefined) {
-            decodedChange.fieldChanges = decodeFieldChangesFromJson(fieldChanges, id, decodedCrossFieldKeys, decodedRootTable, context, decodeNode, idAllocator);
-        }
-        if (nodeExistsConstraint !== undefined) {
-            decodedChange.nodeExistsConstraint = nodeExistsConstraint;
-        }
-        return decodedChange;
-    }
-    function encodeDetachedNodes(detachedNodes, context) {
-        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,
-                }),
-            };
-    }
-    function decodeDetachedNodes(encoded, context) {
-        if (encoded === undefined || encoded.builds.length === 0) {
-            return undefined;
-        }
-        const chunks = fieldsCodec.decode(encoded.trees, {
-            encodeType: chunkCompressionStrategy,
-            originatorId: context.originatorId,
-            idCompressor: context.idCompressor,
-        });
-        const getChunk = (index) => {
-            assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
-            return chunkFieldSingle(chunks[index] ?? oob(), {
-                policy: defaultChunkPolicy,
-                idCompressor: context.idCompressor,
-            });
-        };
-        const map = newTupleBTree();
-        encoded.builds.forEach((build) => {
-            // EncodedRevisionTag cannot be an array so this ensures that we can isolate the tuple
-            const revision = build[1] === undefined ? context.revision : revisionTagCodec.decode(build[1], context);
-            const decodedChunks = build[0].map(([i, n]) => [
-                i,
-                getChunk(n),
-            ]);
-            for (const [id, chunk] of decodedChunks) {
-                map.set([revision, id], chunk);
-            }
-        });
-        return map;
-    }
-    function encodeRevisionInfos(revisions, context) {
-        if (context.revision !== undefined) {
-            assert(revisions.length === 1 &&
-                revisions[0] !== undefined &&
-                revisions[0].revision === context.revision &&
-                revisions[0].rollbackOf === undefined, 0x964 /* A tagged change should only contain the tagged revision */);
-            return undefined;
-        }
-        const encodedRevisions = [];
-        for (const revision of revisions) {
-            const encodedRevision = {
-                revision: revisionTagCodec.encode(revision.revision, context),
-            };
-            if (revision.rollbackOf !== undefined) {
-                encodedRevision.rollbackOf = revisionTagCodec.encode(revision.rollbackOf, context);
-            }
-            encodedRevisions.push(encodedRevision);
-        }
-        return encodedRevisions;
-    }
-    function decodeRevisionInfos(revisions, context) {
-        if (revisions === undefined) {
-            return context.revision !== undefined ? [{ revision: context.revision }] : undefined;
-        }
-        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;
-    }
+    return fieldChangesetCodecs;
+}
+export function makeModularChangeCodecV1(fieldKinds, revisionTagCodec, fieldsCodec, codecOptions, chunkCompressionStrategy = TreeCompressionStrategy.Compressed) {
+    const fieldChangesetCodecs = getFieldChangesetCodecs(fieldKinds, revisionTagCodec, codecOptions);
     const modularChangeCodec = {
-        encode: (change, context) => {
-            const fieldToRoots = getFieldToRoots(change.rootNodes);
-            const isAttachId = (id, count) => {
-                const attachEntry = getFirstAttachField(change.crossFieldKeys, id, count);
-                return { ...attachEntry, value: attachEntry.value !== undefined };
-            };
-            const isDetachId = (id, count) => {
-                const detachEntry = 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 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]);
-                assert(node !== undefined, 0x92e /* Unknown node ID */);
-                return encodeNodeChangesForJson(node, nodeId, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId);
-            };
-            // Destroys only exist in rollback changesets, which are never sent.
-            assert(change.destroys === undefined, 0x899 /* Unexpected changeset with destroys */);
-            const encoded = {
-                maxId: change.maxId,
-                revisions: change.revisions === undefined
-                    ? undefined
-                    : encodeRevisionInfos(change.revisions, context),
-                changes: encodeFieldChangesForJson(change.fieldChanges, undefined, fieldToRoots, context, encodeNode, getInputRootId, isAttachId, isDetachId),
-                builds: encodeDetachedNodes(change.builds, context),
-                refreshers: encodeDetachedNodes(change.refreshers, context),
-                violations: change.constraintViolationCount,
-            };
-            return encoded;
-        },
-        decode: (encodedChange, context) => {
-            const idAllocator = idAllocatorFromMaxId(encodedChange.maxId);
-            const nodeChanges = newTupleBTree();
-            const nodeToParent = newTupleBTree();
-            const crossFieldKeys = newCrossFieldRangeTable();
-            const rootNodes = newRootTable();
-            const decodeNode = (encodedNode, fieldId) => {
-                const nodeId = {
-                    revision: context.revision,
-                    localId: brand(idAllocator.allocate()),
-                };
-                const node = decodeNodeChangesetFromJson(encodedNode, nodeId, crossFieldKeys, rootNodes, context, decodeNode, idAllocator);
-                nodeChanges.set([nodeId.revision, nodeId.localId], node);
-                if (fieldId !== undefined) {
-                    nodeToParent.set([nodeId.revision, nodeId.localId], fieldId);
-                }
-                return nodeId;
-            };
-            const decoded = {
-                rebaseVersion: 1,
-                fieldChanges: decodeFieldChangesFromJson(encodedChange.changes, undefined, crossFieldKeys, rootNodes, context, decodeNode, idAllocator),
-                nodeChanges,
-                rootNodes,
-                nodeToParent,
-                nodeAliases: newTupleBTree(),
-                crossFieldKeys,
-            };
-            if (encodedChange.builds !== undefined) {
-                decoded.builds = decodeDetachedNodes(encodedChange.builds, context);
-            }
-            if (encodedChange.refreshers !== undefined) {
-                decoded.refreshers = decodeDetachedNodes(encodedChange.refreshers, context);
-            }
-            if (encodedChange.violations !== undefined) {
-                decoded.constraintViolationCount = encodedChange.violations;
-            }
-            const decodedRevInfos = decodeRevisionInfos(encodedChange.revisions, context);
-            if (decodedRevInfos !== undefined) {
-                decoded.revisions = decodedRevInfos;
-            }
-            if (encodedChange.maxId !== undefined) {
-                decoded.maxId = encodedChange.maxId;
-            }
-            return decoded;
-        },
+        encode: (change, context) => encodeChange(change, context, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
+        decode: (encodedChange, context) => decodeChange(encodedChange, context, fieldKinds, fieldChangesetCodecs, revisionTagCodec, fieldsCodec, chunkCompressionStrategy),
     };
-    return withSchemaValidation(EncodedModularChangeset, modularChangeCodec, codecOptions.jsonValidator);
+    return withSchemaValidation(EncodedModularChangesetV1, modularChangeCodec, codecOptions.jsonValidator);
 }
 function getChangeHandler(fieldKinds, fieldKind) {
     if (fieldKind === genericFieldKind.identifier) {
@@ -345,40 +295,4 @@ function encodeRevisionOpt(revisionCodec, revision, context) {
     }
     return revision === context.revision ? undefined : revisionCodec.encode(revision, context);
 }
-function getFieldToRoots(rootTable) {
-    const fieldToRoots = newTupleBTree();
-    for (const [[revision, localId], nodeId] of rootTable.nodeChanges.entries()) {
-        const detachId = { revision, localId };
-        const fieldId = rootTable.detachLocations.getFirst(detachId, 1).value;
-        if (fieldId !== undefined) {
-            setInChangeAtomIdMap(getOrAddInFieldRootMap(fieldToRoots, fieldId).nodeChanges, detachId, nodeId);
-        }
-        else {
-            fail("Untracked root change");
-        }
-    }
-    for (const entry of rootTable.oldToNewId.entries()) {
-        const fieldId = rootTable.detachLocations.getFirst(entry.start, 1).value;
-        if (fieldId !== undefined) {
-            getOrAddInFieldRootMap(fieldToRoots, fieldId).renames.set(entry.start, entry.length, entry.value);
-        }
-        else {
-            fail("Untracked root change");
-        }
-    }
-    return fieldToRoots;
-}
-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: newTupleBTree(),
-        renames: newChangeAtomIdTransform(),
-    };
-    map.set(key, newRootChanges);
-    return newRootChanges;
-}
 //# sourceMappingURL=modularChangeCodecV1.js.map