@fluidframework/tree 2.4.0-297027 → 2.4.0-299374

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

@@ -266,6 +266,7 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 		change: OptionalChangeset,
 		isRollback: boolean,
 		genId: IdAllocator<ChangesetLocalId>,
+		revision: RevisionTag | undefined,
 	): OptionalChangeset => {
 		const { moves, childChanges } = change;
 
@@ -298,11 +299,13 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 					change.valueReplace.src === undefined
 						? {
 								isEmpty: true,
-								dst: makeChangeAtomId(genId.allocate()),
+								dst: makeChangeAtomId(genId.allocate(), revision),
 							}
 						: {
 								isEmpty: false,
-								dst: isRollback ? change.valueReplace.src : makeChangeAtomId(genId.allocate()),
+								dst: isRollback
+									? change.valueReplace.src
+									: makeChangeAtomId(genId.allocate(), revision),
 							};
 				if (change.valueReplace.isEmpty === false) {
 					replace.src = change.valueReplace.dst;
@@ -312,7 +315,7 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 				inverted.valueReplace = {
 					isEmpty: false,
 					src: "self",
-					dst: makeChangeAtomId(genId.allocate()),
+					dst: makeChangeAtomId(genId.allocate(), revision),
 				};
 			}
 		}
@@ -581,52 +584,53 @@ export function taggedRegister(id: RegisterId, revision: RevisionTag | undefined
 
 export interface OptionalFieldEditor extends FieldEditor<OptionalChangeset> {
 	/**
-	 * Creates a change which replaces the field with `newContent`
-	 * @param newContent - the new content for the field
+	 * Creates a change which will replace the content already in the field (if any at the time the change applies)
+	 * with new content.
+	 * The content in the field will be moved to the `ids.detach` register.
+	 * The content in the `ids.detach` register will be moved to into the field.
 	 * @param wasEmpty - whether the field is empty when creating this change
-	 * @param changeId - the ID associated with the replacement of the current content.
-	 * @param buildId - the ID associated with the creation of the `newContent`.
+	 * @param ids - the "fill" and "detach" ids associated with the change.
 	 */
 	set(
 		wasEmpty: boolean,
 		ids: {
-			fill: ChangesetLocalId;
-			detach: ChangesetLocalId;
+			fill: ChangeAtomId;
+			detach: ChangeAtomId;
 		},
 	): OptionalChangeset;
 
 	/**
 	 * Creates a change which clears the field's contents (if any).
 	 * @param wasEmpty - whether the field is empty when creating this change
-	 * @param changeId - the ID associated with the detach.
+	 * @param detachId - the ID of the register that existing field content (if any) will be moved to.
 	 */
-	clear(wasEmpty: boolean, id: ChangesetLocalId): OptionalChangeset;
+	clear(wasEmpty: boolean, detachId: ChangeAtomId): OptionalChangeset;
 }
 
 export const optionalFieldEditor: OptionalFieldEditor = {
 	set: (
 		wasEmpty: boolean,
 		ids: {
-			fill: ChangesetLocalId;
+			fill: ChangeAtomId;
 			// Should be interpreted as a set of an empty field if undefined.
-			detach: ChangesetLocalId;
+			detach: ChangeAtomId;
 		},
 	): OptionalChangeset => ({
 		moves: [],
 		childChanges: [],
 		valueReplace: {
 			isEmpty: wasEmpty,
-			src: { localId: ids.fill },
-			dst: { localId: ids.detach },
+			src: ids.fill,
+			dst: ids.detach,
 		},
 	}),
 
-	clear: (wasEmpty: boolean, detachId: ChangesetLocalId): OptionalChangeset => ({
+	clear: (wasEmpty: boolean, detachId: ChangeAtomId): OptionalChangeset => ({
 		moves: [],
 		childChanges: [],
 		valueReplace: {
 			isEmpty: wasEmpty,
-			dst: { localId: detachId },
+			dst: detachId,
 		},
 	}),
 

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

@@ -29,7 +29,6 @@ import type {
 	SummaryElementParser,
 	SummaryElementStringifier,
 } from "../../shared-tree-core/index.js";
-import type { JsonCompatible } from "../../util/index.js";
 import type { CollabWindow } from "../incrementalSummarizationUtils.js";
 
 import { encodeRepo, makeSchemaCodec } from "./codec.js";
@@ -127,18 +126,11 @@ export class SchemaSummarizer implements Summarizable {
 }
 
 /**
- * Dumps schema into a deterministic JSON compatible semi-human readable but unspecified format.
+ * Dumps schema into a deterministic JSON compatible semi-human readable format.
  *
  * @remarks
  * This can be used to help inspect schema for debugging, and to save a snapshot of schema to help detect and review changes to an applications schema.
- *
- * This format may change across major versions of this package: such changes are considered breaking.
- * Beyond that, no compatibility guarantee is provided for this format: it should never be relied upon to load data, it should only be used for comparing outputs from this function.
- * @privateRemarks
- * This currently uses the schema summary format, but that could be changed to something more human readable (particularly if the encoded format becomes less human readable).
- * This intentionally does not leak the format types in the API.
- * @internal
  */
-export function encodeTreeSchema(schema: TreeStoredSchema): JsonCompatible {
+export function encodeTreeSchema(schema: TreeStoredSchema): Format {
 	return encodeRepo(schema);
 }

package/src/feature-libraries/sequence-field/compose.ts

@@ -34,6 +34,7 @@ import {
 	setMoveEffect,
 } from "./moveEffectTable.js";
 import {
+	type Attach,
 	type CellMark,
 	type Changeset,
 	type Detach,
@@ -277,13 +278,16 @@ function composeMarksIgnoreChild(
 			const baseAttachAndDetach = asAttachAndDetach(baseMark);
 			const newOutputId = getOutputCellId(newAttachAndDetach);
 
+			const originalAttach = { ...baseAttachAndDetach.attach };
+			const finalDetach = { ...newAttachAndDetach.detach };
+
+			handleMovePivot(baseMark.count, originalAttach, finalDetach, moveEffects);
+
 			if (areEqualCellIds(newOutputId, baseAttachAndDetach.cellId)) {
 				return { count: baseAttachAndDetach.count, cellId: baseAttachAndDetach.cellId };
 			}
 
 			// `newMark`'s attach portion cancels with `baseMark`'s detach portion.
-			const originalAttach = { ...baseAttachAndDetach.attach };
-			const finalDetach = { ...newAttachAndDetach.detach };
 			const detachRevision = finalDetach.revision;
 			if (detachRevision !== undefined) {
 				finalDetach.revision = detachRevision;
@@ -368,76 +372,81 @@ function composeMarksIgnoreChild(
 		const attach = extractMarkEffect(baseMark);
 		const detach = extractMarkEffect(newMark);
 
-		if (isMoveIn(attach) && isMoveOut(detach)) {
-			const finalSource = getEndpoint(attach);
-			const finalDest = getEndpoint(detach);
+		handleMovePivot(baseMark.count, attach, detach, moveEffects);
 
-			setEndpoint(
-				moveEffects,
-				CrossFieldTarget.Source,
-				finalSource,
-				baseMark.count,
-				finalDest,
-			);
+		if (areEqualCellIds(getOutputCellId(newMark), baseMark.cellId)) {
+			// The output and input cell IDs are the same, so this mark has no effect.
+			return { count: baseMark.count, cellId: baseMark.cellId };
+		}
+		return normalizeCellRename(baseMark.cellId, baseMark.count, attach, detach);
+	} else {
+		const length = baseMark.count;
+		return createNoopMark(length, undefined);
+	}
+}
 
-			const truncatedEndpoint1 = getTruncatedEndpointForInner(
-				moveEffects,
-				CrossFieldTarget.Destination,
-				attach.revision,
-				attach.id,
-				baseMark.count,
-			);
+/**
+ * Checks if `baseAttach` and `newDetach` are both moves, and if so updates their move endpoints as appropriate,
+ * and removes their `finalEndpoint` endpoint fields. Note that can mutate `baseAttach` and `newDetach`.
+ * If the effects are not both moves this function does nothing.
+ * @param count - The number of cells targeted
+ * @param baseAttach - The base attach effect at this location
+ * @param newDetach - The new detach effect at this location
+ */
+function handleMovePivot(
+	count: number,
+	baseAttach: Attach,
+	newDetach: Detach,
+	moveEffects: MoveEffectTable,
+): void {
+	if (isMoveIn(baseAttach) && isMoveOut(newDetach)) {
+		const finalSource = getEndpoint(baseAttach);
+		const finalDest = getEndpoint(newDetach);
 
-			if (truncatedEndpoint1 !== undefined) {
-				setTruncatedEndpoint(
-					moveEffects,
-					CrossFieldTarget.Destination,
-					finalDest,
-					baseMark.count,
-					truncatedEndpoint1,
-				);
-			}
+		setEndpoint(moveEffects, CrossFieldTarget.Source, finalSource, count, finalDest);
 
-			setEndpoint(
+		const truncatedEndpoint1 = getTruncatedEndpointForInner(
+			moveEffects,
+			CrossFieldTarget.Destination,
+			baseAttach.revision,
+			baseAttach.id,
+			count,
+		);
+
+		if (truncatedEndpoint1 !== undefined) {
+			setTruncatedEndpoint(
 				moveEffects,
 				CrossFieldTarget.Destination,
 				finalDest,
-				baseMark.count,
-				finalSource,
+				count,
+				truncatedEndpoint1,
 			);
+		}
+
+		setEndpoint(moveEffects, CrossFieldTarget.Destination, finalDest, count, finalSource);
 
-			const truncatedEndpoint2 = getTruncatedEndpointForInner(
+		const truncatedEndpoint2 = getTruncatedEndpointForInner(
+			moveEffects,
+			CrossFieldTarget.Source,
+			newDetach.revision,
+			newDetach.id,
+			count,
+		);
+
+		if (truncatedEndpoint2 !== undefined) {
+			setTruncatedEndpoint(
 				moveEffects,
 				CrossFieldTarget.Source,
-				detach.revision,
-				detach.id,
-				baseMark.count,
+				finalSource,
+				count,
+				truncatedEndpoint2,
 			);
-
-			if (truncatedEndpoint2 !== undefined) {
-				setTruncatedEndpoint(
-					moveEffects,
-					CrossFieldTarget.Source,
-					finalSource,
-					baseMark.count,
-					truncatedEndpoint2,
-				);
-			}
-
-			// The `finalEndpoint` field of AttachAndDetach move effect pairs is not used,
-			// so we remove it as a normalization.
-			delete attach.finalEndpoint;
-			delete detach.finalEndpoint;
 		}
 
-		if (areEqualCellIds(getOutputCellId(newMark), baseMark.cellId)) {
-			// The output and input cell IDs are the same, so this mark has no effect.
-			return { count: baseMark.count, cellId: baseMark.cellId };
-		}
-		return normalizeCellRename(baseMark.cellId, baseMark.count, attach, detach);
-	} else {
-		const length = baseMark.count;
-		return createNoopMark(length, undefined);
+		// The `finalEndpoint` field of AttachAndDetach move effect pairs is not used,
+		// so we remove it as a normalization.
+		delete baseAttach.finalEndpoint;
+		delete newDetach.finalEndpoint;
 	}
 }
 

package/src/feature-libraries/sequence-field/invert.ts

@@ -46,6 +46,10 @@ import {
 /**
  * Inverts a given changeset.
  * @param change - The changeset to produce the inverse of.
+ * @param isRollback - Whether the inverse is being produced for a rollback.
+ * @param genId - The ID allocator to use for generating new IDs.
+ * @param revision - The revision to use for the inverse changeset.
+ * @param crossFieldManager - The cross-field manager to use for tracking cross-field changes.
  * @returns The inverse of the given `change` such that the inverse can be applied after `change`.
  *
  * WARNING! This implementation is incomplete:
@@ -55,20 +59,27 @@ export function invert(
 	change: Changeset,
 	isRollback: boolean,
 	genId: IdAllocator,
+	revision: RevisionTag | undefined,
 	crossFieldManager: CrossFieldManager,
 ): Changeset {
-	return invertMarkList(change, isRollback, crossFieldManager as CrossFieldManager<NodeId>);
+	return invertMarkList(
+		change,
+		isRollback,
+		crossFieldManager as CrossFieldManager<NodeId>,
+		revision,
+	);
 }
 
 function invertMarkList(
 	markList: MarkList,
 	isRollback: boolean,
 	crossFieldManager: CrossFieldManager<NodeId>,
+	revision: RevisionTag | undefined,
 ): MarkList {
 	const inverseMarkList = new MarkListFactory();
 
 	for (const mark of markList) {
-		const inverseMarks = invertMark(mark, isRollback, crossFieldManager);
+		const inverseMarks = invertMark(mark, isRollback, crossFieldManager, revision);
 		inverseMarkList.push(...inverseMarks);
 	}
 
@@ -79,6 +90,7 @@ function invertMark(
 	mark: Mark,
 	isRollback: boolean,
 	crossFieldManager: CrossFieldManager<NodeId>,
+	revision: RevisionTag | undefined,
 ): Mark[] {
 	if (!isImpactful(mark)) {
 		const inputId = getInputCellId(mark);
@@ -115,6 +127,7 @@ function invertMark(
 					id: mark.id,
 					cellId: outputId,
 					count: mark.count,
+					revision,
 				};
 			} else {
 				inverse = {
@@ -122,6 +135,7 @@ function invertMark(
 					id: mark.id,
 					cellId: outputId,
 					count: mark.count,
+					revision,
 				};
 				if (isRollback) {
 					inverse.idOverride = inputId;
@@ -136,6 +150,7 @@ function invertMark(
 				type: "Remove",
 				count: mark.count,
 				id: inputId.localId,
+				revision,
 			};
 
 			if (isRollback) {
@@ -168,10 +183,14 @@ function invertMark(
 			const moveIn: MoveIn = {
 				type: "MoveIn",
 				id: mark.id,
+				revision,
 			};
 
 			if (mark.finalEndpoint !== undefined) {
-				moveIn.finalEndpoint = { localId: mark.finalEndpoint.localId };
+				moveIn.finalEndpoint = {
+					localId: mark.finalEndpoint.localId,
+					revision: mark.revision,
+				};
 			}
 			let effect: MarkEffect = moveIn;
 			const inputId = getInputCellId(mark);
@@ -179,6 +198,7 @@ function invertMark(
 				const detach: Mutable<Detach> = {
 					type: "Remove",
 					id: mark.id,
+					revision,
 				};
 				if (isRollback) {
 					detach.idOverride = inputId;
@@ -198,6 +218,7 @@ function invertMark(
 				type: "MoveOut",
 				id: mark.id,
 				count: mark.count,
+				revision,
 			};
 
 			if (isRollback) {
@@ -205,7 +226,10 @@ function invertMark(
 			}
 
 			if (mark.finalEndpoint) {
-				invertedMark.finalEndpoint = { localId: mark.finalEndpoint.localId };
+				invertedMark.finalEndpoint = {
+					localId: mark.finalEndpoint.localId,
+					revision: mark.revision,
+				};
 			}
 			return applyMovedChanges(invertedMark, mark.revision, crossFieldManager);
 		}
@@ -225,8 +249,8 @@ function invertMark(
 				changes: mark.changes,
 				...mark.detach,
 			};
-			const attachInverses = invertMark(attach, isRollback, crossFieldManager);
-			const detachInverses = invertMark(detach, isRollback, crossFieldManager);
+			const attachInverses = invertMark(attach, isRollback, crossFieldManager, revision);
+			const detachInverses = invertMark(detach, isRollback, crossFieldManager, revision);
 
 			if (detachInverses.length === 0) {
 				return attachInverses;

package/src/feature-libraries/sequence-field/sequenceFieldEditor.ts

@@ -5,7 +5,7 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import type { ChangesetLocalId } from "../../core/index.js";
+import type { ChangesetLocalId, RevisionTag } from "../../core/index.js";
 import type { FieldEditor, NodeId } from "../modular-schema/index.js";
 
 import { MarkListFactory } from "./markListFactory.js";
@@ -22,9 +22,15 @@ import type {
 import { splitMark } from "./utils.js";
 
 export interface SequenceFieldEditor extends FieldEditor<Changeset> {
-	insert(index: number, count: number, firstId: ChangesetLocalId): Changeset;
-	remove(index: number, count: number, id: ChangesetLocalId): Changeset;
-	revive(index: number, count: number, detachEvent: CellId, isIntention?: true): Changeset;
+	insert(index: number, count: number, firstId: CellId, revision: RevisionTag): Changeset;
+	remove(index: number, count: number, id: ChangesetLocalId, revision: RevisionTag): Changeset;
+	revive(
+		index: number,
+		count: number,
+		detachEvent: CellId,
+		revision: RevisionTag,
+		isIntention?: true,
+	): Changeset;
 
 	/**
 	 *
@@ -32,22 +38,30 @@ export interface SequenceFieldEditor extends FieldEditor<Changeset> {
 	 * @param count - The number of nodes to move
 	 * @param destIndex - The index the nodes should be moved to, interpreted before detaching the moved nodes
 	 * @param detachCellId - The local ID to assign to the first cell being emptied by the move
-	 * @param attachCellId - The local ID to assign to the first cell being filled by the move
+	 * @param attachCellId - The ID to assign to the first cell being filled by the move
+	 * @param revision - The revision to assign to the move marks
 	 */
 	move(
 		sourceIndex: number,
 		count: number,
 		destIndex: number,
 		detachCellId: ChangesetLocalId,
-		attachCellId: ChangesetLocalId,
+		attachCellId: CellId,
+		revision: RevisionTag,
 	): Changeset;
 
-	moveOut(sourceIndex: number, count: number, id: ChangesetLocalId): Changeset;
+	moveOut(
+		sourceIndex: number,
+		count: number,
+		id: ChangesetLocalId,
+		revision: RevisionTag,
+	): Changeset;
 	moveIn(
 		destIndex: number,
 		count: number,
 		moveId: ChangesetLocalId,
-		attachCellId: ChangesetLocalId,
+		attachCellId: CellId,
+		revision: RevisionTag,
 	): Changeset;
 
 	return(
@@ -56,31 +70,49 @@ export interface SequenceFieldEditor extends FieldEditor<Changeset> {
 		destIndex: number,
 		detachCellId: CellId,
 		attachCellId: CellId,
+		revision: RevisionTag,
 	): Changeset;
 }
 
 export const sequenceFieldEditor = {
 	buildChildChange: (index: number, change: NodeId): Changeset =>
 		markAtIndex(index, { count: 1, changes: change }),
-	insert: (index: number, count: number, firstId: ChangesetLocalId): Changeset => {
+	insert: (
+		index: number,
+		count: number,
+		firstId: CellId,
+		revision: RevisionTag | undefined,
+	): Changeset => {
 		const mark: CellMark<Insert> = {
 			type: "Insert",
-			id: firstId,
+			id: firstId.localId,
 			count,
-			cellId: { localId: firstId },
+			cellId: firstId,
+			revision,
 		};
 		return markAtIndex(index, mark);
 	},
-	remove: (index: number, count: number, id: ChangesetLocalId): Changeset =>
-		count === 0 ? [] : markAtIndex(index, { type: "Remove", count, id }),
+	remove: (
+		index: number,
+		count: number,
+		id: ChangesetLocalId,
+		revision: RevisionTag | undefined,
+	): Changeset =>
+		count === 0 ? [] : markAtIndex(index, { type: "Remove", count, id, revision }),
 
-	revive: (index: number, count: number, detachEvent: CellId): Changeset => {
+	revive: (
+		index: number,
+		count: number,
+		detachEvent: CellId,
+		revision: RevisionTag | undefined,
+	): Changeset => {
 		assert(detachEvent.revision !== undefined, 0x724 /* Detach event must have a revision */);
 		const mark: CellMark<Insert> = {
 			type: "Insert",
 			id: detachEvent.localId,
 			count,
 			cellId: detachEvent,
+			revision,
 		};
 		return count === 0 ? [] : markAtIndex(index, mark);
 	},
@@ -90,27 +122,36 @@ export const sequenceFieldEditor = {
 		count: number,
 		destIndex: number,
 		detachCellId: ChangesetLocalId,
-		attachCellId: ChangesetLocalId,
+		attachCellId: CellId,
+		revision: RevisionTag | undefined,
 	): Changeset {
 		const moveIn: Mark = {
 			type: "MoveIn",
 			id: detachCellId,
 			count,
-			cellId: { localId: attachCellId },
+			cellId: attachCellId,
+			revision,
 		};
 		const moveOut: Mark = {
 			type: "MoveOut",
 			id: detachCellId,
 			count,
+			revision,
 		};
 		return moveMarksToMarkList(sourceIndex, count, destIndex, moveOut, moveIn);
 	},
 
-	moveOut(sourceIndex: number, count: number, detachCellId: ChangesetLocalId): Changeset {
+	moveOut(
+		sourceIndex: number,
+		count: number,
+		detachCellId: ChangesetLocalId,
+		revision: RevisionTag,
+	): Changeset {
 		const moveOut: Mark = {
 			type: "MoveOut",
 			id: detachCellId,
 			count,
+			revision,
 		};
 		return markAtIndex(sourceIndex, moveOut);
 	},
@@ -119,13 +160,15 @@ export const sequenceFieldEditor = {
 		destIndex: number,
 		count: number,
 		moveId: ChangesetLocalId,
-		attachCellId: ChangesetLocalId,
+		attachCellId: CellId,
+		revision: RevisionTag,
 	): Changeset {
 		const moveIn: Mark = {
 			type: "MoveIn",
 			id: moveId,
 			count,
-			cellId: { localId: attachCellId },
+			cellId: attachCellId,
+			revision,
 		};
 		return markAtIndex(destIndex, moveIn);
 	},
@@ -136,12 +179,14 @@ export const sequenceFieldEditor = {
 		destIndex: number,
 		detachCellId: CellId,
 		attachCellId: CellId,
+		revision: RevisionTag | undefined,
 	): Changeset {
 		const moveOut: CellMark<MoveOut> = {
 			type: "MoveOut",
 			id: attachCellId.localId,
 			idOverride: detachCellId,
 			count,
+			revision,
 		};
 
 		const returnTo: CellMark<MoveIn> = {
@@ -149,6 +194,7 @@ export const sequenceFieldEditor = {
 			id: attachCellId.localId,
 			count,
 			cellId: attachCellId,
+			revision,
 		};
 
 		return moveMarksToMarkList(sourceIndex, count, destIndex, moveOut, returnTo);

package/src/feature-libraries/treeCompressionUtils.ts

@@ -7,7 +7,7 @@
  * Selects which heuristics to use when encoding tree content.
  * All encoding options here are compatible with the same decoder:
  * the selection here does not impact compatibility.
- * @internal
+ * @alpha
  */
 export enum TreeCompressionStrategy {
 	/**