@fluidframework/tree 2.117.0 → 3.0.0

package/src/entrypoints/alpha.ts

@@ -28,14 +28,11 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
-	InternalTypes, 
-	IsListener, 
+	type InternalTypes, 
 	IsUnion, 
 	IterableTreeArrayContent, 
 	LazyItem, 
 	LeafSchema, 
-	Listenable, 
-	Listeners, 
 	MakeNominal, 
 	MapNodeInsertableData, 
 	NodeFromSchema, 
@@ -45,7 +42,6 @@ export {
 	NodeSchemaOptions, 
 	NumberKeys, 
 	ObjectFromSchemaRecord, 
-	Off, 
 	ReadonlyArrayNode, 
 	RestrictiveReadonlyRecord, 
 	RestrictiveStringRecord, 
@@ -102,6 +98,12 @@ export {
 	AnnotatedAllowedTypeUnsafe, 
 	AnnotatedAllowedTypes, 
 	AnnotatedAllowedTypesUnsafe, 
+	ArrayNodeDeltaOp, 
+	ArrayNodeInsertOp, 
+	ArrayNodeRemoveOp, 
+	ArrayNodeRetainOp, 
+	ArrayNodeTreeChangedDeltaOp, 
+	ArrayNodeTreeChangedRetainOp, 
 	CodecWriteOptionsBeta, 
 	ConciseTree, 
 	ExtensibleUnionNode, 
@@ -117,10 +119,15 @@ export {
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
 	NodeChangedData, 
+	NodeChangedDataDelta, 
+	NodeChangedDataProperties, 
+	NodeChangedDataTreeDelta, 
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
 	RunTransactionParamsBeta, 
+	SchemaCompatibilityStatusBeta,
+	SchemaDiscrepancy,
 	SchemaFactoryBeta, 
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
@@ -137,6 +144,7 @@ export {
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
+	TreeContextBeta, 
 	TreeEncodingOptions, 
 	TreeIndex, 
 	TreeIndexKey, 
@@ -156,6 +164,7 @@ export {
 	configuredSharedTreeBeta, 
 	createIdentifierIndex, 
 	createIndependentTreeBeta, 
+	createIndependentTreeView, 
 	createTreeIndex, 
 	enumFromStrings, 
 	singletonSchema, 
@@ -167,14 +176,8 @@ export {
 	ArrayNodeCustomizableSchema, 
 	ArrayNodeCustomizableSchemaAlpha, 
 	ArrayNodeCustomizableSchemaUnsafe, 
-	ArrayNodeDeltaOp, 
-	ArrayNodeInsertOp, 
 	ArrayNodePojoEmulationSchema, 
-	ArrayNodeRemoveOp, 
-	ArrayNodeRetainOp, 
 	ArrayNodeSchema, 
-	ArrayNodeTreeChangedDeltaOp, 
-	ArrayNodeTreeChangedRetainOp, 
 	ArrayPlaceAnchor, 
 	ChangeMetadata, 
 	CodecName, 
@@ -240,10 +243,6 @@ export {
 	MapNodePojoEmulationSchema, 
 	MapNodeSchema, 
 	NoChangeConstraint, 
-	NodeChangedDataAlpha, 
-	NodeChangedDataDelta, 
-	NodeChangedDataProperties, 
-	NodeChangedDataTreeDelta, 
 	NodeProvider, 
 	NodeSchemaOptionsAlpha, 
 	ObjectNodeSchema, 
@@ -257,10 +256,10 @@ export {
 	RecordNodePojoEmulationSchema, 
 	RecordNodeSchema, 
 	RemoteChangeMetadata, 
-	RevertibleAlpha, 
-	RevertibleAlphaFactory, 
 	RevertOptionsAlpha, 
 	RevertToOptionsAlpha, 
+	RevertibleAlpha, 
+	RevertibleAlphaFactory, 
 	RunTransactionParamsAlpha, 
 	SchemaFactoryAlpha, 
 	SchemaStaticsAlpha, 
@@ -281,6 +280,7 @@ export {
 	SimpleTreeSchema, 
 	StagedSchemaUpgradePolicy, 
 	StagedSchemaUpgradePolicyFactory, 
+	StagedUpgradeStatus, 
 	StringSchema, 
 	TransactionCallbackStatusAlpha, 
 	TransactionConstraintAlpha, 
@@ -292,7 +292,6 @@ export {
 	TreeBranchCommitMetadata, 
 	TreeBranchEvents, 
 	TreeBranchHistory, 
-	TreeChangeEventsAlpha, 
 	TreeCompressionStrategy, 
 	TreeContextAlpha, 
 	TreeDataStoreOptions, 
@@ -312,14 +311,15 @@ export {
 	VoidTransactionCallbackStatusAlpha, 
 	allowUnused, 
 	asAlpha, 
-	asTreeViewAlpha, 
 	checkCompatibility, 
 	cloneWithReplacements, 
+	codePointCount, 
 	comparePersistedSchema, 
 	configuredSharedTreeAlpha, 
 	contentSchemaSymbol, 
 	createArrayInsertionAnchor, 
 	createIndependentTreeAlpha, 
+	createIndependentTreeViewAlpha, 
 	decodeSchemaCompatibilitySnapshot, 
 	defineTreeDataStore, 
 	encodeSchemaCompatibilitySnapshot, 
@@ -343,6 +343,7 @@ export {
 	replaceConciseTreeHandles, 
 	replaceHandles, 
 	replaceVerboseTreeHandles, 
-	trackDirtyNodes
+	trackDirtyNodes, 
+	utf16LengthForCodePoints
 	// #endregion
 } from "../index.js";

package/src/entrypoints/beta.ts

@@ -28,14 +28,11 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
-	InternalTypes, 
-	IsListener, 
+	type InternalTypes, 
 	IsUnion, 
 	IterableTreeArrayContent, 
 	LazyItem, 
 	LeafSchema, 
-	Listenable, 
-	Listeners, 
 	MakeNominal, 
 	MapNodeInsertableData, 
 	NodeFromSchema, 
@@ -45,7 +42,6 @@ export {
 	NodeSchemaOptions, 
 	NumberKeys, 
 	ObjectFromSchemaRecord, 
-	Off, 
 	ReadonlyArrayNode, 
 	RestrictiveReadonlyRecord, 
 	RestrictiveStringRecord, 
@@ -102,6 +98,12 @@ export {
 	AnnotatedAllowedTypeUnsafe, 
 	AnnotatedAllowedTypes, 
 	AnnotatedAllowedTypesUnsafe, 
+	ArrayNodeDeltaOp, 
+	ArrayNodeInsertOp, 
+	ArrayNodeRemoveOp, 
+	ArrayNodeRetainOp, 
+	ArrayNodeTreeChangedDeltaOp, 
+	ArrayNodeTreeChangedRetainOp, 
 	CodecWriteOptionsBeta, 
 	ConciseTree, 
 	ExtensibleUnionNode, 
@@ -117,10 +119,15 @@ export {
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
 	NodeChangedData, 
+	NodeChangedDataDelta, 
+	NodeChangedDataProperties, 
+	NodeChangedDataTreeDelta, 
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
 	RunTransactionParamsBeta, 
+	SchemaCompatibilityStatusBeta,
+	SchemaDiscrepancy,
 	SchemaFactoryBeta, 
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
@@ -137,6 +144,7 @@ export {
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
+	TreeContextBeta, 
 	TreeEncodingOptions, 
 	TreeIndex, 
 	TreeIndexKey, 
@@ -156,6 +164,7 @@ export {
 	configuredSharedTreeBeta, 
 	createIdentifierIndex, 
 	createIndependentTreeBeta, 
+	createIndependentTreeView, 
 	createTreeIndex, 
 	enumFromStrings, 
 	singletonSchema, 

package/src/entrypoints/legacy.ts

@@ -28,14 +28,11 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
-	InternalTypes, 
-	IsListener, 
+	type InternalTypes, 
 	IsUnion, 
 	IterableTreeArrayContent, 
 	LazyItem, 
 	LeafSchema, 
-	Listenable, 
-	Listeners, 
 	MakeNominal, 
 	MapNodeInsertableData, 
 	NodeFromSchema, 
@@ -45,7 +42,6 @@ export {
 	NodeSchemaOptions, 
 	NumberKeys, 
 	ObjectFromSchemaRecord, 
-	Off, 
 	ReadonlyArrayNode, 
 	RestrictiveReadonlyRecord, 
 	RestrictiveStringRecord, 
@@ -102,6 +98,12 @@ export {
 	AnnotatedAllowedTypeUnsafe, 
 	AnnotatedAllowedTypes, 
 	AnnotatedAllowedTypesUnsafe, 
+	ArrayNodeDeltaOp, 
+	ArrayNodeInsertOp, 
+	ArrayNodeRemoveOp, 
+	ArrayNodeRetainOp, 
+	ArrayNodeTreeChangedDeltaOp, 
+	ArrayNodeTreeChangedRetainOp, 
 	CodecWriteOptionsBeta, 
 	ConciseTree, 
 	ExtensibleUnionNode, 
@@ -117,10 +119,15 @@ export {
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
 	NodeChangedData, 
+	NodeChangedDataDelta, 
+	NodeChangedDataProperties, 
+	NodeChangedDataTreeDelta, 
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
 	RunTransactionParamsBeta, 
+	SchemaCompatibilityStatusBeta,
+	SchemaDiscrepancy,
 	SchemaFactoryBeta, 
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
@@ -137,6 +144,7 @@ export {
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
+	TreeContextBeta, 
 	TreeEncodingOptions, 
 	TreeIndex, 
 	TreeIndexKey, 
@@ -156,6 +164,7 @@ export {
 	configuredSharedTreeBeta, 
 	createIdentifierIndex, 
 	createIndependentTreeBeta, 
+	createIndependentTreeView, 
 	createTreeIndex, 
 	enumFromStrings, 
 	singletonSchema, 

package/src/entrypoints/public.ts

@@ -28,14 +28,11 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
-	InternalTypes, 
-	IsListener, 
+	type InternalTypes, 
 	IsUnion, 
 	IterableTreeArrayContent, 
 	LazyItem, 
 	LeafSchema, 
-	Listenable, 
-	Listeners, 
 	MakeNominal, 
 	MapNodeInsertableData, 
 	NodeFromSchema, 
@@ -45,7 +42,6 @@ export {
 	NodeSchemaOptions, 
 	NumberKeys, 
 	ObjectFromSchemaRecord, 
-	Off, 
 	ReadonlyArrayNode, 
 	RestrictiveReadonlyRecord, 
 	RestrictiveStringRecord, 

package/src/extensibleUnionNode.ts

@@ -5,7 +5,7 @@
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { TreeAlpha, Tree } from "./shared-tree/index.js";
+import { TreeAlpha, Tree, TreeBeta } from "./shared-tree/index.js";
 import type {
 	TreeNodeSchema,
 	TreeNodeFromImplicitAllowedTypes,
@@ -19,7 +19,6 @@ import {
 	eraseSchemaDetailsSubclassable,
 	getInnerNode,
 	SchemaFactory,
-	TreeBeta,
 } from "./simple-tree/index.js";
 import type { UnionToIntersection } from "./util/index.js";
 

package/src/feature-libraries/cursorComparator.ts

@@ -3,12 +3,13 @@
  * Licensed under the MIT License.
  */
 
+import { debugAssert } from "@fluidframework/core-utils/internal";
 import {
 	mapCursorField,
 	mapCursorFields,
-	inCursorField,
 	type ITreeCursorSynchronous,
 	type Value,
+	type FieldKey,
 } from "../core/index.js";
 /**
  * Tests whether a cursor's current node matches a previously captured subtree.
@@ -51,25 +52,72 @@ function buildFieldComparator(nodeComparators: NodeComparator[]): FieldComparato
  *
  * The cursor must be in Nodes mode. After this call, the cursor is restored to its original position.
  *
+ * This code is on a hot path for walking formatted text, so it is optimized for performance.
+ *
+ * As an optimization, this makes some assumptions about the cursors,
+ * which we know are true for any actual node which can exist in our public API surface,
+ * but which are not guaranteed by the cursor interface itself.
+ * Specifically this assumes that:
+ * 1. Nodes either have fields or a value, never both.
+ * 2. The type of a leaf value is possible to determine from its value.
  */
 export function buildNodeComparator(cursor: ITreeCursorSynchronous): NodeComparator {
 	const expectedValue: Value = cursor.value;
+	const expectedType = cursor.type;
+
+	// Fast-path for leaves:
+	// This leverages the fact that nodes either have fields of values, never both, so we can skip checking fields.
 	if (expectedValue !== undefined) {
-		return (other: ITreeCursorSynchronous): boolean => Object.is(other.value, expectedValue);
+		return (other: ITreeCursorSynchronous): boolean => {
+			// This assumes that the type of a leaf value is possible to determine from its value,
+			// so we don't need to compare the type as well.
+			// This assumption is validated by the debugAssert below.
+			debugAssert(
+				() =>
+					!Object.is(other.value, expectedValue) ||
+					other.type === expectedType ||
+					"Equal values must have equal types",
+			);
+			return Object.is(other.value, expectedValue);
+		};
 	}
-	const fieldComparators = mapCursorFields(cursor, (fieldCursor) => ({
-		key: fieldCursor.getFieldKey(),
-		compare: buildFieldComparator(mapCursorField(fieldCursor, buildNodeComparator)),
-	}));
+
+	const fieldComparators: Map<FieldKey, (cursor: ITreeCursorSynchronous) => boolean> = new Map(
+		mapCursorFields(cursor, (fieldCursor) => [
+			fieldCursor.getFieldKey(),
+			buildFieldComparator(mapCursorField(fieldCursor, buildNodeComparator)),
+		]),
+	);
+	const fieldCount = fieldComparators.size;
 
 	return (other: ITreeCursorSynchronous): boolean => {
-		if (!Object.is(other.value, expectedValue)) {
+		if (other.type !== expectedType) {
 			return false;
 		}
-		for (const { key, compare } of fieldComparators) {
-			if (!inCursorField(other, key, () => compare(other))) {
+		// We assume that the type sorts nodes into leaf or not, so in this non leaf case,
+		// any node with a value should have returned false above.
+		// This assumption is validated by the debugAssert below.
+		debugAssert(
+			() => other.value === undefined || "Expected other cursor to be in Nodes mode",
+		);
+
+		let otherFieldCount = 0;
+		for (let inField = other.firstField(); inField; inField = other.nextField()) {
+			const fieldValidator = fieldComparators.get(other.getFieldKey());
+			// eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- Suggested fix fails a different lint, and needs an extra compare.
+			if (fieldValidator === undefined || !fieldValidator(other)) {
+				other.exitField();
 				return false;
 			}
+			otherFieldCount++;
+		}
+
+		debugAssert(
+			() => otherFieldCount <= fieldCount || "Extra fields should have been rejected above",
+		);
+
+		if (otherFieldCount !== fieldCount) {
+			return false;
 		}
 
 		return true;

package/src/feature-libraries/index.ts

@@ -155,7 +155,7 @@ export {
 
 export {
 	SchemaValidationError,
-	type SchemaValidationErrorContext,
+	type SchemaValidationErrorDetails,
 	isNodeInSchema,
 	isFieldInSchema,
 	throwOutOfSchema,

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

@@ -23,11 +23,20 @@ import type { CrossFieldManager } 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 */,
-][];
+export interface ChildChangeInfo {
+	nodeId: NodeId;
+
+	/**
+	 * The root ID for this node in the input context of the changeset.
+	 * Undefined if the node was attached in the input context.
+	 */
+	inputRootId: ChangeAtomId | undefined;
+
+	/**
+	 * The ID this changeset detaches this node with.
+	 */
+	detachId: ChangeAtomId | undefined;
+}
 
 /**
  * The return value of calling {@link FieldChangeHandler.intoDelta}.
@@ -106,7 +115,7 @@ export interface FieldChangeHandler<
 	 * the indices are are ordered from smallest to largest (with no duplicates).
 	 * The returned array is owned by the caller.
 	 */
-	getNestedChanges(change: TChangeset): NestedChangesIndices;
+	getNestedChanges(change: TChangeset): ChildChangeInfo[];
 
 	/**
 	 * @returns A list of all cross-field keys contained in the change.
@@ -173,7 +182,7 @@ export interface FieldChangeRebaser<TChangeset> {
 	 * @param filterDetach - This should be called for each range of detaches in the changeset,
 	 * and the detach should be preserved, removed, or converted to a non-move detach as specified.
 	 * If the returned result does not cover the entire detach range, the remainder should be queried again.
-	 * @param filterDetach - This should be called for each range of attaches in the changeset,
+	 * @param filterAttach - This should be called for each range of attaches in the changeset,
 	 * and the attach should be preserved, removed, or converted to a non-move attach as specified.
 	 * If the returned result does not cover the entire detach range, the remainder should be queried again.
 	 * @param preserveOtherEdits - Whether edits other than attaches and detaches (e.g. root renames),
@@ -182,18 +191,74 @@ export interface FieldChangeRebaser<TChangeset> {
 	filterEdits(
 		change: TChangeset,
 		options: {
-			filterDetach: EditFilterFunc;
-			filterAttach: EditFilterFunc;
+			filterDetach: FilterDetachFunc;
+			filterAttach: FilterAttachFunc;
 			preserveOtherEdits: boolean;
 		},
 	): TChangeset;
 }
 
-export type EditFilterFunc = (
-	id: ChangeAtomId,
+export type FilterDetachFunc = (
+	/**
+	 * The ID of the detach being queried.
+	 */
+	detachId: ChangeAtomId,
 	count: number,
+
+	/**
+	 * The input-context ID of the nodes being detached, if they are already detached.
+	 */
+	inputRootId: ChangeAtomId | undefined,
+
+	/**
+	 * The ID of the associated attach, if this is part of a move with a different attach ID.
+	 */
 	endpoint?: ChangeAtomId,
-) => RangeQueryResult<EditFilterStatus>;
+) => RangeQueryResult<FilterDetachResult>;
+
+export type FilterAttachFunc = (
+	/**
+	 * The ID of the attach being queried.
+	 */
+	attachId: ChangeAtomId,
+	count: number,
+
+	/**
+	 * The output-context ID of the nodes being attached, if they are only transiently attached.
+	 */
+	outputRootId: ChangeAtomId | undefined,
+
+	/**
+	 * The ID of the associated detach, if this is part of a move with a different detach ID.
+	 */
+	endpoint?: ChangeAtomId,
+) => RangeQueryResult<FilterAttachResult>;
+
+export interface FilterDetachResult {
+	readonly action: EditFilterStatus;
+
+	/**
+	 * If true, the filtered change should also remove any child changes for the detached nodes.
+	 * This will only be set when `action` is `EditFilterStatus.Remove`.
+	 */
+	readonly shouldRemoveChild?: boolean;
+}
+
+export interface FilterAttachResult {
+	readonly action: EditFilterStatus;
+
+	/**
+	 * When `action` is `EditFilterStatus.PreserveWithoutMove`,
+	 * the filtered change should include a child change with this ID.
+	 */
+	readonly nodeId?: NodeId;
+
+	/**
+	 * When `action` is `EditFilterStatus.PreserveWithoutMove`,
+	 * this ID should be used as the attach ID for the filtered change.
+	 */
+	readonly newAttachId?: ChangeAtomId;
+}
 
 /**
  * Used to describe what should be done with a particular attach or detach during `filterEdits`.

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

@@ -0,0 +1,108 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	makeChangeAtomId,
+	type ChangeAtomId,
+	type FieldKindIdentifier,
+} from "../../core/index.js";
+import { brand, type RangeQueryResult } from "../../util/index.js";
+import type { ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
+import {
+	EditFilterStatus,
+	type FilterAttachResult,
+	type FilterDetachResult,
+} from "./fieldChangeHandler.js";
+import type { FlexFieldKind } from "./fieldKind.js";
+import type {
+	FieldChange,
+	FieldChangeMap,
+	FieldId,
+	ModularChangeset,
+	NodeChangeset,
+	NodeId,
+} from "./modularChangeTypes.js";
+import { makeChangesetInversions } from "./modularChangeUtils.js";
+import { pruneChangeset } from "./prune.js";
+
+export function removeAllDetachesFilter(
+	_id: ChangeAtomId,
+	count: number,
+	_rootId: ChangeAtomId | undefined,
+	_endpointId?: ChangeAtomId,
+): RangeQueryResult<FilterDetachResult> {
+	return {
+		value: { action: EditFilterStatus.Remove, shouldRemoveChild: false },
+		length: count,
+	};
+}
+
+export function removeAllAttachesFilter(
+	_id: ChangeAtomId,
+	count: number,
+	_rootId: ChangeAtomId | undefined,
+	_endpointId?: ChangeAtomId,
+): RangeQueryResult<FilterAttachResult> {
+	return { value: { action: EditFilterStatus.Remove }, length: count };
+}
+
+export function filterEdits(
+	change: ModularChangeset,
+	filterFieldEdits: (fieldChange: FieldChange, fieldId: FieldId) => FieldChange,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): ModularChangeset {
+	const filteredFieldChanges = filterFieldMapEdits(
+		change.fieldChanges,
+		undefined,
+		filterFieldEdits,
+	);
+
+	const filteredNodeChanges: ChangeAtomIdBTree<NodeChangeset> = brand(
+		change.nodeChanges.mapValues((v, k) =>
+			filterNodeEdits(makeChangeAtomId(k[1], k[0]), v, filterFieldEdits),
+		),
+	);
+
+	const { crossFieldKeys: filteredCrossFieldKeys, nodeToParent: filteredNodeToParent } =
+		makeChangesetInversions(filteredFieldChanges, filteredNodeChanges, fieldKinds);
+
+	return pruneChangeset(
+		{
+			...change,
+			fieldChanges: filteredFieldChanges,
+			nodeChanges: filteredNodeChanges,
+			crossFieldKeys: filteredCrossFieldKeys,
+			nodeToParent: filteredNodeToParent,
+		},
+		fieldKinds,
+	);
+}
+
+function filterFieldMapEdits(
+	change: FieldChangeMap,
+	nodeId: NodeId | undefined,
+	filterFieldEdits: (fieldChange: FieldChange, fieldId: FieldId) => FieldChange,
+): FieldChangeMap {
+	return new Map(
+		Array.from(change.entries(), ([field, fieldChange]) => [
+			field,
+			filterFieldEdits(fieldChange, { nodeId, field }),
+		]),
+	);
+}
+
+function filterNodeEdits(
+	nodeId: NodeId,
+	change: NodeChangeset,
+	filterFieldEdits: (fieldChange: FieldChange, fieldId: FieldId) => FieldChange,
+): NodeChangeset {
+	if (change.fieldChanges === undefined) {
+		return change;
+	}
+	return {
+		...change,
+		fieldChanges: filterFieldMapEdits(change.fieldChanges, nodeId, filterFieldEdits),
+	};
+}

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

@@ -16,9 +16,9 @@ import {
 import { brandConst } from "../../util/index.js";
 
 import type {
+	ChildChangeInfo,
 	FieldChangeDelta,
 	FieldChangeHandler,
-	NestedChangesIndices,
 	NodeChangeComposer,
 	NodeChangePruner,
 	NodeChangeRebaser,
@@ -84,9 +84,12 @@ function compose(
 	return composed;
 }
 
-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, index]);
+function getNestedChanges(change: GenericChangeset): ChildChangeInfo[] {
+	return change.toArray().map(([_index, nodeChange]) => ({
+		nodeId: nodeChange,
+		inputRootId: undefined,
+		detachId: undefined,
+	}));
 }
 
 function rebaseGenericChange(