@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -42,19 +42,26 @@ import {
 	type IncrementalEncodingPolicy,
 } from "../chunked-forest/index.js";
 
-import { type ForestCodec, makeForestSummarizerCodec } from "./codec.js";
+import {
+	clientVersionToForestFormatVersion,
+	type ForestCodec,
+	makeForestSummarizerCodec,
+} from "./codec.js";
 import {
 	ForestIncrementalSummaryBehavior,
 	ForestIncrementalSummaryBuilder,
 } from "./incrementalSummaryBuilder.js";
 import {
-	forestSummaryContentKey,
-	forestSummaryKey,
 	minVersionToForestSummaryFormatVersion,
-	supportedForestSummaryFormatVersions,
-	type ForestSummaryFormatVersion,
+	getForestRootSummaryContentKey,
 } from "./summaryTypes.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
+import { ForestFormatVersion } from "./formatCommon.js";
+import {
+	ForestSummaryFormatVersion,
+	forestSummaryKey,
+	supportedForestSummaryFormatVersions,
+} from "./summaryFormatCommon.js";
 
 /**
  * Provides methods for summarizing and loading a forest.
@@ -66,6 +73,7 @@ export class ForestSummarizer
 	private readonly codec: ForestCodec;
 
 	private readonly incrementalSummaryBuilder: ForestIncrementalSummaryBuilder;
+	private readonly forestRootSummaryContentKey: string;
 
 	/**
 	 * @param encoderContext - The schema if provided here must be mutated by the caller to keep it up to date.
@@ -87,11 +95,25 @@ export class ForestSummarizer
 			true /* supportPreVersioningFormat */,
 		);
 
-		// TODO: this should take in CodecWriteOptions, and use it to pick the write version.
 		this.codec = makeForestSummarizerCodec(options, fieldBatchCodec);
+
+		const forestFormatWriteVersion = clientVersionToForestFormatVersion(
+			options.minVersionForCollab,
+		);
+		const summaryFormatWriteVersion = minVersionToForestSummaryFormatVersion(
+			options.minVersionForCollab,
+		);
+		this.forestRootSummaryContentKey = getForestRootSummaryContentKey(
+			summaryFormatWriteVersion,
+		);
+
+		// Incremental summary is supported from ForestFormatVersion.v2 and ForestSummaryFormatVersion.v3 onwards.
+		const enableIncrementalSummary =
+			forestFormatWriteVersion >= ForestFormatVersion.v2 &&
+			summaryFormatWriteVersion >= ForestSummaryFormatVersion.v3 &&
+			encoderContext.encodeType === TreeCompressionStrategy.CompressedIncremental;
 		this.incrementalSummaryBuilder = new ForestIncrementalSummaryBuilder(
-			encoderContext.encodeType ===
-				TreeCompressionStrategy.CompressedIncremental /* enableIncrementalSummary */,
+			enableIncrementalSummary,
 			(cursor: ITreeCursorSynchronous) => this.forest.chunkField(cursor),
 			shouldEncodeIncrementally,
 			initialSequenceNumber,
@@ -153,7 +175,8 @@ export class ForestSummarizer
 
 		this.incrementalSummaryBuilder.completeSummary({
 			incrementalSummaryContext,
-			forestSummaryContent: stringify(encoded),
+			forestSummaryRootContent: stringify(encoded),
+			forestSummaryRootContentKey: this.forestRootSummaryContentKey,
 			builder,
 		});
 	}
@@ -161,15 +184,17 @@ export class ForestSummarizer
 	protected async loadInternal(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,
+		version: ForestSummaryFormatVersion | undefined,
 	): Promise<void> {
-		// The contents of the top-level forest must be present under a summary blob named `forestSummaryContentKey`.
+		// Get the key of the summary blob where the top-level forest content is stored based on the summary format version.
 		// If the summary was generated as `ForestIncrementalSummaryBehavior.SingleBlob`, this blob will contain all
 		// of forest's contents.
 		// If the summary was generated as `ForestIncrementalSummaryBehavior.Incremental`, this blob will contain only
 		// the top-level forest node's contents.
 		// The contents of the incremental chunks will be in separate tree nodes and will be read later during decoding.
+		const forestSummaryRootContentKey = getForestRootSummaryContentKey(version);
 		assert(
-			await services.contains(forestSummaryContentKey),
+			await services.contains(forestSummaryRootContentKey),
 			0xc21 /* Forest summary content missing in snapshot */,
 		);
 
@@ -184,7 +209,7 @@ export class ForestSummarizer
 		// TODO: this code is parsing data without an optional validator, this should be defined in a typebox schema as part of the
 		// forest summary format.
 		const fields = this.codec.decode(
-			await readAndParseSnapshotBlob(forestSummaryContentKey, services, parse),
+			await readAndParseSnapshotBlob(forestSummaryRootContentKey, services, parse),
 			{
 				...this.encoderContext,
 				incrementalEncoderDecoder: this.incrementalSummaryBuilder,

package/src/feature-libraries/forest-summary/{format.ts → formatCommon.ts}

@@ -6,21 +6,22 @@
 import { type Static, Type } from "@sinclair/typebox";
 
 import { schemaFormatV1 } from "../../core/index.js";
-import { brand, type Brand } from "../../util/index.js";
+import { strictEnum, type Values } from "../../util/index.js";
 import { EncodedFieldBatch } from "../chunked-forest/index.js";
 
 /**
  * The format version for the forest.
  */
-export const ForestFormatVersion = {
+export const ForestFormatVersion = strictEnum("ForestFormatVersion", {
 	v1: 1,
-} as const;
-export type ForestFormatVersion = Brand<
-	(typeof ForestFormatVersion)[keyof typeof ForestFormatVersion],
-	"ForestFormatVersion"
->;
+	/** This format supports incremental encoding */
+	v2: 2,
+});
+export type ForestFormatVersion = Values<typeof ForestFormatVersion>;
 
-const FormatGeneric = (
+export const validVersions = new Set([...Object.values(ForestFormatVersion)]);
+
+export const FormatCommon = (
 	version: ForestFormatVersion,
 	// Return type is intentionally derived.
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -33,6 +34,4 @@ const FormatGeneric = (
 		},
 		{ additionalProperties: false },
 	);
-
-export const FormatV1 = FormatGeneric(brand<ForestFormatVersion>(ForestFormatVersion.v1));
-export type FormatV1 = Static<typeof FormatV1>;
+export type Format = Static<ReturnType<typeof FormatCommon>>;

package/src/feature-libraries/forest-summary/formatV1.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { Static } from "@sinclair/typebox";
+
+import { brand } from "../../util/index.js";
+import { FormatCommon, ForestFormatVersion } from "./formatCommon.js";
+
+export const FormatV1 = FormatCommon(brand<ForestFormatVersion>(ForestFormatVersion.v1));
+export type FormatV1 = Static<typeof FormatV1>;

package/src/feature-libraries/forest-summary/formatV2.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { Static } from "@sinclair/typebox";
+
+import { brand } from "../../util/index.js";
+import { FormatCommon, ForestFormatVersion } from "./formatCommon.js";
+
+export const FormatV2 = FormatCommon(brand<ForestFormatVersion>(ForestFormatVersion.v2));
+export type FormatV2 = Static<typeof FormatV2>;

package/src/feature-libraries/forest-summary/incrementalSummaryBuilder.ts

@@ -27,7 +27,7 @@ import type { ISnapshotTree } from "@fluidframework/driver-definitions/internal"
 import { LoggingError } from "@fluidframework/telemetry-utils/internal";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import type { SummaryElementStringifier } from "../../shared-tree-core/index.js";
-import { chunkContentsBlobKey, forestSummaryContentKey } from "./summaryTypes.js";
+import { summaryContentBlobKey } from "./summaryFormatV3.js";
 
 /**
  * State that tells whether a summary is currently being tracked.
@@ -189,7 +189,7 @@ function validateReadyToTrackSummary(
  *
  * An example summary tree with incremental summary:
  *     Forest
- *     ├── ForestTree
+ *     ├── contents
  *     ├── 0
  *     |   ├── contents
  *     |   ├── 1
@@ -202,7 +202,7 @@ function validateReadyToTrackSummary(
  *     |   ├── ...
  *     ├── 5 - "/.../Forest/ForestTree/5"
  * - Forest is a summary tree node added by the shared tree and contains the following:
- *   - The inline portion of the top-level forest content is stored in a summary blob called "ForestTree".
+ *   - The inline portion of the top-level forest content is stored in a summary blob called "contents".
  *     It also contains the {@link ChunkReferenceId}s of the incremental chunks under it.
  *   - The summary for each incremental chunk under it is stored against its {@link ChunkReferenceId}.
  * - For each chunk, the structure of the summary tree is the same as the Forest. It contains the following:
@@ -210,16 +210,6 @@ function validateReadyToTrackSummary(
  *     It also contains the {@link ChunkReferenceId}s of the incremental chunks under it.
  *   - The summary for each incremental chunk under it is stored against its {@link ChunkReferenceId}.
  * - Chunks that do not change between summaries are summarized as handles in the summary tree.
- * @remarks
- * It may seem inconsistent that although the structure for the top-level forest tree is similar to that of
- * an incremental chunk, its content is stored in a summary blob called "ForestTree" while the content for
- * the incremental chunks are stored in a summary blob called "contents".
- * This is to keep this summary backwards compatible with old format (before incremental summaries were added)
- * where the entire forest content was in a summary blob called "ForestTree". So, if incremental summaries were
- * disabled, the forest content will be fully backwards compatible.
- * Note that this limits reusing the root node in a location other than root and a non-root node in the root.
- * We could phase this out by switching to write the top-level contents under "contents" if we want to support
- * the above. However, there is no plan to do that for now.
  *
  * TODO: AB#46752
  * Add strong types for the summary structure to document it better. It will help make it super clear what the actual
@@ -305,7 +295,7 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 			// and the value is the snapshot tree for the chunk.
 			for (const [chunkReferenceId, chunkSnapshotTree] of Object.entries(snapshotTree.trees)) {
 				const chunkSubTreePath = `${parentTreeKey}${chunkReferenceId}`;
-				const chunkContentsPath = `${chunkSubTreePath}/${chunkContentsBlobKey}`;
+				const chunkContentsPath = `${chunkSubTreePath}/${summaryContentBlobKey}`;
 				if (!(await args.services.contains(chunkContentsPath))) {
 					throw new LoggingError(
 						`SharedTree: Cannot find contents for incremental chunk ${chunkContentsPath}`,
@@ -422,7 +412,7 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 				const chunkSummaryBuilder = new SummaryTreeBuilder();
 				this.trackedSummaryProperties.parentSummaryBuilder = chunkSummaryBuilder;
 				chunkSummaryBuilder.addBlob(
-					chunkContentsBlobKey,
+					summaryContentBlobKey,
 					this.trackedSummaryProperties.stringify(chunkEncoder(chunk)),
 				);
 
@@ -454,26 +444,33 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 	 * It clears any tracking state and deletes the tracking properties for summaries that are older than the
 	 * latest successful summary.
 	 * @param incrementalSummaryContext - The context for the incremental summary that contains the sequence numbers.
-	 * If this is undefined, the summary tree will only contain a summary blob for `forestSummaryContent`.
-	 * @param forestSummaryContent - The stringified ForestCodec output of top-level Forest content.
+	 * If this is undefined, the summary tree will only contain a summary blob for `forestSummaryRootContent`.
+	 * @param forestSummaryRootContent - The stringified ForestCodec output of top-level Forest content.
+	 * @param forestSummaryRootContentKey - The key to use for the blob containing `forestSummaryRootContent`.
 	 * @param builder - The summary tree builder to use to add the forest's contents. Note that if tracking an incremental
 	 * summary, this builder will be the same as the one tracked in `trackedSummaryProperties`.
 	 * @returns the Forest's summary tree.
 	 */
 	public completeSummary(args: {
 		incrementalSummaryContext: IExperimentalIncrementalSummaryContext | undefined;
-		forestSummaryContent: string;
+		forestSummaryRootContent: string;
+		forestSummaryRootContentKey: string;
 		builder: SummaryTreeBuilder;
 	}): void {
-		const { incrementalSummaryContext, forestSummaryContent, builder } = args;
+		const {
+			incrementalSummaryContext,
+			forestSummaryRootContent,
+			forestSummaryRootContentKey,
+			builder,
+		} = args;
 		if (!this.enableIncrementalSummary || incrementalSummaryContext === undefined) {
-			builder.addBlob(forestSummaryContentKey, forestSummaryContent);
+			builder.addBlob(forestSummaryRootContentKey, forestSummaryRootContent);
 			return;
 		}
 
 		validateTrackingSummary(this.forestSummaryState, this.trackedSummaryProperties);
 
-		builder.addBlob(forestSummaryContentKey, forestSummaryContent);
+		builder.addBlob(forestSummaryRootContentKey, forestSummaryRootContent);
 
 		// Copy over the entries from the latest summary to the current summary.
 		// In the current summary, there can be fields that haven't changed since the latest summary and the chunks

package/src/feature-libraries/forest-summary/index.ts

@@ -5,5 +5,4 @@
 
 export { ForestSummarizer } from "./forestSummarizer.js";
 export { getCodecTreeForForestFormat } from "./codec.js";
-export { ForestFormatVersion } from "./format.js";
-export { forestSummaryKey } from "./summaryTypes.js";
+export { ForestFormatVersion } from "./formatCommon.js";

package/src/feature-libraries/forest-summary/summaryFormatCommon.ts

@@ -0,0 +1,41 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * The key for the tree that contains the overall forest's summary tree.
+ * This tree is added by the parent of the forest summarizer.
+ * See {@link ForestIncrementalSummaryBuilder} for details on the summary structure.
+ */
+export const forestSummaryKey = "Forest";
+
+/**
+ * The versions for the forest summary.
+ */
+export enum ForestSummaryFormatVersion {
+	/**
+	 * This version represents summary format before summary versioning was introduced.
+	 */
+	v1 = 1,
+	/**
+	 * This version adds metadata to the summary. This is backward compatible with version 1.
+	 */
+	v2 = 2,
+	/**
+	 * This version adds support for summaries with incremental chunks. Also, the ForestSummarizer's root contents are
+	 * stored in {@link summaryContentBlobKeyV3} instead of {@link summaryContentBlobKeyV1}.
+	 * This is not backward compatible with versions 1 and 2.
+	 */
+	v3 = 3,
+	/**
+	 * The latest version of the summary. Must be updated when a new version is added.
+	 */
+	vLatest = v3,
+}
+
+export const supportedForestSummaryFormatVersions = new Set<ForestSummaryFormatVersion>([
+	ForestSummaryFormatVersion.v1,
+	ForestSummaryFormatVersion.v2,
+	ForestSummaryFormatVersion.v3,
+]);

package/src/feature-libraries/forest-summary/summaryFormatV1ToV2.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * The entire contents of the ForestSummarizer's summary (ForestCodec's output) is added to a blob with this key.
+ * This was added in {@link ForestSummaryFormatVersion.v1 | version 1} and is used in
+ * {@link ForestSummaryFormatVersion.v1 | version 1} and {@link ForestSummaryFormatVersion.v2 | version 2}.
+ */
+export const summaryContentBlobKey = "ForestTree";

package/src/feature-libraries/forest-summary/summaryFormatV3.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * From {@link ForestSummaryFormatVersion.v3 | version 3} onwards, the inline portion of the top-level forest content
+ * is stored in a summary blob with this key.
+ * If the summary is not incremental, the content stored is the entire forest content.
+ * If the summary is incremental, the contents of the incremental chunks is stored separately:
+ * The contents of an incremental chunk is under a summary tree node with its {@link ChunkReferenceId} as the key.
+ * The inline portion of the chunk content is encoded with the forest codec and is stored in a blob with this key as
+ * well. The rest of the chunk contents  is stored in the summary tree under the summary tree node.
+ *
+ * @remarks
+ * See the summary format in {@link ForestIncrementalSummaryBuilder} for more details.
+ */
+export const summaryContentBlobKey = "contents";

package/src/feature-libraries/forest-summary/summaryTypes.ts

@@ -4,58 +4,38 @@
  */
 
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
+import {
+	getConfigForMinVersionForCollab,
+	lowestMinVersionForCollab,
+} from "@fluidframework/runtime-utils/internal";
 
-/**
- * The key for the tree that contains the overall forest's summary tree.
- * This tree is added by the parent of the forest summarizer.
- * See {@link ForestIncrementalSummaryBuilder} for details on the summary structure.
- */
-export const forestSummaryKey = "Forest";
-
-/**
- * The key for the blob under ForestSummarizer's root.
- * This blob contains the ForestCodec's output.
- * See {@link ForestIncrementalSummaryBuilder} for details on the summary structure.
- */
-export const forestSummaryContentKey = "ForestTree";
-
-/**
- * The contents of an incremental chunk is under a summary tree node with its {@link ChunkReferenceId} as the key.
- * The inline portion of the chunk content is encoded with the forest codec is stored in a blob with this key.
- * The rest of the chunk contents  is stored in the summary tree under the summary tree node.
- * See the summary format in {@link ForestIncrementalSummaryBuilder} for more details.
- */
-export const chunkContentsBlobKey = "contents";
+import { FluidClientVersion } from "../../codec/index.js";
+import { ForestSummaryFormatVersion } from "./summaryFormatCommon.js";
+import { summaryContentBlobKey as summaryContentBlobKeyV1ToV2 } from "./summaryFormatV1ToV2.js";
+import { summaryContentBlobKey as summaryContentBlobKeyV3 } from "./summaryFormatV3.js";
 
 /**
- * The versions for the forest summary.
+ * Returns the summary format version to use as per the given minimum version for collab.
  */
-export enum ForestSummaryFormatVersion {
-	/**
-	 * This version represents summary format before summary versioning was introduced.
-	 */
-	v1 = 1,
-	/**
-	 * This version adds metadata to the summary. This is backward compatible with version 1.
-	 */
-	v2 = 2,
-	/**
-	 * The latest version of the summary. Must be updated when a new version is added.
-	 */
-	vLatest = v2,
+export function minVersionToForestSummaryFormatVersion(
+	version: MinimumVersionForCollab,
+): ForestSummaryFormatVersion {
+	return getConfigForMinVersionForCollab(version, {
+		[lowestMinVersionForCollab]: ForestSummaryFormatVersion.v2,
+		[FluidClientVersion.v2_74]: ForestSummaryFormatVersion.v3,
+	});
 }
 
-export const supportedForestSummaryFormatVersions = new Set<ForestSummaryFormatVersion>([
-	ForestSummaryFormatVersion.v1,
-	ForestSummaryFormatVersion.v2,
-]);
-
 /**
- * Returns the summary version to use as per the given minimum version for collab.
+ * Gets the key for the blob containing the forest summary root content based on the summary format version.
+ * @param summaryFormatVersion - The version of the forest summary format.
+ * @returns The key for the forest summary root content blob.
  */
-export function minVersionToForestSummaryFormatVersion(
-	version: MinimumVersionForCollab,
-): ForestSummaryFormatVersion {
-	// Currently, version 2 is written which adds metadata blob to the summary.
-	return ForestSummaryFormatVersion.v2;
+export function getForestRootSummaryContentKey(
+	summaryFormatVersion: ForestSummaryFormatVersion | undefined,
+): string {
+	return summaryFormatVersion === undefined ||
+		summaryFormatVersion < ForestSummaryFormatVersion.v3
+		? summaryContentBlobKeyV1ToV2
+		: summaryContentBlobKeyV3;
 }

package/src/feature-libraries/index.ts

@@ -29,11 +29,8 @@ export {
 export { buildForest } from "./object-forest/index.js";
 export {
 	SchemaSummarizer,
-	encodeTreeSchema,
 	makeSchemaCodec,
-	makeSchemaCodecs,
-	getCodecTreeForSchemaFormat,
-	clientVersionToSchemaVersion,
+	schemaCodecBuilder,
 } from "./schema-index/index.js";
 export {
 	stackTreeNodeCursor,
@@ -72,9 +69,7 @@ export {
 	type NodeChangeInverter,
 	type NodeChangeRebaser,
 	type NodeChangePruner,
-	type ComposeNodeManager,
-	type InvertNodeManager,
-	type RebaseNodeManager,
+	type CrossFieldManager,
 	CrossFieldTarget,
 	FlexFieldKind,
 	type FullSchemaPolicy,
@@ -84,20 +79,19 @@ export {
 	type HasFieldChanges,
 	type NodeExistsConstraint,
 	ModularChangeFamily,
-	EncodedModularChangeset,
+	type RelevantRemovedRootsFromChild,
+	EncodedModularChangesetV1,
+	EncodedModularChangesetV2,
 	updateRefreshers,
 	type NodeId,
 	type FieldChangeEncodingContext,
 	type FieldKindConfiguration,
 	type FieldKindConfigurationEntry,
 	isNeverTree,
+	DefaultRevisionReplacer,
 } from "./modular-schema/index.js";
 
-export {
-	mapRootChanges,
-	nodeIdFromChangeAtom,
-	changeAtomFromDetachedNodeId,
-} from "./deltaUtils.js";
+export { mapRootChanges } from "./deltaUtils.js";
 
 export {
 	type TreeChunk,
@@ -138,26 +132,17 @@ export {
 	type Identifier,
 	type Forbidden,
 	type DefaultChangeset,
-	type DetachedRootIds,
 	DefaultChangeFamily,
-	type IdBasedChangeFamilyDataEditor,
-	DefaultIdBasedDataEditor,
-	type DataEditor,
-	type RequiredFieldEditor,
-	type OptionalFieldEditor,
-	type SequenceFieldEditor,
+	DefaultEditBuilder,
+	type IDefaultEditBuilder,
+	type ValueFieldEditBuilder,
+	type OptionalFieldEditBuilder,
+	type SequenceFieldEditBuilder,
 	defaultSchemaPolicy,
 	fieldKinds,
 	fieldKindConfigurations,
 	intoDelta,
 	relevantRemovedRoots,
-	getBuildsIds,
-	type DetachedRootLocation,
-	type DetachedRootsLocation,
-	type DetachedRootIdRange,
-	type Locator,
-	LocationBasedDataEditor,
-	type ILocationBasedDataEditor,
 	getCodecTreeForModularChangeFormat,
 	type ModularChangeFormatVersion,
 } from "./default-schema/index.js";
@@ -227,3 +212,9 @@ export {
 	type TreeIndexKey,
 	type TreeIndexNodes,
 } from "./indexing/index.js";
+
+export {
+	type ChangeAtomIdBTree,
+	getFromChangeAtomIdMap,
+	setInChangeAtomIdMap,
+} from "./changeAtomIdBTree.js";

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -394,12 +394,12 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 	 * Given a cursor in field mode, indexes all nodes under the field and then indexes all nodes up the spine.
 	 */
 	private indexSpine(cursor: ITreeSubscriptionCursor): void {
-		if (keyAsDetachedField(cursor.getFieldKey()) !== rootField) {
-			cursor.exitField();
-			cursor.exitNode();
-		} else {
+		if (keyAsDetachedField(cursor.getFieldKey()) === rootField) {
 			// return early if we're already at the root field
 			return;
+		} else {
+			cursor.exitField();
+			cursor.exitNode();
 		}
 
 		// walk up the spine and index nodes until we reach the root
@@ -470,5 +470,5 @@ function filterNodes(
  * Checks that an array is of the type {@link TreeIndexNodes} and has at least one element.
  */
 export function hasElement<T>(array: readonly T[]): array is TreeIndexNodes<T> {
-	return array.length >= 1;
+	return array.length > 0;
 }

package/src/feature-libraries/mapTreeCursor.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, debugAssert } from "@fluidframework/core-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -161,7 +161,6 @@ export function mapTreeFromCursor(cursor: ITreeCursor): ExclusiveMapTree {
 	const fields: Map<FieldKey, ExclusiveMapTree[]> = new Map();
 	for (let inField = cursor.firstField(); inField; inField = cursor.nextField()) {
 		const field: ExclusiveMapTree[] = mapCursorField(cursor, mapTreeFromCursor);
-		debugAssert(() => field.length > 0 || "field must have at least one child");
 		fields.set(cursor.getFieldKey(), field);
 	}
 

package/src/feature-libraries/mitigatedChangeFamily.ts

@@ -7,8 +7,8 @@ import type {
 	ChangeFamily,
 	ChangeFamilyEditor,
 	ChangeRebaser,
-	EditorOptions,
 	RevisionMetadataSource,
+	RevisionReplacer,
 	RevisionTag,
 	TaggedChange,
 } from "../core/index.js";
@@ -36,9 +36,8 @@ export function makeMitigatedChangeFamily<TEditor extends ChangeFamilyEditor, TC
 		buildEditor: (
 			mintRevisionTag: () => RevisionTag,
 			changeReceiver: (change: TaggedChange<TChange>) => void,
-			options?: EditorOptions,
 		): TEditor => {
-			return unmitigatedChangeFamily.buildEditor(mintRevisionTag, changeReceiver, options);
+			return unmitigatedChangeFamily.buildEditor(mintRevisionTag, changeReceiver);
 		},
 		rebaser: makeMitigatedRebaser(unmitigatedChangeFamily.rebaser, fallbackChange, onError),
 		codecs: unmitigatedChangeFamily.codecs,
@@ -77,11 +76,15 @@ export function makeMitigatedRebaser<TChange>(
 		): TChange => {
 			return withFallback(() => unmitigatedRebaser.rebase(change, over, revisionMetadata));
 		},
-		changeRevision: (
-			change: TChange,
-			newRevision: RevisionTag | undefined,
-			rollbackOf?: RevisionTag,
-		): TChange =>
-			withFallback(() => unmitigatedRebaser.changeRevision(change, newRevision, rollbackOf)),
+		getRevisions: (change: TChange): Set<RevisionTag | undefined> => {
+			try {
+				return unmitigatedRebaser.getRevisions(change);
+			} catch (error: unknown) {
+				onError(error);
+				return new Set();
+			}
+		},
+		changeRevision: (change: TChange, replacer: RevisionReplacer): TChange =>
+			withFallback(() => unmitigatedRebaser.changeRevision(change, replacer)),
 	};
 }

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

@@ -144,10 +144,8 @@ export function allowsFieldSuperset(
 	superset: TreeFieldStoredSchema,
 	monotonicOnly: boolean = true,
 ): boolean {
-	if (!monotonicOnly) {
-		if (isNeverField(policy, originalData, original)) {
-			return true;
-		}
+	if (!monotonicOnly && isNeverField(policy, originalData, original)) {
+		return true;
 	}
 
 	if (!allowsTreeSchemaIdentifierSuperset(original.types, superset.types)) {
@@ -163,7 +161,8 @@ export function allowsFieldSuperset(
 	if (monotonicOnly) {
 		return supersetKind.options.allowMonotonicUpgradeFrom.has(original.kind);
 	} else {
-		const originalKind = policy.fieldKinds.get(original.kind) ?? fail("missing kind");
+		const originalKind =
+			policy.fieldKinds.get(original.kind) ?? fail(0xcab /* missing kind */);
 		return allowsMultiplicitySuperset(originalKind.multiplicity, supersetKind.multiplicity);
 	}
 }
@@ -238,15 +237,20 @@ export function allowsMultiplicitySuperset(
 	}
 
 	switch (superset) {
-		case Multiplicity.Forbidden:
+		case Multiplicity.Forbidden: {
 			return false;
-		case Multiplicity.Optional:
+		}
+		case Multiplicity.Optional: {
 			return original === Multiplicity.Single || original === Multiplicity.Forbidden;
-		case Multiplicity.Single:
+		}
+		case Multiplicity.Single: {
 			return false;
-		case Multiplicity.Sequence:
+		}
+		case Multiplicity.Sequence: {
 			return true;
-		default:
+		}
+		default: {
 			return unreachableCase(superset);
+		}
 	}
 }