@fluidframework/tree 2.118.1 → 3.0.1

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,6 +119,9 @@ export {
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
 	NodeChangedData, 
+	NodeChangedDataDelta, 
+	NodeChangedDataProperties, 
+	NodeChangedDataTreeDelta, 
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
@@ -139,6 +144,7 @@ export {
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
+	TreeContextBeta, 
 	TreeEncodingOptions, 
 	TreeIndex, 
 	TreeIndexKey, 
@@ -158,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,6 +119,9 @@ export {
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
 	NodeChangedData, 
+	NodeChangedDataDelta, 
+	NodeChangedDataProperties, 
+	NodeChangedDataTreeDelta, 
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
@@ -139,6 +144,7 @@ export {
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
+	TreeContextBeta, 
 	TreeEncodingOptions, 
 	TreeIndex, 
 	TreeIndexKey, 
@@ -158,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/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(

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

@@ -29,15 +29,18 @@ export {
 export { EncodedModularChangesetV2 } from "./modularChangeFormatV2.js";
 export { FlexFieldKind, type FullSchemaPolicy } from "./fieldKind.js";
 export {
-	type EditFilterFunc,
+	type ChildChangeInfo,
 	EditFilterStatus,
+	type FilterDetachFunc,
+	type FilterAttachFunc,
+	type FilterAttachResult,
+	type FilterDetachResult,
 	type FieldChangeHandler,
 	type FieldChangeDelta,
 	type FieldChangeEncodingContext,
 	type FieldChangeDecodingContext,
 	type FieldChangeRebaser,
 	type FieldEditor,
-	type NestedChangesIndices,
 	type NodeChangeComposer,
 	type NodeChangeInverter,
 	type NodeChangeRebaser,

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

@@ -16,26 +16,21 @@ import {
 	type TreeChunk,
 } from "../../core/index.js";
 import { brand, idAllocatorFromMaxId, type IdAllocator } from "../../util/index.js";
-import {
-	newChangeAtomIdBTree,
-	setInChangeAtomIdMap,
-	type ChangeAtomIdBTree,
-} from "../changeAtomIdBTree.js";
-import {
-	newCrossFieldKeyTable,
-	type CrossFieldKeyTable,
-	type FieldChange,
-	type FieldChangeMap,
-	type FieldId,
-	type ModularChangeset,
-	type NodeChangeset,
-	type NodeId,
+import { newChangeAtomIdBTree, type ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
+import type {
+	FieldChange,
+	FieldChangeMap,
+	FieldId,
+	ModularChangeset,
+	NodeChangeset,
+	NodeId,
 } from "./modularChangeTypes.js";
 import {
 	CrossFieldManagerI,
 	getChangeHandler,
 	getRevInfoFromTaggedChanges,
 	hasConflicts,
+	makeChangesetInversions,
 	makeModularChangeset,
 	newConstraintState,
 	newCrossFieldTable,
@@ -87,7 +82,6 @@ export function invertModularChange(
 	const crossFieldTable: InvertTable = {
 		...newCrossFieldTable<FieldChange>(),
 		originalFieldToContext: new Map(),
-		invertedNodeToParent: brand(change.change.nodeToParent.clone()),
 	};
 	const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
 	const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
@@ -144,7 +138,11 @@ export function invertModularChange(
 		}
 	}
 
-	const crossFieldKeys = makeCrossFieldKeyTable(invertedFields, invertedNodes, fieldKinds);
+	const { crossFieldKeys, nodeToParent } = makeChangesetInversions(
+		invertedFields,
+		invertedNodes,
+		fieldKinds,
+	);
 
 	const constraintState = newConstraintState(0);
 	updateConstraintsForFields(
@@ -158,7 +156,7 @@ export function invertModularChange(
 	return makeModularChangeset({
 		fieldChanges: invertedFields,
 		nodeChanges: invertedNodes,
-		nodeToParent: crossFieldTable.invertedNodeToParent,
+		nodeToParent,
 		nodeAliases: change.change.nodeAliases,
 		crossFieldKeys,
 		maxId: genId.getMaxId(),
@@ -261,7 +259,6 @@ function invertBuilds(
 
 interface InvertTable extends CrossFieldTable<FieldChange> {
 	originalFieldToContext: Map<FieldChange, InvertContext>;
-	invertedNodeToParent: ChangeAtomIdBTree<FieldId>;
 }
 
 interface InvertContext {
@@ -279,9 +276,7 @@ class InvertManager extends CrossFieldManagerI<FieldChange> {
 		super(table, field, allowInval);
 	}
 
-	public override onMoveIn(id: ChangeAtomId): void {
-		setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
-	}
+	public override onMoveIn(id: ChangeAtomId): void {}
 
 	public override moveKey(
 		target: CrossFieldTarget,
@@ -296,43 +291,3 @@ class InvertManager extends CrossFieldManagerI<FieldChange> {
 		return this.crossFieldTable as InvertTable;
 	}
 }
-
-function makeCrossFieldKeyTable(
-	fields: FieldChangeMap,
-	nodes: ChangeAtomIdBTree<NodeChangeset>,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
-): CrossFieldKeyTable {
-	const keys: CrossFieldKeyTable = newCrossFieldKeyTable();
-	populateCrossFieldKeyTableForFieldMap(keys, fields, undefined, fieldKinds);
-	nodes.forEachPair(([revision, localId], node) => {
-		if (node.fieldChanges !== undefined) {
-			populateCrossFieldKeyTableForFieldMap(
-				keys,
-				node.fieldChanges,
-				{
-					revision,
-					localId,
-				},
-				fieldKinds,
-			);
-		}
-	});
-
-	return keys;
-}
-
-function populateCrossFieldKeyTableForFieldMap(
-	table: CrossFieldKeyTable,
-	fields: FieldChangeMap,
-	parent: NodeId | undefined,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
-): void {
-	for (const [fieldKey, fieldChange] of fields) {
-		const keys = getChangeHandler(fieldKinds, fieldChange.fieldKind).getCrossFieldKeys(
-			fieldChange.change,
-		);
-		for (const { key, count } of keys) {
-			table.set(key, count, { nodeId: parent, field: fieldKey });
-		}
-	}
-}