@fluidframework/tree 2.20.0 → 2.22.0

package/src/core/tree/anchorSet.ts

@@ -22,19 +22,9 @@ import {
 import type { FieldKey } from "../schema-stored/index.js";
 
 import type * as Delta from "./delta.js";
-import type {
-	DetachedPlaceUpPath,
-	DetachedRangeUpPath,
-	PlaceIndex,
-	PlaceUpPath,
-	Range,
-	RangeUpPath,
-	UpPath,
-} from "./pathTree.js";
+import type { PlaceIndex, Range, UpPath } from "./pathTree.js";
 import { EmptyKey } from "./types.js";
 import type { DeltaVisitor } from "./visitDelta.js";
-import type { PathVisitor } from "./visitPath.js";
-import type { AnnouncedVisitor } from "./visitorUtils.js";
 
 /**
  * A way to refer to a particular tree location within an {@link AnchorSet}.
@@ -137,10 +127,9 @@ export interface AnchorEvents {
 	 * rooted at `anchor` _may_ be about to change due to updates from the batch.
 	 *
 	 * @remarks
-	 * The event can optionally return a {@link PathVisitor} to traverse the subtree.
 	 * Called on every parent (transitively) when a change is occurring.
 	 */
-	subtreeChanging(anchor: AnchorNode): PathVisitor | void;
+	subtreeChanging(anchor: AnchorNode): void;
 
 	/**
 	 * Emitted in the middle of applying a batch of changes (i.e. during a delta a visit), if something in the subtree
@@ -689,7 +678,7 @@ export class AnchorSet implements AnchorLocator {
 	 * It is invalid to acquire a visitor without releasing the previous one,
 	 * and this method will throw an error if this is attempted.
 	 */
-	public acquireVisitor(): AnnouncedVisitor & DeltaVisitor {
+	public acquireVisitor(): DeltaVisitor {
 		assert(
 			this.activeVisitor === undefined,
 			0x767 /* Must release existing visitor before acquiring another */,
@@ -716,10 +705,6 @@ export class AnchorSet implements AnchorLocator {
 					}
 				}
 			},
-			// Lookup table for path visitors collected from {@link AnchorEvents.visitSubtreeChanging} emitted events.
-			// The key is the path of the node that the visitor is registered on. The code ensures that the path visitor visits only the appropriate subtrees
-			// by maintaining the mapping only during time between the {@link DeltaVisitor.enterNode} and {@link DeltaVisitor.exitNode} calls for a given anchorNode.
-			pathVisitors: new Map<PathNode, Set<PathVisitor>>(),
 			parentField: undefined as FieldKey | undefined,
 			parent: undefined as UpPath | undefined,
 
@@ -813,47 +798,6 @@ export class AnchorSet implements AnchorLocator {
 					() => {},
 				);
 			},
-			beforeAttach(source: FieldKey, count: number, destination: PlaceIndex): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a0 /* Must be in a field in order to attach */,
-				);
-				const destinationPath: PlaceUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					index: destination,
-				};
-				const sourcePath: DetachedRangeUpPath = brand({
-					field: source,
-					start: 0,
-					end: count,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeAttach(sourcePath, destinationPath);
-					}
-				}
-			},
-			afterAttach(source: FieldKey, destination: Range): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a1 /* Must be in a field in order to attach */,
-				);
-				const sourcePath: DetachedPlaceUpPath = brand({
-					field: source,
-					index: 0,
-				});
-				const destinationPath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...destination,
-				};
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.afterAttach(sourcePath, destinationPath);
-					}
-				}
-			},
 			attach(source: FieldKey, count: number, destination: PlaceIndex): void {
 				this.notifyChildrenChanging();
 				this.attachEdit(source, count, destination);
@@ -877,47 +821,6 @@ export class AnchorSet implements AnchorLocator {
 				this.anchorSet.moveChildren(sourcePath, destinationPath, count);
 				this.depthThresholdForSubtreeChanged = this.currentDepth;
 			},
-			beforeDetach(source: Range, destination: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a3 /* Must be in a field in order to attach */,
-				);
-				const sourcePath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...source,
-				};
-				const destinationPath: DetachedPlaceUpPath = brand({
-					field: destination,
-					index: 0,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeDetach(sourcePath, destinationPath);
-					}
-				}
-			},
-			afterDetach(source: PlaceIndex, count: number, destination: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a4 /* Must be in a field in order to attach */,
-				);
-				const sourcePath: PlaceUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					index: source,
-				};
-				const destinationPath: DetachedRangeUpPath = brand({
-					field: destination,
-					start: 0,
-					end: count,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.afterDetach(sourcePath, destinationPath);
-					}
-				}
-			},
 			detach(source: Range, destination: FieldKey): void {
 				this.notifyChildrenChanging();
 				this.detachEdit(source, destination);
@@ -941,64 +844,6 @@ export class AnchorSet implements AnchorLocator {
 				this.anchorSet.moveChildren(sourcePath, destinationPath, source.end - source.start);
 				this.depthThresholdForSubtreeChanged = this.currentDepth;
 			},
-			beforeReplace(newContent: FieldKey, oldContent: Range, destination: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a6 /* Must be in a field in order to replace */,
-				);
-				const oldContentPath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...oldContent,
-				};
-				const newNodesSourcePath: DetachedRangeUpPath = brand({
-					field: newContent,
-					start: 0,
-					end: oldContent.end - oldContent.start,
-				});
-				const oldNodesDestinationPath: DetachedPlaceUpPath = brand({
-					field: destination,
-					index: 0,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeReplace(
-							newNodesSourcePath,
-							oldContentPath,
-							oldNodesDestinationPath,
-						);
-					}
-				}
-			},
-			afterReplace(newContentSource: FieldKey, newContent: Range, oldContent: FieldKey): void {
-				assert(
-					this.parentField !== undefined,
-					0x7a7 /* Must be in a field in order to replace */,
-				);
-				const newContentPath: RangeUpPath = {
-					parent: this.parent,
-					field: this.parentField,
-					...newContent,
-				};
-				const newNodesSourcePath: DetachedPlaceUpPath = brand({
-					field: newContentSource,
-					index: 0,
-				});
-				const oldNodesDestinationPath: DetachedRangeUpPath = brand({
-					field: oldContent,
-					start: 0,
-					end: newContent.end - newContent.start,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.afterReplace(
-							newNodesSourcePath,
-							newContentPath,
-							oldNodesDestinationPath,
-						);
-					}
-				}
-			},
 			replace(
 				newContentSource: FieldKey,
 				range: Range,
@@ -1019,34 +864,10 @@ export class AnchorSet implements AnchorLocator {
 					count,
 				);
 			},
-			beforeDestroy(detachedField: FieldKey, count: number): void {
-				const range: DetachedRangeUpPath = brand({
-					field: detachedField,
-					start: 0,
-					end: count,
-				});
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						pathVisitor.beforeDestroy(range);
-					}
-				}
-			},
 			create(content: Delta.ProtoNodes, destination: FieldKey): void {
 				// Nothing to do since content can only be created in a new detached field,
 				// which cannot contain any anchors.
 			},
-			afterCreate(content: Delta.ProtoNodes, destination: FieldKey): void {
-				for (const visitors of this.pathVisitors.values()) {
-					for (const pathVisitor of visitors) {
-						const rangePath: DetachedRangeUpPath = brand({
-							field: destination,
-							start: 0,
-							end: content.length,
-						});
-						pathVisitor.afterCreate(rangePath);
-					}
-				}
-			},
 			enterNode(index: number): void {
 				assert(this.parentField !== undefined, 0x3ab /* Must be in a field to enter node */);
 
@@ -1057,19 +878,7 @@ export class AnchorSet implements AnchorLocator {
 				};
 				this.parentField = undefined;
 				this.maybeWithNode((p) => {
-					// avoid multiple pass side-effects
-					if (!this.pathVisitors.has(p)) {
-						const visitors: (PathVisitor | void)[] = p.events.emitAndCollect(
-							"subtreeChanging",
-							p,
-						);
-						if (visitors.length > 0) {
-							this.pathVisitors.set(
-								p,
-								new Set(visitors.filter((v): v is PathVisitor => v !== undefined)),
-							);
-						}
-					}
+					p.events.emit("subtreeChanging", p);
 				});
 				this.currentDepth++;
 			},
@@ -1084,8 +893,6 @@ export class AnchorSet implements AnchorLocator {
 						});
 						this.depthThresholdForSubtreeChanged--;
 					}
-					// Remove subtree path visitors added at this node if there are any
-					this.pathVisitors.delete(p);
 				});
 				const parent = this.parent;
 				this.parentField = parent.parentField;

package/src/core/tree/index.ts

@@ -55,8 +55,6 @@ export {
 	type PlaceUpPath,
 	type PlaceIndex,
 	type NodeIndex,
-	type DetachedPlaceUpPath,
-	type DetachedRangeUpPath,
 	compareUpPaths,
 	compareFieldUpPaths,
 	getDetachedFieldContainingPath,
@@ -98,7 +96,6 @@ export {
 	combineVisitors,
 	makeDetachedFieldIndex,
 } from "./visitorUtils.js";
-export type { PathVisitor } from "./visitPath.js";
 
 export { SparseNode, getDescendant } from "./sparseTree.js";
 

package/src/core/tree/pathTree.ts

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import type { Brand } from "../../util/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
 import { type DetachedField, keyAsDetachedField } from "./types.js";
@@ -60,13 +59,6 @@ export interface FieldUpPath<TUpPath extends UpPath = UpPath> {
 	readonly field: FieldKey; // TODO: Type information, including when in DetachedField.
 }
 
-/**
- * A range of nodes in a detached field.
- * Unlike RangeUpPath, such ranges are generated by create and detach operations,
- * as well as consumed by destroy and attach operations.
- */
-export type DetachedRangeUpPath = Brand<Omit<RangeUpPath, "parent">, "DetachedRangeUpPath">;
-
 /**
  * Delimits the extend of a range.
  */
@@ -101,11 +93,6 @@ export interface PlaceUpPath<TUpPath extends UpPath = UpPath> extends FieldUpPat
 	readonly index: PlaceIndex;
 }
 
-/**
- * A place in a detached field.
- */
-export type DetachedPlaceUpPath = Brand<Omit<PlaceUpPath, "parent">, "DetachedRangeUpPath">;
-
 /**
  * Indicates the index of a node in a field.
  * Zero indicates the first node in a field.

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -42,7 +42,7 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 		rebase: (change: 0, over: 0) => 0,
 	}),
 	codecsFactory: () => noChangeCodecFamily,
-	editor: { buildChildChange: (index, change) => fail("Child changes not supported") },
+	editor: { buildChildChanges: () => fail("Child changes not supported") },
 	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
 	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
 	isEmpty: (change: 0) => true,

package/src/feature-libraries/detachedFieldIndexSummarizer.ts

@@ -6,7 +6,6 @@
 import { bufferToString } from "@fluid-internal/client-utils";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type {
-	IGarbageCollectionData,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -52,16 +51,6 @@ export class DetachedFieldIndexSummarizer implements Summarizable {
 		return this.getAttachSummary(stringify, fullTree, trackState, telemetryContext);
 	}
 
-	public getGCData(fullGC?: boolean): IGarbageCollectionData {
-		// TODO: Properly implement garbage collection. Right now, garbage collection is performed automatically
-		// by the code in SharedObject (from which SharedTreeCore extends). The `runtime.uploadBlob` API delegates
-		// to the `BlobManager`, which automatically populates the summary with ISummaryAttachment entries for each
-		// blob.
-		return {
-			gcNodes: {},
-		};
-	}
-
 	public async load(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,

package/src/feature-libraries/flex-tree/treeEvents.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { PathVisitor, UpPath } from "../../core/index.js";
+import type { UpPath } from "../../core/index.js";
 
 /**
  * This file provides an API for working with trees which is type safe even when schema is not known.
@@ -39,13 +39,11 @@ export interface FlexTreeNodeEvents {
 
 	/**
 	 * Raised when something in the tree is changing, including this node and its descendants.
-	 * The event can optionally return a {@link PathVisitor} to traverse the subtree
 	 * This event is called on every parent (transitively) when a change is occurring.
 	 * Includes changes to this node itself.
 	 * @param upPath - the path corresponding to the location of the node being changed, upward.
-	 * @returns a visitor to traverse the subtree or `void`.
 	 */
-	subtreeChanging(upPath: UpPath): PathVisitor | void;
+	subtreeChanging(upPath: UpPath): void;
 
 	/**
 	 * This has the same contract as {@link TreeChangeEvents.nodeChanged}

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

@@ -7,7 +7,6 @@ import { bufferToString } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type {
-	IGarbageCollectionData,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -114,16 +113,6 @@ export class ForestSummarizer implements Summarizable {
 		return createSingleBlobSummary(treeBlobKey, this.getTreeString(stringify));
 	}
 
-	public getGCData(fullGC?: boolean): IGarbageCollectionData {
-		// TODO: Properly implement garbage collection. Right now, garbage collection is performed automatically
-		// by the code in SharedObject (from which SharedTreeCore extends). The `runtime.uploadBlob` API delegates
-		// to the `BlobManager`, which automatically populates the summary with ISummaryAttachment entries for each
-		// blob.
-		return {
-			gcNodes: {},
-		};
-	}
-
 	public async load(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,

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

@@ -201,9 +201,13 @@ export function isolatedFieldChangeRebaser<TChangeset>(data: {
 
 export interface FieldEditor<TChangeset> {
 	/**
-	 * Creates a changeset which represents the given `change` to the child at `childIndex` of this editor's field.
+	 * Creates a changeset which represents the given changes to the children of this editor's field.
+	 * For each element in the given iterable
+	 * - The number represents the index of the child node in the field.
+	 * - The `NodeId` represents the nested changes for that child node.
+	 * Note: The indices in the iterable must be ordered from smallest to largest (with no duplicates).
 	 */
-	buildChildChange(childIndex: number, change: NodeId): TChangeset;
+	buildChildChanges(changes: Iterable<[index: number, change: NodeId]>): TChangeset;
 }
 
 /**

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

@@ -6,14 +6,11 @@
 import {
 	type DeltaDetachedNodeId,
 	type DeltaMark,
-	type RevisionMetadataSource,
 	Multiplicity,
 	type RevisionTag,
 	replaceAtomRevisions,
 } from "../../core/index.js";
-import { type IdAllocator, fail } from "../../util/index.js";
 import { assert } from "@fluidframework/core-utils/internal";
-import type { CrossFieldManager } from "./crossFieldQueries.js";
 import type {
 	FieldChangeDelta,
 	FieldChangeHandler,
@@ -43,8 +40,8 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 	},
 	codecsFactory: makeGenericChangeCodec,
 	editor: {
-		buildChildChange(index, change): GenericChangeset {
-			return newGenericChangeset([[index, change]]);
+		buildChildChanges(changes: Iterable<[number, NodeId]>): GenericChangeset {
+			return newGenericChangeset(Array.from(changes));
 		},
 	},
 	intoDelta: (change: GenericChangeset, deltaFromChild: ToDelta): FieldChangeDelta => {
@@ -182,39 +179,10 @@ export const genericFieldKind: FieldKindWithEditor = new FieldKindWithEditor(
 export function convertGenericChange<TChange>(
 	changeset: GenericChangeset,
 	target: FieldChangeHandler<TChange>,
-	composeChild: NodeChangeComposer,
-	genId: IdAllocator,
-	revisionMetadata: RevisionMetadataSource,
 ): TChange {
-	const perIndex: TChange[] = [];
-	for (const [index, nodeChange] of changeset.entries()) {
-		perIndex.push(target.editor.buildChildChange(index, nodeChange));
-	}
-
-	if (perIndex.length === 0) {
-		return target.createEmpty();
-	}
-
-	return perIndex.reduce((a, b) =>
-		target.rebaser.compose(
-			a,
-			b,
-			composeChild,
-			genId,
-			invalidCrossFieldManager,
-			revisionMetadata,
-		),
-	);
+	return target.editor.buildChildChanges(changeset.entries());
 }
 
-const invalidFunc = (): never => fail("Should not be called when converting generic changes");
-const invalidCrossFieldManager: CrossFieldManager = {
-	set: invalidFunc,
-	get: invalidFunc,
-	onMoveIn: invalidFunc,
-	moveKey: invalidFunc,
-};
-
 function* relevantRemovedRoots(
 	change: GenericChangeset,
 	relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,

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

@@ -131,8 +131,6 @@ export class ModularChangeFamily
 	private normalizeFieldChanges(
 		change1: FieldChange,
 		change2: FieldChange,
-		genId: IdAllocator,
-		revisionMetadata: RevisionMetadataSource,
 	): {
 		fieldKind: FieldKindIdentifier;
 		changeHandler: FieldChangeHandler<unknown>;
@@ -156,18 +154,8 @@ export class ModularChangeFamily
 		}
 		const fieldKind = getFieldKind(this.fieldKinds, kind);
 		const changeHandler = fieldKind.changeHandler;
-		const normalizedChange1 = this.normalizeFieldChange(
-			change1,
-			changeHandler,
-			genId,
-			revisionMetadata,
-		);
-		const normalizedChange2 = this.normalizeFieldChange(
-			change2,
-			changeHandler,
-			genId,
-			revisionMetadata,
-		);
+		const normalizedChange1 = this.normalizeFieldChange(change1, changeHandler);
+		const normalizedChange2 = this.normalizeFieldChange(change2, changeHandler);
 		return {
 			fieldKind: kind,
 			changeHandler,
@@ -179,8 +167,6 @@ export class ModularChangeFamily
 	private normalizeFieldChange<T>(
 		fieldChange: FieldChange,
 		handler: FieldChangeHandler<T>,
-		genId: IdAllocator,
-		revisionMetadata: RevisionMetadataSource,
 	): FieldChangeset {
 		if (fieldChange.fieldKind !== genericFieldKind.identifier) {
 			return fieldChange.change;
@@ -188,20 +174,7 @@ export class ModularChangeFamily
 
 		// The cast is based on the `fieldKind` check above
 		const genericChange = fieldChange.change as unknown as GenericChangeset;
-		const convertedChange = convertGenericChange(
-			genericChange,
-			handler,
-			(child1, child2) => {
-				assert(
-					child1 === undefined || child2 === undefined,
-					0x92f /* Should not have two changesets to compose */,
-				);
-
-				return child1 ?? child2 ?? fail("Should not compose two undefined node IDs");
-			},
-			genId,
-			revisionMetadata,
-		) as FieldChangeset;
+		const convertedChange = convertGenericChange(genericChange, handler) as FieldChangeset;
 
 		return convertedChange;
 	}
@@ -578,7 +551,7 @@ export class ModularChangeFamily
 			changeHandler,
 			change1: change1Normalized,
 			change2: change2Normalized,
-		} = this.normalizeFieldChanges(change1, change2, idAllocator, revisionMetadata);
+		} = this.normalizeFieldChanges(change1, change2);
 
 		const manager = new ComposeManager(crossFieldTable, change1, fieldId);
 
@@ -1155,12 +1128,7 @@ export class ModularChangeFamily
 			changeHandler,
 			change1: fieldChangeset,
 			change2: baseChangeset,
-		} = this.normalizeFieldChanges(
-			context.newChange,
-			context.baseChange,
-			genId,
-			rebaseMetadata,
-		);
+		} = this.normalizeFieldChanges(context.newChange, context.baseChange);
 
 		const rebaseChild = (
 			curr: NodeId | undefined,
@@ -1338,7 +1306,7 @@ export class ModularChangeFamily
 				changeHandler,
 				change1: fieldChangeset,
 				change2: baseChangeset,
-			} = this.normalizeFieldChanges(fieldChange, baseChange, genId, revisionMetadata);
+			} = this.normalizeFieldChanges(fieldChange, baseChange);
 
 			const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
 
@@ -2938,10 +2906,9 @@ function buildModularChangesetFromNode(props: {
 		nodeId = { localId: brand(props.idAllocator.allocate()), revision: props.revision },
 	} = props;
 	setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
-	const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChange(
-		path.parentIndex,
-		nodeId,
-	);
+	const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
+		[path.parentIndex, nodeId],
+	]);
 
 	const fieldChange: FieldChange = {
 		fieldKind: genericFieldKind.identifier,

package/src/feature-libraries/optional-field/optionalField.ts

@@ -645,11 +645,18 @@ export const optionalFieldEditor: OptionalFieldEditor = {
 		},
 	}),
 
-	buildChildChange: (index: number, childChange: NodeId): OptionalChangeset => {
-		assert(index === 0, 0x404 /* Optional fields only support a single child node */);
+	buildChildChanges: (changes: Iterable<[number, NodeId]>): OptionalChangeset => {
+		const childChanges: ChildChange[] = Array.from(changes, ([index, childChange]) => {
+			assert(index === 0, 0x404 /* Optional fields only support a single child node */);
+			return ["self", childChange];
+		});
+		assert(
+			childChanges.length <= 1,
+			0xabd /* Optional fields only support a single child node */,
+		);
 		return {
 			moves: [],
-			childChanges: [["self", childChange]],
+			childChanges,
 		};
 	},
 };

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

@@ -5,14 +5,10 @@
 
 import { bufferToString } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
-import type {
-	IFluidDataStoreRuntime,
-	IChannelStorageService,
-} from "@fluidframework/datastore-definitions/internal";
+import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import { SummaryType } from "@fluidframework/driver-definitions";
 import type {
 	IExperimentalIncrementalSummaryContext,
-	IGarbageCollectionData,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -46,7 +42,6 @@ export class SchemaSummarizer implements Summarizable {
 	private schemaIndexLastChangedSeq: number | undefined;
 
 	public constructor(
-		private readonly runtime: IFluidDataStoreRuntime,
 		private readonly schema: MutableTreeStoredSchema,
 		options: ICodecOptions,
 		collabWindow: CollabWindow,
@@ -94,16 +89,6 @@ export class SchemaSummarizer implements Summarizable {
 		throw new Error("Method not implemented.");
 	}
 
-	public getGCData(fullGC?: boolean): IGarbageCollectionData {
-		// TODO: Properly implement garbage collection. Right now, garbage collection is performed automatically
-		// by the code in SharedObject (from which SharedTreeCore extends). The `runtime.uploadBlob` API delegates
-		// to the `BlobManager`, which automatically populates the summary with ISummaryAttachment entries for each
-		// blob.
-		return {
-			gcNodes: {},
-		};
-	}
-
 	public async load(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,

package/src/feature-libraries/sequence-field/sequenceFieldEditor.ts

@@ -75,8 +75,19 @@ export interface SequenceFieldEditor extends FieldEditor<Changeset> {
 }
 
 export const sequenceFieldEditor = {
-	buildChildChange: (index: number, change: NodeId): Changeset =>
-		markAtIndex(index, { count: 1, changes: change }),
+	buildChildChanges: (changes: Iterable<[number, NodeId]>): Changeset => {
+		const changeset: Changeset = [];
+		let currentIndex = 0;
+		for (const [index, change] of changes) {
+			assert(index >= currentIndex, 0xabe /* Child changes must be in order. */);
+			if (index > currentIndex) {
+				changeset.push({ count: index - currentIndex });
+			}
+			changeset.push({ count: 1, changes: change });
+			currentIndex = index + 1;
+		}
+		return changeset;
+	},
 	insert: (
 		index: number,
 		count: number,