@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -16,13 +16,23 @@ 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>,
-	id: ChangeAtomId,
+	revision: RevisionTag | undefined,
+	id: ChangesetLocalId,
 	count: number,
 	value: T,
 ): void {
-	map.set(id, count, value);
+	map.set({ revision, localId: id }, count, value);
 }
 
 export function getFirstFromCrossFieldMap<T>(
@@ -30,168 +40,60 @@ export function getFirstFromCrossFieldMap<T>(
 	revision: RevisionTag | undefined,
 	id: ChangesetLocalId,
 	count: number,
-): RangeQueryResult<T | undefined> {
+): RangeQueryResult<ChangeAtomId, T> {
 	return map.getFirst({ revision, localId: id }, count);
 }
 
-// TODO: Rename to NodeMoveType(Attach | Detach)
 export enum CrossFieldTarget {
 	Source,
 	Destination,
 }
 
-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 undoing an 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 undoing an 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>;
-
+/**
+ * Used by {@link FieldChangeHandler} implementations for exchanging information across other fields
+ * while rebasing, composing, or inverting a change.
+ */
+export interface CrossFieldManager<T = unknown> {
 	/**
-	 * 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.
+	 * 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.
 	 */
-	composeAttachDetach(
-		baseAttachId: ChangeAtomId,
-		newDetachId: ChangeAtomId,
+	get(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-	): 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 must 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;
+		addDependency: boolean,
+	): RangeQueryResult<ChangeAtomId, T>;
 
-	// 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).
 	/**
-	 * 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`.
+	 * 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.
 	 */
-	composeDetachAttach(
-		baseDetachId: ChangeAtomId,
-		newAttachId: ChangeAtomId,
+	set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-		convertToPin: boolean,
+		newValue: T,
+		invalidateDependents: boolean,
 	): void;
-}
 
-export interface RebaseNodeManager {
-	// XXX: It's not clear whether the returned changes are already rebased or not.
 	/**
-	 * 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.
+	 * 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.
 	 */
-	getNewChangesForBaseAttach(
-		baseAttachId: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<RebaseDetachedNodeEntry | undefined>;
+	onMoveIn(id: NodeId): void;
 
-	// 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.
 	/**
-	 * 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.
+	 * 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.
 	 */
-	rebaseOverDetach(
-		baseDetachId: ChangeAtomId,
+	moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		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/defaultRevisionReplacer.ts

@@ -0,0 +1,70 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type {
+	ChangeAtomId,
+	ChangesetLocalId,
+	RevisionReplacer,
+	RevisionTag,
+} from "../../core/index.js";
+import { brand, brandConst, newTupleBTree, type Mutable } from "../../util/index.js";
+import {
+	getFromChangeAtomIdMap,
+	setInChangeAtomIdMap,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
+
+export class DefaultRevisionReplacer implements RevisionReplacer {
+	/**
+	 * Mapping from (obsolete revision tag, original local id) to the updated local id.
+	 */
+	private readonly updatedLocalIds: ChangeAtomIdBTree<ChangesetLocalId> = newTupleBTree();
+	/**
+	 * The set of local IDs already used in the scope of the updated revision.
+	 */
+	private readonly localIds: Set<ChangesetLocalId> = new Set();
+	/**
+	 * The maximum local ID seen so far in the scope of the updated revision.
+	 */
+	private maxSeen: ChangesetLocalId = brandConst(-1)();
+
+	public constructor(
+		public readonly updatedRevision: RevisionTag,
+		private readonly obsoleteRevisions: Set<RevisionTag | undefined>,
+	) {}
+
+	public isObsolete(revision: RevisionTag | undefined): boolean {
+		return this.obsoleteRevisions.has(revision);
+	}
+
+	public getUpdatedAtomId<T extends ChangeAtomId>(id: T): T {
+		if (this.isObsolete(id.revision)) {
+			const updated: Mutable<T> = { ...id, revision: this.updatedRevision };
+			const prior: ChangesetLocalId | undefined = getFromChangeAtomIdMap(
+				this.updatedLocalIds,
+				id,
+			);
+			if (prior === undefined) {
+				let localId: ChangesetLocalId;
+				if (this.localIds.has(id.localId)) {
+					this.maxSeen = brand(this.maxSeen + 1);
+					localId = this.maxSeen;
+				} else {
+					// This change atom ID uses a local ID that has not yet been used in the scope of the updated revision.
+					// We reuse it as is to minimize the number of IDs that need to be updated.
+					localId = id.localId;
+					this.maxSeen = brand(Math.max(this.maxSeen, localId));
+					this.localIds.add(id.localId);
+				}
+				setInChangeAtomIdMap(this.updatedLocalIds, id, localId);
+				updated.localId = localId;
+			} else {
+				updated.localId = prior;
+			}
+			return updated;
+		}
+		return id;
+	}
+}

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

@@ -5,31 +5,46 @@
 
 import type { ICodecFamily, IJsonCodec } from "../../codec/index.js";
 import type {
-	ChangeAtomId,
-	ChangeAtomIdRangeMap,
 	ChangeEncodingContext,
+	DeltaDetachedNodeChanges,
+	DeltaDetachedNodeId,
+	DeltaDetachedNodeRename,
 	DeltaFieldChanges,
 	DeltaFieldMap,
 	EncodedRevisionTag,
 	RevisionMetadataSource,
+	RevisionReplacer,
 	RevisionTag,
 } from "../../core/index.js";
-import type { IdAllocator, Invariant, RangeQueryResult } from "../../util/index.js";
-import type {
-	ComposeNodeManager,
-	InvertNodeManager,
-	RebaseNodeManager,
-} from "./crossFieldQueries.js";
+import type { IdAllocator, Invariant } from "../../util/index.js";
 
+import type { CrossFieldManager } from "./crossFieldQueries.js";
 import type { EncodedNodeChangeset } from "./modularChangeFormatV1.js";
-import type {
-	ChangeAtomIdBTree,
-	CrossFieldKeyRange,
+import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
+
+export type NestedChangesIndices = [
 	NodeId,
-	RebaseVersion,
-} from "./modularChangeTypes.js";
+	number | undefined /* inputIndex */,
+	number | undefined /* outputIndex */,
+][];
 
-export type NestedChangesIndices = [NodeId, number /* inputIndex */][];
+/**
+ * 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[];
+}
 
 /**
  * Functionality provided by a field kind which will be composed with other `FieldChangeHandler`s to
@@ -50,7 +65,27 @@ export interface FieldChangeHandler<
 		>,
 	) => ICodecFamily<TChangeset, FieldChangeEncodingContext>;
 	readonly editor: TEditor;
-	intoDelta(change: TChangeset, deltaFromChild: ToDelta): DeltaFieldChanges;
+	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>;
 
 	/**
 	 * Returns whether this change is empty, meaning that it represents no modifications to the field
@@ -95,7 +130,7 @@ export interface FieldChangeRebaser<TChangeset> {
 		change2: TChangeset,
 		composeChild: NodeChangeComposer,
 		genId: IdAllocator,
-		nodeManager: ComposeNodeManager,
+		crossFieldManager: CrossFieldManager,
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;
 
@@ -108,11 +143,10 @@ export interface FieldChangeRebaser<TChangeset> {
 		isRollback: boolean,
 		genId: IdAllocator,
 		revision: RevisionTag | undefined,
-		nodeManager: InvertNodeManager,
+		crossFieldManager: CrossFieldManager,
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;
 
-	// XXX: It's not clear whether `rebaseChild` must be called in all cases.
 	/**
 	 * Rebase `change` over `over`.
 	 * See `ChangeRebaser` for details.
@@ -122,9 +156,8 @@ export interface FieldChangeRebaser<TChangeset> {
 		over: TChangeset,
 		rebaseChild: NodeChangeRebaser,
 		genId: IdAllocator,
-		nodeManager: RebaseNodeManager,
+		crossFieldManager: CrossFieldManager,
 		revisionMetadata: RebaseRevisionMetadata,
-		rebaseVersion: RebaseVersion,
 	): TChangeset;
 
 	/**
@@ -132,11 +165,7 @@ export interface FieldChangeRebaser<TChangeset> {
 	 */
 	prune(change: TChangeset, pruneChild: NodeChangePruner): TChangeset;
 
-	replaceRevisions(
-		change: TChangeset,
-		oldRevisions: Set<RevisionTag | undefined>,
-		newRevisions: RevisionTag | undefined,
-	): TChangeset;
+	replaceRevisions(change: TChangeset, replacer: RevisionReplacer): TChangeset;
 
 	/**
 	 * Returns a copy of the given changeset with the same declarations (e.g., new cells) but no actual changes.
@@ -217,7 +246,10 @@ export type NodeChangeComposer = (
 
 export type NodeChangePruner = (change: NodeId) => NodeId | undefined;
 
-export type HasDetachedChanges = (detachId: ChangeAtomId, count: number) => boolean;
+/**
+ * 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;
@@ -226,20 +258,6 @@ export interface RebaseRevisionMetadata extends RevisionMetadataSource {
 
 export interface FieldChangeEncodingContext {
 	readonly baseContext: ChangeEncodingContext;
-	readonly rootNodeChanges: ChangeAtomIdBTree<NodeId>;
-	readonly rootRenames: ChangeAtomIdRangeMap<ChangeAtomId>;
 	encodeNode(nodeId: NodeId): EncodedNodeChangeset;
-	getInputRootId(
-		outputRootId: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<ChangeAtomId | undefined>;
-
-	isAttachId(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
-	isDetachId(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
-
 	decodeNode(encodedNode: EncodedNodeChangeset): NodeId;
-	decodeRootNodeChange(detachId: ChangeAtomId, encodedNode: EncodedNodeChangeset): void;
-	decodeRootRename(oldId: ChangeAtomId, newId: ChangeAtomId, count: number): void;
-	decodeMoveAndDetach(detachId: ChangeAtomId, count: number): void;
-	generateId(): ChangeAtomId;
 }

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

@@ -7,20 +7,21 @@ import { assert } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
 
 import {
+	type DeltaDetachedNodeId,
 	type DeltaMark,
 	type FieldKindIdentifier,
 	Multiplicity,
-	type RevisionTag,
-	replaceAtomRevisions,
-	type DeltaFieldChanges,
+	type RevisionReplacer,
 } from "../../core/index.js";
 
 import type {
+	FieldChangeDelta,
 	FieldChangeHandler,
 	NestedChangesIndices,
 	NodeChangeComposer,
 	NodeChangePruner,
 	NodeChangeRebaser,
+	RelevantRemovedRootsFromChild,
 	ToDelta,
 } from "./fieldChangeHandler.js";
 import { makeGenericChangeCodec } from "./genericFieldKindCodecs.js";
@@ -35,7 +36,7 @@ import { brandConst } from "../../util/index.js";
 export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 	rebaser: {
 		compose,
-		invert: (change): GenericChangeset => change,
+		invert: (change: GenericChangeset): GenericChangeset => change,
 		rebase: rebaseGenericChange,
 		prune: pruneGenericChange,
 		replaceRevisions,
@@ -44,10 +45,10 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 	codecsFactory: makeGenericChangeCodec,
 	editor: {
 		buildChildChanges(changes: Iterable<[number, NodeId]>): GenericChangeset {
-			return newGenericChangeset(Array.from(changes));
+			return newGenericChangeset([...changes]);
 		},
 	},
-	intoDelta: (change: GenericChangeset, deltaFromChild: ToDelta): DeltaFieldChanges => {
+	intoDelta: (change: GenericChangeset, deltaFromChild: ToDelta): FieldChangeDelta => {
 		let nodeIndex = 0;
 		const markList: DeltaMark[] = [];
 		for (const [index, nodeChange] of change.entries()) {
@@ -59,8 +60,9 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 			markList.push({ count: 1, fields: deltaFromChild(nodeChange) });
 			nodeIndex += 1;
 		}
-		return markList;
+		return { local: markList };
 	},
+	relevantRemovedRoots,
 	isEmpty: (change: GenericChangeset): boolean => change.length === 0,
 	getNestedChanges,
 	createEmpty: newGenericChangeset,
@@ -75,7 +77,7 @@ function compose(
 	const composed = change1.clone();
 	for (const [index, id2] of change2.entries()) {
 		const id1 = composed.get(index);
-		const idComposed = id1 !== undefined ? composeChildren(id1, id2) : id2;
+		const idComposed = id1 === undefined ? id2 : composeChildren(id1, id2);
 		composed.set(index, idComposed);
 	}
 
@@ -84,7 +86,7 @@ function compose(
 
 function getNestedChanges(change: GenericChangeset): NestedChangesIndices {
 	// For generic changeset, the indices in the input and output contexts are the same.
-	return change.toArray().map(([index, nodeChange]) => [nodeChange, index]);
+	return change.toArray().map(([index, nodeChange]) => [nodeChange, index, index]);
 }
 
 function rebaseGenericChange(
@@ -146,7 +148,7 @@ function pruneGenericChange(
 	for (const [index, node] of changeset.entries()) {
 		const prunedNode = pruneChild(node);
 		if (prunedNode !== undefined) {
-			pruned.set(index, prunedNode);
+			pruned.set(index, node);
 		}
 	}
 	return pruned;
@@ -154,10 +156,9 @@ function pruneGenericChange(
 
 function replaceRevisions(
 	changeset: GenericChangeset,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): GenericChangeset {
-	return changeset.mapValues((node) => replaceAtomRevisions(node, oldRevisions, newRevision));
+	return changeset.mapValues((node) => replacer.getUpdatedAtomId(node));
 }
 
 /**
@@ -185,3 +186,12 @@ export function convertGenericChange<TChange>(
 ): TChange {
 	return target.editor.buildChildChanges(changeset.entries());
 }
+
+function* relevantRemovedRoots(
+	change: GenericChangeset,
+	relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,
+): Iterable<DeltaDetachedNodeId> {
+	for (const nodeChange of change.values()) {
+		yield* relevantRemovedRootsFromChild(nodeChange);
+	}
+}

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

@@ -12,12 +12,10 @@ export {
 } from "./comparison.js";
 export { isNeverField, isNeverTree } from "./isNeverTree.js";
 export {
-	type InvertNodeManager,
-	type RebaseNodeManager,
-	type ComposeNodeManager,
+	addCrossFieldQuery,
+	type CrossFieldManager,
 	type CrossFieldMap,
 	type CrossFieldQuerySet,
-	type DetachedNodeEntry,
 	CrossFieldTarget,
 	setInCrossFieldMap,
 } from "./crossFieldQueries.js";
@@ -25,12 +23,14 @@ export {
 	ChangesetLocalIdSchema,
 	EncodedChangeAtomId,
 	EncodedRevisionInfo,
-	EncodedModularChangeset,
+	EncodedModularChangesetV1,
 	EncodedNodeChangeset,
 } from "./modularChangeFormatV1.js";
+export { EncodedModularChangesetV2 } from "./modularChangeFormatV2.js";
 export { FlexFieldKind, type FullSchemaPolicy } from "./fieldKind.js";
 export {
 	type FieldChangeHandler,
+	type FieldChangeDelta,
 	type FieldChangeRebaser,
 	type FieldEditor,
 	type NodeChangeComposer,
@@ -39,26 +39,23 @@ export {
 	type NodeChangePruner,
 	referenceFreeFieldChangeRebaser,
 	type RebaseRevisionMetadata,
+	type RelevantRemovedRootsFromChild,
 	type ToDelta,
 	NodeAttachState,
 	type FieldChangeEncodingContext,
 	type NestedChangesIndices,
 } from "./fieldChangeHandler.js";
-export {
-	type CrossFieldKey,
-	type CrossFieldKeyRange,
-	type FieldChange,
-	type FieldChangeMap,
-	type FieldChangeset,
-	type HasFieldChanges,
-	type ModularChangeset,
-	type NodeExistsConstraint,
-	type NodeId,
-	type ChangeAtomIdBTree,
-	type RebaseVersion,
-	getFromChangeAtomIdMap,
-	setInChangeAtomIdMap,
-	rangeQueryChangeAtomIdMap,
+export type {
+	CrossFieldKey,
+	CrossFieldKeyRange,
+	FieldChange,
+	FieldChangeMap,
+	FieldChangeset,
+	HasFieldChanges,
+	ModularChangeset,
+	NoChangeConstraint,
+	NodeExistsConstraint,
+	NodeId,
 } from "./modularChangeTypes.js";
 export {
 	convertGenericChange,
@@ -75,7 +72,6 @@ export {
 	rebaseRevisionMetadataFromInfo,
 	intoDelta,
 	relevantRemovedRoots,
-	getBuildIds,
 	updateRefreshers,
 } from "./modularChangeFamily.js";
 export { makeModularChangeCodecFamily } from "./modularChangeCodecs.js";
@@ -83,3 +79,4 @@ export type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
+export { DefaultRevisionReplacer } from "./defaultRevisionReplacer.js";