@fluidframework/tree 2.118.0 → 3.0.0

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

@@ -38,7 +38,6 @@ import {
 	revisionMetadataSourceFromInfo,
 	areEqualChangeAtomIds,
 	type ChangeAtomId,
-	areEqualChangeAtomIdOpts,
 	tagChange,
 	makeAnonChange,
 	type DeltaDetachedNodeChanges,
@@ -56,7 +55,6 @@ import {
 	brand,
 	idAllocatorFromMaxId,
 	idAllocatorFromState,
-	type RangeQueryResult,
 	getOrCreate,
 	mergeTupleBTrees,
 	type TupleBTree,
@@ -76,7 +74,6 @@ import type { TreeChunk } from "../chunked-forest/index.js";
 
 import type { CrossFieldTarget } from "./crossFieldQueries.js";
 import {
-	EditFilterStatus,
 	type FieldChangeHandler,
 	NodeAttachState,
 	type RebaseRevisionMetadata,
@@ -100,18 +97,23 @@ import {
 import {
 	CrossFieldManagerI,
 	getChangeHandler,
+	getFieldsForCrossFieldKey,
+	getParentFieldId,
 	getRevInfoFromTaggedChanges,
 	hasConflicts,
 	makeModularChangeset,
 	newConstraintState,
 	newCrossFieldTable,
 	nodeChangeFromId,
+	normalizeFieldId,
+	normalizeNodeId,
 	revisionInfoFromTaggedChange,
 	updateConstraintsForFields,
 	type CrossFieldTable,
 } from "./modularChangeUtils.js";
 import { invertModularChange } from "./invert.js";
-import { pruneFieldMap } from "./prune.js";
+import { pruneChangeset } from "./prune.js";
+import { removeAllAttachesFilter, removeAllDetachesFilter } from "./filterEdits.js";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -790,7 +792,7 @@ export class ModularChangeFamily
 		);
 
 		const rebased = makeModularChangeset({
-			fieldChanges: pruneFieldMap(rebasedFields, rebasedNodes, this.fieldKinds),
+			fieldChanges: rebasedFields,
 			nodeChanges: rebasedNodes,
 			nodeToParent: crossFieldTable.rebasedNodeToParent,
 			nodeAliases: change.nodeAliases,
@@ -805,7 +807,7 @@ export class ModularChangeFamily
 			refreshers: change.refreshers,
 		});
 
-		return rebased;
+		return pruneChangeset(rebased, this.fieldKinds);
 	}
 
 	// This performs a first pass on all fields which have both new and base changes.
@@ -1340,63 +1342,6 @@ export class ModularChangeFamily
 		return { fieldKind, change: brand(emptyChange) };
 	}
 
-	public validateChangeset(change: ModularChangeset): void {
-		let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
-
-		for (const [[revision, localId], node] of change.nodeChanges.entries()) {
-			if (node.fieldChanges === undefined) {
-				continue;
-			}
-
-			const nodeId: NodeId = { revision, localId };
-			const numChildren = this.validateFieldChanges(change, node.fieldChanges, nodeId);
-
-			numNodes += numChildren;
-		}
-
-		assert(
-			numNodes === change.nodeChanges.size,
-			0xa4d /* Node table contains unparented nodes */,
-		);
-	}
-
-	/**
-	 * Asserts that each child and cross field key in each field has a correct entry in
-	 * `nodeToParent` or `crossFieldKeyTable`.
-	 * @returns the number of children found.
-	 */
-	private validateFieldChanges(
-		change: ModularChangeset,
-		fieldChanges: FieldChangeMap,
-		nodeParent: NodeId | undefined,
-	): number {
-		let numChildren = 0;
-		for (const [field, fieldChange] of fieldChanges.entries()) {
-			const fieldId = { nodeId: nodeParent, field };
-			const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
-			for (const [child, _index] of handler.getNestedChanges(fieldChange.change)) {
-				const parentFieldId = getParentFieldId(change, child);
-				assert(
-					areEqualFieldIds(parentFieldId, fieldId),
-					0xa4e /* Inconsistent node parentage */,
-				);
-				numChildren += 1;
-			}
-
-			for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
-				const fields = getFieldsForCrossFieldKey(change, keyRange.key, keyRange.count);
-				assert(
-					fields.length === 1 &&
-						fields[0] !== undefined &&
-						areEqualFieldIds(fields[0], fieldId),
-					0xa4f /* Inconsistent cross field keys */,
-				);
-			}
-		}
-
-		return numChildren;
-	}
-
 	private getEffectiveChange(change: ModularChangeset): ModularChangeset {
 		if (hasConflicts(change)) {
 			return this.muteChange(change);
@@ -1439,8 +1384,8 @@ export class ModularChangeFamily
 			fieldKind: change.fieldKind,
 			change: brand(
 				handler.rebaser.filterEdits(change.change, {
-					filterDetach: removeAllEditsFilter,
-					filterAttach: removeAllEditsFilter,
+					filterDetach: removeAllDetachesFilter,
+					filterAttach: removeAllAttachesFilter,
 					preserveOtherEdits: false,
 				}),
 			),
@@ -1448,14 +1393,6 @@ export class ModularChangeFamily
 	}
 }
 
-function removeAllEditsFilter(
-	_id: ChangeAtomId,
-	count: number,
-	_endpointId?: ChangeAtomId,
-): RangeQueryResult<EditFilterStatus> {
-	return { value: EditFilterStatus.Remove, length: count };
-}
-
 function replaceCrossFieldKeyTableRevisions(
 	table: CrossFieldKeyTable,
 	replacer: RevisionReplacer,
@@ -2508,53 +2445,6 @@ function replaceFieldIdRevision(fieldId: FieldId, replacer: RevisionReplacer): F
 	};
 }
 
-export function getParentFieldId(changeset: ModularChangeset, nodeId: NodeId): FieldId {
-	const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
-	assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
-	return normalizeFieldId(parentId, changeset.nodeAliases);
-}
-
-function getFieldsForCrossFieldKey(
-	changeset: ModularChangeset,
-	key: CrossFieldKey,
-	count: number,
-): FieldId[] {
-	const fieldIds: FieldId[] = [];
-	for (const { value: fieldId } of changeset.crossFieldKeys.getAll(key, count)) {
-		if (fieldId !== undefined) {
-			fieldIds.push(normalizeFieldId(fieldId, changeset.nodeAliases));
-		}
-	}
-
-	return fieldIds;
-}
-
-// This is only exported for use in test utilities.
-export function normalizeFieldId(
-	fieldId: FieldId,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
-): FieldId {
-	return fieldId.nodeId === undefined
-		? fieldId
-		: { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) };
-}
-
-/**
- * @returns The canonical form of nodeId, according to nodeAliases
- */
-function normalizeNodeId(nodeId: NodeId, nodeAliases: ChangeAtomIdBTree<NodeId>): NodeId {
-	let currentId = nodeId;
-
-	while (true) {
-		const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
-		if (dealiased === undefined) {
-			return currentId;
-		}
-
-		currentId = dealiased;
-	}
-}
-
 /**
  * A rebaseChild callback for fields with no new changes.
  * Asserts that there are no new changes and returns undefined.
@@ -2576,10 +2466,6 @@ interface ModularChangesetContent {
 	crossFieldKeys: CrossFieldKeyTable;
 }
 
-function areEqualFieldIds(a: FieldId, b: FieldId): boolean {
-	return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
-}
-
 function newFieldIdKeyBTree<V>(): TupleBTree<FieldIdKey, V> {
 	return newTupleBTree(compareFieldIdKeys);
 }

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

@@ -5,6 +5,7 @@
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import {
+	areEqualChangeAtomIdOpts,
 	newChangeAtomIdRangeMap,
 	type ChangesetLocalId,
 	type FieldKey,
@@ -32,8 +33,11 @@ import type { FlexFieldKind } from "./fieldKind.js";
 import { genericFieldKind } from "./genericFieldKind.js";
 import {
 	newCrossFieldKeyTable,
+	type CrossFieldKey,
+	type CrossFieldKeyTable,
 	type FieldChange,
 	type FieldChangeMap,
+	type FieldId,
 	type ModularChangeset,
 	type NodeChangeset,
 	type NodeId,
@@ -278,8 +282,8 @@ export function updateConstraintsForFields(
 ): void {
 	for (const field of fields.values()) {
 		const handler = getChangeHandler(fieldKinds, field.fieldKind);
-		for (const [nodeId, inputIndex, _outputIndex] of handler.getNestedChanges(field.change)) {
-			const isInputDetached = inputIndex === undefined;
+		for (const { nodeId, inputRootId } of handler.getNestedChanges(field.change)) {
+			const isInputDetached = inputRootId !== undefined;
 			const inputAttachState =
 				parentInputAttachState === NodeAttachState.Detached || isInputDetached
 					? NodeAttachState.Detached
@@ -329,3 +333,161 @@ export function nodeChangeFromId(
 	assert(node !== undefined, 0x9ca /* Unknown node ID */);
 	return node;
 }
+
+/**
+ * @returns The canonical form of nodeId, according to nodeAliases
+ */
+export function normalizeNodeId(
+	nodeId: NodeId,
+	nodeAliases: ChangeAtomIdBTree<NodeId>,
+): NodeId {
+	let currentId = nodeId;
+
+	while (true) {
+		const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
+		if (dealiased === undefined) {
+			return currentId;
+		}
+
+		currentId = dealiased;
+	}
+}
+
+export function makeChangesetInversions(
+	fields: FieldChangeMap,
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): { crossFieldKeys: CrossFieldKeyTable; nodeToParent: ChangeAtomIdBTree<FieldId> } {
+	const crossFieldKeys: CrossFieldKeyTable = newCrossFieldKeyTable();
+	const nodeToParent: ChangeAtomIdBTree<FieldId> = newChangeAtomIdBTree();
+	populateInversionsFromFieldMap(fields, undefined, fieldKinds, crossFieldKeys, nodeToParent);
+
+	nodes.forEachPair(([revision, localId], node) => {
+		if (node.fieldChanges !== undefined) {
+			populateInversionsFromFieldMap(
+				node.fieldChanges,
+				{
+					revision,
+					localId,
+				},
+				fieldKinds,
+				crossFieldKeys,
+				nodeToParent,
+			);
+		}
+	});
+
+	return { crossFieldKeys, nodeToParent };
+}
+
+function populateInversionsFromFieldMap(
+	fields: FieldChangeMap,
+	parent: NodeId | undefined,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	crossFieldKeys: CrossFieldKeyTable,
+	nodeToParent: ChangeAtomIdBTree<FieldId>,
+): void {
+	for (const [fieldKey, fieldChange] of fields) {
+		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+		for (const { key, count } of handler.getCrossFieldKeys(fieldChange.change)) {
+			crossFieldKeys.set(key, count, { nodeId: parent, field: fieldKey });
+		}
+
+		for (const { nodeId } of handler.getNestedChanges(fieldChange.change)) {
+			nodeToParent.set([nodeId.revision, nodeId.localId], { nodeId: parent, field: fieldKey });
+		}
+	}
+}
+
+export function validateChangeset(
+	change: ModularChangeset,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): void {
+	let numNodes = validateFieldChanges(change, change.fieldChanges, undefined, fieldKinds);
+
+	for (const [[revision, localId], node] of change.nodeChanges.entries()) {
+		if (node.fieldChanges === undefined) {
+			continue;
+		}
+
+		const nodeId: NodeId = { revision, localId };
+		const numChildren = validateFieldChanges(change, node.fieldChanges, nodeId, fieldKinds);
+
+		numNodes += numChildren;
+	}
+
+	assert(
+		numNodes === change.nodeChanges.size,
+		0xa4d /* Node table contains unparented nodes */,
+	);
+}
+
+/**
+ * Asserts that each child and cross field key in each field has a correct entry in
+ * `nodeToParent` or `crossFieldKeyTable`.
+ * @returns the number of children found.
+ */
+function validateFieldChanges(
+	change: ModularChangeset,
+	fieldChanges: FieldChangeMap,
+	nodeParent: NodeId | undefined,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): number {
+	let numChildren = 0;
+	for (const [field, fieldChange] of fieldChanges.entries()) {
+		const fieldId = { nodeId: nodeParent, field };
+		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+		for (const { nodeId } of handler.getNestedChanges(fieldChange.change)) {
+			const parentFieldId = getParentFieldId(change, nodeId);
+			assert(
+				areEqualFieldIds(parentFieldId, fieldId),
+				0xa4e /* Inconsistent node parentage */,
+			);
+			numChildren += 1;
+		}
+
+		for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
+			const fields = getFieldsForCrossFieldKey(change, keyRange.key, keyRange.count);
+			assert(
+				fields.length === 1 && fields[0] !== undefined && areEqualFieldIds(fields[0], fieldId),
+				0xa4f /* Inconsistent cross field keys */,
+			);
+		}
+	}
+
+	return numChildren;
+}
+
+export function getParentFieldId(changeset: ModularChangeset, nodeId: NodeId): FieldId {
+	const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+	assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
+	return normalizeFieldId(parentId, changeset.nodeAliases);
+}
+
+export function normalizeFieldId(
+	fieldId: FieldId,
+	nodeAliases: ChangeAtomIdBTree<NodeId>,
+): FieldId {
+	return fieldId.nodeId === undefined
+		? fieldId
+		: { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) };
+}
+
+export function getFieldsForCrossFieldKey(
+	changeset: ModularChangeset,
+	key: CrossFieldKey,
+	count: number,
+): FieldId[] {
+	const fieldIds: FieldId[] = [];
+	for (const { value: fieldId } of changeset.crossFieldKeys.getAll(key, count)) {
+		if (fieldId !== undefined) {
+			fieldIds.push(normalizeFieldId(fieldId, changeset.nodeAliases));
+		}
+	}
+
+	return fieldIds;
+}
+
+function areEqualFieldIds(a: FieldId, b: FieldId): boolean {
+	return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
+}

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

@@ -3,16 +3,47 @@
  * Licensed under the MIT License.
  */
 
-import type { FieldKindIdentifier } from "../../core/index.js";
-import { brand } from "../../util/index.js";
+import type { ChangesetLocalId, FieldKindIdentifier, RevisionTag } from "../../core/index.js";
+import { brand, type Mutable } from "../../util/index.js";
 import { setInChangeAtomIdMap, type ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 import type { FlexFieldKind } from "./fieldKind.js";
-import type { FieldChangeMap, NodeChangeset, NodeId } from "./modularChangeTypes.js";
-import { getChangeHandler, nodeChangeFromId } from "./modularChangeUtils.js";
+import type {
+	FieldChangeMap,
+	FieldId,
+	ModularChangeset,
+	NodeChangeset,
+	NodeId,
+} from "./modularChangeTypes.js";
+import { getChangeHandler, nodeChangeFromId, normalizeNodeId } from "./modularChangeUtils.js";
 
-export function pruneFieldMap(
+export function pruneChangeset(
+	changeset: ModularChangeset,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): ModularChangeset {
+	const prunedChangeset: Mutable<ModularChangeset> = {
+		...changeset,
+		nodeChanges: changeset.nodeChanges.clone(),
+		nodeToParent: changeset.nodeToParent.clone(),
+		nodeAliases: changeset.nodeAliases.clone(),
+	};
+
+	prunedChangeset.fieldChanges =
+		pruneFieldMap(
+			prunedChangeset.fieldChanges,
+			prunedChangeset.nodeChanges,
+			prunedChangeset.nodeToParent,
+			prunedChangeset.nodeAliases,
+			fieldKinds,
+		) ?? new Map();
+
+	return prunedChangeset;
+}
+
+function pruneFieldMap(
 	changeset: FieldChangeMap | undefined,
-	nodeMap: ChangeAtomIdBTree<NodeChangeset>,
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	nodeToParent: ChangeAtomIdBTree<FieldId>,
+	nodeAliases: ChangeAtomIdBTree<NodeId>,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): FieldChangeMap | undefined {
 	if (changeset === undefined) {
@@ -24,7 +55,7 @@ export function pruneFieldMap(
 		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
 
 		const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) =>
-			pruneNodeChange(nodeId, nodeMap, fieldKinds),
+			pruneNodeChange(nodeId, nodes, nodeToParent, nodeAliases, fieldKinds),
 		);
 
 		if (!handler.isEmpty(prunedFieldChangeset)) {
@@ -38,24 +69,35 @@ export function pruneFieldMap(
 function pruneNodeChange(
 	nodeId: NodeId,
 	nodeMap: ChangeAtomIdBTree<NodeChangeset>,
+	nodeToParent: ChangeAtomIdBTree<FieldId>,
+	nodeAliases: ChangeAtomIdBTree<NodeId>,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): NodeId | undefined {
 	const changeset = nodeChangeFromId(nodeMap, nodeId);
 	const prunedFields =
 		changeset.fieldChanges === undefined
 			? undefined
-			: pruneFieldMap(changeset.fieldChanges, nodeMap, fieldKinds);
+			: pruneFieldMap(changeset.fieldChanges, nodeMap, nodeToParent, nodeAliases, fieldKinds);
 
 	const prunedChange = { ...changeset, fieldChanges: prunedFields };
 	if (prunedChange.fieldChanges === undefined) {
 		delete prunedChange.fieldChanges;
 	}
 
+	const normalizedNodeId = normalizeNodeId(nodeId, nodeAliases);
 	if (isEmptyNodeChangeset(prunedChange)) {
-		nodeMap.delete([nodeId.revision, nodeId.localId]);
+		const nodeIdKey: [RevisionTag | undefined, ChangesetLocalId] = [
+			normalizedNodeId.revision,
+			normalizedNodeId.localId,
+		];
+
+		nodeMap.delete(nodeIdKey);
+		nodeToParent.delete(nodeIdKey);
+
+		// TODO: Also remove aliases for this node.
 		return undefined;
 	} else {
-		setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
+		setInChangeAtomIdMap(nodeMap, normalizedNodeId, prunedChange);
 		return nodeId;
 	}
 }

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

@@ -46,10 +46,11 @@ import {
 	type NodeId,
 	type RelevantRemovedRootsFromChild,
 	type ToDelta,
-	type NestedChangesIndices,
 	type FieldChangeDelta,
 	FlexFieldKind,
-	type EditFilterFunc,
+	type FilterDetachFunc,
+	type FilterAttachFunc,
+	type ChildChangeInfo,
 } from "../modular-schema/index.js";
 
 import type {
@@ -537,16 +538,6 @@ function areEqualRegisterIds(id1: RegisterId, id2: RegisterId): boolean {
 	return id1 === "self" || id2 === "self" ? id1 === id2 : areEqualChangeAtomIds(id1, id2);
 }
 
-function areEqualRegisterIdsOpt(
-	id1: RegisterId | undefined,
-	id2: RegisterId | undefined,
-): boolean {
-	if (id1 === undefined || id2 === undefined) {
-		return id1 === id2;
-	}
-	return areEqualRegisterIds(id1, id2);
-}
-
 function getBidirectionalMaps(moves: OptionalChangeset["moves"]): {
 	srcToDst: ChangeAtomIdMap<ChangeAtomId>;
 	dstToSrc: ChangeAtomIdMap<ChangeAtomId>;
@@ -738,28 +729,17 @@ export const optionalChangeHandler: FieldChangeHandler<
 	getCrossFieldKeys: (_change) => [],
 };
 
-function getNestedChanges(change: OptionalChangeset): NestedChangesIndices {
-	// True iff the content of the field changes in some way
-	const isFieldContentChanged =
-		change.valueReplace !== undefined && change.valueReplace.src !== "self";
-
-	// The node that is moved into the field (if any).
-	const nodeMovedIntoField = change.valueReplace?.src;
+function getNestedChanges(change: OptionalChangeset): ChildChangeInfo[] {
+	const detachId = change.valueReplace?.dst;
 
 	return change.childChanges.map(([register, nodeId]) => {
-		// The node is removed in the input context iif register is not self.
-		const inputIndex = register === "self" ? 0 : undefined;
-		const outputIndex =
-			register === "self"
-				? // If the node starts out as not-removed, it is removed in the output context iff the field content is changed
-					isFieldContentChanged
-					? undefined
-					: 0
-				: // If the node starts out as removed, then it remains removed in the output context iff it is not the node that is moved into the field
-					areEqualRegisterIdsOpt(register, nodeMovedIntoField)
-					? 0
-					: undefined;
-		return [nodeId, inputIndex, outputIndex];
+		// The node is attached in the input context iif register is self.
+		const inputDetachId = register === "self" ? undefined : register;
+		return {
+			nodeId,
+			inputRootId: inputDetachId,
+			detachId: register === "self" ? detachId : undefined,
+		};
 	});
 }
 
@@ -818,31 +798,39 @@ export const optional: Optional = new FlexFieldKind(
 function filterEdits(
 	change: OptionalChangeset,
 	options: {
-		filterDetach: EditFilterFunc;
-		filterAttach: EditFilterFunc;
+		filterDetach: FilterDetachFunc;
+		filterAttach: FilterAttachFunc;
 		preserveOtherEdits: boolean;
 	},
 ): OptionalChangeset {
 	const filtered: Mutable<OptionalChangeset> = { ...change };
-	if (filtered.valueReplace !== undefined) {
-		if (isReplaceEffectful(filtered.valueReplace)) {
-			const detachId = getEffectfulDst(filtered.valueReplace);
+	if (change.valueReplace !== undefined) {
+		if (isReplaceEffectful(change.valueReplace)) {
+			const detachId = getEffectfulDst(change.valueReplace);
 			const detachResult =
-				detachId === undefined ? undefined : options.filterDetach(detachId, 1).value;
+				detachId === undefined
+					? undefined
+					: options.filterDetach(detachId, 1, undefined).value;
 
-			const attachId = filtered.valueReplace.src;
+			const attachId = change.valueReplace.src;
 			const attachResult =
-				attachId === undefined ? undefined : options.filterAttach(attachId, 1).value;
+				attachId === undefined
+					? undefined
+					: options.filterAttach(attachId, 1, undefined).value.action;
 
-			if (detachResult === EditFilterStatus.Remove) {
+			if (detachResult?.action === EditFilterStatus.Remove) {
 				assert(
 					attachId === undefined || attachResult === EditFilterStatus.Remove,
 					0xd0e /* Cannot remove detach without also removing attach */,
 				);
 
 				delete filtered.valueReplace;
+				if (detachResult.shouldRemoveChild === true) {
+					filtered.childChanges = filtered.childChanges.filter(([id]) => id !== "self");
+				}
 			} else if (attachResult === EditFilterStatus.Remove) {
-				delete filtered.valueReplace.src;
+				filtered.valueReplace = { ...change.valueReplace };
+				delete (filtered.valueReplace as Mutable<Replace>).src;
 			}
 		} else if (!options.preserveOtherEdits) {
 			delete filtered.valueReplace;