@fluidframework/tree 2.72.0 → 2.73.0

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

@@ -8,7 +8,14 @@ import type {
 	FieldKindData,
 	Multiplicity,
 	SchemaPolicy,
+	TreeFieldStoredSchema,
+	TreeStoredSchema,
+	TreeTypeSet,
 } from "../../core/index.js";
+import type { MakeNominal } from "../../util/index.js";
+
+import type { FieldChangeHandler, FieldEditor } from "./fieldChangeHandler.js";
+import { isNeverField } from "./isNeverTree.js";
 
 /**
  * Functionality for FieldKinds that is stable,
@@ -22,26 +29,96 @@ import type {
  *
  * These policies include the data encoding, change encoding, change rebase and change application.
  *
- * @sealed * @privateRemarks
- * This being @sealed is for users of this package.
- * This package itself may provide implementations.
- * This pattern was picked instead of an interface since we do not have a convention for how to mark interfaces as only allowed to be implemented by the package declaring them,
- * and using a class also gets stronger (nominal) typing for objects which will be down cast.
+ * @privateRemarks
+ * Using a class gets stronger (nominal) typing for objects which will be down cast.
  */
-export abstract class FlexFieldKind<
-	TName extends string = string,
+export class FlexFieldKind<
+	// TODO: stronger typing
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	TEditor extends FieldEditor<any> = FieldEditor<any>,
+	TName extends FieldKindIdentifier = FieldKindIdentifier,
 	TMultiplicity extends Multiplicity = Multiplicity,
 > implements FieldKindData
 {
+	protected _typeCheck!: MakeNominal;
+
 	/**
-	 * @param identifier - Globally scoped identifier.
-	 * @param multiplicity - bound on the number of children that fields of this kind may have.
-	 * TODO: consider replacing with numeric upper and lower bounds.
+	 * Change handling policy.
 	 */
-	protected constructor(
-		public readonly identifier: TName & FieldKindIdentifier,
+	// TODO: stronger typing
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	public readonly changeHandler: FieldChangeHandler<any, TEditor>;
+
+	public constructor(
+		public readonly identifier: TName,
 		public readonly multiplicity: TMultiplicity,
-	) {}
+		// TODO: stronger typing
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		private readonly options: FieldKindOptions<FieldChangeHandler<any, TEditor>>,
+	) {
+		this.changeHandler = options.changeHandler;
+	}
+
+	/**
+	 * Returns true if and only if `superset` permits a (non-strict) superset of the subtrees
+	 * allowed by field made from `this` and `originalTypes`.
+	 *
+	 * TODO: clarify the relationship between this and FieldKindData, and issues with cyclic schema upgrades.
+	 */
+	public allowsFieldSuperset(
+		policy: SchemaPolicy,
+		originalData: TreeStoredSchema,
+		originalTypes: TreeTypeSet,
+		superset: TreeFieldStoredSchema,
+	): boolean {
+		if (
+			isNeverField(policy, originalData, {
+				kind: this.identifier,
+				types: originalTypes,
+				// Metadata is not used for this check.
+				persistedMetadata: undefined,
+			})
+		) {
+			return true;
+		}
+		if (isNeverField(policy, originalData, superset)) {
+			return false;
+		}
+		return this.options.allowsTreeSupersetOf(originalTypes, superset);
+	}
+}
+
+/**
+ * Additional options for {@link FlexFieldKind}.
+ *
+ * @remarks
+ * Puts the more confusing parameters into this object so they get explicit names to help with clarity.
+ */
+export interface FieldKindOptions<TFieldChangeHandler> {
+	/**
+	 * Change handling policy.
+	 */
+	readonly changeHandler: TFieldChangeHandler;
+
+	/**
+	 * Returns true if and only if `superset` permits a (non-strict) superset of the subtrees
+	 * allowed by field made from `this` and `originalTypes`.
+	 * @remarks
+	 * Used by {@link FlexFieldKind.allowsFieldSuperset}, which handles the `never` cases before calling this.
+	 */
+	readonly allowsTreeSupersetOf: (
+		originalTypes: TreeTypeSet,
+		superset: TreeFieldStoredSchema,
+	) => boolean;
+
+	/**
+	 * Kinds (in addition to this) whose edits can be processed by changeHandler.
+	 * If the kind of a field changes, and edits are rebased across that kind change,
+	 * listing the other old kind here can prevent those edits from being conflicted and
+	 * provide a chance to handle them.
+	 */
+	// TODO: provide this and use it for improved support for rebasing changes across schema upgrades.
+	// readonly handlesEditsFrom: ReadonlySet<FieldKindIdentifier>;
 }
 
 /**

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

@@ -4,14 +4,13 @@
  */
 
 import type { FieldKindIdentifier } from "../../core/index.js";
-
-import type { FieldKindWithEditor } from "./fieldKindWithEditor.js";
+import type { FlexFieldKind } from "./fieldKind.js";
 
 /**
  * Configuration for a single field kind.
  */
 export interface FieldKindConfigurationEntry {
-	readonly kind: FieldKindWithEditor;
+	readonly kind: FlexFieldKind;
 	/**
 	 * The format to be used for encoding changesets for this field kind.
 	 */

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

@@ -9,6 +9,7 @@ import { BTree } from "@tylerbu/sorted-btree-es6";
 import {
 	type DeltaDetachedNodeId,
 	type DeltaMark,
+	type FieldKindIdentifier,
 	Multiplicity,
 	type RevisionTag,
 	replaceAtomRevisions,
@@ -24,10 +25,11 @@ import type {
 	RelevantRemovedRootsFromChild,
 	ToDelta,
 } from "./fieldChangeHandler.js";
-import { FieldKindWithEditor } from "./fieldKindWithEditor.js";
 import { makeGenericChangeCodec } from "./genericFieldKindCodecs.js";
 import { newGenericChangeset, type GenericChangeset } from "./genericFieldKindTypes.js";
 import type { NodeId } from "./modularChangeTypes.js";
+import { FlexFieldKind } from "./fieldKind.js";
+import { brandConst } from "../../util/index.js";
 
 /**
  * {@link FieldChangeHandler} implementation for {@link GenericChangeset}.
@@ -164,12 +166,10 @@ function replaceRevisions(
 /**
  * {@link FieldKind} used to represent changes to elements of a field in a field-kind-agnostic format.
  */
-export const genericFieldKind: FieldKindWithEditor = new FieldKindWithEditor(
-	"ModularEditBuilder.Generic",
+export const genericFieldKind: FlexFieldKind = new FlexFieldKind(
+	brandConst("ModularEditBuilder.Generic")<FieldKindIdentifier>(),
 	Multiplicity.Sequence,
-	genericChangeHandler,
-	(types, other) => false,
-	new Set(),
+	{ changeHandler: genericChangeHandler, allowsTreeSupersetOf: (types, other) => false },
 );
 
 /**

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

@@ -26,7 +26,6 @@ export {
 	EncodedNodeChangeset,
 } from "./modularChangeFormat.js";
 export { FlexFieldKind, type FullSchemaPolicy } from "./fieldKind.js";
-export { FieldKindWithEditor } from "./fieldKindWithEditor.js";
 export {
 	type FieldChangeHandler,
 	type FieldChangeDelta,

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

@@ -13,12 +13,11 @@ import {
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 	Multiplicity,
+	type SchemaPolicy,
 } from "../../core/index.js";
 
-import type { FullSchemaPolicy } from "./fieldKind.js";
-
 export function isNeverField(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	field: TreeFieldStoredSchema,
 ): boolean {
@@ -26,7 +25,7 @@ export function isNeverField(
 }
 
 export function isNeverFieldRecursive(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	field: TreeFieldStoredSchema,
 	parentTypeStack: Set<TreeNodeStoredSchema>,
@@ -54,29 +53,29 @@ export function isNeverFieldRecursive(
 	}
 	return false;
 }
+
 /**
  * Returns true iff there are no possible trees that could meet this schema.
  * Trees which are infinite (like endless linked lists) are considered impossible.
  *
  * `undefined` means the schema is not present and thus a NeverTree.
  */
-
 export function isNeverTree(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	treeNode: TreeNodeStoredSchema | undefined,
 ): boolean {
 	return isNeverTreeRecursive(policy, originalData, treeNode, new Set());
 }
+
 /**
  * Returns true iff there are no possible trees that could meet this schema.
  * Trees which are infinite (like endless linked lists) are considered impossible.
  *
  * `undefined` means the schema is not present and thus a NeverTree.
  */
-
 export function isNeverTreeRecursive(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	treeNode: TreeNodeStoredSchema | undefined,
 	parentTypeStack: Set<TreeNodeStoredSchema>,

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

@@ -70,7 +70,6 @@ import {
 	NodeAttachState,
 	type RebaseRevisionMetadata,
 } from "./fieldChangeHandler.js";
-import { type FieldKindWithEditor, withEditor } from "./fieldKindWithEditor.js";
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
 import type { GenericChangeset } from "./genericFieldKindTypes.js";
 import {
@@ -87,6 +86,7 @@ import {
 	type NodeChangeset,
 	type NodeId,
 } from "./modularChangeTypes.js";
+import type { FlexFieldKind } from "./fieldKind.js";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -99,10 +99,10 @@ export class ModularChangeFamily
 {
 	public static readonly emptyChange: ModularChangeset = makeModularChangeset();
 
-	public readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>;
+	public readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>;
 
 	public constructor(
-		fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+		fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		public readonly codecs: ICodecFamily<ModularChangeset, ChangeEncodingContext>,
 	) {
 		this.fieldKinds = fieldKinds;
@@ -1908,7 +1908,7 @@ function invertBuilds(
  */
 export function* relevantRemovedRoots(
 	change: ModularChangeset,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): Iterable<DeltaDetachedNodeId> {
 	yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
 }
@@ -1916,7 +1916,7 @@ export function* relevantRemovedRoots(
 function* relevantRemovedRootsFromFields(
 	change: FieldChangeMap,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): Iterable<DeltaDetachedNodeId> {
 	for (const [_, fieldChange] of change) {
 		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
@@ -2022,7 +2022,7 @@ export function updateRefreshers(
  */
 export function intoDelta(
 	taggedChange: TaggedChange<ModularChangeset>,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): DeltaRoot {
 	const change = taggedChange.change;
 	const rootDelta: Mutable<DeltaRoot> = {};
@@ -2091,7 +2091,7 @@ function copyDetachedNodes(
 function intoDeltaImpl(
 	change: FieldChangeMap,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 	global: DeltaDetachedNodeChanges[],
 	rename: DeltaDetachedNodeRename[],
 ): Map<FieldKey, DeltaFieldChanges> {
@@ -2121,7 +2121,7 @@ function intoDeltaImpl(
 function deltaFromNodeChange(
 	change: NodeChangeset,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 	global: DeltaDetachedNodeChanges[],
 	rename: DeltaDetachedNodeRename[],
 ): DeltaFieldMap {
@@ -2173,19 +2173,19 @@ function isEmptyNodeChangeset(change: NodeChangeset): boolean {
 }
 
 export function getFieldKind(
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 	kind: FieldKindIdentifier,
-): FieldKindWithEditor {
+): FlexFieldKind {
 	if (kind === genericFieldKind.identifier) {
 		return genericFieldKind;
 	}
 	const fieldKind = fieldKinds.get(kind);
 	assert(fieldKind !== undefined, 0x3ad /* Unknown field kind */);
-	return withEditor(fieldKind);
+	return fieldKind;
 }
 
 export function getChangeHandler(
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 	kind: FieldKindIdentifier,
 ): FieldChangeHandler<unknown> {
 	return getFieldKind(fieldKinds, kind).changeHandler;
@@ -2668,7 +2668,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 
 	public constructor(
 		family: ChangeFamily<ChangeFamilyEditor, ModularChangeset>,
-		private readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+		private readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		changeReceiver: (change: TaggedChange<ModularChangeset>) => void,
 	) {
 		super(family, changeReceiver);

package/src/feature-libraries/object-forest/objectForest.ts

@@ -52,12 +52,8 @@ import {
 import { chunkField, defaultChunkPolicy } from "../chunked-forest/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { type CursorWithNode, SynchronousCursor } from "../treeCursorUtils.js";
-import {
-	defaultSchemaPolicy,
-	FieldKinds,
-	isFieldInSchema,
-	throwOutOfSchema,
-} from "../default-schema/index.js";
+import { defaultSchemaPolicy, FieldKinds } from "../default-schema/index.js";
+import { isFieldInSchema, throwOutOfSchema } from "../schemaChecker.js";
 
 /** A `MapTree` with mutable fields */
 interface MutableMapTree extends MapTree {

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

@@ -12,4 +12,5 @@ export {
 	optionalFieldEditor,
 	optionalChangeRebaser,
 	optionalFieldIntoDelta,
+	type OptionalFieldEditor,
 } from "./optionalField.js";

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

@@ -12,7 +12,6 @@ import type {
 import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
 import type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
-import { makeOptionalFieldCodec as makeV1Codec } from "./optionalFieldCodecV1.js";
 import { makeOptionalFieldCodec as makeV2Codec } from "./optionalFieldCodecV2.js";
 
 export const makeOptionalFieldCodecFamily = (
@@ -23,7 +22,4 @@ export const makeOptionalFieldCodecFamily = (
 		ChangeEncodingContext
 	>,
 ): ICodecFamily<OptionalChangeset, FieldChangeEncodingContext> =>
-	makeCodecFamily([
-		[1, makeV1Codec(revisionTagCodec)],
-		[2, makeV2Codec(revisionTagCodec)],
-	]);
+	makeCodecFamily([[2, makeV2Codec(revisionTagCodec)]]);

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

@@ -4,6 +4,10 @@
  */
 
 import { fail, unreachableCase } from "@fluidframework/core-utils/internal";
+import {
+	getConfigForMinVersionForCollab,
+	lowestMinVersionForCollab,
+} from "@fluidframework/runtime-utils/internal";
 
 import {
 	type CodecTree,
@@ -40,9 +44,12 @@ import type { MinimumVersionForCollab } from "@fluidframework/runtime-definition
 export function clientVersionToSchemaVersion(
 	clientVersion: MinimumVersionForCollab,
 ): SchemaFormatVersion {
-	return clientVersion < FluidClientVersion.v2_43
-		? brand(SchemaFormatVersion.v1)
-		: brand(SchemaFormatVersion.v2);
+	return brand(
+		getConfigForMinVersionForCollab(clientVersion, {
+			[lowestMinVersionForCollab]: SchemaFormatVersion.v1,
+			[FluidClientVersion.v2_43]: SchemaFormatVersion.v2,
+		}),
+	);
 }
 
 export function getCodecTreeForSchemaFormat(

package/src/feature-libraries/{default-schema/schemaChecker.ts → schemaChecker.ts}

@@ -13,10 +13,10 @@ import {
 	MapNodeStoredSchema,
 	Multiplicity,
 	type SchemaAndPolicy,
-} from "../../core/index.js";
-import { allowsValue } from "../valueUtilities.js";
-import type { MapTreeFieldViewGeneric, MinimalMapTreeNodeView } from "../mapTreeCursor.js";
-import { iterableHasSome, mapIterable } from "../../util/index.js";
+} from "../core/index.js";
+import { allowsValue } from "./valueUtilities.js";
+import type { MapTreeFieldViewGeneric, MinimalMapTreeNodeView } from "./mapTreeCursor.js";
+import { iterableHasSome, mapIterable } from "../util/index.js";
 
 export enum SchemaValidationError {
 	Field_KindNotInSchemaPolicy,

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

@@ -11,7 +11,6 @@ import type {
 } from "../../core/index.js";
 import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
-import { makeV1Codec } from "./sequenceFieldCodecV1.js";
 import { makeV2Codec } from "./sequenceFieldCodecV2.js";
 import { makeV3Codec } from "./sequenceFieldCodecV3.js";
 import type { Changeset, MarkList } from "./types.js";
@@ -25,7 +24,6 @@ export const sequenceFieldChangeCodecFactory = (
 	>,
 ): ICodecFamily<MarkList, FieldChangeEncodingContext> =>
 	makeCodecFamily<Changeset, FieldChangeEncodingContext>([
-		[1, makeV1Codec(revisionTagCodec)],
 		[2, makeV2Codec(revisionTagCodec)],
 		[3, makeV3Codec(revisionTagCodec)],
 	]);

package/src/index.ts

@@ -60,7 +60,6 @@ export {
 	type SharedTreeOptionsBeta,
 	type ForestType,
 	type SharedTreeFormatOptions,
-	SharedTreeFormatVersion,
 	Tree,
 	type RunTransaction,
 	type ForestOptions,
@@ -285,6 +284,9 @@ export {
 	type SimpleAllowedTypeAttributes,
 	encodeSimpleSchema,
 	decodeSimpleSchema,
+	exportCompatibilitySchemaSnapshot,
+	importCompatibilitySchemaSnapshot,
+	checkCompatibility,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,

package/src/packageVersion.ts

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

package/src/shared-tree/index.ts

@@ -13,7 +13,6 @@ export {
 	type ForestType,
 	type SharedTreeContentSnapshot,
 	type SharedTreeFormatOptions,
-	SharedTreeFormatVersion,
 	buildConfiguredForest,
 	defaultSharedTreeOptions,
 	type ForestOptions,

package/src/shared-tree/sharedTree.ts

@@ -574,56 +574,6 @@ export function getBranch<T extends ImplicitFieldSchema | UnsafeUnknownSchema>(
 	return kernel.checkout as unknown as BranchableTree;
 }
 
-/**
- * Format versions supported by SharedTree.
- *
- * Each version documents a required minimum version of the \@fluidframework/tree package.
- * @alpha
- */
-export const SharedTreeFormatVersion = {
-	/**
-	 * Requires \@fluidframework/tree \>= 2.0.0.
-	 *
-	 * @deprecated FF does not currently plan on supporting this format long-term.
-	 * Do not write production documents using this format, as they may not be loadable in the future.
-	 */
-	v1: 1,
-
-	/**
-	 * Requires \@fluidframework/tree \>= 2.0.0.
-	 */
-	v2: 2,
-
-	/**
-	 * Requires \@fluidframework/tree \>= 2.0.0.
-	 */
-	v3: 3,
-
-	/**
-	 * Requires \@fluidframework/tree \>= 2.0.0.
-	 */
-	v5: 5,
-
-	/**
-	 * For testing purposes only.
-	 */
-	vSharedBranches: 100,
-} as const;
-
-/**
- * Format versions supported by SharedTree.
- *
- * Each version documents a required minimum version of the \@fluidframework/tree package.
- * @alpha
- * @privateRemarks
- * See packages/dds/tree/docs/main/compatibility.md for information on how to add support for a new format.
- *
- * TODO: Before this gets promoted past Alpha,
- * a separate abstraction more suited for use in the public API should be adopted rather than reusing the same types used internally.
- * Such an abstraction should probably be in the form of a Fluid-Framework wide compatibility enum.
- */
-export type SharedTreeFormatVersion = typeof SharedTreeFormatVersion;
-
 /**
  * Defines for each EditManagerFormatVersion the SharedTreeChangeFormatVersion to use.
  * This is an arbitrary mapping that is injected in the EditManger codec.
@@ -631,14 +581,6 @@ export type SharedTreeFormatVersion = typeof SharedTreeFormatVersion;
  * This is because the format for SharedTree changes are not explicitly versioned.
  */
 export const changeFormatVersionForEditManager = DependentFormatVersion.fromPairs([
-	[
-		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v1),
-		brand<SharedTreeChangeFormatVersion>(1),
-	],
-	[
-		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v2),
-		brand<SharedTreeChangeFormatVersion>(2),
-	],
 	[
 		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v3),
 		brand<SharedTreeChangeFormatVersion>(3),
@@ -660,18 +602,6 @@ export const changeFormatVersionForEditManager = DependentFormatVersion.fromPair
  * This is because the format for SharedTree changes are not explicitly versioned.
  */
 export const changeFormatVersionForMessage = DependentFormatVersion.fromPairs([
-	[
-		brand<MessageFormatVersion>(MessageFormatVersion.undefined),
-		brand<SharedTreeChangeFormatVersion>(1),
-	],
-	[
-		brand<MessageFormatVersion>(MessageFormatVersion.v1),
-		brand<SharedTreeChangeFormatVersion>(1),
-	],
-	[
-		brand<MessageFormatVersion>(MessageFormatVersion.v2),
-		brand<SharedTreeChangeFormatVersion>(2),
-	],
 	[
 		brand<MessageFormatVersion>(MessageFormatVersion.v3),
 		brand<SharedTreeChangeFormatVersion>(3),

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -74,10 +74,7 @@ interface ChangeFormatDependencies {
 	readonly schemaChange: SchemaFormatVersion;
 }
 
-export type SharedTreeChangeFormatVersion = Brand<
-	1 | 2 | 3 | 4,
-	"SharedTreeChangeFormatVersion"
->;
+export type SharedTreeChangeFormatVersion = Brand<3 | 4, "SharedTreeChangeFormatVersion">;
 
 /**
  * Defines for each SharedTree change format the corresponding dependent formats to use.
@@ -89,8 +86,6 @@ export const dependenciesForChangeFormat: Map<
 	SharedTreeChangeFormatVersion,
 	ChangeFormatDependencies
 > = new Map([
-	[brand(1), { modularChange: brand(1), schemaChange: brand(SchemaFormatVersion.v1) }],
-	[brand(2), { modularChange: brand(2), schemaChange: brand(SchemaFormatVersion.v1) }],
 	[brand(3), { modularChange: brand(3), schemaChange: brand(SchemaFormatVersion.v1) }],
 	[brand(4), { modularChange: brand(4), schemaChange: brand(SchemaFormatVersion.v1) }],
 ]);

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

@@ -5,6 +5,10 @@
 
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import { unreachableCase } from "@fluidframework/core-utils/internal";
+import {
+	getConfigForMinVersionForCollab,
+	lowestMinVersionForCollab,
+} from "@fluidframework/runtime-utils/internal";
 
 import {
 	type CodecTree,
@@ -16,6 +20,7 @@ import {
 	type ICodecOptions,
 	type IJsonCodec,
 	makeCodecFamily,
+	makeDiscontinuedCodecVersion,
 } from "../codec/index.js";
 import { makeVersionDispatchingCodec } from "../codec/index.js";
 import type {
@@ -49,10 +54,13 @@ export function clientVersionToEditManagerFormatVersion(
 	clientVersion: MinimumVersionForCollab,
 	writeVersionOverride?: EditManagerFormatVersion,
 ): EditManagerFormatVersion {
-	const compatibleVersion: EditManagerFormatVersion =
-		clientVersion < FluidClientVersion.v2_43
-			? brand(EditManagerFormatVersion.v3)
-			: brand(EditManagerFormatVersion.v4);
+	const compatibleVersion: EditManagerFormatVersion = brand(
+		getConfigForMinVersionForCollab(clientVersion, {
+			[lowestMinVersionForCollab]: EditManagerFormatVersion.v3,
+			[FluidClientVersion.v2_43]: EditManagerFormatVersion.v4,
+		}),
+	);
+
 	return writeVersionOverride ?? compatibleVersion;
 }
 
@@ -125,21 +133,25 @@ export function makeEditManagerCodecs<TChangeset>(
 			EditManagerEncodingContext
 		>,
 	][] = Array.from(editManagerFormatVersions, (version) => {
-		const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 		switch (version) {
 			case EditManagerFormatVersion.v1:
 			case EditManagerFormatVersion.v2:
+				return [version, makeDiscontinuedCodecVersion(options, version, "2.73.0")];
 			case EditManagerFormatVersion.v3:
-			case EditManagerFormatVersion.v4:
+			case EditManagerFormatVersion.v4: {
+				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
 					version,
 					makeV1CodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
-			case EditManagerFormatVersion.v5:
+			}
+			case EditManagerFormatVersion.v5: {
+				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
 					version,
 					makeV5CodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
+			}
 			default:
 				unreachableCase(version);
 		}