@fluidframework/tree 2.91.0 → 2.93.0

package/src/feature-libraries/chunked-forest/codec/schemaBasedEncode.ts

@@ -34,13 +34,13 @@ import {
 } from "./compressedEncode.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
-	type EncodedFieldBatch,
 	type EncodedFieldBatchV1,
+	type EncodedFieldBatchV1OrV2,
 	type EncodedFieldBatchV2,
 	type EncodedValueShape,
 	FieldBatchFormatVersion,
 	SpecialField,
-} from "./format.js";
+} from "./format/index.js";
 import { defaultIncrementalEncodingPolicy } from "./incrementalEncodingPolicy.js";
 import { NodeShapeBasedEncoder } from "./nodeEncoder.js";
 
@@ -55,7 +55,7 @@ export function schemaCompressedEncodeV1(
 	fieldBatch: FieldBatch,
 	idCompressor: IIdCompressor,
 ): EncodedFieldBatchV1 {
-	return schemaCompressedEncode(
+	const encoded: EncodedFieldBatchV1OrV2 = schemaCompressedEncode(
 		schema,
 		policy,
 		fieldBatch,
@@ -63,6 +63,8 @@ export function schemaCompressedEncodeV1(
 		undefined /* incrementalEncoder */,
 		brand(FieldBatchFormatVersion.v1),
 	);
+	// Since incrementalEncoder was not provided, no V2 features should be used, and this cast should be safe.
+	return encoded as EncodedFieldBatchV1;
 }
 
 /**
@@ -104,7 +106,7 @@ function schemaCompressedEncode(
 	idCompressor: IIdCompressor,
 	incrementalEncoder: IncrementalEncoder | undefined,
 	version: FieldBatchFormatVersion,
-): EncodedFieldBatch {
+): EncodedFieldBatchV1OrV2 {
 	return compressedEncode(
 		fieldBatch,
 		buildContext(schema, policy, idCompressor, incrementalEncoder, version),

package/src/feature-libraries/chunked-forest/codec/uncompressedEncode.ts

@@ -12,15 +12,15 @@ import { brand } from "../../../util/index.js";
 import type { FluidSerializableReadOnly } from "../../valueUtilities.js";
 
 import type { FieldBatch } from "./fieldBatch.js";
-import {
-	FieldBatchFormatVersion,
-	type EncodedFieldBatch,
-	type EncodedFieldBatchV1,
-	type EncodedFieldBatchV2,
-	type EncodedNestedArrayShape,
-	type EncodedNodeShape,
-} from "./format.js";
-import type { ShapeIndex } from "./formatGeneric.js";
+import type {
+	EncodedFieldBatchV1,
+	EncodedFieldBatchV1AndV2,
+	EncodedFieldBatchV2,
+	EncodedNestedArrayShape,
+	EncodedNodeShape,
+	ShapeIndex,
+} from "./format/index.js";
+import { FieldBatchFormatVersion } from "./format/index.js";
 
 /**
  * Encode data from `cursor` in the simplest way supported by `EncodedChunk` using {@link FieldBatchFormatVersion.v1}.
@@ -49,7 +49,7 @@ export function uncompressedEncodeV2(batch: FieldBatch): EncodedFieldBatchV2 {
 function uncompressedEncode(
 	batch: FieldBatch,
 	version: FieldBatchFormatVersion,
-): EncodedFieldBatch {
+): EncodedFieldBatchV1AndV2 {
 	const rootFields = batch.map(encodeSequence);
 	return {
 		version,

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

@@ -16,7 +16,6 @@ export {
 } from "./chunkTree.js";
 export { buildChunkedForest } from "./chunkedForest.js";
 export {
-	type EncodedFieldBatch,
 	FieldBatchFormatVersion,
 	type FieldBatch,
 	type FieldBatchCodec,
@@ -26,5 +25,7 @@ export {
 	type ChunkReferenceId,
 	type IncrementalEncodingPolicy,
 	defaultIncrementalEncodingPolicy,
+	type EncodedFieldBatchV1OrV2,
+	type EncodedFieldBatchV2,
 } from "./codec/index.js";
 export { emptyChunk } from "./emptyChunk.js";

package/src/feature-libraries/chunked-forest/uniformChunk.ts

@@ -5,7 +5,6 @@
 
 import { assert, compareArrays, oob, fail } from "@fluidframework/core-utils/internal";
 import type { SessionSpaceCompressedId, IIdCompressor } from "@fluidframework/id-compressor";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	CursorLocationType,
@@ -54,7 +53,7 @@ export class UniformChunk extends ReferenceCountedBase implements TreeChunk {
 		idCompressor?: IIdCompressor,
 	) {
 		super();
-		this.idCompressor = idCompressor;
+		this.idCompressor = shape.treeShape.mayContainCompressedIds ? idCompressor : undefined;
 		assert(
 			shape.treeShape.valuesPerTopLevelNode * shape.topLevelLength === values.length,
 			0x4c3 /* invalid number of values for shape */,
@@ -100,30 +99,45 @@ export class TreeShape {
 	// TODO: this is only needed at chunk roots. Optimize it base on that.
 	public readonly positions: readonly NodePositionInfo[];
 
+	/**
+	 * Whether chunks using this shape (including any descendant leaf within it) may contain values compressed by the {@link UniformChunk.idCompressor}.
+	 *
+	 * @remarks
+	 * For string leaf nodes, this can be explicitly set to `true` to indicate that the value may be a compressed id
+	 * stored as a number that needs to be decompressed back to a string.
+	 * For non-leaf nodes, this is automatically derived from whether any child shapes have it set.
+	 */
+	public readonly mayContainCompressedIds: boolean;
+
 	/**
 	 *
 	 * @param type - {@link TreeNodeSchemaIdentifier} used to compare shapes.
 	 * @param hasValue - whether or not the TreeShape has a value.
 	 * @param fieldsArray - an array of {@link FieldShape} values, which contains a TreeShape for each FieldKey.
 	 *
-	 * @param maybeDecompressedStringAsNumber - used to check whether or not the value could have been compressed by the idCompressor.
-	 * This flag can only be set on string leaf nodes, and will throw a usage error otherwise.
-	 * If set to true, an additional check can be made (example: getting the value of {@link Cursor}) to return the original uncompressed value.
+	 * @param maybeCompressedIdLeaf - whether the value may have been compressed by the {@link UniformChunk.idCompressor}.
+	 * Can only be explicitly set to `true` on string leaf nodes; otherwise this constructor asserts.
+	 * For non-leaf nodes, {@link TreeShape.mayContainCompressedIds} is automatically derived from child shapes.
 	 */
 	public constructor(
 		public readonly type: TreeNodeSchemaIdentifier,
 		public readonly hasValue: boolean,
 		public readonly fieldsArray: readonly FieldShape[],
-		public readonly maybeDecompressedStringAsNumber: boolean = false,
+		maybeCompressedIdLeaf: boolean = false,
 	) {
-		if (
-			maybeDecompressedStringAsNumber &&
-			!(hasValue && type === "com.fluidframework.leaf.string")
-		) {
-			throw new UsageError(
-				"maybeDecompressedStringAsNumber flag can only be set to true for string leaf node.",
+		assert(
+			hasValue === false || fieldsArray.length === 0,
+			0xcef /* only non-leaf can have fields */,
+		);
+		if (maybeCompressedIdLeaf) {
+			assert(
+				hasValue && type === "com.fluidframework.leaf.string",
+				0xcf0 /* only strings can opt into maybeCompressedIdLeaf */,
 			);
 		}
+		// For non-leaf nodes, derive from whether any child shapes contain compressed ids.
+		this.mayContainCompressedIds =
+			maybeCompressedIdLeaf || fieldsArray.some(([, shape]) => shape.mayContainCompressedIds);
 		const fields: Map<FieldKey, OffsetShape> = new Map();
 		let numberOfValues = hasValue ? 1 : 0;
 		const infos: NodePositionInfo[] = [
@@ -146,7 +160,7 @@ export class TreeShape {
 	}
 
 	public equals(other: TreeShape): boolean {
-		// TODO: either dedup instances and/or store a collision resistant hash for fast compare.
+		// TODO: either dedupe instances and/or store a collision resistant hash for fast compare.
 
 		if (
 			!compareArrays(
@@ -157,7 +171,11 @@ export class TreeShape {
 		) {
 			return false;
 		}
-		return this.type === other.type && this.hasValue === other.hasValue;
+		return (
+			this.type === other.type &&
+			this.hasValue === other.hasValue &&
+			this.mayContainCompressedIds === other.mayContainCompressedIds
+		);
 	}
 
 	public withTopLevelLength(topLevelLength: number): ChunkShape {
@@ -548,16 +566,20 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	}
 
 	public get value(): Value {
-		const idCompressor = this.chunk.idCompressor;
 		const info = this.nodeInfo(CursorLocationType.Nodes);
-		// If the maybeDecompressedStringAsNumber flag is set to true, we check if the value is a number.
-		// This flag can only ever be set on string leaf nodes, so if the value is a number, we can assume it is a compressible, known stable id.
-		if (info.shape.hasValue && info.shape.maybeDecompressedStringAsNumber) {
+		if (info.shape.hasValue) {
 			const value = this.chunk.values[info.valueOffset];
-			if (typeof value === "number" && idCompressor !== undefined) {
+			// If mayContainCompressedIds is set, check if the value is a number (i.e. a compressed ID that needs decompression).
+			if (info.shape.mayContainCompressedIds && typeof value === "number") {
+				const idCompressor = this.chunk.idCompressor;
+				assert(
+					idCompressor !== undefined,
+					0xcf1 /* chunk required idCompressor but did not provide it */,
+				);
 				return idCompressor.decompress(value as SessionSpaceCompressedId);
 			}
+			return value;
 		}
-		return info.shape.hasValue ? this.chunk.values[info.valueOffset] : undefined;
+		return undefined;
 	}
 }

package/src/feature-libraries/cursorComparator.ts

@@ -0,0 +1,77 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	mapCursorField,
+	mapCursorFields,
+	inCursorField,
+	type ITreeCursorSynchronous,
+	type Value,
+} from "../core/index.js";
+/**
+ * Tests whether a cursor's current node matches a previously captured subtree.
+ * Built by {@link buildNodeComparator}
+ */
+export type NodeComparator = (cursor: ITreeCursorSynchronous) => boolean;
+
+type FieldComparator = (cursor: ITreeCursorSynchronous) => boolean;
+
+/**
+ * creates a FieldComparator that checks a field has the expected number of
+ *
+ * @remarks
+ * The returned comparator checks that the field has the expected number of children
+ * and that each child node matches the corresponding comparator.
+ */
+function buildFieldComparator(nodeComparators: NodeComparator[]): FieldComparator {
+	const expectedLength = nodeComparators.length;
+	return (cursor: ITreeCursorSynchronous): boolean => {
+		if (cursor.getFieldLength() !== expectedLength) {
+			return false;
+		}
+		for (let inNodes = cursor.firstNode(); inNodes; inNodes = cursor.nextNode()) {
+			const comparator = nodeComparators[cursor.fieldIndex];
+			if (comparator?.(cursor) !== true) {
+				cursor.exitNode();
+				return false;
+			}
+		}
+		return true;
+	};
+}
+/**
+ * Walks the cursor at its current node position and builds a comparator that can test whether another
+ * cursor position has the same structure and values.
+ *
+ * @remarks
+ * Fields are compared by key (not iteration order), so this is safe regardless of cursor field ordering.
+ * Missing fields in the compared node will cause a mismatch.
+ *
+ * The cursor must be in Nodes mode. After this call, the cursor is restored to its original position.
+ *
+ */
+export function buildNodeComparator(cursor: ITreeCursorSynchronous): NodeComparator {
+	const expectedValue: Value = cursor.value;
+	if (expectedValue !== undefined) {
+		return (other: ITreeCursorSynchronous): boolean => Object.is(other.value, expectedValue);
+	}
+	const fieldComparators = mapCursorFields(cursor, (fieldCursor) => ({
+		key: fieldCursor.getFieldKey(),
+		compare: buildFieldComparator(mapCursorField(fieldCursor, buildNodeComparator)),
+	}));
+
+	return (other: ITreeCursorSynchronous): boolean => {
+		if (!Object.is(other.value, expectedValue)) {
+			return false;
+		}
+		for (const { key, compare } of fieldComparators) {
+			if (!inCursorField(other, key, () => compare(other))) {
+				return false;
+			}
+		}
+
+		return true;
+	};
+}

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

@@ -23,7 +23,7 @@ import {
 } from "../../util/index.js";
 import type {
 	ChunkReferenceId,
-	EncodedFieldBatch,
+	EncodedFieldBatchV2,
 	IncrementalEncoderDecoder,
 	IncrementalEncodingPolicy,
 	TreeChunk,
@@ -48,7 +48,7 @@ interface ChunkLoadProperties {
 	/**
 	 * The encoded contents of the chunk.
 	 */
-	readonly encodedContents: EncodedFieldBatch;
+	readonly encodedContents: EncodedFieldBatchV2;
 	/**
 	 * The path for this chunk's contents in the summary tree relative to the forest's summary tree.
 	 * This path is used to generate a summary handle for the chunk if it doesn't change between summaries.
@@ -263,7 +263,7 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 				}
 				const chunkContents = (await args.readAndParseChunk(
 					chunkContentsPath,
-				)) as EncodedFieldBatch; // TODO: this should use a codec to validate the data instead of just type casting.
+				)) as EncodedFieldBatchV2; // TODO: this should use a codec to validate the data instead of just type casting.
 				this.loadedChunksMap.set(chunkReferenceId, {
 					encodedContents: chunkContents,
 					summaryPath: chunkSubTreePath,
@@ -336,7 +336,7 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 	 */
 	public encodeIncrementalField(
 		cursor: ITreeCursorSynchronous,
-		chunkEncoder: (chunk: TreeChunk) => EncodedFieldBatch,
+		chunkEncoder: (chunk: TreeChunk) => EncodedFieldBatchV2,
 	): ChunkReferenceId[] {
 		// Validate that a summary is currently being tracked and that the tracked summary properties are defined.
 		const trackedSummaryProperties = this.requireTrackingSummary();
@@ -478,7 +478,7 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 	 */
 	public decodeIncrementalChunk(
 		referenceId: ChunkReferenceId,
-		chunkDecoder: (encoded: EncodedFieldBatch) => TreeChunk,
+		chunkDecoder: (encoded: EncodedFieldBatchV2) => TreeChunk,
 	): TreeChunk {
 		const ChunkLoadProperties = this.loadedChunksMap.get(`${referenceId}`);
 		assert(ChunkLoadProperties !== undefined, 0xc86 /* Encoded incremental chunk not found */);

package/src/feature-libraries/index.ts

@@ -29,7 +29,6 @@ export {
 export { buildForest } from "./object-forest/index.js";
 export {
 	SchemaSummarizer,
-	makeSchemaCodec,
 	schemaCodecBuilder,
 } from "./schema-index/index.js";
 export {
@@ -47,6 +46,10 @@ export {
 	jsonableTreeFromFieldCursor,
 	jsonableTreeFromForest,
 } from "./treeTextCursor.js";
+export {
+	buildNodeComparator,
+	type NodeComparator,
+} from "./cursorComparator.js";
 
 import * as SequenceField from "./sequence-field/index.js";
 // eslint-disable-next-line unicorn/prefer-export-from -- fixing requires `export * as` (breaks API-Extractor) or named exports (changes public API)
@@ -191,9 +194,8 @@ export { DetachedFieldIndexSummarizer } from "./detachedFieldIndexSummarizer.js"
 
 export {
 	type SchemaChange,
-	makeSchemaChangeCodecs,
+	makeSchemaChangeCodec,
 	EncodedSchemaChange,
-	getCodecTreeForSchemaChangeFormat,
 } from "./schema-edits/index.js";
 
 export { makeMitigatedChangeFamily } from "./mitigatedChangeFamily.js";

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -51,6 +51,7 @@ export type KeyFinder<TKey> = (tree: ITreeSubscriptionCursor) => TKey;
  * calling {@link keys} will not include any keys that are stored in the index but only map to detached nodes.
  */
 export class AnchorTreeIndex<TKey, TValue> implements TreeIndex<TKey, TValue> {
+	public readonly [Symbol.toStringTag] = "AnchorTreeIndex";
 	public disposed = false;
 	/**
 	 * Caches {@link KeyFinder}s for each schema definition. If a schema maps to null, it does not
@@ -60,6 +61,8 @@ export class AnchorTreeIndex<TKey, TValue> implements TreeIndex<TKey, TValue> {
 	private readonly keyFinders = new Map<TreeNodeSchemaIdentifier, KeyFinder<TKey> | null>();
 	/**
 	 * The actual index from keys to anchor nodes.
+	 * @remarks
+	 * Should not store empty values (and thus values should be a valid {@link TreeIndexNodes}).
 	 */
 	private readonly keyToNodes = new Map<TKey, AnchorNode[]>();
 	/**
@@ -271,7 +274,11 @@ export class AnchorTreeIndex<TKey, TValue> implements TreeIndex<TKey, TValue> {
 	public *allEntries(): IterableIterator<[TKey, TValue]> {
 		this.checkNotDisposed();
 		for (const [key, nodes] of this.keyToNodes.entries()) {
-			const value = this.getValue(nodes as unknown as TreeIndexNodes<AnchorNode>);
+			assert(
+				hasElement(nodes),
+				0xce9 /* expected at least one node for each key in the index */,
+			);
+			const value = this.getValue(nodes);
 			if (value !== undefined) {
 				yield [key, value];
 			}
@@ -420,13 +427,15 @@ export class AnchorTreeIndex<TKey, TValue> implements TreeIndex<TKey, TValue> {
 			indexedNodes !== undefined,
 			0xa90 /* destroyed anchor node should be tracked by index */,
 		);
-		const index = indexedNodes.indexOf(anchorNode);
-		assert(index !== -1, 0xa91 /* destroyed anchor node should be tracked by index */);
 		const newNodes = filterNodes(indexedNodes, (n) => n !== anchorNode);
-		if (newNodes !== undefined && newNodes.length > 0) {
-			this.keyToNodes.set(key, newNodes);
-		} else {
+		if (newNodes === undefined) {
 			this.keyToNodes.delete(key);
+		} else {
+			assert(
+				newNodes.length < indexedNodes.length,
+				0xa91 /* destroyed anchor node should be tracked by index */,
+			);
+			this.keyToNodes.set(key, newNodes);
 		}
 		this.nodeToKey.delete(anchorNode);
 		assert(
@@ -444,7 +453,7 @@ export class AnchorTreeIndex<TKey, TValue> implements TreeIndex<TKey, TValue> {
 			return nodeStatus === TreeStatus.InDocument;
 		});
 
-		if (attachedNodes !== undefined && hasElement(attachedNodes)) {
+		if (attachedNodes !== undefined) {
 			return this.getValue(attachedNodes);
 		}
 	}
@@ -456,11 +465,13 @@ export class AnchorTreeIndex<TKey, TValue> implements TreeIndex<TKey, TValue> {
 function filterNodes(
 	anchorNodes: readonly AnchorNode[] | undefined,
 	filter: (node: AnchorNode) => boolean,
-): AnchorNode[] | undefined {
+): (AnchorNode[] & TreeIndexNodes<AnchorNode>) | undefined {
 	if (anchorNodes !== undefined) {
-		return anchorNodes.filter(filter);
+		const filtered = anchorNodes.filter(filter);
+		if (hasElement(filtered)) {
+			return filtered;
+		}
 	}
-
 	return undefined;
 }
 

package/src/feature-libraries/indexing/types.ts

@@ -3,10 +3,12 @@
  * Licensed under the MIT License.
  */
 
+import type { FluidReadonlyMap } from "@fluidframework/core-interfaces/internal";
+
 /**
  * an array of nodes that is guaranteed to have at least one element
  *
- * @alpha
+ * @beta
  */
 export type TreeIndexNodes<TNode> = readonly [first: TNode, ...rest: TNode[]];
 
@@ -23,9 +25,9 @@ export type TreeIndexNodes<TNode> = readonly [first: TNode, ...rest: TNode[]];
  * Since currently partially loading a tree is not supported, there is no need for this.
  * At some point the low level shared tree index type for persisted indexes could be leveraged to provide user facing extensible sets of persisted indexes.
  * @sealed
- * @alpha
+ * @beta
  */
-export interface TreeIndex<TKey, TValue> extends ReadonlyMap<TKey, TValue> {
+export interface TreeIndex<TKey, TValue> extends FluidReadonlyMap<TKey, TValue> {
 	/**
 	 * Disposes the index such that it can no longer be used and receives no updates for changes in the tree.
 	 * @remarks

package/src/feature-libraries/mitigatedChangeFamily.ts

@@ -73,8 +73,11 @@ export function makeMitigatedRebaser<TChange>(
 			change: TaggedChange<TChange>,
 			over: TaggedChange<TChange>,
 			revisionMetadata: RevisionMetadataSource,
+			ignoreNoChangeViolation?: boolean,
 		): TChange => {
-			return withFallback(() => unmitigatedRebaser.rebase(change, over, revisionMetadata));
+			return withFallback(() =>
+				unmitigatedRebaser.rebase(change, over, revisionMetadata, ignoreNoChangeViolation),
+			);
 		},
 		getRevisions: (change: TChange): Set<RevisionTag | undefined> => {
 			try {

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { ICodecFamily, IJsonCodec } from "../../codec/index.js";
+import type { ICodecFamily, JsonCodecPart } from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
 	DeltaDetachedNodeChanges,
@@ -11,10 +11,10 @@ import type {
 	DeltaDetachedNodeRename,
 	DeltaFieldChanges,
 	DeltaFieldMap,
-	EncodedRevisionTag,
 	RevisionMetadataSource,
 	RevisionReplacer,
 	RevisionTag,
+	RevisionTagSchema,
 } from "../../core/index.js";
 import type { IdAllocator, Invariant } from "../../util/index.js";
 
@@ -57,10 +57,9 @@ export interface FieldChangeHandler<
 	_typeCheck?: Invariant<TChangeset>;
 	readonly rebaser: FieldChangeRebaser<TChangeset>;
 	readonly codecsFactory: (
-		revisionTagCodec: IJsonCodec<
+		revisionTagCodec: JsonCodecPart<
 			RevisionTag,
-			EncodedRevisionTag,
-			EncodedRevisionTag,
+			typeof RevisionTagSchema,
 			ChangeEncodingContext
 		>,
 	) => ICodecFamily<TChangeset, FieldChangeEncodingContext>;

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

@@ -97,7 +97,6 @@ function rebaseGenericChange(
 	const rebased: GenericChangeset = new BTree();
 	let nextIndex = 0;
 
-	// eslint-disable-next-line no-constant-condition
 	while (true) {
 		const newEntry = change.getPairOrNextHigher(nextIndex);
 		const baseEntry = over.getPairOrNextHigher(nextIndex);

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

@@ -9,6 +9,7 @@ import type { TAnySchema } from "@sinclair/typebox";
 import {
 	type ICodecOptions,
 	type IJsonCodec,
+	type JsonCodecPart,
 	type SchemaValidationFunction,
 	extractJsonValidator,
 	withSchemaValidation,
@@ -22,6 +23,7 @@ import type {
 	ITreeCursorSynchronous,
 	RevisionInfo,
 	RevisionTag,
+	RevisionTagSchema,
 } from "../../core/index.js";
 import {
 	type IdAllocator,
@@ -279,10 +281,9 @@ export function decodeNodeChangesetFromJson(
 export function encodeDetachedNodes(
 	detachedNodes: ChangeAtomIdBTree<TreeChunk> | undefined,
 	context: ChangeEncodingContext,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
@@ -336,10 +337,9 @@ export function encodeDetachedNodes(
 export function decodeDetachedNodes(
 	encoded: EncodedBuilds | undefined,
 	context: ChangeEncodingContext,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
@@ -385,18 +385,16 @@ export function decodeDetachedNodes(
 export function encodeRevisionInfos(
 	revisions: readonly RevisionInfo[],
 	context: ChangeEncodingContext,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 ): EncodedRevisionInfo[] | undefined {
 	if (context.revision !== undefined) {
 		assert(
-			// eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- Using optional chaining here would change behavior: `revisions[0]?.rollbackOf === undefined` is true when revisions[0] is undefined, but this check requires revisions[0] to be defined. As currently written, such a change would be safe because context.revision is included in the check and from a couple lines above is confirmed not undefined. But this more verbose form is clearer.
 			revisions.length === 1 &&
-				// eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+				// eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- Using optional chaining here would change behavior: `revisions[0]?.rollbackOf === undefined` is true when revisions[0] is undefined, but this check requires revisions[0] to be defined. As currently written, such a change would be safe because context.revision is included in the check and from a couple lines above is confirmed not undefined. But this more verbose form is clearer.
 				revisions[0] !== undefined &&
 				revisions[0].revision === context.revision &&
 				revisions[0].rollbackOf === undefined,
@@ -425,10 +423,9 @@ export function encodeRevisionInfos(
 export function decodeRevisionInfos(
 	revisions: readonly EncodedRevisionInfo[] | undefined,
 	context: ChangeEncodingContext,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 ): RevisionInfo[] | undefined {
@@ -462,10 +459,9 @@ export function encodeChange(
 			codec: FieldCodec;
 		}
 	>,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
@@ -514,10 +510,9 @@ export function decodeChange(
 			codec: FieldCodec;
 		}
 	>,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
@@ -580,10 +575,9 @@ export function decodeChange(
 
 export function getFieldChangesetCodecs(
 	fieldKinds: FieldKindConfiguration,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 	codecOptions: ICodecOptions,
@@ -629,10 +623,9 @@ export function getFieldChangesetCodecs(
 
 export function makeModularChangeCodecV1(
 	fieldKinds: FieldKindConfiguration,
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,