@fluidframework/tree 2.82.0 → 2.90.0-378676

package/src/feature-libraries/forest-summary/codec.ts

@@ -9,6 +9,7 @@ import {
 	getConfigForMinVersionForCollab,
 	lowestMinVersionForCollab,
 } from "@fluidframework/runtime-utils/internal";
+import { Type } from "@sinclair/typebox";
 
 import {
 	type CodecTree,
@@ -21,12 +22,9 @@ import type { FieldKey, ITreeCursorSynchronous } from "../../core/index.js";
 import { brand, type JsonCompatibleReadOnly } from "../../util/index.js";
 import type { FieldBatchCodec, FieldBatchEncodingContext } from "../chunked-forest/index.js";
 
-import {
-	ForestFormatVersion,
-	validVersions,
-	type Format,
-	FormatCommon,
-} from "./formatCommon.js";
+import { ForestFormatVersion, validVersions, type Format } from "./formatCommon.js";
+import { FormatV1 } from "./formatV1.js";
+import { FormatV2 } from "./formatV2.js";
 
 /**
  * Uses field cursors
@@ -61,7 +59,10 @@ export function makeForestSummarizerCodec(
 ): ForestCodec {
 	const inner = fieldBatchCodec;
 	const writeVersion = clientVersionToForestFormatVersion(options.minVersionForCollab);
-	const formatSchema = FormatCommon(writeVersion);
+	const formatSchema = Type.Union([FormatV1, FormatV2]);
+	// Both the encode and decode logic here support both v1 and v2, as does `validVersions` and `formatSchema`.
+	// This makes this use of makeVersionedValidatedCodec atypical as it is a single call being used to make a codec that supports all versions,
+	// instead of one call per version, then using another utility to select between them based on version.
 	return makeVersionedValidatedCodec(options, validVersions, formatSchema, {
 		encode: (data: FieldSet, context: FieldBatchEncodingContext): Format => {
 			const keys: FieldKey[] = [];

package/src/feature-libraries/forest-summary/formatCommon.ts

@@ -20,8 +20,8 @@ export type ForestFormatVersion = Values<typeof ForestFormatVersion>;
 
 export const validVersions = new Set([...Object.values(ForestFormatVersion)]);
 
-export const FormatCommon = (
-	version: ForestFormatVersion,
+export const FormatCommon = <const TVersion extends ForestFormatVersion>(
+	version: TVersion,
 	// Return type is intentionally derived.
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 ) =>
@@ -33,4 +33,6 @@ export const FormatCommon = (
 		},
 		{ additionalProperties: false },
 	);
-export type Format = Static<ReturnType<typeof FormatCommon>>;
+export type Format<TVersion extends ForestFormatVersion = ForestFormatVersion> = Static<
+	ReturnType<typeof FormatCommon<TVersion>>
+>;

package/src/feature-libraries/forest-summary/formatV1.ts

@@ -5,9 +5,7 @@
 
 import type { Static } from "@sinclair/typebox";
 
-import { brand } from "../../util/index.js";
-
 import { FormatCommon, ForestFormatVersion } from "./formatCommon.js";
 
-export const FormatV1 = FormatCommon(brand<ForestFormatVersion>(ForestFormatVersion.v1));
+export const FormatV1 = FormatCommon(ForestFormatVersion.v1);
 export type FormatV1 = Static<typeof FormatV1>;

package/src/feature-libraries/forest-summary/formatV2.ts

@@ -5,9 +5,7 @@
 
 import type { Static } from "@sinclair/typebox";
 
-import { brand } from "../../util/index.js";
-
 import { FormatCommon, ForestFormatVersion } from "./formatCommon.js";
 
-export const FormatV2 = FormatCommon(brand<ForestFormatVersion>(ForestFormatVersion.v2));
+export const FormatV2 = FormatCommon(ForestFormatVersion.v2);
 export type FormatV2 = Static<typeof FormatV2>;

package/src/feature-libraries/index.ts

@@ -69,8 +69,10 @@ export {
 	type NodeChangeInverter,
 	type NodeChangeRebaser,
 	type NodeChangePruner,
-	type CrossFieldManager,
-	CrossFieldTarget,
+	type ComposeNodeManager,
+	type InvertNodeManager,
+	type RebaseNodeManager,
+	NodeMoveType,
 	FlexFieldKind,
 	type FullSchemaPolicy,
 	allowsRepoSuperset,
@@ -79,7 +81,6 @@ export {
 	type HasFieldChanges,
 	type NodeExistsConstraint,
 	ModularChangeFamily,
-	type RelevantRemovedRootsFromChild,
 	EncodedModularChangesetV1,
 	EncodedModularChangesetV2,
 	updateRefreshers,
@@ -92,7 +93,11 @@ export {
 	ModularChangeFormatVersion,
 } from "./modular-schema/index.js";
 
-export { mapRootChanges } from "./deltaUtils.js";
+export {
+	mapRootChanges,
+	nodeIdFromChangeAtom,
+	changeAtomFromDetachedNodeId,
+} from "./deltaUtils.js";
 
 export {
 	type TreeChunk,
@@ -128,17 +133,25 @@ export {
 export {
 	FieldKinds,
 	type DefaultChangeset,
+	type DetachedRootIds,
 	DefaultChangeFamily,
-	DefaultEditBuilder,
-	type IDefaultEditBuilder,
-	type ValueFieldEditBuilder,
-	type OptionalFieldEditBuilder,
-	type SequenceFieldEditBuilder,
+	type IdBasedChangeFamilyDataEditor,
+	DefaultIdBasedDataEditor,
+	type DataEditor,
+	type RequiredFieldEditor,
+	type OptionalFieldEditor,
+	type SequenceFieldEditor,
 	defaultSchemaPolicy,
 	fieldKinds,
 	fieldKindConfigurations,
 	intoDelta,
 	relevantRemovedRoots,
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
+	type DetachedRootIdRange,
+	type Locator,
+	LocationBasedDataEditor,
+	type ILocationBasedDataEditor,
 	getCodecTreeForModularChangeFormat,
 } from "./default-schema/index.js";
 

package/src/feature-libraries/mitigatedChangeFamily.ts

@@ -7,6 +7,7 @@ import type {
 	ChangeFamily,
 	ChangeFamilyEditor,
 	ChangeRebaser,
+	EditorOptions,
 	RevisionMetadataSource,
 	RevisionReplacer,
 	RevisionTag,
@@ -36,8 +37,9 @@ export function makeMitigatedChangeFamily<TEditor extends ChangeFamilyEditor, TC
 		buildEditor: (
 			mintRevisionTag: () => RevisionTag,
 			changeReceiver: (change: TaggedChange<TChange>) => void,
+			options?: EditorOptions,
 		): TEditor => {
-			return unmitigatedChangeFamily.buildEditor(mintRevisionTag, changeReceiver);
+			return unmitigatedChangeFamily.buildEditor(mintRevisionTag, changeReceiver, options);
 		},
 		rebaser: makeMitigatedRebaser(unmitigatedChangeFamily.rebaser, fallbackChange, onError),
 		codecs: unmitigatedChangeFamily.codecs,

package/src/feature-libraries/modular-schema/crossFieldQueries.ts

@@ -16,23 +16,13 @@ import type { NodeId } from "./modularChangeTypes.js";
 export type CrossFieldMap<T> = ChangeAtomIdRangeMap<T>;
 export type CrossFieldQuerySet = CrossFieldMap<boolean>;
 
-export function addCrossFieldQuery(
-	set: CrossFieldQuerySet,
-	revision: RevisionTag | undefined,
-	id: ChangesetLocalId,
-	count: number,
-): void {
-	setInCrossFieldMap(set, revision, id, count, true);
-}
-
 export function setInCrossFieldMap<T>(
 	map: CrossFieldMap<T>,
-	revision: RevisionTag | undefined,
-	id: ChangesetLocalId,
+	id: ChangeAtomId,
 	count: number,
 	value: T,
 ): void {
-	map.set({ revision, localId: id }, count, value);
+	map.set(id, count, value);
 }
 
 export function getFirstFromCrossFieldMap<T>(
@@ -40,60 +30,167 @@ export function getFirstFromCrossFieldMap<T>(
 	revision: RevisionTag | undefined,
 	id: ChangesetLocalId,
 	count: number,
-): RangeQueryResult<ChangeAtomId, T> {
+): RangeQueryResult<T | undefined> {
 	return map.getFirst({ revision, localId: id }, count);
 }
 
-export enum CrossFieldTarget {
-	Source,
-	Destination,
+export enum NodeMoveType {
+	Detach,
+	Attach,
 }
 
-/**
- * Used by {@link FieldChangeHandler} implementations for exchanging information across other fields
- * while rebasing, composing, or inverting a change.
- */
-export interface CrossFieldManager<T = unknown> {
+export interface InvertNodeManager {
+	/**
+	 * Transfers the given node changes from the input context of the field changeset being inverted to the input context of the detached space (from which it may be further moved).
+	 *
+	 * This must be called for each detach in the field kind when rolling-back or reverting a detach.
+	 * This implies that all detaches in the field must be inverted.
+	 * @param detachId - The ID of the detach to invert.
+	 * @param count - The number of nodes being detached.
+	 * @param nodeChanges - The node changes to transfer.
+	 * @param newAttachId - The ID that the nodes will be attached with in the inverted changeset of this field.
+	 */
+	invertDetach(
+		detachId: ChangeAtomId,
+		count: number,
+		nodeChanges: NodeId | undefined,
+		newAttachId: ChangeAtomId,
+	): void;
+
+	/**
+	 * Gets the node changes associated with the node being attached in input changeset.
+	 *
+	 * This must be called for each attach in the field kind when rolling-back or reverting a attach.
+	 * This implies that all attaches in the field must be inverted.
+	 * @param attachId - The ID of the attach to invert.
+	 * @param count - The number of nodes being attached.
+	 */
+	invertAttach(
+		attachId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<DetachedNodeEntry | undefined>;
+}
+
+export interface ComposeNodeManager {
+	/**
+	 * Allows a field kind to query nested changes associated with a node in the input context of the new changeset.
+	 * This should be called for every detach in the base changeset.
+	 * @param baseDetachId - The ID of the detach in the base changeset.
+	 * @param count - The number of nodes being detached.
+	 */
+	getNewChangesForBaseDetach(
+		baseDetachId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<DetachedNodeEntry | undefined>;
+
 	/**
-	 * Returns the first data range associated with the key of `target`, `revision`, between `id` and `id + count`.
-	 * Calling this records a dependency for the current field on this key if `addDependency` is true.
+	 * Must be called by a field kind when composing an attach in the base changeset with a detach in the new changeset.
+	 * This allows Modular Change Family to keep track of how a given node is being renamed.
+	 * @param baseAttachId - The ID of the attach in the base changeset.
+	 * @param newDetachId - The ID of the detach in the new changeset.
+	 * @param count - The number of nodes being attached then detached.
 	 */
-	get(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	composeAttachDetach(
+		baseAttachId: ChangeAtomId,
+		newDetachId: ChangeAtomId,
 		count: number,
-		addDependency: boolean,
-	): RangeQueryResult<ChangeAtomId, T>;
+	): void;
+
+	/**
+	 * Must be called by a field kind when composing an attach in the base changeset with nested changes the new changeset.
+	 *
+	 * This is needed because child changes are represented at the location of the node they impact in the input context of a changeset.
+	 * So if the later of the two changes being composed carries nested changes for a node,
+	 * then in the composed changeset, these nested changes need to be represented at the location of that node in the input context of the composed changeset.
+	 *
+	 * @param baseAttachId - The ID of the attach in the base changeset.
+	 * @param newChanges - The ID of the nested changes associated with this node in the new changeset.
+	 */
+	sendNewChangesToBaseSourceLocation(baseAttachId: ChangeAtomId, newChanges: NodeId): void;
 
+	// XXX: It doesn't seem like it should be mandatory to call this if you don't want the rename to be removed (e.g., optional field pin).
 	/**
-	 * Sets the range of keys to `newValue`.
-	 * If `invalidateDependents` is true, all fields which took a dependency on this key will be considered invalidated
-	 * and will be given a chance to address the new data in `amendCompose`, or a second pass of `rebase` or `invert` as appropriate.
+	 * Must be called by a field kind when composing a detach in the base changeset with an attach of the same nodes in the new changeset.
+	 * @param baseDetachId - The ID of the detach in the base changeset.
+	 * @param newAttachId - The ID of the attach in the new changeset.
+	 * @param count - The number of nodes being detached then attached.
+	 * @param convertToPin - Should be set to true if the composed change will include a detach and attach with `newAttachId`.
+	 * Otherwise the composed change should not include either `baseDetachId` or `newAttachId`.
 	 */
-	set(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	composeDetachAttach(
+		baseDetachId: ChangeAtomId,
+		newAttachId: ChangeAtomId,
 		count: number,
-		newValue: T,
-		invalidateDependents: boolean,
+		convertToPin: boolean,
 	): void;
+}
 
+export interface RebaseNodeManager {
+	// XXX: It's not clear whether the returned changes are already rebased or not.
 	/**
-	 * This must be called whenever a new node is moved into this field as part of the current rebase, compose, or invert.
-	 * Calling this for a node which was already in the field is tolerated.
+	 * Must be called by a field kind when rebasing over an attach.
+	 * The returned child changes and detach intentions must be represented in the output changeset.
+	 * @param baseAttachId - The ID of the attach that is being rebased over.
+	 * @param count - The number of nodes attached by the base attach.
+	 * @returns The new nested changes and detach intentions associated with the node in the changeset being rebased.
 	 */
-	onMoveIn(id: NodeId): void;
+	getNewChangesForBaseAttach(
+		baseAttachId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<RebaseDetachedNodeEntry | undefined>;
 
+	// XXX: It's not clear if this must be called even when newDetachId and nodeChange are undefined.
+	// XXX: It's not clear if it's okay to call this once with a newDetachId then once with a nodeChange.
+	// XXX: It's not clear if nodeChange should be rebased already, or should not be rebased, or if it doesn't matter.
 	/**
-	 * This must be called whenever a new cross field key is moved into this field as part of the current rebase or compose.
-	 * Calling this for a key which was already in the field is tolerated.
+	 * Must be called by a field kind when rebasing over a detach.
+	 * The field kind must provide the nested changes and detach intentions associated with the node in the changeset being rebased.
+	 * @param baseDetachId - The ID of the detach that is being rebased over.
+	 * @param count - The number of nodes detached by the base detach.
+	 * @param newDetachId - The ID associated the detach intention (if any) for these nodes in the rebased changeset.
+	 * @param nodeChange - The nested changes (if any) associated with this node in the rebased changeset.
+	 * @param newDetachCellId - An additional ID to associate with this node.
+	 * This ID will be included in the result of {@link getNewChangesForBaseAttach}.
+	 * This is only used by sequence field for compatibility with earlier client versions.
 	 */
-	moveKey(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	rebaseOverDetach(
+		baseDetachId: ChangeAtomId,
 		count: number,
+		newDetachId: ChangeAtomId | undefined,
+		nodeChange: NodeId | undefined,
+		newDetachCellId?: ChangeAtomId,
 	): void;
+
+	addDetach(id: ChangeAtomId, count: number): void;
+	removeDetach(id: ChangeAtomId, count: number): void;
+
+	/**
+	 * Returns whether nodes which were either previously detached by `id` or the base changeset is now detaching with `id`
+	 * are also reattached by the base changeset.
+	 */
+	doesBaseAttachNodes(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
+
+	/**
+	 * Returns the root ID the base change renames `id` to, if any.
+	 */
+	getBaseRename(id: ChangeAtomId, count: number): RangeQueryResult<ChangeAtomId | undefined>;
+
+	/**
+	 * Given a detached node ID in the base changeset's output context,
+	 * returns the ID the rebased changeset renames that ID to, if any.
+	 */
+	getNewRenameForBaseRename(
+		baseRenameTo: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<ChangeAtomId | undefined>;
+}
+
+export interface DetachedNodeEntry {
+	nodeChange?: NodeId;
+	detachId?: ChangeAtomId;
+}
+
+export interface RebaseDetachedNodeEntry extends DetachedNodeEntry {
+	// This is only needed for sequence field to implement detach cell IDs.
+	cellRename?: ChangeAtomId;
 }

package/src/feature-libraries/modular-schema/fieldChangeHandler.ts

@@ -5,10 +5,9 @@
 
 import type { ICodecFamily, IJsonCodec } from "../../codec/index.js";
 import type {
+	ChangeAtomId,
+	ChangeAtomIdRangeMap,
 	ChangeEncodingContext,
-	DeltaDetachedNodeChanges,
-	DeltaDetachedNodeId,
-	DeltaDetachedNodeRename,
 	DeltaFieldChanges,
 	DeltaFieldMap,
 	EncodedRevisionTag,
@@ -16,35 +15,18 @@ import type {
 	RevisionReplacer,
 	RevisionTag,
 } from "../../core/index.js";
-import type { IdAllocator, Invariant } from "../../util/index.js";
+import type { IdAllocator, Invariant, RangeQueryResult } from "../../util/index.js";
+import type { ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 
-import type { CrossFieldManager } from "./crossFieldQueries.js";
+import type {
+	ComposeNodeManager,
+	InvertNodeManager,
+	RebaseNodeManager,
+} from "./crossFieldQueries.js";
 import type { EncodedNodeChangeset } from "./modularChangeFormatV1.js";
-import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
-
-export type NestedChangesIndices = [
-	NodeId,
-	number | undefined /* inputIndex */,
-	number | undefined /* outputIndex */,
-][];
+import type { CrossFieldKeyRange, NodeId, RebaseVersion } from "./modularChangeTypes.js";
 
-/**
- * The return value of calling {@link FieldChangeHandler.intoDelta}.
- */
-export interface FieldChangeDelta {
-	/**
-	 * {@inheritdoc DeltaFieldChanges}
-	 */
-	readonly local?: DeltaFieldChanges;
-	/**
-	 * {@inheritdoc DeltaRoot.global}
-	 */
-	readonly global?: readonly DeltaDetachedNodeChanges[];
-	/**
-	 * {@inheritdoc DeltaRoot.rename}
-	 */
-	readonly rename?: readonly DeltaDetachedNodeRename[];
-}
+export type NestedChangesIndices = readonly (readonly [NodeId, inputIndex: number])[];
 
 /**
  * Functionality provided by a field kind which will be composed with other `FieldChangeHandler`s to
@@ -65,27 +47,7 @@ export interface FieldChangeHandler<
 		>,
 	) => ICodecFamily<TChangeset, FieldChangeEncodingContext>;
 	readonly editor: TEditor;
-	intoDelta(change: TChangeset, deltaFromChild: ToDelta): FieldChangeDelta;
-	/**
-	 * Returns the set of removed roots that should be in memory for the given change to be applied.
-	 * A removed root is relevant if any of the following is true:
-	 * - It is being inserted
-	 * - It is being restored
-	 * - It is being edited
-	 * - The ID it is associated with is being changed
-	 *
-	 * Implementations are allowed to be conservative by returning more removed roots than strictly necessary
-	 * (though they should, for the sake of performance, try to avoid doing so).
-	 *
-	 * Implementations are not allowed to return IDs for non-root trees, even if they are removed.
-	 *
-	 * @param change - The change to be applied.
-	 * @param relevantRemovedRootsFromChild - Delegate for collecting relevant removed roots from child changes.
-	 */
-	readonly relevantRemovedRoots: (
-		change: TChangeset,
-		relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,
-	) => Iterable<DeltaDetachedNodeId>;
+	intoDelta(change: TChangeset, deltaFromChild: ToDelta): DeltaFieldChanges;
 
 	/**
 	 * Returns whether this change is empty, meaning that it represents no modifications to the field
@@ -114,6 +76,12 @@ export interface FieldChangeHandler<
 	 */
 	getCrossFieldKeys(change: TChangeset): CrossFieldKeyRange[];
 
+	// XXX: Document
+	getDetachCellIds(
+		change: TChangeset,
+		rootRenames: ChangeAtomIdRangeMap<ChangeAtomId>,
+	): { detachId: ChangeAtomId; cellId: ChangeAtomId; count: number }[];
+
 	createEmpty(): TChangeset;
 }
 
@@ -130,7 +98,7 @@ export interface FieldChangeRebaser<TChangeset> {
 		change2: TChangeset,
 		composeChild: NodeChangeComposer,
 		genId: IdAllocator,
-		crossFieldManager: CrossFieldManager,
+		nodeManager: ComposeNodeManager,
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;
 
@@ -143,10 +111,11 @@ export interface FieldChangeRebaser<TChangeset> {
 		isRollback: boolean,
 		genId: IdAllocator,
 		revision: RevisionTag | undefined,
-		crossFieldManager: CrossFieldManager,
+		nodeManager: InvertNodeManager,
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;
 
+	// XXX: It's not clear whether `rebaseChild` must be called in all cases.
 	/**
 	 * Rebase `change` over `over`.
 	 * See `ChangeRebaser` for details.
@@ -156,8 +125,9 @@ export interface FieldChangeRebaser<TChangeset> {
 		over: TChangeset,
 		rebaseChild: NodeChangeRebaser,
 		genId: IdAllocator,
-		crossFieldManager: CrossFieldManager,
+		nodeManager: RebaseNodeManager,
 		revisionMetadata: RebaseRevisionMetadata,
+		rebaseVersion: RebaseVersion,
 	): TChangeset;
 
 	/**
@@ -246,11 +216,6 @@ export type NodeChangeComposer = (
 
 export type NodeChangePruner = (change: NodeId) => NodeId | undefined;
 
-/**
- * A function that returns the set of removed roots that should be in memory for a given node changeset to be applied.
- */
-export type RelevantRemovedRootsFromChild = (child: NodeId) => Iterable<DeltaDetachedNodeId>;
-
 export interface RebaseRevisionMetadata extends RevisionMetadataSource {
 	readonly getRevisionToRebase: () => RevisionTag | undefined;
 	readonly getBaseRevisions: () => RevisionTag[];
@@ -258,6 +223,96 @@ export interface RebaseRevisionMetadata extends RevisionMetadataSource {
 
 export interface FieldChangeEncodingContext {
 	readonly baseContext: ChangeEncodingContext;
+
+	/**
+	 * A map from root ID to node ID, containing all roots which were last detached from this field.
+	 * The field must encode these root node changes.
+	 * This is only needed when encoding to a ModularChangeFormat older than v3,
+	 * as in those versions, changes to root nodes were represented in the field they were last detached from.
+	 * This should only be used during encoding.
+	 */
+	readonly rootNodeChanges: ChangeAtomIdBTree<NodeId>;
+
+	/**
+	 * A map from input context root ID to output context root ID, containing all roots which were last detached from this field.
+	 * The field must encode these renames.
+	 * This is only needed when encoding to a ModularChangeFormat older than v3,
+	 * as in those versions, root node renames were represented in the field they were last detached from.
+	 * This should only be used during encoding.
+	 */
+	readonly rootRenames: ChangeAtomIdRangeMap<ChangeAtomId>;
+
+	// This should only be called during encoding.
 	encodeNode(nodeId: NodeId): EncodedNodeChangeset;
+
+	/**
+	 * Returns the input context root ID from an output context root ID.
+	 * This is only needed for encoding to sequence field format v3 and older.
+	 * This should only be called during encoding.
+	 */
+	getInputRootId(
+		outputRootId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<ChangeAtomId | undefined>;
+
+	/**
+	 * Returns the input context root ID from an output context root ID.
+	 * This is only needed for encoding to sequence field format v3 and older.
+	 * This should only be called during encoding.
+	 */
+	isAttachId(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
+
+	/**
+	 * Returns whether `id` is used as a detach ID in this changeset.
+	 * This is only needed for encoding to sequence field format v3 and older.
+	 * This should only be called during encoding.
+	 */
+	isDetachId(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
+
+	/**
+	 * Returns the detach cell ID for the attach associated with `moveId`.
+	 * If there is no associated detach cell ID, or the ID is the same as `moveId`,
+	 * this will return undefined.
+	 * This is only needed for encoding to sequence field format v3 and older.
+	 * This should only be called during encoding.
+	 */
+	getCellIdForMove(
+		moveId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<ChangeAtomId | undefined>;
+
+	// This should only be called during decoding.
 	decodeNode(encodedNode: EncodedNodeChangeset): NodeId;
+
+	/**
+	 * Must be called for each root node changeset encoded in this field.
+	 * This is only needed when encoding to a ModularChangeFormat older than v3,
+	 * as in those versions, changes to root node were represented in the field they were last detached from.
+	 * This should only be called during decoding.
+	 */
+	decodeRootNodeChange(detachId: ChangeAtomId, encodedNode: EncodedNodeChangeset): void;
+
+	/**
+	 * Must be called for each root node rename encoded in this field.
+	 * This is only needed when encoding to a ModularChangeFormat older than v3,
+	 * as in those versions, root node renames were represented in the field they were last detached from.
+	 * This should only be called during decoding.
+	 */
+	decodeRootRename(oldId: ChangeAtomId, newId: ChangeAtomId, count: number): void;
+
+	/**
+	 * Must be called for each node which has its detach location changed to this field.
+	 * The node may be either detached by this change, or already detached in this change's input context.
+	 * This is only needed when encoding to a ModularChangeFormat older than v3,
+	 * as in those versions, root node locations were represented in the field they were last detached from.
+	 * This should only be called during decoding.
+	 */
+	decodeMoveAndDetach(detachId: ChangeAtomId, count: number): void;
+
+	/**
+	 * Generates a new ChangeAtomId which has not been used in this changeset.
+	 * This is only needed for decoding optional field format v2 and older.
+	 * This should only be called during decoding.
+	 */
+	generateId(): ChangeAtomId;
 }