@fluidframework/tree 2.71.0 → 2.73.0

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

@@ -7,16 +7,32 @@ import { type Static, Type } from "@sinclair/typebox";
 
 import { Versioned } from "../../codec/index.js";
 import { schemaFormatV1 } from "../../core/index.js";
+import { brand, type Brand } from "../../util/index.js";
 
-export const version = 1.0;
+/**
+ * The format version for the forest.
+ */
+export const ForestFormatVersion = {
+	v1: 1,
+} as const;
+export type ForestFormatVersion = Brand<
+	(typeof ForestFormatVersion)[keyof typeof ForestFormatVersion],
+	"ForestFormatVersion"
+>;
 
-export const Format = Type.Object(
-	{
-		version: Type.Literal(version),
-		keys: Type.Array(schemaFormatV1.FieldKeySchema),
-		fields: Versioned,
-	},
-	{ additionalProperties: false },
-);
+const FormatGeneric = (
+	version: ForestFormatVersion,
+	// Return type is intentionally derived.
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+) =>
+	Type.Object(
+		{
+			version: Type.Literal(version),
+			keys: Type.Array(schemaFormatV1.FieldKeySchema),
+			fields: Versioned,
+		},
+		{ additionalProperties: false },
+	);
 
+export const Format = FormatGeneric(brand<ForestFormatVersion>(ForestFormatVersion.v1));
 export type Format = Static<typeof Format>;

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

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

package/src/feature-libraries/index.ts

@@ -33,6 +33,7 @@ export {
 	makeSchemaCodec,
 	makeSchemaCodecs,
 	getCodecTreeForSchemaFormat,
+	clientVersionToSchemaVersion,
 } from "./schema-index/index.js";
 export {
 	stackTreeNodeCursor,
@@ -80,7 +81,6 @@ export {
 	genericFieldKind,
 	type HasFieldChanges,
 	type NodeExistsConstraint,
-	FieldKindWithEditor,
 	ModularChangeFamily,
 	type RelevantRemovedRootsFromChild,
 	EncodedModularChangeset,
@@ -103,11 +103,10 @@ export {
 	defaultChunkPolicy,
 	type FieldBatch,
 	type FieldBatchCodec,
-	type FieldBatchFormatVersion,
+	FieldBatchFormatVersion,
 	getCodecTreeForFieldBatchFormat,
 	makeTreeChunker,
 	makeFieldBatchCodec,
-	fluidVersionToFieldBatchCodecWriteVersion,
 	type FieldBatchEncodingContext,
 	emptyChunk,
 	combineChunks,
@@ -145,13 +144,16 @@ export {
 	fieldKindConfigurations,
 	intoDelta,
 	relevantRemovedRoots,
+	getCodecTreeForModularChangeFormat,
+	type ModularChangeFormatVersion,
+} from "./default-schema/index.js";
+
+export {
 	SchemaValidationError,
 	isNodeInSchema,
 	isFieldInSchema,
 	throwOutOfSchema,
-	getCodecTreeForModularChangeFormat,
-	type ModularChangeFormatVersion,
-} from "./default-schema/index.js";
+} from "./schemaChecker.js";
 
 export {
 	type FlexTreeOptionalField,
@@ -203,7 +205,6 @@ export {
 	makeSchemaChangeCodecs,
 	EncodedSchemaChange,
 	getCodecTreeForSchemaChangeFormat,
-	type SchemaChangeFormatVersion,
 } from "./schema-edits/index.js";
 
 export { makeMitigatedChangeFamily } from "./mitigatedChangeFamily.js";

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

@@ -19,7 +19,6 @@ import {
 import { compareSets } from "../../util/index.js";
 
 import type { FullSchemaPolicy } from "./fieldKind.js";
-import { withEditor } from "./fieldKindWithEditor.js";
 import { isNeverTree } from "./isNeverTree.js";
 
 /**
@@ -133,8 +132,8 @@ export function allowsFieldSuperset(
 	original: TreeFieldStoredSchema,
 	superset: TreeFieldStoredSchema,
 ): boolean {
-	return withEditor(
-		policy.fieldKinds.get(original.kind) ?? fail(0xb1b /* missing kind */),
+	return (
+		policy.fieldKinds.get(original.kind) ?? fail(0xb1b /* missing kind */)
 	).allowsFieldSuperset(policy, originalData, original.types, superset);
 }
 

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

@@ -6,7 +6,6 @@
 export {
 	makeSchemaChangeCodecs,
 	getCodecTreeForSchemaChangeFormat,
-	type SchemaChangeFormatVersion,
 } from "./schemaChangeCodecs.js";
 export type { SchemaChange } from "./schemaChangeTypes.js";
 export { EncodedSchemaChange } from "./schemaChangeFormat.js";

package/src/feature-libraries/schema-edits/schemaChangeCodecs.ts

@@ -4,11 +4,12 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
+import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
 
 import {
 	type CodecTree,
+	type CodecWriteOptions,
 	type ICodecFamily,
-	type ICodecOptions,
 	type IJsonCodec,
 	makeCodecFamily,
 	makeVersionDispatchingCodec,
@@ -18,32 +19,31 @@ import { getCodecTreeForSchemaFormat, makeSchemaCodec } from "../schema-index/in
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
-import { SchemaVersion } from "../../core/index.js";
-import type { Brand } from "../../util/index.js";
+import { SchemaFormatVersion } from "../../core/index.js";
+import { brand } from "../../util/index.js";
 
 /**
  * Create a family of schema change codecs.
  * @param options - Specifies common codec options, including which `validator` to use.
  * @returns The composed codec family.
  */
-export function makeSchemaChangeCodecs(options: ICodecOptions): ICodecFamily<SchemaChange> {
+export function makeSchemaChangeCodecs(
+	options: CodecWriteOptions,
+): ICodecFamily<SchemaChange> {
 	return makeCodecFamily([
-		[SchemaVersion.v1, makeSchemaChangeCodecV1(options, SchemaVersion.v1)],
-		[SchemaVersion.v2, makeSchemaChangeCodecV1(options, SchemaVersion.v2)],
+		[SchemaFormatVersion.v1, makeSchemaChangeCodecV1(options, brand(SchemaFormatVersion.v1))],
+		[SchemaFormatVersion.v2, makeSchemaChangeCodecV1(options, brand(SchemaFormatVersion.v2))],
 	]);
 }
 
-export type SchemaChangeFormatVersion = Brand<
-	SchemaVersion.v1 | SchemaVersion.v2,
-	"SchemaChangeFormatVersion"
->;
 export function getCodecTreeForSchemaChangeFormat(
-	version: SchemaChangeFormatVersion,
+	version: SchemaFormatVersion,
+	clientVersion: MinimumVersionForCollab,
 ): CodecTree {
 	return {
 		name: "SchemaChange",
 		version,
-		children: [getCodecTreeForSchemaFormat(version)],
+		children: [getCodecTreeForSchemaFormat(clientVersion)],
 	};
 }
 
@@ -54,8 +54,8 @@ export function getCodecTreeForSchemaChangeFormat(
  * @returns The composed codec.
  */
 export function makeSchemaChangeCodec(
-	options: ICodecOptions,
-	writeVersion: SchemaVersion,
+	options: CodecWriteOptions,
+	writeVersion: SchemaFormatVersion,
 ): IJsonCodec<SchemaChange> {
 	const family = makeSchemaChangeCodecs(options);
 	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
@@ -68,8 +68,8 @@ export function makeSchemaChangeCodec(
  * @returns The composed schema change codec.
  */
 function makeSchemaChangeCodecV1(
-	options: ICodecOptions,
-	schemaWriteVersion: SchemaVersion,
+	options: CodecWriteOptions,
+	schemaWriteVersion: SchemaFormatVersion,
 ): IJsonCodec<SchemaChange, EncodedSchemaChange> {
 	const schemaCodec = makeSchemaCodec(options, schemaWriteVersion);
 	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {