@fluidframework/tree 2.83.0 → 2.90.0-378676

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

@@ -7,14 +7,13 @@ import { fail } from "@fluidframework/core-utils/internal";
 
 import type { CodecTree } from "../../codec/index.js";
 import {
-	type DeltaDetachedNodeId,
+	type DeltaFieldChanges,
 	type FieldKindIdentifier,
 	forbiddenFieldKindIdentifier,
 	Multiplicity,
 } from "../../core/index.js";
 import { identifierFieldIdentifier } from "../fieldKindIdentifiers.js";
 import {
-	type FieldChangeDelta,
 	type FieldChangeHandler,
 	type FieldEditor,
 	type FieldKindConfiguration,
@@ -42,12 +41,12 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 	}),
 	codecsFactory: () => noChangeCodecFamily,
 	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },
-	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
-	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
+	intoDelta: (change, deltaFromChild: ToDelta): DeltaFieldChanges => ({ marks: [] }),
 	isEmpty: (change: 0) => true,
 	getNestedChanges: (change: 0) => [],
 	createEmpty: () => 0,
 	getCrossFieldKeys: () => [],
+	getDetachCellIds: () => [],
 };
 
 /**
@@ -138,6 +137,16 @@ export const fieldKindConfigurations: ReadonlyMap<
 			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
 		]),
 	],
+	[
+		ModularChangeFormatVersion.vDetachedRoots,
+		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
+			[required.identifier, { kind: required, formatVersion: 2 }],
+			[optional.identifier, { kind: optional, formatVersion: 3 }],
+			[sequence.identifier, { kind: sequence, formatVersion: 2 }],
+			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
+			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
+		]),
+	],
 ]);
 
 export function getCodecTreeForModularChangeFormat(

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

@@ -13,14 +13,25 @@ export {
 
 export {
 	type DefaultChangeset,
+	type DetachedRootIds,
+	type DetachedRootIdRange,
 	DefaultChangeFamily,
-	DefaultEditBuilder,
-	type IDefaultEditBuilder,
-	type ValueFieldEditBuilder,
-	type OptionalFieldEditBuilder,
-	type SequenceFieldEditBuilder,
+	type IdBasedChangeFamilyDataEditor,
+	DefaultIdBasedDataEditor,
+	type DataEditor,
+	type RequiredFieldEditor,
+	type OptionalFieldEditor,
+	type SequenceFieldEditor,
 	intoDelta,
 	relevantRemovedRoots,
 } from "./defaultEditBuilder.js";
 
+export {
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
+	type Locator,
+	LocationBasedDataEditor,
+	type ILocationBasedDataEditor,
+} from "./locationBasedEditBuilder.js";
+
 export { MappedEditBuilder } from "./mappedEditBuilder.js";

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

@@ -0,0 +1,231 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import {
+	type ChangeAtomId,
+	type FieldKey,
+	type FieldUpPath,
+	type UpPath,
+	type TreeChunk,
+	type NormalizedUpPath,
+	type NormalizedFieldUpPath,
+	rootFieldKey,
+	makeDetachedNodeId,
+	offsetChangeAtomId,
+	type EditorOptions,
+} from "../../core/index.js";
+
+import type {
+	DetachedRootIds,
+	DataEditor,
+	OptionalFieldEditor,
+	RequiredFieldEditor,
+	SequenceFieldEditor,
+} from "./defaultEditBuilder.js";
+
+export type DetachedRootLocation = FieldKey;
+export type DetachedRootsLocation = readonly DetachedRootRangeLocation[];
+export interface DetachedRootRangeLocation {
+	readonly field: FieldKey;
+	readonly count: number;
+}
+
+export interface Locator {
+	locationFromId(id: ChangeAtomId): DetachedRootLocation;
+	idFromLocation(id: DetachedRootLocation): ChangeAtomId;
+	locationsFromIdRanges(id: DetachedRootIds): DetachedRootsLocation;
+	idRangesFromLocations(id: DetachedRootsLocation): DetachedRootIds;
+	isAttachable(id: ChangeAtomId): boolean | undefined;
+}
+
+export type ILocationBasedDataEditor = DataEditor<
+	TreeChunk,
+	DetachedRootLocation,
+	DetachedRootsLocation
+>;
+
+/**
+ * Implementation of {@link DataEditor} based on the default set of supported field kinds.
+ * @sealed
+ */
+export class LocationBasedDataEditor
+	implements DataEditor<TreeChunk, DetachedRootLocation, DetachedRootsLocation>
+{
+	public constructor(
+		private readonly idBasedEditor: DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>,
+		private readonly locator: Locator,
+		private readonly options: EditorOptions,
+	) {}
+
+	public addNodeExistsConstraint(path: UpPath): void {
+		const normal = normalizeUpPath(path, this.locator, this.options);
+		this.idBasedEditor.addNodeExistsConstraint(normal);
+	}
+
+	public addNodeExistsConstraintOnRevert(path: UpPath): void {
+		const normal = normalizeUpPath(path, this.locator, this.options);
+		this.idBasedEditor.addNodeExistsConstraintOnRevert(normal);
+	}
+
+	public addNoChangeConstraint(): void {
+		this.idBasedEditor.addNoChangeConstraint();
+	}
+
+	public addNoChangeConstraintOnRevert(): void {
+		this.idBasedEditor.addNoChangeConstraintOnRevert();
+	}
+
+	public buildRoots(content: TreeChunk): DetachedRootsLocation {
+		const roots = this.idBasedEditor.buildRoots(content);
+		const locations = this.locator.locationsFromIdRanges(roots);
+		return locations;
+	}
+
+	public valueField(field: FieldUpPath): RequiredFieldEditor<TreeChunk, DetachedRootLocation> {
+		const normal = normalizeFieldUpPath(field, this.locator, this.options);
+		const lowLevelEditor = this.idBasedEditor.valueField(normal);
+		const locator = this.locator;
+		const editBuilder = {
+			set: (newContent: TreeChunk): void => {
+				lowLevelEditor.set(newContent);
+			},
+			attach: (newContent: DetachedRootLocation): void => {
+				const changeAtom = locator.idFromLocation(newContent);
+				validateIsAttachable(changeAtom, locator);
+				lowLevelEditor.attach(changeAtom);
+			},
+		};
+		return editBuilder;
+	}
+
+	public optionalField(
+		field: FieldUpPath,
+	): OptionalFieldEditor<TreeChunk, DetachedRootLocation> {
+		const normal = normalizeFieldUpPath(field, this.locator, this.options);
+		const lowLevelEditor = this.idBasedEditor.optionalField(normal);
+		const locator = this.locator;
+		const editBuilder = {
+			set: (newContent: TreeChunk | undefined, wasEmpty: boolean): void => {
+				lowLevelEditor.set(newContent, wasEmpty);
+			},
+			attach: (newContent: DetachedRootLocation | undefined, wasEmpty: boolean): void => {
+				if (newContent === undefined) {
+					editBuilder.clear(wasEmpty);
+					return;
+				}
+				const changeAtom = locator.idFromLocation(newContent);
+				validateIsAttachable(changeAtom, locator);
+				lowLevelEditor.attach(changeAtom, wasEmpty);
+			},
+			clear: (wasEmpty: boolean): void => {
+				lowLevelEditor.clear(wasEmpty);
+			},
+		};
+		return editBuilder;
+	}
+
+	public move(
+		sourceField: FieldUpPath,
+		sourceIndex: number,
+		count: number,
+		destinationField: FieldUpPath,
+		destIndex: number,
+	): void {
+		const normalSource = normalizeFieldUpPath(sourceField, this.locator, this.options);
+		const normalDestination = normalizeFieldUpPath(
+			destinationField,
+			this.locator,
+			this.options,
+		);
+		this.idBasedEditor.move(normalSource, sourceIndex, count, normalDestination, destIndex);
+	}
+
+	public sequenceField(
+		field: FieldUpPath,
+	): SequenceFieldEditor<TreeChunk, DetachedRootsLocation> {
+		const normal = normalizeFieldUpPath(field, this.locator, this.options);
+		const lowLevelEditor = this.idBasedEditor.sequenceField(normal);
+		const locator = this.locator;
+		const editBuilder = {
+			insert: (index: number, content: TreeChunk): void => {
+				lowLevelEditor.insert(index, content);
+			},
+			attach: (index: number, newContent: DetachedRootsLocation): void => {
+				const range = locator.idRangesFromLocations(newContent);
+				validateAreAttachable(range, locator);
+				lowLevelEditor.attach(index, range);
+			},
+			remove: (index: number, count: number): void => {
+				lowLevelEditor.remove(index, count);
+			},
+		};
+		return editBuilder;
+	}
+}
+
+function normalizeUpPath(
+	path: UpPath,
+	locator: Locator,
+	options: EditorOptions,
+): NormalizedUpPath {
+	if (path.parent === undefined) {
+		if (path.parentField === rootFieldKey) {
+			return { ...path, parent: undefined, detachedNodeId: undefined };
+		} else {
+			if (options.enableDetachedRootEditing !== true) {
+				throw new UsageError(
+					`Edits and constraints on detached trees require a minimum version for collaboration >= TBD.`,
+				);
+			}
+			const nodeId = locator.idFromLocation(path.parentField);
+			const detachedNodeId = makeDetachedNodeId(nodeId.revision, nodeId.localId);
+			return { ...path, parent: undefined, detachedNodeId };
+		}
+	} else {
+		return {
+			parent: normalizeUpPath(path.parent, locator, options),
+			parentField: path.parentField,
+			parentIndex: path.parentIndex,
+		};
+	}
+}
+
+function normalizeFieldUpPath(
+	path: FieldUpPath,
+	locator: Locator,
+	options: EditorOptions,
+): NormalizedFieldUpPath {
+	if (path.parent === undefined) {
+		if (path.field === rootFieldKey) {
+			return { parent: undefined, field: rootFieldKey };
+		} else {
+			throw new UsageError(
+				"Editing only allowed on the root field or on fields under nodes with TreeStatus.InDocument or TreeStatus.Removed status",
+			);
+		}
+	} else {
+		return { parent: normalizeUpPath(path.parent, locator, options), field: path.field };
+	}
+}
+
+function validateAreAttachable(nodeIds: DetachedRootIds, locator: Locator): void {
+	for (const idRange of nodeIds) {
+		const baseAtom = idRange.first;
+		for (let idOffset = 0; idOffset < idRange.count; idOffset++) {
+			validateIsAttachable(offsetChangeAtomId(baseAtom, idOffset), locator);
+		}
+	}
+}
+
+function validateIsAttachable(nodeId: ChangeAtomId, locator: Locator): void {
+	const isAttachable = locator.isAttachable(nodeId);
+	if (!(isAttachable ?? false)) {
+		throw new UsageError(
+			`Nodes that may have been detached from a required field can only be re-attached by reverting the detach.`,
+		);
+	}
+}

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

@@ -6,30 +6,45 @@
 import type { NormalizedFieldUpPath, NormalizedUpPath } from "../../core/index.js";
 
 import type {
-	IDefaultEditBuilder,
-	OptionalFieldEditBuilder,
-	SequenceFieldEditBuilder,
-	ValueFieldEditBuilder,
+	DataEditor,
+	OptionalFieldEditor,
+	SequenceFieldEditor,
+	RequiredFieldEditor,
 } from "./defaultEditBuilder.js";
 
 /**
  * An IDefaultEditBuilder implementation based on another IDefaultEditBuilder that uses a different content type for insertions.
  */
-export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<TAdapted> {
+export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
+	implements DataEditor<TAdapted, TDetachedRoot, TDetachedRoots>
+{
 	public constructor(
-		private readonly baseBuilder: IDefaultEditBuilder<TBase>,
+		private readonly baseBuilder: DataEditor<TBase, TDetachedRoot, TDetachedRoots>,
 		private readonly mapDelegate: (input: TAdapted) => TBase,
 	) {}
-	public valueField(field: NormalizedFieldUpPath): ValueFieldEditBuilder<TAdapted> {
+
+	public buildRoots(content: TAdapted): TDetachedRoots {
+		return this.baseBuilder.buildRoots(this.mapDelegate(content));
+	}
+
+	public valueField(
+		field: NormalizedFieldUpPath,
+	): RequiredFieldEditor<TAdapted, TDetachedRoot> {
 		const baseField = this.baseBuilder.valueField(field);
 		return {
 			set: (newContent: TAdapted): void => {
 				const mappedContent = this.mapDelegate(newContent);
 				baseField.set(mappedContent);
 			},
+			attach: (content: TDetachedRoot): void => {
+				baseField.attach(content);
+			},
 		};
 	}
-	public optionalField(field: NormalizedFieldUpPath): OptionalFieldEditBuilder<TAdapted> {
+
+	public optionalField(
+		field: NormalizedFieldUpPath,
+	): OptionalFieldEditor<TAdapted, TDetachedRoot> {
 		const baseField = this.baseBuilder.optionalField(field);
 		return {
 			set: (newContent: TAdapted | undefined, wasEmpty: boolean): void => {
@@ -37,9 +52,17 @@ export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<T
 					newContent === undefined ? undefined : this.mapDelegate(newContent);
 				baseField.set(mappedContent, wasEmpty);
 			},
+			attach: (content, wasEmpty: boolean): void => {
+				baseField.attach(content, wasEmpty);
+			},
+			clear(wasEmpty: boolean): void {
+				baseField.clear(wasEmpty);
+			},
 		};
 	}
-	public sequenceField(field: NormalizedFieldUpPath): SequenceFieldEditBuilder<TAdapted> {
+	public sequenceField(
+		field: NormalizedFieldUpPath,
+	): SequenceFieldEditor<TAdapted, TDetachedRoots> {
 		const baseField = this.baseBuilder.sequenceField(field);
 		return {
 			insert: (index: number, content: TAdapted): void => {
@@ -49,6 +72,9 @@ export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<T
 			remove: (index: number, count: number): void => {
 				baseField.remove(index, count);
 			},
+			attach: (index: number, detachedContent: TDetachedRoots): void => {
+				baseField.attach(index, detachedContent);
+			},
 		};
 	}
 	public move(

package/src/feature-libraries/deltaUtils.ts

@@ -7,14 +7,19 @@ import {
 	type ChangeAtomId,
 	type DeltaDetachedNodeId,
 	type DeltaRoot,
+	makeChangeAtomId,
 	makeDetachedNodeId,
 } from "../core/index.js";
-import type { Mutable } from "../util/index.js";
+import { brand, type Mutable } from "../util/index.js";
 
 export function nodeIdFromChangeAtom(changeAtom: ChangeAtomId): DeltaDetachedNodeId {
 	return makeDetachedNodeId(changeAtom.revision, changeAtom.localId);
 }
 
+export function changeAtomFromDetachedNodeId(changeAtom: DeltaDetachedNodeId): ChangeAtomId {
+	return makeChangeAtomId(brand(changeAtom.minor), changeAtom.major);
+}
+
 /**
  * Converts a `Delta.Root` whose tree content is represented with by `TIn` instances
  * into a `Delta.Root`whose tree content is represented with by `TOut` instances.

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

@@ -51,6 +51,8 @@ export interface FlexTreeContext {
 	 * If true, none of the nodes in this context can be used.
 	 */
 	isDisposed(): boolean;
+
+	runInTransaction(fn: () => void): void;
 }
 
 /**
@@ -66,6 +68,14 @@ export interface FlexTreeHydratedContextMinimal {
 	 * The checkout object associated with this context.
 	 */
 	readonly checkout: ITreeCheckout;
+
+	/**
+	 * Returns a new {@link FlexTreeField} that will live as long as the caller allows up to the next call to {@link clear} or disposal of the context.
+	 * @remarks
+	 * Due to limited support for detached fields, not all operations are supported.
+	 * Additionally if the detached field's content is deleted, the field will become out of schema if it is required: it must not be used after that point.
+	 */
+	detachedField?(key: DetachedField, schema: FieldKindIdentifier): FlexTreeField;
 }
 
 /**
@@ -152,6 +162,13 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 		return this.checkout.storedSchema;
 	}
 
+	public runInTransaction(fn: () => void): void {
+		debugAssert(() => !this.disposed || "Disposed");
+		this.checkout.transaction.start(false);
+		fn();
+		this.checkout.transaction.commit();
+	}
+
 	/**
 	 * Called before editing.
 	 * Clears all cursors so editing can proceed.

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

@@ -14,15 +14,14 @@ import {
 } from "../../core/index.js";
 import type {
 	FieldKinds,
-	SequenceFieldEditBuilder,
-	ValueFieldEditBuilder,
-	OptionalFieldEditBuilder,
+	SequenceFieldEditor,
+	RequiredFieldEditor,
+	OptionalFieldEditor,
 } from "../default-schema/index.js";
 import type {
 	MapTreeFieldViewGeneric,
 	MapTreeNodeViewGeneric,
 	MinimalFieldMap,
-	MinimalMapTreeNodeView,
 } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 
@@ -309,7 +308,7 @@ export type FlexibleFieldContent = readonly FlexibleNodeContent[];
 /**
  * Tree for inserting as a node.
  */
-export type FlexibleNodeContent = MinimalMapTreeNodeView;
+export type FlexibleNodeContent = FlexTreeNode;
 
 /**
  * {@link FlexTreeField} that stores a sequence of children.
@@ -354,7 +353,7 @@ export interface FlexTreeSequenceField extends FlexTreeField {
 	/**
 	 * Get an editor for this sequence.
 	 */
-	readonly editor: SequenceFieldEditBuilder<FlexibleFieldContent>;
+	readonly editor: SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]>;
 }
 
 /**
@@ -366,7 +365,7 @@ export interface FlexTreeSequenceField extends FlexTreeField {
 export interface FlexTreeRequiredField extends FlexTreeField {
 	get content(): FlexTreeUnknownUnboxed;
 
-	readonly editor: ValueFieldEditBuilder<FlexibleNodeContent>;
+	readonly editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode>;
 }
 
 /**
@@ -385,7 +384,7 @@ export interface FlexTreeRequiredField extends FlexTreeField {
 export interface FlexTreeOptionalField extends FlexTreeField {
 	get content(): FlexTreeUnknownUnboxed | undefined;
 
-	readonly editor: OptionalFieldEditBuilder<FlexibleNodeContent>;
+	readonly editor: OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode>;
 }
 
 // #endregion

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

@@ -9,7 +9,6 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import {
 	type AnchorNode,
 	CursorLocationType,
-	type ExclusiveMapTree,
 	type FieldAnchor,
 	type FieldKey,
 	type FieldKindIdentifier,
@@ -27,18 +26,21 @@ import { combineChunks } from "../chunked-forest/index.js";
 import {
 	FieldKinds,
 	MappedEditBuilder,
-	type IDefaultEditBuilder,
-	type OptionalFieldEditBuilder,
-	type SequenceFieldEditBuilder,
-	type ValueFieldEditBuilder,
+	type SequenceFieldEditor,
+	type RequiredFieldEditor,
+	type DataEditor,
+	type OptionalFieldEditor,
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
 } from "../default-schema/index.js";
-import { cursorForMapTreeField } from "../mapTreeCursor.js";
+import { cursorForMapTreeField, type MinimalMapTreeNodeView } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 
 import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
+	type FlexTreeNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
@@ -52,7 +54,7 @@ import {
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
 import { LazyEntity } from "./lazyEntity.js";
-import { type LazyTreeNode, getOrCreateHydratedFlexTreeNode } from "./lazyNode.js";
+import { LazyTreeNode, getOrCreateHydratedFlexTreeNode } from "./lazyNode.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 
 /**
@@ -230,21 +232,28 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 	 * This path is not valid to hold onto across edits: this must be recalled for each edit.
 	 */
 	public getFieldPathForEditing(): NormalizedFieldUpPath {
-		if (
-			!this.isFreed() &&
+		if (!this.isFreed()) {
 			// Only allow editing if we are the root document field...
-			((this.parent === undefined && this.anchor.fieldKey === rootFieldKey) ||
-				// ...or are under a node in the document
-				(this.parent !== undefined &&
-					treeStatusFromAnchorCache(this.parent.anchorNode) === TreeStatus.InDocument))
-		) {
-			return this.getFieldPath();
+			if (this.parent === undefined && this.anchor.fieldKey === rootFieldKey) {
+				return this.getFieldPath();
+			}
+			// ...or are under a node in the document
+			if (this.parent !== undefined) {
+				const status = treeStatusFromAnchorCache(this.parent.anchorNode);
+				if (status === TreeStatus.InDocument || status === TreeStatus.Removed) {
+					return this.getFieldPath();
+				}
+			}
 		}
 
 		throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
 	}
 
-	protected getEditor(): IDefaultEditBuilder<ITreeCursorSynchronous> {
+	protected getEditor(): DataEditor<
+		ITreeCursorSynchronous,
+		DetachedRootLocation,
+		DetachedRootsLocation
+	> {
 		return new MappedEditBuilder(
 			this.context.checkout.editor,
 			(cursor: ITreeCursorSynchronous) =>
@@ -253,6 +262,11 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 	}
 }
 
+function fieldFromNode(node: FlexTreeNode): FieldKey {
+	assert(node instanceof LazyTreeNode, "Invalid tree type");
+	return node.anchorNode.parentField;
+}
+
 export class LazySequence extends LazyField implements FlexTreeSequenceField {
 	public at(index: number): FlexTreeUnknownUnboxed | undefined {
 		const finalIndex = indexForAt(index, this.length);
@@ -267,32 +281,48 @@ export class LazySequence extends LazyField implements FlexTreeSequenceField {
 		return this.map((x) => x);
 	}
 
-	public editor: SequenceFieldEditBuilder<FlexibleFieldContent> = {
+	public editor: SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]> = {
 		insert: (index, newContent) => {
 			this.sequenceEditor().insert(index, cursorForMapTreeField(newContent));
 		},
 		remove: (index, count) => {
 			this.sequenceEditor().remove(index, count);
 		},
+		attach: (index, content) => {
+			const contentLocations: DetachedRootsLocation = content.map((node) => ({
+				field: fieldFromNode(node),
+				count: 1,
+			}));
+			this.sequenceEditor().attach(index, contentLocations);
+		},
 	};
 
-	private sequenceEditor(): SequenceFieldEditBuilder<ITreeCursorSynchronous> {
+	private sequenceEditor(): SequenceFieldEditor<
+		ITreeCursorSynchronous,
+		DetachedRootsLocation
+	> {
 		const fieldPath = this.getFieldPathForEditing();
 		return this.getEditor().sequenceField(fieldPath);
 	}
 }
 
 export class LazyValueField extends LazyField implements FlexTreeRequiredField {
-	public editor: ValueFieldEditBuilder<FlexibleNodeContent> = {
+	public editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
 		set: (newContent) => {
 			this.valueFieldEditor().set(cursorForMapTreeField([newContent]));
 		},
+		attach: (content) => {
+			const root = fieldFromNode(content);
+			this.valueFieldEditor().attach(root);
+		},
 	};
 
-	private valueFieldEditor(): ValueFieldEditBuilder<ITreeCursorSynchronous> {
+	private valueFieldEditor(): RequiredFieldEditor<
+		ITreeCursorSynchronous,
+		DetachedRootLocation
+	> {
 		const fieldPath = this.getFieldPathForEditing();
-		const fieldEditor = this.getEditor().valueField(fieldPath);
-		return fieldEditor;
+		return this.getEditor().valueField(fieldPath);
 	}
 
 	public get content(): FlexTreeUnknownUnboxed {
@@ -301,16 +331,27 @@ export class LazyValueField extends LazyField implements FlexTreeRequiredField {
 }
 
 export class LazyOptionalField extends LazyField implements FlexTreeOptionalField {
-	public editor: OptionalFieldEditBuilder<ExclusiveMapTree> = {
+	public editor: OptionalFieldEditor<MinimalMapTreeNodeView, FlexTreeNode> = {
 		set: (newContent, wasEmpty) => {
 			this.optionalEditor().set(
 				newContent === undefined ? newContent : cursorForMapTreeField([newContent]),
 				wasEmpty,
 			);
 		},
+		attach: (content, wasEmpty) => {
+			if (content === undefined) {
+				this.optionalEditor().clear(wasEmpty);
+			} else {
+				const root = fieldFromNode(content);
+				this.optionalEditor().attach(root, wasEmpty);
+			}
+		},
+		clear: (wasEmpty) => {
+			this.optionalEditor().clear(wasEmpty);
+		},
 	};
 
-	private optionalEditor(): OptionalFieldEditBuilder<ITreeCursorSynchronous> {
+	private optionalEditor(): OptionalFieldEditor<ITreeCursorSynchronous, DetachedRootLocation> {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.getEditor().optionalField(fieldPath);
 		return fieldEditor;