@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

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

@@ -0,0 +1,204 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import { TAnySchema } from "@sinclair/typebox";
+
+import { IJsonCodec } from "../../codec/index.js";
+import { ChangeEncodingContext, EncodedRevisionTag, RevisionTag } from "../../core/index.js";
+import { Mutable } from "../../util/index.js";
+import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
+import { EncodedNodeChangeset, type FieldChangeEncodingContext } from "../modular-schema/index.js";
+
+import { EncodedOptionalChangeset, EncodedRegisterId } from "./optionalFieldChangeFormatV1.js";
+import type { Move, OptionalChangeset, RegisterId } from "./optionalFieldChangeTypes.js";
+
+function makeRegisterIdCodec(
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): IJsonCodec<RegisterId, EncodedRegisterId, EncodedRegisterId, ChangeEncodingContext> {
+	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
+	return {
+		encode: (registerId: RegisterId, context: ChangeEncodingContext) => {
+			if (registerId === "self") {
+				return null;
+			}
+			return changeAtomIdCodec.encode(registerId, context);
+		},
+		decode: (registerId: EncodedRegisterId, context: ChangeEncodingContext) => {
+			if (registerId === null) {
+				return "self";
+			}
+			return changeAtomIdCodec.decode(registerId, context);
+		},
+		encodedSchema: EncodedRegisterId,
+	};
+}
+
+export function makeOptionalFieldCodec(
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): IJsonCodec<
+	OptionalChangeset,
+	EncodedOptionalChangeset<TAnySchema>,
+	EncodedOptionalChangeset<TAnySchema>,
+	FieldChangeEncodingContext
+> {
+	const registerIdCodec = makeRegisterIdCodec(revisionTagCodec);
+
+	return {
+		encode: (change: OptionalChangeset, context: FieldChangeEncodingContext) => {
+			const encoded: EncodedOptionalChangeset<TAnySchema> = {};
+			encoded.m = [];
+
+			if (change.valueReplace !== undefined) {
+				if (change.valueReplace.src !== undefined) {
+					encoded.m.push([
+						registerIdCodec.encode(change.valueReplace.src, context.baseContext),
+						registerIdCodec.encode("self", context.baseContext),
+						true,
+					]);
+				}
+
+				// When the source of the replace is "self", the destination is a reserved ID that will only be used if
+				// the tree in the field is concurrently replaced.
+				if (change.valueReplace.isEmpty || change.valueReplace.src === "self") {
+					encoded.d = registerIdCodec.encode(
+						change.valueReplace.dst,
+						context.baseContext,
+					);
+				} else {
+					encoded.m.push([
+						registerIdCodec.encode("self", context.baseContext),
+						registerIdCodec.encode(change.valueReplace.dst, context.baseContext),
+						false,
+					]);
+				}
+			}
+
+			for (const [src, dst] of change.moves) {
+				encoded.m.push([
+					registerIdCodec.encode(src, context.baseContext),
+					registerIdCodec.encode(dst, context.baseContext),
+					true,
+				]);
+			}
+
+			if (encoded.m.length === 0) {
+				delete encoded.m;
+			}
+
+			if (change.childChanges.length > 0) {
+				encoded.c = [];
+				for (const [id, childChange] of change.childChanges) {
+					encoded.c.push([
+						registerIdCodec.encode(id, context.baseContext),
+						context.encodeNode(childChange),
+					]);
+				}
+			}
+
+			return encoded;
+		},
+
+		decode: (
+			encoded: EncodedOptionalChangeset<TAnySchema>,
+			context: FieldChangeEncodingContext,
+		) => {
+			// The register that the node in the optional field is moved to upon detach
+			let detached: RegisterId | undefined;
+			// The register that the node is moved from to upon attaching that node in the optional field
+			let attached: RegisterId | undefined;
+			const moves: Move[] = [];
+			if (encoded.m !== undefined) {
+				for (const [encodedSrc, encodedDst] of encoded.m) {
+					const src = registerIdCodec.decode(encodedSrc, context.baseContext);
+					const dst = registerIdCodec.decode(encodedDst, context.baseContext);
+					if (src === "self" || dst === "self") {
+						if (src === "self") {
+							assert(detached === undefined, 0x8d0 /* Multiple detached nodes */);
+							detached = dst;
+						}
+						if (dst === "self") {
+							assert(attached === undefined, 0x8d1 /* Multiple attached nodes */);
+							attached = src;
+						}
+					} else {
+						moves.push([src, dst]);
+					}
+				}
+			}
+			const decoded: Mutable<OptionalChangeset> = {
+				moves,
+				childChanges:
+					encoded.c?.map(([id, encodedChange]) => [
+						registerIdCodec.decode(id, context.baseContext),
+						context.decodeNode(encodedChange),
+					]) ?? [],
+			};
+
+			if (detached !== undefined && attached !== undefined) {
+				if (detached === "self" || attached === "self") {
+					assert(
+						encoded.d !== undefined,
+						0x8d2 /* Invalid change: pin must have a reserved detach ID */,
+					);
+					const reserved = registerIdCodec.decode(encoded.d, context.baseContext);
+					assert(reserved !== "self", 0x8d3 /* Invalid reserved detach ID */);
+					decoded.valueReplace = { isEmpty: false, dst: reserved, src: "self" };
+				} else {
+					assert(
+						encoded.d === undefined,
+						0x8d4 /* Invalid change: unexpected reserved detach ID on a change that detaches a node from the field */,
+					);
+					decoded.valueReplace = {
+						isEmpty: false,
+						dst: detached,
+						src: attached,
+					};
+				}
+			} else if (attached !== undefined) {
+				assert(
+					encoded.d !== undefined,
+					0x8d5 /* Invalid change: attach must have a reserved detach ID */,
+				);
+				const reserved = registerIdCodec.decode(encoded.d, context.baseContext);
+				assert(reserved !== "self", 0x8d6 /* Invalid reserved detach ID */);
+				decoded.valueReplace = {
+					isEmpty: true,
+					dst: reserved,
+					src: attached,
+				};
+			} else if (detached !== undefined) {
+				assert(
+					encoded.d === undefined,
+					0x8d7 /* Invalid change: unexpected reserved detach ID on a change that detaches a node from the field */,
+				);
+				assert(detached !== "self", 0x8d8 /* Invalid detach ID */);
+				decoded.valueReplace = {
+					isEmpty: false,
+					dst: detached,
+				};
+			} else if (encoded.d !== undefined) {
+				const detachId = registerIdCodec.decode(encoded.d, context.baseContext);
+				assert(detachId !== "self", 0x8d9 /* Invalid detach ID */);
+				decoded.valueReplace = {
+					isEmpty: true,
+					dst: detachId,
+				};
+			}
+			return decoded;
+		},
+		encodedSchema: EncodedOptionalChangeset(EncodedNodeChangeset),
+	};
+}

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

@@ -0,0 +1,135 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { TAnySchema } from "@sinclair/typebox";
+
+import { IJsonCodec } from "../../codec/index.js";
+import {
+	ChangeAtomId,
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
+} from "../../core/index.js";
+import { Mutable } from "../../util/index.js";
+import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
+import {
+	EncodedNodeChangeset,
+	type EncodedChangeAtomId,
+	type FieldChangeEncodingContext,
+} from "../modular-schema/index.js";
+
+import { EncodedOptionalChangeset, EncodedRegisterId } from "./optionalFieldChangeFormatV2.js";
+import type { OptionalChangeset, RegisterId, Replace } from "./optionalFieldChangeTypes.js";
+
+function makeRegisterIdCodec(
+	changeAtomIdCodec: IJsonCodec<
+		ChangeAtomId,
+		EncodedChangeAtomId,
+		EncodedChangeAtomId,
+		ChangeEncodingContext
+	>,
+): IJsonCodec<RegisterId, EncodedRegisterId, EncodedRegisterId, ChangeEncodingContext> {
+	return {
+		encode: (registerId: RegisterId, context: ChangeEncodingContext) => {
+			if (registerId === "self") {
+				return null;
+			}
+			return changeAtomIdCodec.encode(registerId, context);
+		},
+		decode: (registerId: EncodedRegisterId, context: ChangeEncodingContext) => {
+			if (registerId === null) {
+				return "self";
+			}
+			return changeAtomIdCodec.decode(registerId, context);
+		},
+		encodedSchema: EncodedRegisterId,
+	};
+}
+
+export function makeOptionalFieldCodec(
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): IJsonCodec<
+	OptionalChangeset,
+	EncodedOptionalChangeset<TAnySchema>,
+	EncodedOptionalChangeset<TAnySchema>,
+	FieldChangeEncodingContext
+> {
+	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
+	const registerIdCodec = makeRegisterIdCodec(changeAtomIdCodec);
+
+	return {
+		encode: (change: OptionalChangeset, context: FieldChangeEncodingContext) => {
+			const encoded: EncodedOptionalChangeset<TAnySchema> = {};
+
+			if (change.moves.length > 0) {
+				encoded.m = change.moves.map(([src, dst]) => [
+					changeAtomIdCodec.encode(src, context.baseContext),
+					changeAtomIdCodec.encode(dst, context.baseContext),
+				]);
+			}
+
+			if (change.valueReplace !== undefined) {
+				encoded.r = {
+					e: change.valueReplace.isEmpty,
+					d: changeAtomIdCodec.encode(change.valueReplace.dst, context.baseContext),
+				};
+				if (change.valueReplace.src !== undefined) {
+					encoded.r.s = registerIdCodec.encode(
+						change.valueReplace.src,
+						context.baseContext,
+					);
+				}
+			}
+
+			if (change.childChanges.length > 0) {
+				encoded.c = [];
+				for (const [id, childChange] of change.childChanges) {
+					encoded.c.push([
+						registerIdCodec.encode(id, context.baseContext),
+						context.encodeNode(childChange),
+					]);
+				}
+			}
+
+			return encoded;
+		},
+
+		decode: (
+			encoded: EncodedOptionalChangeset<TAnySchema>,
+			context: FieldChangeEncodingContext,
+		) => {
+			const decoded: Mutable<OptionalChangeset> = {
+				moves:
+					encoded.m?.map(([encodedSrc, encodedDst]) => [
+						changeAtomIdCodec.decode(encodedSrc, context.baseContext),
+						changeAtomIdCodec.decode(encodedDst, context.baseContext),
+					]) ?? [],
+				childChanges:
+					encoded.c?.map(([id, encodedChange]) => [
+						registerIdCodec.decode(id, context.baseContext),
+						context.decodeNode(encodedChange),
+					]) ?? [],
+			};
+
+			if (encoded.r !== undefined) {
+				const replace: Mutable<Replace> = {
+					isEmpty: encoded.r.e,
+					dst: changeAtomIdCodec.decode(encoded.r.d, context.baseContext),
+				};
+				if (encoded.r.s !== undefined) {
+					replace.src = registerIdCodec.decode(encoded.r.s, context.baseContext);
+				}
+				decoded.valueReplace = replace;
+			}
+			return decoded;
+		},
+		encodedSchema: EncodedOptionalChangeset(EncodedNodeChangeset),
+	};
+}

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

@@ -3,219 +3,23 @@
  * Licensed under the MIT License.
  */
 
-import { TAnySchema, Type } from "@sinclair/typebox";
-import { assert } from "@fluidframework/core-utils";
-import { ICodecFamily, IJsonCodec, makeCodecFamily, unitCodec } from "../../codec/index.js";
+import { ICodecFamily, IJsonCodec, makeCodecFamily } from "../../codec/index.js";
 import { ChangeEncodingContext, EncodedRevisionTag, RevisionTag } from "../../core/index.js";
-import { JsonCompatibleReadOnly, Mutable } from "../../util/index.js";
-import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
-import type { NodeChangeset } from "../modular-schema/index.js";
-import type { Move, OptionalChangeset, RegisterId } from "./optionalFieldChangeTypes.js";
-import { EncodedOptionalChangeset, EncodedRegisterId } from "./optionalFieldChangeFormat.js";
+import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
-export const noChangeCodecFamily: ICodecFamily<0, ChangeEncodingContext> = makeCodecFamily<
-	0,
-	ChangeEncodingContext
->([[0, unitCodec]]);
+import type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
+import { makeOptionalFieldCodec as makeV1Codec } from "./optionalFieldCodecV1.js";
+import { makeOptionalFieldCodec as makeV2Codec } from "./optionalFieldCodecV2.js";
 
-export const makeOptionalFieldCodecFamily = <TChildChange = NodeChangeset>(
-	childCodec: IJsonCodec<
-		TChildChange,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>,
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-): ICodecFamily<OptionalChangeset<TChildChange>, ChangeEncodingContext> =>
-	makeCodecFamily([[0, makeOptionalFieldCodec(childCodec, revisionTagCodec)]]);
-
-function makeRegisterIdCodec(
+export const makeOptionalFieldCodecFamily = (
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
 		EncodedRevisionTag,
 		ChangeEncodingContext
 	>,
-): IJsonCodec<RegisterId, EncodedRegisterId, EncodedRegisterId, ChangeEncodingContext> {
-	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
-	return {
-		encode: (registerId: RegisterId, context: ChangeEncodingContext) => {
-			if (registerId === "self") {
-				return null;
-			}
-			return changeAtomIdCodec.encode(registerId, context);
-		},
-		decode: (registerId: EncodedRegisterId, context: ChangeEncodingContext) => {
-			if (registerId === null) {
-				return "self";
-			}
-			return changeAtomIdCodec.decode(registerId, context);
-		},
-		encodedSchema: EncodedRegisterId,
-	};
-}
-
-function makeOptionalFieldCodec<TChildChange = NodeChangeset>(
-	childCodec: IJsonCodec<
-		TChildChange,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>,
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-): IJsonCodec<
-	OptionalChangeset<TChildChange>,
-	EncodedOptionalChangeset<TAnySchema>,
-	EncodedOptionalChangeset<TAnySchema>,
-	ChangeEncodingContext
-> {
-	const registerIdCodec = makeRegisterIdCodec(revisionTagCodec);
-
-	return {
-		encode: (change: OptionalChangeset<TChildChange>, context: ChangeEncodingContext) => {
-			const encoded: EncodedOptionalChangeset<TAnySchema> = {};
-			encoded.m = [];
-
-			if (change.valueReplace !== undefined) {
-				if (change.valueReplace.src !== undefined) {
-					encoded.m.push([
-						registerIdCodec.encode(change.valueReplace.src, context),
-						registerIdCodec.encode("self", context),
-						true,
-					]);
-				}
-
-				if (change.valueReplace.isEmpty) {
-					encoded.d = registerIdCodec.encode(change.valueReplace.dst, context);
-				} else {
-					encoded.m.push([
-						registerIdCodec.encode("self", context),
-						registerIdCodec.encode(change.valueReplace.dst, context),
-						false,
-					]);
-				}
-			}
-
-			for (const [src, dst] of change.moves) {
-				encoded.m.push([
-					registerIdCodec.encode(src, context),
-					registerIdCodec.encode(dst, context),
-					true,
-				]);
-			}
-
-			if (encoded.m.length === 0) {
-				delete encoded.m;
-			}
-
-			if (change.childChanges.length > 0) {
-				encoded.c = [];
-				for (const [id, childChange] of change.childChanges) {
-					encoded.c.push([
-						registerIdCodec.encode(id, context),
-						childCodec.encode(childChange, context),
-					]);
-				}
-			}
-
-			return encoded;
-		},
-
-		decode: (encoded: EncodedOptionalChangeset<TAnySchema>, context: ChangeEncodingContext) => {
-			// The register that the node in the optional field is moved to upon detach
-			let detached: RegisterId | undefined;
-			// The register that the node is moved from to upon attaching that node in the optional field
-			let attached: RegisterId | undefined;
-			const moves: Move[] = [];
-			if (encoded.m !== undefined) {
-				for (const [encodedSrc, encodedDst] of encoded.m) {
-					const src = registerIdCodec.decode(encodedSrc, context);
-					const dst = registerIdCodec.decode(encodedDst, context);
-					if (src === "self" || dst === "self") {
-						if (src === "self") {
-							assert(detached === undefined, 0x8d0 /* Multiple detached nodes */);
-							detached = dst;
-						}
-						if (dst === "self") {
-							assert(attached === undefined, 0x8d1 /* Multiple attached nodes */);
-							attached = src;
-						}
-					} else {
-						moves.push([src, dst]);
-					}
-				}
-			}
-			const decoded: Mutable<OptionalChangeset<TChildChange>> = {
-				moves,
-				childChanges:
-					encoded.c?.map(([id, encodedChange]) => [
-						registerIdCodec.decode(id, context),
-						childCodec.decode(encodedChange, context),
-					]) ?? [],
-			};
-
-			if (detached !== undefined && attached !== undefined) {
-				if (detached === "self" || attached === "self") {
-					assert(
-						encoded.d !== undefined,
-						0x8d2 /* Invalid change: pin must have a reserved detach ID */,
-					);
-					const reserved = registerIdCodec.decode(encoded.d, context);
-					assert(reserved !== "self", 0x8d3 /* Invalid reserved detach ID */);
-					decoded.valueReplace = { isEmpty: false, dst: reserved, src: "self" };
-				} else {
-					assert(
-						encoded.d === undefined,
-						0x8d4 /* Invalid change: unexpected reserved detach ID on a change that detaches a node from the field */,
-					);
-					decoded.valueReplace = {
-						isEmpty: false,
-						dst: detached,
-						src: attached,
-					};
-				}
-			} else if (attached !== undefined) {
-				assert(
-					encoded.d !== undefined,
-					0x8d5 /* Invalid change: attach must have a reserved detach ID */,
-				);
-				const reserved = registerIdCodec.decode(encoded.d, context);
-				assert(reserved !== "self", 0x8d6 /* Invalid reserved detach ID */);
-				decoded.valueReplace = {
-					isEmpty: true,
-					dst: reserved,
-					src: attached,
-				};
-			} else if (detached !== undefined) {
-				assert(
-					encoded.d === undefined,
-					0x8d7 /* Invalid change: unexpected reserved detach ID on a change that detaches a node from the field */,
-				);
-				assert(detached !== "self", 0x8d8 /* Invalid detach ID */);
-				decoded.valueReplace = {
-					isEmpty: false,
-					dst: detached,
-				};
-			} else if (encoded.d !== undefined) {
-				const detachId = registerIdCodec.decode(encoded.d, context);
-				assert(detachId !== "self", 0x8d9 /* Invalid detach ID */);
-				decoded.valueReplace = {
-					isEmpty: true,
-					dst: detachId,
-				};
-			}
-			return decoded;
-		},
-		encodedSchema: EncodedOptionalChangeset(childCodec.encodedSchema ?? Type.Any()),
-	};
-}
+): ICodecFamily<OptionalChangeset, FieldChangeEncodingContext> =>
+	makeCodecFamily([
+		[1, makeV1Codec(revisionTagCodec)],
+		[2, makeV2Codec(revisionTagCodec)],
+	]);

package/src/feature-libraries/schema-aware/README.md

@@ -6,7 +6,7 @@ TODO:
 
     - Generate the actual APIs we need for use with Tree:
         - Flexible should align with `ContextuallyTypedNodeData`
-        - Normalized should align with `EditableTree`. This will likely require an extra setter on editable fields and on `EditableTree` for extra fields to work around [lacking support for variant accessors for index signatures in TypeScript](https://github.com/microsoft/TypeScript/issues/43826).
+        - Normalized should align with `FlexTree`. This will likely require an extra setter on editable fields and on `FlexTree` for extra fields to work around [lacking support for variant accessors for index signatures in TypeScript](https://github.com/microsoft/TypeScript/issues/43826).
     - Allow use in libraries which don't have full schema information:
         - Make unrestricted field types include an extra type in the union that covers the other cases generically.
     - Support extra map fields.

package/src/feature-libraries/schema-aware/schemaAware.ts

@@ -3,22 +3,26 @@
  * Licensed under the MIT License.
  */
 
-import { TreeNodeSchemaIdentifier, TreeValue, ValueSchema } from "../../core/index.js";
+import {
+	TreeNodeSchemaIdentifier,
+	TreeValue,
+	ValueSchema,
+	Multiplicity,
+} from "../../core/index.js";
+import { Assume, FlattenKeys, _InlineTrick } from "../../util/index.js";
 import { ContextuallyTypedNodeData, typeNameSymbol, valueSymbol } from "../contextuallyTyped.js";
 import {
-	FlexFieldSchema,
-	FlexTreeNodeSchema,
 	FlexAllowedTypes,
-	LeafNodeSchema,
-	FlexObjectNodeSchema,
-	FlexObjectNodeFields,
 	FlexFieldNodeSchema,
-	FlexMapNodeSchema,
+	FlexFieldSchema,
 	FlexListToUnion,
+	FlexMapNodeSchema,
+	FlexObjectNodeFields,
+	FlexObjectNodeSchema,
+	FlexTreeNodeSchema,
 	LazyItem,
+	LeafNodeSchema,
 } from "../typed-schema/index.js";
-import { Assume, FlattenKeys, _InlineTrick } from "../../util/index.js";
-import { Multiplicity } from "../multiplicity.js";
 
 /**
  * Empty Object for use in type computations that should contribute no fields when `&`ed with another type.

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

@@ -3,6 +3,6 @@
  * Licensed under the MIT License.
  */
 
-export { makeSchemaChangeCodec } from "./schemaChangeCodecs.js";
+export { makeSchemaChangeCodecs } from "./schemaChangeCodecs.js";
 export { SchemaChange } from "./schemaChangeTypes.js";
 export { EncodedSchemaChange } from "./schemaChangeFormat.js";

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

@@ -3,17 +3,34 @@
  * Licensed under the MIT License.
  */
 
-import { ICodecOptions, IJsonCodec } from "../../codec/index.js";
+import { assert } from "@fluidframework/core-utils/internal";
+
+import {
+	type ICodecFamily,
+	ICodecOptions,
+	IJsonCodec,
+	makeCodecFamily,
+	withSchemaValidation,
+} from "../../codec/index.js";
 import { makeSchemaCodec } from "../schema-index/index.js";
+
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import { SchemaChange } from "./schemaChangeTypes.js";
 
-export function makeSchemaChangeCodec({
+export function makeSchemaChangeCodecs(options: ICodecOptions): ICodecFamily<SchemaChange> {
+	return makeCodecFamily([[1, makeSchemaChangeCodec(options)]]);
+}
+
+function makeSchemaChangeCodec({
 	jsonValidator: validator,
 }: ICodecOptions): IJsonCodec<SchemaChange, EncodedSchemaChange> {
 	const schemaCodec = makeSchemaCodec({ jsonValidator: validator });
-	return {
+	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {
 		encode: (schemaChange) => {
+			assert(
+				!schemaChange.isInverse,
+				0x933 /* Inverse schema changes should never be transmitted */,
+			);
 			return {
 				new: schemaCodec.encode(schemaChange.schema.new),
 				old: schemaCodec.encode(schemaChange.schema.old),
@@ -25,8 +42,11 @@ export function makeSchemaChangeCodec({
 					new: schemaCodec.decode(encoded.new),
 					old: schemaCodec.decode(encoded.old),
 				},
+				isInverse: false,
 			};
 		},
 		encodedSchema: EncodedSchemaChange,
 	};
+
+	return withSchemaValidation(EncodedSchemaChange, schemaChangeCodec, validator);
 }

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

@@ -4,6 +4,7 @@
  */
 
 import { Static, Type } from "@sinclair/typebox";
+
 import { Format } from "../schema-index/index.js";
 
 export const EncodedSchemaChange = Type.Object({

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

@@ -13,4 +13,10 @@ export interface SchemaChange {
 	 * This property contains the new stored schema for the document and the old schema for inverting.
 	 */
 	readonly schema: { new: TreeStoredSchema; old: TreeStoredSchema };
+
+	/**
+	 * Whether this change reverses a previous schema change.
+	 * While non-inverse changes are expected to be backwards compatible, inverse changes are not.
+	 */
+	readonly isInverse: boolean;
 }