@fluidframework/tree 2.91.0 → 2.93.0

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

@@ -27,11 +27,11 @@ import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 import { decode } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
-	type EncodedFieldBatch,
-	FieldBatchFormatVersion,
 	EncodedFieldBatchV1,
 	EncodedFieldBatchV2,
-} from "./format.js";
+	FieldBatchFormatVersion,
+	type EncodedFieldBatchV1OrV2,
+} from "./format/index.js";
 import type { IncrementalEncodingPolicy } from "./incrementalEncodingPolicy.js";
 import { schemaCompressedEncodeV1, schemaCompressedEncodeV2 } from "./schemaBasedEncode.js";
 import { uncompressedEncodeV1, uncompressedEncodeV2 } from "./uncompressedEncode.js";
@@ -67,7 +67,7 @@ export interface IncrementalEncoder {
 	 */
 	encodeIncrementalField(
 		cursor: ITreeCursorSynchronous,
-		chunkEncoder: (chunk: TreeChunk) => EncodedFieldBatch,
+		chunkEncoder: (chunk: TreeChunk) => EncodedFieldBatchV2,
 	): ChunkReferenceId[];
 }
 
@@ -87,7 +87,7 @@ export interface IncrementalDecoder {
 	 */
 	decodeIncrementalChunk(
 		referenceId: ChunkReferenceId,
-		chunkDecoder: (encoded: EncodedFieldBatch) => TreeChunk,
+		chunkDecoder: (encoded: EncodedFieldBatchV2) => TreeChunk,
 	): TreeChunk;
 }
 /**
@@ -117,25 +117,28 @@ export type FieldBatchCodec = ReturnType<typeof fieldBatchCodecBuilder.build>;
  */
 function makeFieldBatchCodecForVersion(
 	version: FieldBatchFormatVersion,
-	uncompressedEncodeFn: (batch: FieldBatch) => EncodedFieldBatch,
+	uncompressedEncodeFn: (batch: FieldBatch) => EncodedFieldBatchV1OrV2,
 	schemaCompressedEncodeFn: (
 		schema: StoredSchemaCollection,
 		policy: SchemaPolicy,
 		fieldBatch: FieldBatch,
 		idCompressor: IIdCompressor,
 		incrementalEncoder: IncrementalEncoder | undefined,
-	) => EncodedFieldBatch,
+	) => EncodedFieldBatchV1OrV2,
 	encodedFieldBatchType: TSchema,
 ): CodecAndSchema<FieldBatch, FieldBatchEncodingContext> {
 	return {
-		encode: (data: FieldBatch, context: FieldBatchEncodingContext): EncodedFieldBatch => {
+		encode: (
+			data: FieldBatch,
+			context: FieldBatchEncodingContext,
+		): EncodedFieldBatchV1OrV2 => {
 			for (const cursor of data) {
 				assert(
 					cursor.mode === CursorLocationType.Fields,
 					0x8a3 /* FieldBatch expects fields cursors */,
 				);
 			}
-			let encoded: EncodedFieldBatch;
+			let encoded: EncodedFieldBatchV1OrV2;
 			let incrementalEncoder: IncrementalEncoder | undefined;
 			switch (context.encodeType) {
 				case TreeCompressionStrategy.Uncompressed: {
@@ -176,7 +179,10 @@ function makeFieldBatchCodecForVersion(
 			// TODO: consider checking input data was in schema.
 			return encoded;
 		},
-		decode: (data: EncodedFieldBatch, context: FieldBatchEncodingContext): FieldBatch => {
+		decode: (
+			data: EncodedFieldBatchV1OrV2,
+			context: FieldBatchEncodingContext,
+		): FieldBatch => {
 			// TODO: consider checking data is in schema.
 			return decode(
 				data,

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

@@ -30,13 +30,15 @@ import type { IncrementalEncoder } from "./codecs.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
 	type EncodedAnyShape,
-	type EncodedChunkShape,
-	type EncodedFieldBatch,
+	type EncodedChunkShapeV1,
+	type EncodedChunkShapeV1OrV2,
+	type EncodedChunkShapeV2,
+	type EncodedFieldBatchV1OrV2,
 	type EncodedNestedArrayShape,
 	type EncodedValueShape,
 	FieldBatchFormatVersion,
 	SpecialField,
-} from "./format.js";
+} from "./format/index.js";
 
 /**
  * Encode data from `FieldBatch` into an `EncodedFieldBatch`.
@@ -48,7 +50,7 @@ import {
 export function compressedEncode(
 	fieldBatch: FieldBatch,
 	context: EncoderContext,
-): EncodedFieldBatch {
+): EncodedFieldBatchV1OrV2 {
 	const batchBuffer: BufferFormat[] = [];
 
 	// Populate buffer, including shape and identifier references
@@ -60,8 +62,8 @@ export function compressedEncode(
 	return updateShapesAndIdentifiersEncoding(context.version, batchBuffer);
 }
 
-export type BufferFormat = BufferFormatGeneric<EncodedChunkShape>;
-export type Shape = ShapeGeneric<EncodedChunkShape>;
+export type BufferFormat = BufferFormatGeneric<EncodedChunkShapeV1OrV2>;
+export type Shape = ShapeGeneric<EncodedChunkShapeV1OrV2>;
 
 /**
  * Like {@link FieldEncoder}, except data will be prefixed with the key.
@@ -163,7 +165,7 @@ export function asNodesEncoder(encoder: NodeEncoder): NodesEncoder {
 /**
  * Encodes a chunk with {@link EncodedAnyShape} by prefixing the data with its shape.
  */
-export class AnyShape extends ShapeGeneric<EncodedChunkShape> {
+export class AnyShape extends ShapeGeneric<EncodedChunkShapeV1OrV2> {
 	private constructor() {
 		super();
 	}
@@ -172,7 +174,7 @@ export class AnyShape extends ShapeGeneric<EncodedChunkShape> {
 	public encodeShape(
 		identifiers: DeduplicationTable<string>,
 		shapes: DeduplicationTable<Shape>,
-	): EncodedChunkShape {
+	): EncodedChunkShapeV1 {
 		const encodedAnyShape: EncodedAnyShape = 0;
 		return { d: encodedAnyShape };
 	}
@@ -268,7 +270,7 @@ export const anyFieldEncoder: FieldEncoder = {
  * which is an easy way to keep all the related code together without extra objects.
  */
 export class InlineArrayEncoder
-	extends ShapeGeneric<EncodedChunkShape>
+	extends ShapeGeneric<EncodedChunkShapeV1OrV2>
 	implements NodesEncoder, FieldEncoder
 {
 	public static readonly empty: InlineArrayEncoder = new InlineArrayEncoder(0, {
@@ -328,7 +330,7 @@ export class InlineArrayEncoder
 	public encodeShape(
 		identifiers: DeduplicationTable<string>,
 		shapes: DeduplicationTable<Shape>,
-	): EncodedChunkShape {
+	): EncodedChunkShapeV1 {
 		return {
 			b: {
 				length: this.length,
@@ -352,7 +354,7 @@ export class InlineArrayEncoder
 /**
  * Encodes the shape for a nested array as {@link EncodedNestedArrayShape} shape.
  */
-export class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> {
+export class NestedArrayShape extends ShapeGeneric<EncodedChunkShapeV1OrV2> {
 	/**
 	 * @param innerShape - The shape of each item in this nested array.
 	 */
@@ -363,7 +365,7 @@ export class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> {
 	public encodeShape(
 		identifiers: DeduplicationTable<string>,
 		shapes: DeduplicationTable<Shape>,
-	): EncodedChunkShape {
+	): EncodedChunkShapeV1OrV2 {
 		const shape: EncodedNestedArrayShape =
 			shapes.valueToIndex.get(this.innerShape) ??
 			fail(0xb4f /* index for shape not found in table */);
@@ -422,11 +424,11 @@ export class NestedArrayEncoder implements FieldEncoder {
 /**
  * Encodes the shape for an incremental chunk as {@link EncodedIncrementalChunkShape} shape.
  */
-export class IncrementalChunkShape extends ShapeGeneric<EncodedChunkShape> {
+export class IncrementalChunkShape extends ShapeGeneric<EncodedChunkShapeV2> {
 	public encodeShape(
 		identifiers: DeduplicationTable<string>,
 		shapes: DeduplicationTable<Shape>,
-	): EncodedChunkShape {
+	): EncodedChunkShapeV2 {
 		return {
 			e: 0 /* EncodedIncrementalChunkShape */,
 		};

package/src/feature-libraries/chunked-forest/codec/{formatGeneric.ts → format/formatGeneric.ts}

@@ -5,7 +5,7 @@
 
 import { type Static, type TSchema, Type } from "@sinclair/typebox";
 
-import type { FieldBatchFormatVersion } from "./format.js";
+import type { FieldBatchFormatVersion } from "./versions.js";
 
 /**
  * Identifier OR Index of an identifier in the identifier list.

package/src/feature-libraries/chunked-forest/codec/{format.ts → format/formatV1.ts}

@@ -5,49 +5,21 @@
 
 import { type Static, Type } from "@sinclair/typebox";
 
-import { unionOptions } from "../../../codec/index.js";
-import { strictEnum, type Values } from "../../../util/index.js";
+import { unionOptions } from "../../../../codec/index.js";
 
-import {
-	Count,
-	EncodedFieldBatchGeneric,
-	IdentifierOrIndex,
-	ShapeIndex,
-} from "./formatGeneric.js";
-
-/**
- * The format version for the field batch.
- */
-export const FieldBatchFormatVersion = strictEnum("FieldBatchFormatVersion", {
-	/**
-	 * Initial version.
-	 * @remarks
-	 * For simplicity of implementation the format for this version allows the same chunk shapes as v2, but must not use {@link EncodedIncrementalChunkShape}
-	 * as older clients will not know how to handle that shape but think they can handle this format.
-	 */
-	v1: 1,
-	/**
-	 * Adds support for incremental encoding of chunks.
-	 * @remarks
-	 * {@link EncodedIncrementalChunkShape} was added in this version.
-	 */
-	v2: 2,
-});
-export type FieldBatchFormatVersion = Values<typeof FieldBatchFormatVersion>;
-
-// Compatible versions used for format/version validation.
-// TODO: A proper version update policy will need to be documented.
-export const validVersions = new Set([...Object.values(FieldBatchFormatVersion)]);
+import { Count, IdentifierOrIndex, ShapeIndex } from "./formatGeneric.js";
 
 /**
  * Top level length is implied from length of data array.
  * All content are of this shape.
  */
+export type EncodedNestedArrayShape = Static<typeof EncodedNestedArrayShape>;
 export const EncodedNestedArrayShape = ShapeIndex;
 
 /**
  * Inline array.
  */
+export type EncodedInlineArrayShape = Static<typeof EncodedInlineArrayShape>;
 export const EncodedInlineArrayShape = Type.Object(
 	{
 		length: Count,
@@ -64,18 +36,14 @@ export const EncodedInlineArrayShape = Type.Object(
  *
  * Used for polymorphism.
  */
+export type EncodedAnyShape = Static<typeof EncodedAnyShape>;
 export const EncodedAnyShape = Type.Literal(0);
 
-/**
- * Encoded content is a {@link ChunkReferenceId}.
- * This represents the shape of a chunk that is encoded separately and is referenced by its {@link ChunkReferenceId}.
- */
-export const EncodedIncrementalChunkShape = Type.Literal(0);
-
 /**
  * Content of the encoded field is specified by the Shape referenced by the ShapeIndex.
  * This is a tuple for conciseness.
  */
+export type EncodedFieldShape = Static<typeof EncodedFieldShape>;
 export const EncodedFieldShape = Type.Tuple([
 	/**
 	 * Field key for this field.
@@ -87,33 +55,6 @@ export const EncodedFieldShape = Type.Tuple([
 	ShapeIndex,
 ]);
 
-export type EncodedFieldShape = Static<typeof EncodedFieldShape>;
-
-enum CounterRelativeTo {
-	// Relative to previous node of same type in depth first pre-order traversal.
-	PreviousNodeOfType_DepthFirstPreOrder,
-	// TODO: add alternative relative mode relative to previous note at a path to allow delta encoded sequences (like points where x and y are delta encoded relative to previous points).
-}
-
-enum CounterMode {
-	Number,
-	// TODO: document wrap modes and bit skipping. Note UUID subVersion here (ex: UUIDv4)
-	UUID,
-}
-
-/**
- * Delta encoded value relative to a previous node's value.
- */
-export const EncodedCounter = Type.Object(
-	{
-		relativeTo: Type.Enum(CounterRelativeTo),
-		// If not provided, delta inline in data.
-		delta: Type.Optional(Type.Number()),
-		mode: Type.Enum(CounterMode),
-	},
-	{ additionalProperties: false },
-);
-
 /**
  * Used in {@link EncodedValueShape} for special field kind handling.
  */
@@ -159,6 +100,10 @@ export const EncodedValueShape = Type.Union([
 ]);
 export type EncodedValueShape = undefined | Static<typeof EncodedValueShape>;
 
+/**
+ * The encoded form of a {@link Shape} for a node.
+ */
+export type EncodedNodeShape = Static<typeof EncodedNodeShape>;
 export const EncodedNodeShape = Type.Object(
 	{
 		/**
@@ -181,6 +126,30 @@ export const EncodedNodeShape = Type.Object(
 	{ additionalProperties: false },
 );
 
+/**
+ * The chunk shapes supported by the V1 format.
+ * @remarks
+ * See {@link EncodedChunkShapeV1}.
+ */
+export const shapesV1 = {
+	/**
+	 * {@link EncodedNestedArrayShape} union member.
+	 */
+	a: Type.Optional(EncodedNestedArrayShape),
+	/**
+	 * {@link EncodedInlineArrayShape} union member.
+	 */
+	b: Type.Optional(EncodedInlineArrayShape),
+	/**
+	 * {@link EncodedNodeShape} union member.
+	 */
+	c: Type.Optional(EncodedNodeShape),
+	/**
+	 * {@link EncodedAnyShape} union member.
+	 */
+	d: Type.Optional(EncodedAnyShape),
+} as const;
+
 /**
  * Discriminated union that represents the shapes of chunks in the encoded data.
  * "Chunk" here refers to a chunk of tree data, rooted at a range of nodes, that is encoded as a
@@ -191,52 +160,13 @@ export const EncodedNodeShape = Type.Object(
  * This is similar to other such concepts in the system.
  *
  * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
+ * @privateRemarks
+ * Because the TypeScript types for how we model these unions don't require exactly one property,
+ * to prevent a union with more options from being assignable to this one, we include Never.
+ * This matters in this case because the V2 format only differs in that it has another entry in this Union.
  */
-export const EncodedChunkShape = Type.Object(
-	{
-		/**
-		 * {@link EncodedNestedArrayShape} union member.
-		 */
-		a: Type.Optional(EncodedNestedArrayShape),
-		/**
-		 * {@link EncodedInlineArrayShape} union member.
-		 */
-		b: Type.Optional(EncodedInlineArrayShape),
-		/**
-		 * {@link EncodedNodeShape} union member.
-		 */
-		c: Type.Optional(EncodedNodeShape),
-		/**
-		 * {@link EncodedAnyShape} union member.
-		 */
-		d: Type.Optional(EncodedAnyShape),
-		/**
-		 * {@link EncodedIncrementalChunkShape} union member.
-		 */
-		e: Type.Optional(EncodedIncrementalChunkShape),
-	},
+export type EncodedChunkShapeV1 = Static<typeof EncodedChunkShapeV1>;
+export const EncodedChunkShapeV1 = Type.Object(
+	{ ...shapesV1, e: Type.Optional(Type.Never()) },
 	unionOptions,
 );
-
-export type EncodedChunkShape = Static<typeof EncodedChunkShape>;
-
-export type EncodedNestedArrayShape = Static<typeof EncodedNestedArrayShape>;
-export type EncodedInlineArrayShape = Static<typeof EncodedInlineArrayShape>;
-export type EncodedNodeShape = Static<typeof EncodedNodeShape>;
-export type EncodedAnyShape = Static<typeof EncodedAnyShape>;
-export type EncodedIncrementalChunkShape = Static<typeof EncodedIncrementalChunkShape>;
-
-export const EncodedFieldBatchV1 = EncodedFieldBatchGeneric(
-	FieldBatchFormatVersion.v1,
-	EncodedChunkShape,
-);
-export type EncodedFieldBatchV1 = Static<typeof EncodedFieldBatchV1>;
-
-export const EncodedFieldBatchV2 = EncodedFieldBatchGeneric(
-	FieldBatchFormatVersion.v2,
-	EncodedChunkShape,
-);
-export type EncodedFieldBatchV2 = Static<typeof EncodedFieldBatchV2>;
-
-export const EncodedFieldBatch = Type.Union([EncodedFieldBatchV1, EncodedFieldBatchV2]);
-export type EncodedFieldBatch = Static<typeof EncodedFieldBatch>;

package/src/feature-libraries/chunked-forest/codec/format/formatV2.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type Static, Type } from "@sinclair/typebox";
+
+import { unionOptions } from "../../../../codec/index.js";
+
+import { shapesV1 } from "./formatV1.js";
+
+/**
+ * Encoded content is a {@link ChunkReferenceId}.
+ * This represents the shape of a chunk that is encoded separately and is referenced by its {@link ChunkReferenceId}.
+ */
+export type EncodedIncrementalChunkShape = Static<typeof EncodedIncrementalChunkShape>;
+export const EncodedIncrementalChunkShape = Type.Literal(0);
+
+/**
+ * V2 extension of {@link EncodedChunkShapeV1}.
+ * @remarks
+ * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
+ */
+export type EncodedChunkShapeV2 = Static<typeof EncodedChunkShapeV2>;
+export const EncodedChunkShapeV2 = Type.Object(
+	{
+		...shapesV1,
+		e: Type.Optional(EncodedIncrementalChunkShape),
+	},
+	unionOptions,
+);

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

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export type {
+	EncodedChunkShapeV1,
+	EncodedInlineArrayShape,
+	EncodedNestedArrayShape,
+	EncodedNodeShape,
+	EncodedValueShape,
+	EncodedFieldShape,
+} from "./formatV1.js";
+export {
+	EncodedAnyShape,
+	SpecialField,
+} from "./formatV1.js";
+export { EncodedIncrementalChunkShape, EncodedChunkShapeV2 } from "./formatV2.js";
+export {
+	FieldBatchFormatVersion,
+	EncodedFieldBatchV1,
+	EncodedFieldBatchV2,
+	type EncodedFieldBatchV1OrV2,
+	type EncodedFieldBatchV1AndV2,
+	type EncodedChunkShapeV1OrV2,
+} from "./versions.js";
+export type {
+	ShapeIndex,
+	IdentifierOrIndex,
+	EncodedFieldBatchGeneric,
+} from "./formatGeneric.js";

package/src/feature-libraries/chunked-forest/codec/format/versions.ts

@@ -0,0 +1,81 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { Static } from "@sinclair/typebox";
+
+import { strictEnum, type Values } from "../../../../util/index.js";
+
+import { EncodedFieldBatchGeneric } from "./formatGeneric.js";
+import { EncodedChunkShapeV1 } from "./formatV1.js";
+import { EncodedChunkShapeV2 } from "./formatV2.js";
+
+/**
+ * The format version for the field batch.
+ */
+export type FieldBatchFormatVersion = Values<typeof FieldBatchFormatVersion>;
+export const FieldBatchFormatVersion = strictEnum("FieldBatchFormatVersion", {
+	/**
+	 * Initial version.
+	 * @remarks
+	 * For simplicity of implementation the format for this version allows the same chunk shapes as v2, but must not use {@link EncodedIncrementalChunkShape}
+	 * as older clients will not know how to handle that shape but think they can handle this format.
+	 */
+	v1: 1,
+	/**
+	 * Adds support for incremental encoding of chunks.
+	 * @remarks
+	 * {@link EncodedIncrementalChunkShape} was added in this version.
+	 */
+	v2: 2,
+});
+
+/**
+ * Encoded {@link FieldBatch} using V1 format.
+ * @remarks
+ * Does not support {@link EncodedIncrementalChunkShape}.
+ */
+export type EncodedFieldBatchV1 = Static<typeof EncodedFieldBatchV1>;
+export const EncodedFieldBatchV1 = EncodedFieldBatchGeneric(
+	FieldBatchFormatVersion.v1,
+	EncodedChunkShapeV1,
+);
+
+/**
+ * Encoded {@link FieldBatch} using V2 format.
+ * @remarks
+ * Adds support for {@link EncodedIncrementalChunkShape}.
+ */
+export type EncodedFieldBatchV2 = Static<typeof EncodedFieldBatchV2>;
+export const EncodedFieldBatchV2 = EncodedFieldBatchGeneric(
+	FieldBatchFormatVersion.v2,
+	EncodedChunkShapeV2,
+);
+
+/**
+ * Encoded {@link FieldBatch}, which might use V2 features, but might also have been from a V1 encoder.
+ * @remarks
+ * Type wise, equivalent to V2, as that is a superset of V1.
+ * Used instead of just V2 for clarity.
+ */
+export type EncodedFieldBatchV1OrV2 = EncodedFieldBatchV1 | EncodedFieldBatchV2;
+
+/**
+ * Encoded data, compatible with both V1 and V2 formats.
+ * @remarks
+ * This is the intersection of the two versions, which is possible because V2 is a non-breaking extension of V1.
+ * This type can be used when the code is compatible with both versions and does not need to distinguish between them.
+ *
+ * Type wise, equivalent to V1, as that is a subset of V2.
+ * Used instead of just V1 for clarity.
+ */
+export type EncodedFieldBatchV1AndV2 = EncodedFieldBatchV1 & EncodedFieldBatchV2;
+
+/**
+ * Encoded chunk shape, which might use V2 features, but might also have been from a V1 encoder.
+ * @remarks
+ * Type wise, equivalent to V2, as that is a superset of V1.
+ * Used instead of just V2 for clarity.
+ */
+export type EncodedChunkShapeV1OrV2 = EncodedChunkShapeV1 | EncodedChunkShapeV2;

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

@@ -3,8 +3,12 @@
  * Licensed under the MIT License.
  */
 
-export type { EncodedFieldBatch } from "./format.js";
-export { FieldBatchFormatVersion } from "./format.js";
+export type {
+	EncodedFieldBatchV1,
+	EncodedFieldBatchV1OrV2,
+	EncodedFieldBatchV2,
+} from "./format/index.js";
+export { FieldBatchFormatVersion } from "./format/index.js";
 export type { FieldBatch } from "./fieldBatch.js";
 export {
 	type FieldBatchCodec,

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

@@ -24,7 +24,11 @@ import {
 	type NodeEncoder,
 	encodeValue,
 } from "./compressedEncode.js";
-import type { EncodedChunkShape, EncodedFieldShape, EncodedValueShape } from "./format.js";
+import type {
+	EncodedChunkShapeV1OrV2,
+	EncodedFieldShape,
+	EncodedValueShape,
+} from "./format/index.js";
 
 /**
  * Encodes a node with the {@link EncodedNodeShape} shape.
@@ -32,7 +36,10 @@ import type { EncodedChunkShape, EncodedFieldShape, EncodedValueShape } from "./
  * The fact this is also a Shape is an implementation detail of the encoder: that allows the shape it uses to be itself,
  * which is an easy way to keep all the related code together without extra objects.
  */
-export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements NodeEncoder {
+export class NodeShapeBasedEncoder
+	extends Shape<EncodedChunkShapeV1OrV2>
+	implements NodeEncoder
+{
 	/**
 	 * Set of keys for fields that are encoded using {@link NodeShapeBasedEncoder.specializedFieldEncoders}.
 	 * TODO: Ensure uniform chunks, encoding and identifier generation sort fields the same.
@@ -80,7 +87,7 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 	public encodeNode(
 		cursor: ITreeCursorSynchronous,
 		context: EncoderContext,
-		outputBuffer: BufferFormat<EncodedChunkShape>,
+		outputBuffer: BufferFormat<EncodedChunkShapeV1OrV2>,
 	): void {
 		if (this.type === undefined) {
 			outputBuffer.push(new IdentifierToken(cursor.type));
@@ -94,7 +101,7 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 			cursor.exitField();
 		}
 
-		const otherFieldsBuffer: BufferFormat<EncodedChunkShape> = [];
+		const otherFieldsBuffer: BufferFormat<EncodedChunkShapeV1OrV2> = [];
 
 		forEachField(cursor, () => {
 			const key = cursor.getFieldKey();
@@ -115,8 +122,8 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 
 	public encodeShape(
 		identifiers: DeduplicationTable<string>,
-		shapes: DeduplicationTable<Shape<EncodedChunkShape>>,
-	): EncodedChunkShape {
+		shapes: DeduplicationTable<Shape<EncodedChunkShapeV1OrV2>>,
+	): EncodedChunkShapeV1OrV2 {
 		return {
 			c: {
 				type: encodeOptionalIdentifier(this.type, identifiers),
@@ -129,7 +136,7 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 
 	public countReferencedShapesAndIdentifiers(
 		identifiers: Counter<string>,
-		shapeDiscovered: (shape: Shape<EncodedChunkShape>) => void,
+		shapeDiscovered: (shape: Shape<EncodedChunkShapeV1OrV2>) => void,
 	): void {
 		if (this.type !== undefined) {
 			identifiers.add(this.type);
@@ -145,7 +152,7 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 		}
 	}
 
-	public get shape(): Shape<EncodedChunkShape> {
+	public get shape(): Shape<EncodedChunkShapeV1OrV2> {
 		return this;
 	}
 }
@@ -153,7 +160,7 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 export function encodeFieldShapes(
 	fieldEncoders: readonly KeyedFieldEncoder[],
 	identifiers: DeduplicationTable<string>,
-	shapes: DeduplicationTable<Shape<EncodedChunkShape>>,
+	shapes: DeduplicationTable<Shape<EncodedChunkShapeV1OrV2>>,
 ): EncodedFieldShape[] | undefined {
 	if (fieldEncoders.length === 0) {
 		return undefined;
@@ -182,14 +189,14 @@ function encodeOptionalIdentifier(
 
 function encodeOptionalFieldShape(
 	encoder: FieldEncoder | undefined,
-	shapes: DeduplicationTable<Shape<EncodedChunkShape>>,
+	shapes: DeduplicationTable<Shape<EncodedChunkShapeV1OrV2>>,
 ): number | undefined {
 	return encoder === undefined ? undefined : dedupShape(encoder.shape, shapes);
 }
 
 function dedupShape(
-	shape: Shape<EncodedChunkShape>,
-	shapes: DeduplicationTable<Shape<EncodedChunkShape>>,
+	shape: Shape<EncodedChunkShapeV1OrV2>,
+	shapes: DeduplicationTable<Shape<EncodedChunkShapeV1OrV2>>,
 ): number {
 	return shapes.valueToIndex.get(shape) ?? fail(0xb51 /* missing shape */);
 }