@fluidframework/tree 2.52.0 → 2.53.0

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

@@ -4,7 +4,7 @@
  */
 
 import { type ICodecFamily, makeCodecFamily, unitCodec } from "../../codec/index.js";
-import type { FieldChangeEncodingContext } from "../index.js";
+import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
 export const noChangeCodecFamily: ICodecFamily<0, FieldChangeEncodingContext> =
 	makeCodecFamily<0, FieldChangeEncodingContext>([[1, unitCodec]]);

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

@@ -42,7 +42,7 @@ import type { Format } from "./format.js";
 /**
  * The storage key for the blob in the summary containing tree data
  */
-const treeBlobKey = "ForestTree";
+export const treeBlobKey = "ForestTree";
 
 /**
  * Provides methods for summarizing and loading a forest.

package/src/feature-libraries/index.ts

@@ -92,6 +92,7 @@ export { mapRootChanges } from "./deltaUtils.js";
 export {
 	type TreeChunk,
 	chunkTree,
+	chunkField,
 	chunkFieldSingle,
 	buildChunkedForest,
 	defaultChunkPolicy,
@@ -101,6 +102,7 @@ export {
 	makeFieldBatchCodec,
 	fluidVersionToFieldBatchCodecWriteVersion,
 	type FieldBatchEncodingContext,
+	emptyChunk,
 } from "./chunked-forest/index.js";
 
 export {

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

@@ -169,6 +169,12 @@ export interface FieldChangeRebaser<TChangeset> {
 		oldRevisions: Set<RevisionTag | undefined>,
 		newRevisions: RevisionTag | undefined,
 	): TChangeset;
+
+	/**
+	 * Returns a copy of the given changeset with the same declarations (e.g., new cells) but no actual changes.
+	 * This is a kludge. TODO: remove once AB#46104 is completed.
+	 */
+	mute(change: TChangeset): TChangeset;
 }
 
 /**
@@ -179,11 +185,13 @@ export function referenceFreeFieldChangeRebaser<TChangeset>(data: {
 	compose: (change1: TChangeset, change2: TChangeset) => TChangeset;
 	invert: (change: TChangeset) => TChangeset;
 	rebase: (change: TChangeset, over: TChangeset) => TChangeset;
+	mute: (change: TChangeset) => TChangeset;
 }): FieldChangeRebaser<TChangeset> {
 	return isolatedFieldChangeRebaser({
 		compose: (change1, change2, _composeChild, _genId) => data.compose(change1, change2),
 		invert: (change, _invertChild, _genId) => data.invert(change),
 		rebase: (change, over, _rebaseChild, _genId) => data.rebase(change, over),
+		mute: (change) => data.mute(change),
 	});
 }
 
@@ -191,6 +199,7 @@ export function isolatedFieldChangeRebaser<TChangeset>(data: {
 	compose: FieldChangeRebaser<TChangeset>["compose"];
 	invert: FieldChangeRebaser<TChangeset>["invert"];
 	rebase: FieldChangeRebaser<TChangeset>["rebase"];
+	mute: FieldChangeRebaser<TChangeset>["mute"];
 }): FieldChangeRebaser<TChangeset> {
 	return {
 		...data,

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

@@ -39,6 +39,7 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 		rebase: rebaseGenericChange,
 		prune: pruneGenericChange,
 		replaceRevisions,
+		mute: (change: GenericChangeset): GenericChangeset => change,
 	},
 	codecsFactory: makeGenericChangeCodec,
 	editor: {

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

@@ -213,6 +213,7 @@ function makeModularChangeCodec(
 		context: FieldChangeEncodingContext,
 	): EncodedNodeChangeset {
 		const encodedChange: EncodedNodeChangeset = {};
+		// Note: revert constraints are ignored for now because they would only be needed if we supported reverting changes made by peers.
 		const { fieldChanges, nodeExistsConstraint } = change;
 
 		if (fieldChanges !== undefined) {

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

@@ -39,6 +39,7 @@ import {
 	newChangeAtomIdRangeMap,
 	type DeltaDetachedNodeChanges,
 	type DeltaDetachedNodeRename,
+	mapTaggedChange,
 } from "../../core/index.js";
 import {
 	type IdAllocationState,
@@ -213,24 +214,16 @@ export class ModularChangeFamily
 	}
 
 	private composeAllFields(
-		change1: ModularChangeset,
-		change2: ModularChangeset,
+		potentiallyConflictedChange1: ModularChangeset,
+		potentiallyConflictedChange2: ModularChangeset,
 		revInfos: RevisionInfo[],
 		idState: IdAllocationState,
 	): ModularChangesetContent {
-		if (hasConflicts(change1) && hasConflicts(change2)) {
-			return {
-				fieldChanges: new Map(),
-				nodeChanges: newTupleBTree(),
-				nodeToParent: newTupleBTree(),
-				nodeAliases: newTupleBTree(),
-				crossFieldKeys: newCrossFieldKeyTable(),
-			};
-		} else if (hasConflicts(change1)) {
-			return change2;
-		} else if (hasConflicts(change2)) {
-			return change1;
-		}
+		// Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
+		// This means that compose must preserve declarations (e.g., new cells) made by conflicted changes (so that we can rebase over the composition).
+		// TODO: remove once AB#46104 is completed
+		const change1 = this.getEffectiveChange(potentiallyConflictedChange1);
+		const change2 = this.getEffectiveChange(potentiallyConflictedChange2);
 
 		const genId: IdAllocator = idAllocatorFromState(idState);
 		const revisionMetadata: RevisionMetadataSource = revisionMetadataSourceFromInfo(revInfos);
@@ -857,12 +850,17 @@ export class ModularChangeFamily
 
 	public rebase(
 		taggedChange: TaggedChange<ModularChangeset>,
-		over: TaggedChange<ModularChangeset>,
+		potentiallyConflictedOver: TaggedChange<ModularChangeset>,
 		revisionMetadata: RevisionMetadataSource,
 	): ModularChangeset {
-		if (hasConflicts(over.change)) {
-			return taggedChange.change;
-		}
+		// Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
+		// This means that we must rebase over a muted version of the conflicted changeset.
+		// That is, a version that includes its declarations (e.g., new cells) but not its changes.
+		// TODO: remove once AB#46104 is completed
+		const over = mapTaggedChange(
+			potentiallyConflictedOver,
+			this.getEffectiveChange(potentiallyConflictedOver.change),
+		);
 
 		const change = taggedChange.change;
 		const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
@@ -1711,6 +1709,50 @@ export class ModularChangeFamily
 
 		return numChildren;
 	}
+
+	private getEffectiveChange(change: ModularChangeset): ModularChangeset {
+		if (hasConflicts(change)) {
+			return this.muteChange(change);
+		}
+		return change;
+	}
+
+	/**
+	 * Returns a copy of the given changeset with the same declarations (e.g., new cells) but no actual changes.
+	 */
+	private muteChange(change: ModularChangeset): ModularChangeset {
+		const muted: Mutable<ModularChangeset> = {
+			...change,
+			crossFieldKeys: newCrossFieldKeyTable(),
+			fieldChanges: this.muteFieldChanges(change.fieldChanges),
+			nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
+		};
+		return muted;
+	}
+
+	private muteNodeChange(change: NodeChangeset): NodeChangeset {
+		if (change.fieldChanges === undefined) {
+			return change;
+		}
+		return {
+			...change,
+			fieldChanges: this.muteFieldChanges(change.fieldChanges),
+		};
+	}
+
+	private muteFieldChanges(change: FieldChangeMap): FieldChangeMap {
+		return new Map(
+			Array.from(change.entries(), ([key, value]) => [key, this.muteFieldChange(value)]),
+		);
+	}
+
+	private muteFieldChange(change: FieldChange): FieldChange {
+		const handler = getChangeHandler(this.fieldKinds, change.fieldKind);
+		return {
+			fieldKind: change.fieldKind,
+			change: brand(handler.rebaser.mute(change.change)),
+		};
+	}
 }
 
 function replaceCrossFieldKeyTableRevisions(

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

@@ -465,6 +465,10 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 
 		return updated;
 	},
+
+	mute: (change: OptionalChangeset): OptionalChangeset => {
+		return { childChanges: change.childChanges, moves: [] };
+	},
 };
 
 function replaceReplaceRevisions(

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

@@ -11,6 +11,7 @@ import { prune } from "./prune.js";
 import { rebase } from "./rebase.js";
 import { replaceRevisions } from "./replaceRevisions.js";
 import type { Changeset } from "./types.js";
+import { omitMarkEffect } from "./utils.js";
 
 export type SequenceChangeRebaser = FieldChangeRebaser<Changeset>;
 
@@ -20,4 +21,7 @@ export const sequenceFieldChangeRebaser = {
 	rebase,
 	prune,
 	replaceRevisions,
+	mute: (change: Changeset): Changeset => {
+		return change.map((mark) => omitMarkEffect(mark));
+	},
 };

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

@@ -15,8 +15,10 @@ import type {
 } from "../../core/index.js";
 import { type JsonCompatibleReadOnly, type Mutable, brand } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
-import type { FieldChangeEncodingContext } from "../index.js";
-import { EncodedNodeChangeset } from "../modular-schema/index.js";
+import {
+	EncodedNodeChangeset,
+	type FieldChangeEncodingContext,
+} from "../modular-schema/index.js";
 
 import {
 	Changeset as ChangesetSchema,

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

@@ -19,8 +19,10 @@ import type {
 } from "../../core/index.js";
 import { type JsonCompatibleReadOnly, type Mutable, brand } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
-import type { FieldChangeEncodingContext } from "../index.js";
-import { EncodedNodeChangeset } from "../modular-schema/index.js";
+import {
+	EncodedNodeChangeset,
+	type FieldChangeEncodingContext,
+} from "../modular-schema/index.js";
 
 import { Changeset as ChangesetSchema, type Encoded } from "./formatV2.js";
 import type { SequenceCodecHelpers } from "./helperTypes.js";

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

@@ -12,8 +12,10 @@ import type {
 	RevisionTag,
 } from "../../core/index.js";
 import type { JsonCompatibleReadOnly } from "../../util/index.js";
-import type { FieldChangeEncodingContext } from "../index.js";
-import { EncodedNodeChangeset } from "../modular-schema/index.js";
+import {
+	EncodedNodeChangeset,
+	type FieldChangeEncodingContext,
+} from "../modular-schema/index.js";
 
 import { Changeset as ChangesetSchema, type Encoded } from "./formatV3.js";
 import { makeV2CodecHelpers } from "./sequenceFieldCodecV2.js";

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

@@ -9,7 +9,7 @@ import type {
 	EncodedRevisionTag,
 	RevisionTag,
 } from "../../core/index.js";
-import type { FieldChangeEncodingContext } from "../index.js";
+import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
 import { makeV1Codec } from "./sequenceFieldCodecV1.js";
 import { makeV2Codec } from "./sequenceFieldCodecV2.js";

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

@@ -4,7 +4,7 @@
  */
 
 import type { ChangeAtomId, ChangesetLocalId, RevisionTag } from "../../core/index.js";
-import type { NodeId } from "../index.js";
+import type { NodeId } from "../modular-schema/index.js";
 
 export type CellCount = number;
 

package/src/index.ts

@@ -118,6 +118,7 @@ export {
 	type InternalTreeNode,
 	type WithType,
 	type NodeChangedData,
+	type SchemaUpgrade,
 	// Types not really intended for public use, but used in links.
 	// Can not be moved to internalTypes since doing so causes app code to throw errors like:
 	// Error: src/simple-tree/objectNode.ts:72:1 - (ae-unresolved-link) The @link reference could not be resolved: The package "@fluidframework/tree" does not have an export "TreeNodeApi"
@@ -168,9 +169,9 @@ export {
 	type UnannotateAllowedTypes,
 	type UnannotateAllowedType,
 	type UnannotateAllowedTypesList,
-	type UnannotateAllowedTypeOrLazyItem,
 	type UnannotateImplicitFieldSchema,
 	type UnannotateSchemaRecord,
+	type SchemaStaticsAlpha,
 	// Beta APIs
 	TreeBeta,
 	type TreeChangeEventsBeta,

package/src/jsonDomainSchema.ts

@@ -11,9 +11,11 @@ import type {
 	ValidateRecursiveSchema,
 	// #region Unused imports to make d.ts cleaner
 	/* eslint-disable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars */
+	ArrayNodeCustomizableSchemaUnsafe,
 	System_Unsafe,
 	TreeNodeSchemaNonClass,
 	TreeNodeSchemaClass,
+	TreeRecordNodeUnsafe,
 	NodeKind,
 	TreeNodeSchemaCore,
 	WithType,
@@ -52,6 +54,7 @@ export namespace JsonAsTree {
 	] as const satisfies AllowedTypes;
 
 	/**
+	 * {@inheritDoc JsonAsTree.(Primitive:variable)}
 	 * @alpha
 	 */
 	export type Primitive = TreeNodeFromImplicitAllowedTypes<typeof Primitive>;
@@ -72,6 +75,7 @@ export namespace JsonAsTree {
 	export const Tree = [...Primitive, () => JsonObject, () => Array] as const;
 
 	/**
+	 * {@inheritDoc JsonAsTree.(Tree:variable)}
 	 * @alpha
 	 */
 	export type Tree = TreeNodeFromImplicitAllowedTypes<typeof Tree>;

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.52.0";
+export const pkgVersion = "2.53.0";

package/src/shared-tree/independentView.ts

@@ -42,7 +42,7 @@ import {
 } from "./sharedTree.js";
 import { createTreeCheckout } from "./treeCheckout.js";
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
-import { initialize } from "./schematizeTree.js";
+import { initialize, initializerFromChunk } from "./schematizeTree.js";
 
 /**
  * Create an uninitialized {@link TreeView} that is not tied to any {@link ITree} instance.
@@ -152,7 +152,11 @@ export function independentInitializedViewInternal<const TSchema extends Implici
 		breaker,
 	});
 
-	initialize(checkout, { schema, initialTree: rootFieldCursor });
+	initialize(
+		checkout,
+		schema,
+		initializerFromChunk(checkout, () => checkout.forest.chunkField(rootFieldCursor)),
+	);
 	return new SchematizingSimpleTreeView<TSchema>(
 		checkout,
 		config,

package/src/shared-tree/index.ts

@@ -35,8 +35,6 @@ export {
 	type TreeBranchFork,
 } from "./treeCheckout.js";
 
-export { type TreeStoredContent } from "./schematizeTree.js";
-
 export { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 
 export type {