@fluidframework/tree 2.81.0-374083 → 2.81.1

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

@@ -5,14 +5,17 @@
 
 import { fail } from "@fluidframework/core-utils/internal";
 
+import type { CodecTree } from "../../codec/index.js";
 import {
-	type ChangeAtomId,
-	type DeltaFieldChanges,
+	type DeltaDetachedNodeId,
 	type FieldKindIdentifier,
 	forbiddenFieldKindIdentifier,
 	Multiplicity,
 } from "../../core/index.js";
+import { brand, type Brand } from "../../util/index.js";
+import { identifierFieldIdentifier } from "../fieldKindIdentifiers.js";
 import {
+	type FieldChangeDelta,
 	type FieldChangeHandler,
 	type FieldEditor,
 	type FieldKindConfiguration,
@@ -22,20 +25,10 @@ import {
 	type ToDelta,
 	referenceFreeFieldChangeRebaser,
 } from "../modular-schema/index.js";
-import {
-	type OptionalChangeset,
-	type OptionalFieldEditor,
-	optionalChangeHandler,
-	optionalFieldEditor,
-} from "../optional-field/index.js";
-import {
-	sequenceFieldChangeHandler,
-	type SequenceFieldEditor,
-} from "../sequence-field/index.js";
+import { optional, required } from "../optional-field/index.js";
+import { sequence } from "../sequence-field/index.js";
 
 import { noChangeCodecFamily } from "./noChangeCodecs.js";
-import type { CodecTree } from "../../codec/index.js";
-import { brand, brandConst, type Brand } from "../../util/index.js";
 
 /**
  * ChangeHandler that only handles no-op / identity changes.
@@ -49,95 +42,30 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 	}),
 	codecsFactory: () => noChangeCodecFamily,
 	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },
-	intoDelta: (change, deltaFromChild: ToDelta): DeltaFieldChanges => [],
+	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
+	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
 	isEmpty: (change: 0) => true,
 	getNestedChanges: (change: 0) => [],
 	createEmpty: () => 0,
 	getCrossFieldKeys: () => [],
 };
 
-/**
- * {@link FieldEditor} for required fields (always contain exactly 1 child).
- * @remarks
- * This shares code with optional fields, since they are the same edit wise except setting to empty is not allowed,
- * and the content is always assumed to not be empty.
- * This means the actual edits implemented for optional fields are sufficient to support required fields
- * which is why this is defined and implemented in terms of optional fields.
- */
-export interface RequiredFieldEditor extends FieldEditor<OptionalChangeset> {
-	/**
-	 * Creates a change which replaces the current value of the field with `newValue`.
-	 * @param ids - The ids for the fill and detach fields.
-	 */
-	set(ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset;
-}
-
-const optionalIdentifier = brandConst("Optional")<FieldKindIdentifier>();
-const requiredIdentifier = brandConst("Value")<FieldKindIdentifier>();
-const sequenceIdentifier = brandConst("Sequence")<FieldKindIdentifier>();
-const identifierFieldIdentifier = brandConst("Identifier")<FieldKindIdentifier>();
-
-/**
- * 0 or 1 items.
- */
-export const optional = new FlexFieldKind(optionalIdentifier, Multiplicity.Optional, {
-	changeHandler: optionalChangeHandler,
-	allowMonotonicUpgradeFrom: new Set([
-		identifierFieldIdentifier,
-		requiredIdentifier,
-		forbiddenFieldKindIdentifier,
-	]),
-});
-
-export const requiredFieldEditor: RequiredFieldEditor = {
-	...optionalFieldEditor,
-	set: (ids: {
-		fill: ChangeAtomId;
-		detach: ChangeAtomId;
-	}): OptionalChangeset => optionalFieldEditor.set(false, ids),
-};
-
-export const requiredFieldChangeHandler: FieldChangeHandler<
-	OptionalChangeset,
-	RequiredFieldEditor
-> = {
-	...optionalChangeHandler,
-	editor: requiredFieldEditor,
-};
-
-/**
- * Exactly one item.
- */
-export const required = new FlexFieldKind(requiredIdentifier, Multiplicity.Single, {
-	changeHandler: requiredFieldChangeHandler,
-	allowMonotonicUpgradeFrom: new Set([identifierFieldIdentifier]),
-});
-
-/**
- * 0 or more items.
- */
-export const sequence = new FlexFieldKind(sequenceIdentifier, Multiplicity.Sequence, {
-	changeHandler: sequenceFieldChangeHandler,
-	allowMonotonicUpgradeFrom: new Set([
-		required.identifier,
-		optional.identifier,
-		identifierFieldIdentifier,
-		forbiddenFieldKindIdentifier,
-	]),
-});
-
 /**
  * Exactly one identifier.
  */
-export const identifier = new FlexFieldKind(identifierFieldIdentifier, Multiplicity.Single, {
-	changeHandler: noChangeHandler,
-	// By omitting required here,
-	// this is making a policy choice that a schema upgrade cannot be done from required to identifier.
-	// Since an identifier can be upgraded into a required field,
-	// preventing the inverse helps ensure that schema upgrades are monotonic.
-	// Which direction is allowed is a subjective policy choice.
-	allowMonotonicUpgradeFrom: new Set([]),
-});
+export const identifier: Identifier = new FlexFieldKind(
+	identifierFieldIdentifier,
+	Multiplicity.Single,
+	{
+		changeHandler: noChangeHandler,
+		// By omitting required here,
+		// this is making a policy choice that a schema upgrade cannot be done from required to identifier.
+		// Since an identifier can be upgraded into a required field,
+		// preventing the inverse helps ensure that schema upgrades are monotonic.
+		// Which direction is allowed is a subjective policy choice.
+		allowMonotonicUpgradeFrom: new Set([]),
+	},
+);
 
 /**
  * Exactly 0 items.
@@ -167,7 +95,7 @@ export const identifier = new FlexFieldKind(identifierFieldIdentifier, Multiplic
  *
  * See {@link emptyField} for a constant, reusable field using Forbidden.
  */
-export const forbidden = new FlexFieldKind(
+export const forbidden: Forbidden = new FlexFieldKind(
 	forbiddenFieldKindIdentifier,
 	Multiplicity.Forbidden,
 	{
@@ -210,19 +138,9 @@ export const fieldKindConfigurations: ReadonlyMap<
 			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
 		]),
 	],
-	[
-		brand(101), // Detached roots
-		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 type ModularChangeFormatVersion = Brand<3 | 4 | 5 | 101, "ModularChangeFormatVersion">;
+export type ModularChangeFormatVersion = Brand<3 | 4 | 5, "ModularChangeFormatVersion">;
 export function getCodecTreeForModularChangeFormat(
 	version: ModularChangeFormatVersion,
 ): CodecTree {
@@ -257,20 +175,6 @@ export const fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind> = new M
 // TODO: Find a way to make docs like {@inheritDoc required} work in vscode.
 // TODO: ensure thy work in generated docs.
 // TODO: add these comments to the rest of the cases below.
-export interface Required
-	extends FlexFieldKind<RequiredFieldEditor, typeof requiredIdentifier, Multiplicity.Single> {}
-export interface Optional
-	extends FlexFieldKind<
-		OptionalFieldEditor,
-		typeof optionalIdentifier,
-		Multiplicity.Optional
-	> {}
-export interface Sequence
-	extends FlexFieldKind<
-		SequenceFieldEditor,
-		typeof sequenceIdentifier,
-		Multiplicity.Sequence
-	> {}
 export interface Identifier
 	extends FlexFieldKind<
 		FieldEditor<0>,
@@ -289,9 +193,9 @@ export interface Forbidden
  */
 export const FieldKinds: {
 	// TODO: inheritDoc for these somehow
-	readonly required: Required;
-	readonly optional: Optional;
-	readonly sequence: Sequence;
+	readonly required: typeof required;
+	readonly optional: typeof optional;
+	readonly sequence: typeof sequence;
 	readonly identifier: Identifier;
 	readonly forbidden: Forbidden;
 } = { required, optional, sequence, identifier, forbidden };

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

@@ -5,11 +5,6 @@
 
 export {
 	FieldKinds,
-	type Required,
-	type Optional,
-	type Sequence,
-	type Identifier,
-	type Forbidden,
 	fieldKinds,
 	fieldKindConfigurations,
 	getCodecTreeForModularChangeFormat,
@@ -19,26 +14,14 @@ export {
 
 export {
 	type DefaultChangeset,
-	type DetachedRootIds,
-	type DetachedRootIdRange,
 	DefaultChangeFamily,
-	type IdBasedChangeFamilyDataEditor,
-	DefaultIdBasedDataEditor,
-	type DataEditor,
-	type RequiredFieldEditor,
-	type OptionalFieldEditor,
-	type SequenceFieldEditor,
+	DefaultEditBuilder,
+	type IDefaultEditBuilder,
+	type ValueFieldEditBuilder,
+	type OptionalFieldEditBuilder,
+	type SequenceFieldEditBuilder,
 	intoDelta,
-	getBuildsIds,
 	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/mappedEditBuilder.ts

@@ -6,45 +6,30 @@
 import type { NormalizedFieldUpPath, NormalizedUpPath } from "../../core/index.js";
 
 import type {
-	DataEditor,
-	OptionalFieldEditor,
-	SequenceFieldEditor,
-	RequiredFieldEditor,
+	IDefaultEditBuilder,
+	OptionalFieldEditBuilder,
+	SequenceFieldEditBuilder,
+	ValueFieldEditBuilder,
 } from "./defaultEditBuilder.js";
 
 /**
  * An IDefaultEditBuilder implementation based on another IDefaultEditBuilder that uses a different content type for insertions.
  */
-export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
-	implements DataEditor<TAdapted, TDetachedRoot, TDetachedRoots>
-{
+export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<TAdapted> {
 	public constructor(
-		private readonly baseBuilder: DataEditor<TBase, TDetachedRoot, TDetachedRoots>,
+		private readonly baseBuilder: IDefaultEditBuilder<TBase>,
 		private readonly mapDelegate: (input: TAdapted) => TBase,
 	) {}
-
-	public buildRoots(content: TAdapted): TDetachedRoots {
-		return this.baseBuilder.buildRoots(this.mapDelegate(content));
-	}
-
-	public valueField(
-		field: NormalizedFieldUpPath,
-	): RequiredFieldEditor<TAdapted, TDetachedRoot> {
+	public valueField(field: NormalizedFieldUpPath): ValueFieldEditBuilder<TAdapted> {
 		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,
-	): OptionalFieldEditor<TAdapted, TDetachedRoot> {
+	public optionalField(field: NormalizedFieldUpPath): OptionalFieldEditBuilder<TAdapted> {
 		const baseField = this.baseBuilder.optionalField(field);
 		return {
 			set: (newContent: TAdapted | undefined, wasEmpty: boolean): void => {
@@ -52,17 +37,9 @@ export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
 					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,
-	): SequenceFieldEditor<TAdapted, TDetachedRoots> {
+	public sequenceField(field: NormalizedFieldUpPath): SequenceFieldEditBuilder<TAdapted> {
 		const baseField = this.baseBuilder.sequenceField(field);
 		return {
 			insert: (index: number, content: TAdapted): void => {
@@ -72,9 +49,6 @@ export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
 			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,19 +7,14 @@ import {
 	type ChangeAtomId,
 	type DeltaDetachedNodeId,
 	type DeltaRoot,
-	makeChangeAtomId,
 	makeDetachedNodeId,
 } from "../core/index.js";
-import { brand, type Mutable } from "../util/index.js";
+import 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/fieldKindIdentifiers.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { FieldKindIdentifier } from "../core/index.js";
+import { brandConst } from "../util/index.js";
+
+// A collection of identifiers for FieldKinds.
+// These are declared before the field kinds that use them are declared to avoid direct (possibly cyclic) dependencies between FieldKinds .
+// Fieldkinds refer to each-other via these identifiers for schema evolution purposes, so without this indirection they would likely form dependency cycles.
+
+export const optionalIdentifier = brandConst("Optional")<FieldKindIdentifier>();
+export const requiredIdentifier = brandConst("Value")<FieldKindIdentifier>();
+export const sequenceIdentifier = brandConst("Sequence")<FieldKindIdentifier>();
+export const identifierFieldIdentifier = brandConst("Identifier")<FieldKindIdentifier>();

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

@@ -51,8 +51,6 @@ export interface FlexTreeContext {
 	 * If true, none of the nodes in this context can be used.
 	 */
 	isDisposed(): boolean;
-
-	runInTransaction(fn: () => void): void;
 }
 
 /**
@@ -68,14 +66,6 @@ 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;
 }
 
 /**
@@ -162,13 +152,6 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 		return this.checkout.storedSchema;
 	}
 
-	public runInTransaction(fn: () => void): void {
-		debugAssert(() => !this.disposed || "Disposed");
-		this.checkout.transaction.start();
-		fn();
-		this.checkout.transaction.commit();
-	}
-
 	/**
 	 * Called before editing.
 	 * Clears all cursors so editing can proceed.

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

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

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

@@ -9,6 +9,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import {
 	type AnchorNode,
 	CursorLocationType,
+	type ExclusiveMapTree,
 	type FieldAnchor,
 	type FieldKey,
 	type FieldKindIdentifier,
@@ -22,24 +23,22 @@ import {
 	rootFieldKey,
 } from "../../core/index.js";
 import { disposeSymbol, getOrCreate } from "../../util/index.js";
+import { combineChunks } from "../chunked-forest/index.js";
 import {
 	FieldKinds,
 	MappedEditBuilder,
-	type SequenceFieldEditor,
-	type RequiredFieldEditor,
-	type DataEditor,
-	type OptionalFieldEditor,
-	type DetachedRootLocation,
-	type DetachedRootsLocation,
+	type IDefaultEditBuilder,
+	type OptionalFieldEditBuilder,
+	type SequenceFieldEditBuilder,
+	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
-import { cursorForMapTreeField, type MinimalMapTreeNodeView } from "../mapTreeCursor.js";
+import { cursorForMapTreeField } 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,
@@ -53,9 +52,8 @@ import {
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
 import { LazyEntity } from "./lazyEntity.js";
-import { LazyTreeNode, getOrCreateHydratedFlexTreeNode } from "./lazyNode.js";
+import { type LazyTreeNode, getOrCreateHydratedFlexTreeNode } from "./lazyNode.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
-import { combineChunks } from "../chunked-forest/index.js";
 
 /**
  * Reuse fields.
@@ -232,30 +230,21 @@ 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...
-			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();
-				}
-			}
+			((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();
 		}
 
-		throw new UsageError(
-			"Editing only allowed on the root field or on fields under nodes with TreeStatus.InDocument or TreeStatus.Removed status",
-		);
+		throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
 	}
 
-	protected getEditor(): DataEditor<
-		ITreeCursorSynchronous,
-		DetachedRootLocation,
-		DetachedRootsLocation
-	> {
+	protected getEditor(): IDefaultEditBuilder<ITreeCursorSynchronous> {
 		return new MappedEditBuilder(
 			this.context.checkout.editor,
 			(cursor: ITreeCursorSynchronous) =>
@@ -264,11 +253,6 @@ 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);
@@ -283,48 +267,32 @@ export class LazySequence extends LazyField implements FlexTreeSequenceField {
 		return this.map((x) => x);
 	}
 
-	public editor: SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]> = {
+	public editor: SequenceFieldEditBuilder<FlexibleFieldContent> = {
 		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(): SequenceFieldEditor<
-		ITreeCursorSynchronous,
-		DetachedRootsLocation
-	> {
+	private sequenceEditor(): SequenceFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		return this.getEditor().sequenceField(fieldPath);
 	}
 }
 
 export class LazyValueField extends LazyField implements FlexTreeRequiredField {
-	public editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
+	public editor: ValueFieldEditBuilder<FlexibleNodeContent> = {
 		set: (newContent) => {
 			this.valueFieldEditor().set(cursorForMapTreeField([newContent]));
 		},
-		attach: (content) => {
-			const root = fieldFromNode(content);
-			this.valueFieldEditor().attach(root);
-		},
 	};
 
-	private valueFieldEditor(): RequiredFieldEditor<
-		ITreeCursorSynchronous,
-		DetachedRootLocation
-	> {
+	private valueFieldEditor(): ValueFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
-		return this.getEditor().valueField(fieldPath);
+		const fieldEditor = this.getEditor().valueField(fieldPath);
+		return fieldEditor;
 	}
 
 	public get content(): FlexTreeUnknownUnboxed {
@@ -333,27 +301,16 @@ export class LazyValueField extends LazyField implements FlexTreeRequiredField {
 }
 
 export class LazyOptionalField extends LazyField implements FlexTreeOptionalField {
-	public editor: OptionalFieldEditor<MinimalMapTreeNodeView, FlexTreeNode> = {
+	public editor: OptionalFieldEditBuilder<ExclusiveMapTree> = {
 		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(): OptionalFieldEditor<ITreeCursorSynchronous, DetachedRootLocation> {
+	private optionalEditor(): OptionalFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.getEditor().optionalField(fieldPath);
 		return fieldEditor;

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

@@ -4,9 +4,11 @@
  */
 
 import { debugAssert } from "@fluidframework/core-utils/internal";
-import type { FlexTreeNode } from "./flexTreeTypes.js";
+
 import type { FieldKey } from "../../core/index.js";
 
+import type { FlexTreeNode } from "./flexTreeTypes.js";
+
 /*
  * This file sets up a static observation tracking system.
  *