@fluidframework/tree 2.73.0 → 2.74.0-368706

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -12,6 +12,7 @@ import {
 	type ChangeFamily,
 	type ChangeRebaser,
 	type DeltaDetachedNodeId,
+	type EditorOptions,
 	type RevisionMetadataSource,
 	type RevisionTag,
 	type RevisionTagCodec,
@@ -23,7 +24,7 @@ import {
 	ModularChangeFamily,
 	type ModularChangeset,
 	type TreeChunk,
-	type TreeCompressionStrategyPrivate,
+	type TreeCompressionStrategy,
 	fieldKindConfigurations,
 	fieldKinds,
 	makeModularChangeCodecFamily,
@@ -38,7 +39,7 @@ import {
 
 import { makeSharedTreeChangeCodecFamily } from "./sharedTreeChangeCodecs.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import { IdBasedSharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 
 /**
  * Implementation of {@link ChangeFamily} that combines edits to fields and schema changes.
@@ -47,7 +48,7 @@ import { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
  */
 export class SharedTreeChangeFamily
 	implements
-		ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>,
+		ChangeFamily<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
 		ChangeRebaser<SharedTreeChange>
 {
 	public static readonly emptyChange: SharedTreeChange = {
@@ -61,7 +62,7 @@ export class SharedTreeChangeFamily
 		revisionTagCodec: RevisionTagCodec,
 		fieldBatchCodec: FieldBatchCodec,
 		codecOptions: CodecWriteOptions,
-		chunkCompressionStrategy?: TreeCompressionStrategyPrivate,
+		chunkCompressionStrategy?: TreeCompressionStrategy,
 		private readonly idCompressor?: IIdCompressor,
 	) {
 		const modularChangeCodec = makeModularChangeCodecFamily(
@@ -81,11 +82,13 @@ export class SharedTreeChangeFamily
 	public buildEditor(
 		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<SharedTreeChange>) => void,
-	): SharedTreeEditBuilder {
-		return new SharedTreeEditBuilder(
+		options?: EditorOptions,
+	): IdBasedSharedTreeEditBuilder {
+		return new IdBasedSharedTreeEditBuilder(
 			this.modularChangeFamily,
 			mintRevisionTag,
 			changeReceiver,
+			options,
 		);
 	}
 

package/src/shared-tree/sharedTreeEditBuilder.ts

@@ -4,14 +4,22 @@
  */
 
 import type {
+	ChangeAtomId,
 	ChangeFamilyEditor,
+	EditorOptions,
 	RevisionTag,
 	TaggedChange,
+	TreeChunk,
 	TreeStoredSchema,
 } from "../core/index.js";
 import {
-	DefaultEditBuilder,
-	type IDefaultEditBuilder,
+	DefaultIdBasedDataEditor,
+	LocationBasedDataEditor,
+	type DetachedRootIds,
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
+	type Locator,
+	type DataEditor,
 	type ModularChangeFamily,
 } from "../feature-libraries/index.js";
 
@@ -33,7 +41,16 @@ export interface ISchemaEditor {
 /**
  * SharedTree editor for transactional tree data and schema changes.
  */
-export interface ISharedTreeEditor extends IDefaultEditBuilder {
+export interface IIdBasedSharedTreeEditor
+	extends DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds> {
+	/**
+	 * Editor for schema changes.
+	 */
+	schema: ISchemaEditor;
+}
+
+export interface ILocationBasedSharedTreeEditor
+	extends DataEditor<TreeChunk, DetachedRootLocation, DetachedRootsLocation> {
 	/**
 	 * Editor for schema changes.
 	 */
@@ -41,12 +58,12 @@ export interface ISharedTreeEditor extends IDefaultEditBuilder {
 }
 
 /**
- * Implementation of {@link IDefaultEditBuilder} based on the default set of supported field kinds.
+ * Implementation of {@link DataEditor} based on the default set of supported field kinds.
  * @sealed
  */
-export class SharedTreeEditBuilder
-	extends DefaultEditBuilder
-	implements ChangeFamilyEditor, ISharedTreeEditor
+export class IdBasedSharedTreeEditBuilder
+	extends DefaultIdBasedDataEditor
+	implements ChangeFamilyEditor, IIdBasedSharedTreeEditor
 {
 	public readonly schema: ISchemaEditor;
 
@@ -54,12 +71,17 @@ export class SharedTreeEditBuilder
 		modularChangeFamily: ModularChangeFamily,
 		mintRevisionTag: () => RevisionTag,
 		private readonly changeReceiver: (change: TaggedChange<SharedTreeChange>) => void,
+		options?: EditorOptions,
 	) {
-		super(modularChangeFamily, mintRevisionTag, (taggedChange) =>
-			changeReceiver({
-				...taggedChange,
-				change: { changes: [{ type: "data", innerChange: taggedChange.change }] },
-			}),
+		super(
+			modularChangeFamily,
+			mintRevisionTag,
+			(taggedChange) =>
+				changeReceiver({
+					...taggedChange,
+					change: { changes: [{ type: "data", innerChange: taggedChange.change }] },
+				}),
+			options,
 		);
 
 		this.schema = {
@@ -82,3 +104,15 @@ export class SharedTreeEditBuilder
 		};
 	}
 }
+
+export class LocationBasedSharedTreeEditBuilder
+	extends LocationBasedDataEditor
+	implements ILocationBasedSharedTreeEditor
+{
+	public readonly schema: ISchemaEditor;
+
+	public constructor(idBasedEditor: IIdBasedSharedTreeEditor, locator: Locator) {
+		super(idBasedEditor, locator);
+		this.schema = idBasedEditor.schema;
+	}
+}

package/src/shared-tree/treeAlpha.ts

@@ -50,8 +50,6 @@ import {
 	isObjectNodeSchema,
 	isTreeNode,
 	toInitialSchema,
-	convertField,
-	toUnhydratedSchema,
 	type TreeParsingOptions,
 	type NodeChangedData,
 	type ConciseTree,
@@ -60,6 +58,7 @@ import {
 	borrowCursorFromTreeNodeOrValue,
 	contentSchemaSymbol,
 	type TreeNodeSchema,
+	getUnhydratedContext,
 } from "../simple-tree/index.js";
 import { brand, extractFromOpaque, type JsonCompatible } from "../util/index.js";
 import {
@@ -824,7 +823,7 @@ export const TreeAlpha: TreeAlpha = {
 		return createFromCursor(
 			schema,
 			cursor,
-			convertField(normalizeFieldSchema(schema), toUnhydratedSchema),
+			getUnhydratedContext(schema).flexContext.schema.rootFieldSchema,
 		);
 	},
 

package/src/shared-tree/treeCheckout.ts

@@ -47,18 +47,27 @@ import {
 	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	LeafNodeStoredSchema,
+	type ChangeAtomId,
+	offsetChangeAtomId,
 	diffHistories,
+	type ReadOnlyDetachedFieldIndex,
 } from "../core/index.js";
 import {
+	type DetachedRootIds,
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
 	type FieldBatchCodec,
-	type TreeCompressionStrategyPrivate,
+	type Locator,
+	type TreeCompressionStrategy,
 	allowsRepoSuperset,
 	buildForest,
+	changeAtomFromDetachedNodeId,
 	createNodeIdentifierManager,
 	defaultSchemaPolicy,
 	intoDelta,
 	jsonableTreeFromCursor,
 	makeFieldBatchCodec,
+	nodeIdFromChangeAtom,
 } from "../feature-libraries/index.js";
 import {
 	SquashingTransactionStack,
@@ -68,11 +77,22 @@ import {
 	type SharedTreeBranchChange,
 	type Transactor,
 } from "../shared-tree-core/index.js";
-import { Breakable, disposeSymbol, getOrCreate, type WithBreakable } from "../util/index.js";
+import {
+	Breakable,
+	disposeSymbol,
+	getOrCreate,
+	makeArray,
+	type WithBreakable,
+} from "../util/index.js";
 
 import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import type { ISharedTreeEditor, SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import {
+	type IdBasedSharedTreeEditBuilder,
+	type ILocationBasedSharedTreeEditor,
+	type IIdBasedSharedTreeEditor,
+	LocationBasedSharedTreeEditBuilder,
+} from "./sharedTreeEditBuilder.js";
 import type { IDisposable } from "@fluidframework/core-interfaces";
 import {
 	type ImplicitFieldSchema,
@@ -223,7 +243,7 @@ export interface ITreeCheckout extends AnchorLocator, ViewableTree, WithBreakabl
 	 * Used to edit the state of the tree. Edits will be immediately applied locally to the tree.
 	 * If there is no transaction currently ongoing, then the edits will be submitted to Fluid immediately as well.
 	 */
-	readonly editor: ISharedTreeEditor;
+	readonly editor: ILocationBasedSharedTreeEditor;
 
 	/**
 	 * A collection of functions for managing transactions.
@@ -281,13 +301,13 @@ export function createTreeCheckout(
 	mintRevisionTag: () => RevisionTag,
 	revisionTagCodec: RevisionTagCodec,
 	args?: {
-		branch?: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>;
-		changeFamily?: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>;
+		branch?: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
+		changeFamily?: ChangeFamily<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
 		schema?: TreeStoredSchemaRepository;
 		forest?: IEditableForest;
 		fieldBatchCodec?: FieldBatchCodec;
 		removedRoots?: DetachedFieldIndex;
-		chunkCompressionStrategy?: TreeCompressionStrategyPrivate;
+		chunkCompressionStrategy?: TreeCompressionStrategy;
 		logger?: ITelemetryLoggerExt;
 		breaker?: Breakable;
 		disposeForksAfterTransaction?: boolean;
@@ -369,6 +389,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public disposed = false;
 
 	private editLock: EditLock;
+	private readonly locator: Locator;
 
 	private readonly views = new Set<TreeView<ImplicitFieldSchema>>();
 
@@ -384,7 +405,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 */
 	private readonly revertibleCommitBranches = new Map<
 		RevisionTag,
-		SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>
+		SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>
 	>();
 
 	/**
@@ -397,16 +418,19 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public events: Listenable<CheckoutEvents> = this.#events;
 
 	public constructor(
-		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
 		/** True if and only if this checkout is for a branch which is persisted and shared with other clients. */
 		public readonly isSharedBranch: boolean,
-		private readonly changeFamily: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>,
+		private readonly changeFamily: ChangeFamily<
+			IdBasedSharedTreeEditBuilder,
+			SharedTreeChange
+		>,
 		public readonly storedSchema: TreeStoredSchemaRepository,
 		public readonly forest: IEditableForest,
 		private readonly mintRevisionTag: () => RevisionTag,
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly idCompressor: IIdCompressor,
-		public removedRoots: DetachedFieldIndex = makeDetachedFieldIndex(
+		private readonly _removedRoots: DetachedFieldIndex = makeDetachedFieldIndex(
 			"repair",
 			revisionTagCodec,
 			idCompressor,
@@ -418,9 +442,38 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	) {
 		this.#transaction = this.createTransactionStack(branch);
 		this.editLock = new EditLock(this.#transaction.activeBranchEditor);
+		this.locator = {
+			locationFromId: (id: ChangeAtomId): DetachedRootLocation => {
+				const rootId = this.removedRoots.getEntry(nodeIdFromChangeAtom(id));
+				return this.removedRoots.toFieldKey(rootId);
+			},
+			idFromLocation: (location: DetachedRootLocation): ChangeAtomId => {
+				const nodeId = this.removedRoots.fromFieldKey(location);
+				return changeAtomFromDetachedNodeId(nodeId);
+			},
+			locationsFromIdRanges: (ids: DetachedRootIds): DetachedRootsLocation => {
+				return ids.flatMap((id) => {
+					return makeArray(id.count, (offset) => {
+						const field = this.locator.locationFromId(offsetChangeAtomId(id.first, offset));
+						return { field, count: 1 };
+					});
+				});
+			},
+			idRangesFromLocations: (ids: DetachedRootsLocation): DetachedRootIds => {
+				return ids.map((id) => {
+					assert(id.count === 1, "Expected count of 1");
+					const first = this.locator.idFromLocation(id.field);
+					return { first, count: id.count };
+				});
+			},
+		};
 		this.registerForBranchEvents();
 	}
 
+	public get removedRoots(): ReadOnlyDetachedFieldIndex {
+		return this._removedRoots;
+	}
+
 	private registerForBranchEvents(): void {
 		this.#transaction.branch.events.on("afterChange", this.onAfterBranchChange);
 		this.#transaction.activeBranchEvents.on("afterChange", this.onAfterChange);
@@ -434,14 +487,14 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	private createTransactionStack(
-		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
-	): SquashingTransactionStack<SharedTreeEditBuilder, SharedTreeChange> {
+		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
+	): SquashingTransactionStack<IdBasedSharedTreeEditBuilder, SharedTreeChange> {
 		return new SquashingTransactionStack(
 			branch,
 			(commits) => {
 				const revision = this.mintRevisionTag();
 				for (const transactionStep of commits) {
-					this.removedRoots.updateMajor(transactionStep.revision, revision);
+					this._removedRoots.updateMajor(transactionStep.revision, revision);
 				}
 
 				const squashedChange = this.changeFamily.rebaser.compose(commits);
@@ -452,12 +505,12 @@ export class TreeCheckout implements ITreeCheckoutFork {
 				const disposeForks = this.disposeForksAfterTransaction
 					? trackForksForDisposal(this)
 					: undefined;
-				// When each transaction is started, take a snapshot of the current state of removed roots
-				const removedRootsSnapshot = this.removedRoots.clone();
+				// When each transaction is started, make a restorable checkpoint of the current state of removed roots
+				const restoreRemovedRoots = this._removedRoots.createCheckpoint();
 				return (result) => {
 					switch (result) {
 						case TransactionResult.Abort:
-							this.removedRoots = removedRootsSnapshot;
+							restoreRemovedRoots();
 							break;
 						case TransactionResult.Commit:
 							if (!this.transaction.isInProgress()) {
@@ -566,7 +619,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			if (innerChange.type === "data") {
 				const delta = intoDelta(tagChange(innerChange.innerChange, revision));
 				this.withCombinedVisitor((visitor) => {
-					visitDelta(delta, visitor, this.removedRoots, revision);
+					visitDelta(delta, visitor, this._removedRoots, revision);
 				});
 			} else if (innerChange.type === "schema") {
 				// Schema changes from a current to a new schema are expected to be backwards compatible.
@@ -597,14 +650,14 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		this.withCombinedVisitor((visitor) => {
 			revisions.forEach((revision) => {
 				// get all the roots last created or used by the revision
-				const roots = this.removedRoots.getRootsLastTouchedByRevision(revision);
+				const roots = this._removedRoots.getRootsLastTouchedByRevision(revision);
 
 				// get the detached field for the root and delete it from the removed roots
 				for (const root of roots) {
-					visitor.destroy(this.removedRoots.toFieldKey(root), 1);
+					visitor.destroy(this._removedRoots.toFieldKey(root), 1);
 				}
 
-				this.removedRoots.deleteRootsLastTouchedByRevision(revision);
+				this._removedRoots.deleteRootsLastTouchedByRevision(revision);
 			});
 		});
 	};
@@ -731,9 +784,9 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		return this.forest.anchors.events;
 	}
 
-	public get editor(): ISharedTreeEditor {
+	public get editor(): ILocationBasedSharedTreeEditor {
 		this.checkNotDisposed();
-		return this.editLock.editor;
+		return new LocationBasedSharedTreeEditBuilder(this.editLock.editor, this.locator);
 	}
 
 	public locate(anchor: Anchor): AnchorNode | undefined {
@@ -754,7 +807,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 * To avoid updating observers of the view state with intermediate results during a transaction,
 	 * use {@link ITreeCheckout#branch} and {@link ISharedTreeFork#merge}.
 	 */
-	#transaction: SquashingTransactionStack<SharedTreeEditBuilder, SharedTreeChange>;
+	#transaction: SquashingTransactionStack<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
 
 	public branch(): TreeCheckout {
 		this.checkNotDisposed(
@@ -774,7 +827,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			this.mintRevisionTag,
 			this.revisionTagCodec,
 			this.idCompressor,
-			this.removedRoots.clone(),
+			this._removedRoots.clone(),
 			this.logger,
 			this.breaker,
 			this.disposeForksAfterTransaction,
@@ -784,7 +837,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	public switchBranch(
-		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
 	): void {
 		// TODO: Dispose old branch, if necessary
 		assert(
@@ -894,8 +947,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		this.assertNoUntrackedRoots();
 		const trees: [string | number | undefined, number, JsonableTree][] = [];
 		const cursor = this.forest.allocateCursor("getRemovedRoots");
-		for (const { id, root } of this.removedRoots.entries()) {
-			const parentField = this.removedRoots.toFieldKey(root);
+		for (const { id, root } of this._removedRoots.entries()) {
+			const parentField = this._removedRoots.toFieldKey(root);
 			this.forest.moveCursorToPath({ parent: undefined, parentField, parentIndex: 0 }, cursor);
 			const tree = jsonableTreeFromCursor(cursor);
 			// This method is used for tree consistency comparison.
@@ -915,7 +968,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public load(): void {
 		// Set the tip revision as the latest relevant revision for any removed roots that are loaded from a summary - this allows them to be garbage collected later.
 		// When a load happens, the head of the trunk and the head of the local/main branch must be the same (this is enforced by SharedTree).
-		this.removedRoots.setRevisionsForLoadedData(this.#transaction.branch.getHead().revision);
+		this._removedRoots.setRevisionsForLoadedData(this.#transaction.branch.getHead().revision);
 		// The content of the checkout (e.g. the forest) has (maybe) changed, so fire an afterBatch event.
 		this.#events.emit("afterBatch");
 	}
@@ -987,8 +1040,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	private assertNoUntrackedRoots(): void {
 		const cursor = this.forest.getCursorAboveDetachedFields();
 		const rootFields = new Set([rootFieldKey]);
-		for (const { root } of this.removedRoots.entries()) {
-			rootFields.add(this.removedRoots.toFieldKey(root));
+		for (const { root } of this._removedRoots.entries()) {
+			rootFields.add(this._removedRoots.toFieldKey(root));
 		}
 
 		if (!cursor.firstField()) {
@@ -1070,19 +1123,23 @@ class EditLock {
 	 * Edits the tree by calling the methods of the editor passed into the {@link EditLock} constructor.
 	 * @remarks Edits will throw an error if the lock is currently locked.
 	 */
-	public readonly editor: ISharedTreeEditor;
+	public readonly editor: IIdBasedSharedTreeEditor;
 	private locked = false;
 
 	/**
 	 * @param editor - an editor which will be used to create a new editor that is monitored to determine if any changes are happening to the tree.
 	 * Use {@link EditLock.editor} in place of the original editor to ensure that changes are monitored.
 	 */
-	public constructor(editor: ISharedTreeEditor) {
+	public constructor(editor: IIdBasedSharedTreeEditor) {
 		const checkLock = (): void => this.checkUnlocked("Editing the tree");
 		this.editor = {
 			get schema() {
 				return editor.schema;
 			},
+			buildRoots(unhydrated) {
+				checkLock();
+				return editor.buildRoots(unhydrated);
+			},
 			valueField(...fieldArgs) {
 				const valueField = editor.valueField(...fieldArgs);
 				return {
@@ -1090,6 +1147,10 @@ class EditLock {
 						checkLock();
 						valueField.set(...editArgs);
 					},
+					attach(...editArgs) {
+						checkLock();
+						valueField.attach(...editArgs);
+					},
 				};
 			},
 			optionalField(...fieldArgs) {
@@ -1099,6 +1160,14 @@ class EditLock {
 						checkLock();
 						optionalField.set(...editArgs);
 					},
+					attach(...editArgs) {
+						checkLock();
+						optionalField.attach(...editArgs);
+					},
+					clear(...editArgs) {
+						checkLock();
+						optionalField.clear(...editArgs);
+					},
 				};
 			},
 			sequenceField(...fieldArgs) {
@@ -1108,6 +1177,10 @@ class EditLock {
 						checkLock();
 						sequenceField.insert(...editArgs);
 					},
+					attach(...editArgs) {
+						checkLock();
+						sequenceField.attach(...editArgs);
+					},
 					remove(...editArgs) {
 						checkLock();
 						sequenceField.remove(...editArgs);

package/src/shared-tree-core/branch.ts

@@ -22,6 +22,7 @@ import {
 	rebaseBranch,
 	tagRollbackInverse,
 	type RebaseStatsWithDuration,
+	type EditorOptions,
 } from "../core/index.js";
 import { hasSome, defineLazyCachedProperty } from "../util/index.js";
 import type {
@@ -128,9 +129,12 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		private readonly telemetryEventBatcher?: TelemetryEventBatcher<
 			keyof RebaseStatsWithDuration
 		>,
+		private readonly editorOptions?: EditorOptions,
 	) {
-		this.editor = this.changeFamily.buildEditor(mintRevisionTag, (change) =>
-			this.apply(change),
+		this.editor = this.changeFamily.buildEditor(
+			mintRevisionTag,
+			(change) => this.apply(change),
+			this.editorOptions,
 		);
 		this.unsubscribeBranchTrimmer = branchTrimmer?.on("ancestryTrimmed", (commit) => {
 			this.#events.emit("ancestryTrimmed", commit);
@@ -196,6 +200,8 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 			this.changeFamily,
 			this.mintRevisionTag,
 			this.branchTrimmer,
+			undefined,
+			this.editorOptions,
 		);
 		this.#events.emit("fork", fork);
 		return fork;

package/src/shared-tree-core/editManager.ts

@@ -18,6 +18,7 @@ import {
 	mintCommit,
 	type RebaseStatsWithDuration,
 	tagChange,
+	type EditorOptions,
 } from "../core/index.js";
 import { type Mutable, brand, getOrCreate, mapIterable } from "../util/index.js";
 
@@ -123,6 +124,7 @@ export class EditManager<
 		public readonly localSessionId: SessionId,
 		private readonly mintRevisionTag: () => RevisionTag,
 		private readonly onSharedBranchCreated?: (branchId: BranchId) => void,
+		editorOptions?: EditorOptions,
 		logger?: ITelemetryLoggerExt,
 	) {
 		this.trunkBase = {
@@ -147,9 +149,10 @@ export class EditManager<
 			mintRevisionTag,
 			this._events,
 			this.telemetryEventBatcher,
+			editorOptions,
 		);
 
-		this.createAndAddSharedBranch("main", undefined, undefined, mainTrunk);
+		this.createAndAddSharedBranch("main", undefined, undefined, mainTrunk, editorOptions);
 	}
 
 	public getLocalBranch(branchId: BranchId): SharedTreeBranch<TEditor, TChangeset> {
@@ -480,8 +483,15 @@ export class EditManager<
 		sessionId: SessionId | undefined,
 		parent: SharedBranch<TEditor, TChangeset> | undefined,
 		branch: SharedTreeBranch<TEditor, TChangeset>,
+		editorOptions?: EditorOptions,
 	): SharedBranch<TEditor, TChangeset> {
-		const sharedBranch = this.createSharedBranch(branchId, sessionId, parent, branch);
+		const sharedBranch = this.createSharedBranch(
+			branchId,
+			sessionId,
+			parent,
+			branch,
+			editorOptions,
+		);
 		this.addSharedBranch(branchId, sharedBranch);
 		return sharedBranch;
 	}
@@ -512,6 +522,7 @@ export class EditManager<
 		sessionId: SessionId | undefined,
 		parent: SharedBranch<TEditor, TChangeset> | undefined,
 		branch: SharedTreeBranch<TEditor, TChangeset>,
+		editorOptions?: EditorOptions,
 	): SharedBranch<TEditor, TChangeset> {
 		const sharedBranch = new SharedBranch(
 			parent,
@@ -523,6 +534,7 @@ export class EditManager<
 			this.mintRevisionTag,
 			this._events,
 			this.telemetryEventBatcher,
+			editorOptions,
 		);
 
 		return sharedBranch;
@@ -695,6 +707,7 @@ class SharedBranch<TEditor extends ChangeFamilyEditor, TChangeset> {
 		private readonly mintRevisionTag: () => RevisionTag,
 		branchTrimmer: Listenable<BranchTrimmingEvents>,
 		telemetryEventBatcher: TelemetryEventBatcher<keyof RebaseStatsWithDuration> | undefined,
+		editorOptions?: EditorOptions,
 	) {
 		this.localBranch = new SharedTreeBranch(
 			this.trunk.getHead(),
@@ -702,6 +715,7 @@ class SharedBranch<TEditor extends ChangeFamilyEditor, TChangeset> {
 			mintRevisionTag,
 			branchTrimmer,
 			telemetryEventBatcher,
+			editorOptions,
 		);
 
 		this.sequenceIdToCommit.set(baseCommitSequenceId, this.trunk.getHead());

package/src/shared-tree-core/editManagerCodecs.ts

@@ -33,7 +33,7 @@ import { brand, type JsonCompatibleReadOnly } from "../util/index.js";
 
 import type { SummaryData } from "./editManager.js";
 import { makeV1CodecWithVersion } from "./editManagerCodecsV1toV4.js";
-import { makeV5CodecWithVersion } from "./editManagerCodecsV5.js";
+import { makeSharedBranchesCodecWithVersion } from "./editManagerCodecsVSharedBranches.js";
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
 import {
 	EditManagerFormatVersion,
@@ -70,7 +70,16 @@ export function clientVersionToEditManagerFormatVersion(
 export function editManagerFormatVersionSelectorForSharedBranches(
 	clientVersion: MinimumVersionForCollab,
 ): EditManagerFormatVersion {
-	return brand(EditManagerFormatVersion.v5);
+	return brand(EditManagerFormatVersion.vSharedBranches);
+}
+
+/**
+ * Returns the version that should be used for testing shared branches.
+ */
+export function editManagerFormatVersionSelectorForDetachedRootEditing(
+	clientVersion: MinimumVersionForCollab,
+): EditManagerFormatVersion {
+	return brand(EditManagerFormatVersion.vDetachedRoots);
 }
 
 export interface EditManagerCodecOptions {
@@ -138,18 +147,21 @@ export function makeEditManagerCodecs<TChangeset>(
 			case EditManagerFormatVersion.v2:
 				return [version, makeDiscontinuedCodecVersion(options, version, "2.73.0")];
 			case EditManagerFormatVersion.v3:
-			case EditManagerFormatVersion.v4: {
+			case EditManagerFormatVersion.v4:
+			case EditManagerFormatVersion.vDetachedRoots: {
 				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
 					version,
 					makeV1CodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
 			}
-			case EditManagerFormatVersion.v5: {
+			case EditManagerFormatVersion.v5:
+				return [version, makeDiscontinuedCodecVersion(options, version, "2.74.0")];
+			case EditManagerFormatVersion.vSharedBranches: {
 				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
 					version,
-					makeV5CodecWithVersion(changeCodec, revisionTagCodec, options, version),
+					makeSharedBranchesCodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
 			}
 			default: