@fluidframework/tree 2.51.0 → 2.53.0-350190

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/object-forest/objectForest.ts

@@ -55,8 +55,8 @@ import { type CursorWithNode, SynchronousCursor } from "../treeCursorUtils.js";
 import {
 	defaultSchemaPolicy,
 	FieldKinds,
-	inSchemaOrThrow,
 	isFieldInSchema,
+	throwOutOfSchema,
 } from "../default-schema/index.js";
 
 /** A `MapTree` with mutable fields */
@@ -158,11 +158,15 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 								// Metadata is not used for schema checks
 								persistedMetadata: undefined,
 							};
-				const maybeError = isFieldInSchema(documentRoot, fieldSchema, {
-					schema,
-					policy: defaultSchemaPolicy,
-				});
-				inSchemaOrThrow(maybeError);
+				isFieldInSchema(
+					documentRoot,
+					fieldSchema,
+					{
+						schema,
+						policy: defaultSchemaPolicy,
+					},
+					throwOutOfSchema,
+				);
 			}
 		}
 	}

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/index.ts

@@ -114,9 +114,11 @@ export {
 	type SchemaCompatibilityStatus,
 	type FieldProps,
 	type FieldPropsAlpha,
+	normalizeFieldSchema,
 	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"
@@ -167,9 +169,9 @@ export {
 	type UnannotateAllowedTypes,
 	type UnannotateAllowedType,
 	type UnannotateAllowedTypesList,
-	type UnannotateAllowedTypeOrLazyItem,
 	type UnannotateImplicitFieldSchema,
 	type UnannotateSchemaRecord,
+	type SchemaStaticsAlpha,
 	// Beta APIs
 	TreeBeta,
 	type TreeChangeEventsBeta,
@@ -214,6 +216,10 @@ export {
 	type SimpleObjectFieldSchema,
 	type SimpleRecordNodeSchema,
 	normalizeAllowedTypes,
+	walkFieldSchema,
+	walkNodeSchema,
+	walkAllowedTypes,
+	type SchemaVisitor,
 	getSimpleSchema,
 	type ReadonlyArrayNode,
 	type InsertableTreeNodeFromAllowedTypes,

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.51.0";
+export const pkgVersion = "2.53.0-350190";

package/src/shared-tree/independentView.ts

@@ -12,9 +12,11 @@ import {
 
 import type { ICodecOptions } from "../codec/index.js";
 import {
+	type ITreeCursorSynchronous,
 	type RevisionTag,
 	RevisionTagCodec,
 	SchemaVersion,
+	type TreeStoredSchema,
 	TreeStoredSchemaRepository,
 } from "../core/index.js";
 import {
@@ -24,7 +26,6 @@ import {
 	type FieldBatchEncodingContext,
 	defaultSchemaPolicy,
 	TreeCompressionStrategy,
-	initializeForest,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import/no-internal-modules
 import type { Format } from "../feature-libraries/schema-index/formatV1.js";
@@ -41,6 +42,7 @@ import {
 } from "./sharedTree.js";
 import { createTreeCheckout } from "./treeCheckout.js";
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
+import { initialize } from "./schematizeTree.js";
 
 /**
  * Create an uninitialized {@link TreeView} that is not tied to any {@link ITree} instance.
@@ -85,6 +87,8 @@ export function independentView<const TSchema extends ImplicitFieldSchema>(
  * Such a view can never experience collaboration or be persisted to to a Fluid Container.
  *
  * This can be useful for testing, as well as use-cases like working on local files instead of documents stored in some Fluid service.
+ * @privateRemarks
+ * TODO: Providing an API which generates a {@link ViewableTree} extended with export options from {@link ITreeAlpha} and maybe even branching APIs would likely be better that just exposing a {@link TreeViewAlpha}.
  * @alpha
  */
 export function independentInitializedView<const TSchema extends ImplicitFieldSchema>(
@@ -92,22 +96,11 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 	options: ForestOptions & ICodecOptions,
 	content: ViewContent,
 ): TreeViewAlpha<TSchema> {
-	const breaker = new Breakable("independentInitializedView");
 	const idCompressor: IIdCompressor = content.idCompressor;
-	const mintRevisionTag = (): RevisionTag => idCompressor.generateCompressedId();
-	const revisionTagCodec = new RevisionTagCodec(idCompressor);
-
 	const fieldBatchCodec = makeFieldBatchCodec(options, 1);
 	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
 
-	const schema = new TreeStoredSchemaRepository(schemaCodec.decode(content.schema as Format));
-	const forest = buildConfiguredForest(
-		breaker,
-		options.forest ?? defaultSharedTreeOptions.forest,
-		schema,
-		idCompressor,
-	);
-
+	const schema = schemaCodec.decode(content.schema as Format);
 	const context: FieldBatchEncodingContext = {
 		encodeType: TreeCompressionStrategy.Compressed,
 		idCompressor,
@@ -117,21 +110,54 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 
 	const fieldCursors = fieldBatchCodec.decode(content.tree as JsonCompatibleReadOnly, context);
 	assert(fieldCursors.length === 1, 0xa5b /* must have exactly 1 field in batch */);
-	// Checked above.
-	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	initializeForest(forest, fieldCursors[0]!, revisionTagCodec, idCompressor, false);
+
+	return independentInitializedViewInternal(
+		config,
+		options,
+		schema,
+		// Checked above.
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		fieldCursors[0]!,
+		idCompressor,
+	);
+}
+
+/**
+ * {@link independentInitializedView} but using internal types instead of persisted data formats.
+ */
+export function independentInitializedViewInternal<const TSchema extends ImplicitFieldSchema>(
+	config: TreeViewConfiguration<TSchema>,
+	options: ForestOptions & ICodecOptions,
+	schema: TreeStoredSchema,
+	rootFieldCursor: ITreeCursorSynchronous,
+	idCompressor: IIdCompressor,
+): SchematizingSimpleTreeView<TSchema> {
+	const breaker = new Breakable("independentInitializedView");
+	const revisionTagCodec = new RevisionTagCodec(idCompressor);
+	const mintRevisionTag = (): RevisionTag => idCompressor.generateCompressedId();
+
+	// To ensure the forest is in schema when constructed, start it with an empty schema and set the schema repository content later.
+	const schemaRepository = new TreeStoredSchemaRepository();
+
+	const forest = buildConfiguredForest(
+		breaker,
+		options.forest ?? defaultSharedTreeOptions.forest,
+		schemaRepository,
+		idCompressor,
+	);
 
 	const checkout = createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCodec, {
 		forest,
-		schema,
+		schema: schemaRepository,
 		breaker,
 	});
-	const out: TreeViewAlpha<TSchema> = new SchematizingSimpleTreeView<TSchema>(
+
+	initialize(checkout, { schema, initialTree: rootFieldCursor });
+	return new SchematizingSimpleTreeView<TSchema>(
 		checkout,
 		config,
 		createNodeIdentifierManager(idCompressor),
 	);
-	return out;
 }
 
 /**

package/src/shared-tree/schematizeTree.ts

@@ -19,7 +19,7 @@ import {
 	defaultSchemaPolicy,
 	mapTreeFromCursor,
 } from "../feature-libraries/index.js";
-import { toStoredSchema, type SchemaCompatibilityTester } from "../simple-tree/index.js";
+import { toUpgradeSchema, type SchemaCompatibilityTester } from "../simple-tree/index.js";
 import { isReadonlyArray } from "../util/index.js";
 
 import type { ITreeCheckout } from "./treeCheckout.js";
@@ -219,7 +219,7 @@ export function ensureSchema(
 			return false;
 		}
 		case UpdateType.SchemaCompatible: {
-			checkout.updateSchema(toStoredSchema(viewSchema.viewSchemaRoot));
+			checkout.updateSchema(toUpgradeSchema(viewSchema.viewSchema.root));
 			return true;
 		}
 		default: {

package/src/shared-tree/schematizingTreeView.ts

@@ -12,7 +12,7 @@ import type {
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { anchorSlot, type SchemaPolicy } from "../core/index.js";
+import { anchorSlot } from "../core/index.js";
 import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
@@ -49,11 +49,12 @@ import {
 	HydratedContext,
 	SimpleContextSlot,
 	areImplicitFieldSchemaEqual,
-	createUnknownOptionalFieldPolicy,
 	prepareForInsertionContextless,
 	type FieldSchema,
-	toStoredSchema,
 	tryDisposeTreeNode,
+	FieldSchemaAlpha,
+	TreeViewConfigurationAlpha,
+	toInitialSchema,
 } from "../simple-tree/index.js";
 import {
 	type Breakable,
@@ -90,7 +91,6 @@ export class SchematizingSimpleTreeView<
 	 * Undefined iff uninitialized or disposed.
 	 */
 	private currentCompatibility: SchemaCompatibilityStatus | undefined;
-	private readonly schemaPolicy: SchemaPolicy;
 	public readonly events: Listenable<TreeViewEvents & TreeBranchEvents> &
 		IEmitter<TreeViewEvents & TreeBranchEvents> &
 		HasListeners<TreeViewEvents & TreeBranchEvents> = createEmitter();
@@ -132,13 +132,10 @@ export class SchematizingSimpleTreeView<
 		checkout.forest.anchors.slots.set(ViewSlot, this);
 
 		this.rootFieldSchema = normalizeFieldSchema(config.schema);
-		this.schemaPolicy = {
-			...defaultSchemaPolicy,
-			validateSchema: config.enableSchemaValidation,
-			allowUnknownOptionalFields: createUnknownOptionalFieldPolicy(this.rootFieldSchema),
-		};
 
-		this.viewSchema = new SchemaCompatibilityTester(this.schemaPolicy, this.rootFieldSchema);
+		const configAlpha = new TreeViewConfigurationAlpha({ schema: config.schema });
+
+		this.viewSchema = new SchemaCompatibilityTester(configAlpha);
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -175,15 +172,16 @@ export class SchematizingSimpleTreeView<
 		}
 
 		this.runSchemaEdit(() => {
-			const schema = toStoredSchema(this.viewSchema.viewSchemaRoot);
+			const schema = toInitialSchema(this.config.schema);
 			const mapTree = prepareForInsertionContextless(
 				content as InsertableContent | undefined,
 				this.rootFieldSchema,
 				{
 					schema,
-					policy: this.schemaPolicy,
+					policy: defaultSchemaPolicy,
 				},
 				this,
+				schema.rootFieldSchema,
 			);
 
 			initialize(this.checkout, {
@@ -316,16 +314,22 @@ export class SchematizingSimpleTreeView<
 
 		if (compatibility.canView) {
 			this.flexTreeContext = new Context(
-				this.schemaPolicy,
+				defaultSchemaPolicy,
 				this.checkout,
 				this.nodeKeyManager,
 			);
 			assert(!slots.has(SimpleContextSlot), 0xa47 /* extra simple tree context */);
+			assert(
+				this.rootFieldSchema instanceof FieldSchemaAlpha,
+				0xbfa /* all field schema should be FieldSchemaAlpha */,
+			);
 			slots.set(
 				SimpleContextSlot,
 				new HydratedContext(
-					normalizeFieldSchema(this.rootFieldSchema).annotatedAllowedTypesNormalized,
 					this.flexTreeContext,
+					HydratedContext.schemaMapFromRootSchema(
+						this.rootFieldSchema.annotatedAllowedTypesNormalized,
+					),
 				),
 			);
 
@@ -433,7 +437,12 @@ export class SchematizingSimpleTreeView<
 			);
 		}
 		const view = this.getFlexTreeContext();
-		setField(view.root, this.rootFieldSchema, newRoot as InsertableContent | undefined);
+		setField(
+			view.root,
+			this.rootFieldSchema,
+			newRoot as InsertableContent | undefined,
+			this.checkout.storedSchema.rootFieldSchema,
+		);
 	}
 
 	// #region Branching

package/src/shared-tree/sharedTree.ts

@@ -3,11 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type {
-	ErasedType,
-	IFluidHandle,
-	IFluidLoadable,
-} from "@fluidframework/core-interfaces/internal";
+import type { ErasedType, IFluidLoadable } from "@fluidframework/core-interfaces/internal";
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
@@ -31,7 +27,6 @@ import {
 	type FieldKey,
 	type GraphCommit,
 	type IEditableForest,
-	type ITreeCursor,
 	type JsonableTree,
 	LeafNodeStoredSchema,
 	MapNodeStoredSchema,
@@ -40,7 +35,6 @@ import {
 	SchemaVersion,
 	type TaggedChange,
 	type TreeFieldStoredSchema,
-	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 	TreeStoredSchemaRepository,
@@ -85,10 +79,7 @@ import {
 	type VerboseTree,
 	tryStoredSchemaAsArray,
 	type SimpleNodeSchema,
-	customFromCursorStored,
 	FieldKind,
-	type CustomTreeNode,
-	type CustomTreeValue,
 	type ITreeAlpha,
 	type SimpleObjectFieldSchema,
 } from "../simple-tree/index.js";
@@ -382,21 +373,7 @@ export class SharedTreeKernel
 	}
 
 	public exportVerbose(): VerboseTree | undefined {
-		const cursor = this.checkout.forest.allocateCursor("contentSnapshot");
-		try {
-			moveToDetachedField(this.checkout.forest, cursor);
-			const length = cursor.getFieldLength();
-			if (length === 0) {
-				return undefined;
-			} else if (length === 1) {
-				cursor.enterNode(0);
-				return verboseFromCursor(cursor, this.storedSchema.nodeSchema);
-			} else {
-				fail(0xac8 /* Invalid document root length */);
-			}
-		} finally {
-			cursor.free();
-		}
+		return this.checkout.exportVerbose();
 	}
 
 	public exportSimpleSchema(): SimpleTreeSchema {
@@ -723,23 +700,6 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
 	disposeForksAfterTransaction: true,
 };
 
-function verboseFromCursor(
-	reader: ITreeCursor,
-	schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>,
-): VerboseTree {
-	const fields = customFromCursorStored(reader, schema, verboseFromCursor);
-	const nodeSchema =
-		schema.get(reader.type) ?? fail(0xac9 /* missing schema for type in cursor */);
-	if (nodeSchema instanceof LeafNodeStoredSchema) {
-		return fields as CustomTreeValue;
-	}
-
-	return {
-		type: reader.type,
-		fields: fields as CustomTreeNode<IFluidHandle>,
-	};
-}
-
 function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFieldSchema {
 	let kind: FieldKind;
 	switch (schema.kind) {