@fluidframework/tree 2.91.0 → 2.92.0

package/src/core/tree/cursor.ts

@@ -134,7 +134,7 @@ export interface ITreeCursor {
 	getFieldKey(): FieldKey;
 
 	/**
-	 * @returns the number of immediate children in the current field.
+	 * Returns the number of immediate children in the current field.
 	 *
 	 * Allowed when `mode` is `Fields`, and not `pending`.
 	 */
@@ -334,6 +334,8 @@ export interface ITreeCursorSynchronous extends ITreeCursor {
 }
 
 /**
+ * Applies a mapping function to each field of the current node, returning the results as an array.
+ *
  * @param cursor - tree whose fields will be visited.
  * @param f - builds output from field, which will be selected in cursor when cursor is provided.
  * If `f` moves cursor, it must put it back to where it was at the beginning of `f` before returning.
@@ -353,6 +355,8 @@ export function mapCursorFields<T, TCursor extends ITreeCursor = ITreeCursor>(
 }
 
 /**
+ * Iterates over each field of the current node, invoking a callback for each.
+ *
  * @param cursor - cursor at a node whose fields will be visited.
  * @param f - For on each field.
  * If `f` moves cursor, it must put it back to where it was at the beginning of `f` before returning.
@@ -368,6 +372,8 @@ export function forEachField<TCursor extends ITreeCursor = ITreeCursor>(
 }
 
 /**
+ * Applies a mapping function to each node of the current field, returning the results as an array.
+ *
  * @param cursor - tree whose field will be visited.
  * @param f - builds output from field member, which will be selected in cursor when cursor is provided.
  * If `f` moves cursor, it must put it back to where it was at the beginning of `f` before returning.
@@ -386,6 +392,8 @@ export function mapCursorField<T, TCursor extends ITreeCursor = ITreeCursor>(
 }
 
 /**
+ * Lazily iterates over each node in the current field, yielding the result of applying a mapping function to each.
+ *
  * @param cursor - The tree whose field will be visited.
  * @param f - Builds output from field member, which will be selected in cursor when cursor is provided.
  * If `f` moves cursor, it must put it back to where it was at the beginning of `f` before returning.
@@ -403,6 +411,8 @@ export function* iterateCursorField<T, TCursor extends ITreeCursor = ITreeCursor
 }
 
 /**
+ * Iterates over each node in the current field, invoking a callback for each.
+ *
  * @param cursor - cursor at a field whose nodes will be visited.
  * @param f - For on each node.
  * If `f` moves cursor, it must put it back to where it was at the beginning of `f` before returning.
@@ -418,6 +428,47 @@ export function forEachNode<TCursor extends ITreeCursor = ITreeCursor>(
 }
 
 /**
+ * Iterates over a subrange of nodes in the current field, invoking a callback for each.
+ * See {@link forEachNode} for a version that visits all nodes in the field.
+ *
+ * @param cursor - cursor at a field whose nodes will be visited.
+ * @param startIndex - index of first node to visit. Must be non-negative.
+ * @param endIndex - index of first node to NOT visit. Must be greater than or equal to `startIndex`.
+ * @param f - For on each node.
+ * If `f` moves cursor, it must put it back to where it was at the beginning of `f` before returning.
+ */
+export function forEachNodeSubsequence<TCursor extends ITreeCursor = ITreeCursor>(
+	cursor: TCursor,
+	startIndex: number,
+	endIndex: number,
+	f: (cursor: TCursor) => void,
+): void {
+	assert(cursor.mode === CursorLocationType.Fields, 0xce5 /* should be in fields */);
+
+	assert(startIndex >= 0, 0xce6 /* invalid startIndex */);
+	assert(endIndex >= startIndex, 0xce7 /* invalid endIndex */);
+	const outputLength = endIndex - startIndex;
+	if (outputLength === 0) {
+		// Avoids out of bounds index on cursor.enterNode when requesting 0 length subarray at end of array.
+		return;
+	}
+
+	cursor.enterNode(startIndex);
+	for (let i = 0; i < outputLength; i++) {
+		f(cursor);
+		const hasNext = cursor.nextNode();
+		if (!hasNext) {
+			assert(i === outputLength - 1, 0xce8 /* requested endIndex is out of bounds */);
+			return;
+		}
+	}
+	cursor.exitNode();
+}
+
+/**
+ * Deeply iterates over each node in the current subtree (rooted at a node or field),
+ * invoking a callback for each.
+ *
  * @param cursor - cursor at a field or node.
  * @param f - Function to invoke for each node.
  * If `f` moves the cursor, it must put it back to where it was at the beginning of `f` before returning.

package/src/core/tree/deltaUtil.ts

@@ -7,7 +7,7 @@ import type { Mutable } from "../../util/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
 import type { TreeChunk } from "./chunk.js";
-import type { DetachedNodeId, FieldChanges, Root } from "./delta.js";
+import type { DetachedNodeId, FieldChanges, FieldMap, Root } from "./delta.js";
 import { rootFieldKey } from "./types.js";
 
 export const emptyDelta: Root = {};
@@ -58,3 +58,39 @@ export function offsetDetachId(
 export function areDetachedNodeIdsEqual(a: DetachedNodeId, b: DetachedNodeId): boolean {
 	return a.major === b.major && a.minor === b.minor;
 }
+
+/**
+ * Returns true if a delta field map contains any changes that would be visible in the document (eg, an insert, move, edit)
+ * @param fields - Delta FieldMap to check for visible changes
+ * @returns True if change map contains any changes that would be visible in the document, false otherwise
+ */
+export function deltaFieldMapHasVisibleChanges(fields: FieldMap | undefined): boolean {
+	if (fields === undefined || fields.size === 0) {
+		return false;
+	}
+	for (const [, fieldChanges] of fields) {
+		if (deltaFieldChangesHaveVisibleChanges(fieldChanges)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Returns true if the given field changes contains any changes that would be visible in the document (eg, an insert, move, edit)
+ * @param fieldChanges - Field changes to check for visible changes
+ * @returns True if the field changes contain any changes that would be visible in the document, false otherwise
+ */
+export function deltaFieldChangesHaveVisibleChanges(fieldChanges: FieldChanges): boolean {
+	for (const mark of fieldChanges.marks) {
+		if (
+			mark.attach !== undefined ||
+			mark.detach !== undefined ||
+			deltaFieldMapHasVisibleChanges(mark.fields)
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}

package/src/core/tree/detachedFieldIndexCodecs.ts

@@ -8,8 +8,8 @@ import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/interna
 
 import {
 	ClientVersionDispatchingCodecBuilder,
-	type CodecWriteOptions,
 	FluidClientVersion,
+	type ICodecOptions,
 } from "../../codec/index.js";
 import type { RevisionTagCodec } from "../rebase/index.js";
 
@@ -17,9 +17,9 @@ import { makeDetachedNodeToFieldCodecV1 } from "./detachedFieldIndexCodecV1.js";
 import { makeDetachedNodeToFieldCodecV2 } from "./detachedFieldIndexCodecV2.js";
 import { DetachedFieldIndexFormatVersion } from "./detachedFieldIndexFormatCommon.js";
 
-type BuildData = CodecWriteOptions & {
-	revisionTagCodec: RevisionTagCodec;
-	idCompressor: IIdCompressor;
+type BuildData = ICodecOptions & {
+	readonly revisionTagCodec: RevisionTagCodec;
+	readonly idCompressor: IIdCompressor;
 };
 
 export const detachedFieldIndexCodecBuilder = ClientVersionDispatchingCodecBuilder.build(

package/src/core/tree/index.ts

@@ -29,6 +29,7 @@ export {
 	inCursorNode,
 	CursorMarker,
 	isCursor,
+	forEachNodeSubsequence,
 } from "./cursor.js";
 export type {
 	ProtoNodes,
@@ -107,6 +108,9 @@ export {
 	makeDetachedNodeId,
 	offsetDetachId,
 	emptyDelta,
+	areDetachedNodeIdsEqual,
+	deltaFieldMapHasVisibleChanges,
+	deltaFieldChangesHaveVisibleChanges,
 } from "./deltaUtil.js";
 
 export {

package/src/core/tree/visitDelta.ts

@@ -206,7 +206,6 @@ function transferRoots(
 				delayed.push({ oldId, newId });
 				continue;
 			}
-			// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- intentional behavior
 			newRootId = detachedFieldIndex.createEntry(newId, revision);
 			const fields = mapToUpdate.get(oldRootId);
 			if (fields !== undefined) {
@@ -318,6 +317,18 @@ export interface DeltaVisitor {
 	 * @remarks This should only be called when the "current location" is a Field.
 	 */
 	exitField(key: FieldKey): void;
+
+	/**
+	 * Optional hook for obtaining the complete ordered change description for a field, suitable
+	 * for producing positional deltas for external representations (e.g. a text editor or virtual
+	 * list) without needing to diff the old and new states.
+	 * @remarks
+	 * Called once per field per delta, during the first (detach) pass only, after `enterField` but
+	 * before any `attach`, `detach`, or `enterNode` calls for the field. Firing only during the
+	 * detach pass ensures marks are always relative to the original array positions rather than an
+	 * intermediate partially-transformed state.
+	 */
+	fieldMarks?(marks: readonly Delta.Mark[]): void;
 }
 
 interface PassConfig {
@@ -401,6 +412,7 @@ function detachPass(
 	visitor: DeltaVisitor,
 	config: PassConfig,
 ): void {
+	visitor.fieldMarks?.(fieldChanges.marks);
 	let index = 0;
 	for (const mark of fieldChanges.marks) {
 		if (mark.fields !== undefined) {

package/src/core/tree/visitorUtils.ts

@@ -149,6 +149,11 @@ export function combineVisitors(visitors: readonly CombinableVisitor[]): Combine
 				v.exitField(...args);
 			}
 		},
+		fieldMarks: (marks) => {
+			for (const v of allVisitors) {
+				v.fieldMarks?.(marks);
+			}
+		},
 	};
 }
 

package/src/entrypoints/alpha.ts

@@ -5,7 +5,7 @@
 
 /*
  * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate entrypoints" in @fluid-tools/build-cli.
+ * Generated by "generate:entrypoint-sources".
  */
 
 export {
@@ -102,6 +102,10 @@ export {
 	AnnotatedAllowedTypeUnsafe, 
 	AnnotatedAllowedTypes, 
 	AnnotatedAllowedTypesUnsafe, 
+	ArrayNodeDeltaOp, 
+	ArrayNodeInsertOp, 
+	ArrayNodeRemoveOp, 
+	ArrayNodeRetainOp, 
 	CodecWriteOptionsBeta, 
 	ConciseTree, 
 	ExtensibleUnionNode, 
@@ -115,7 +119,10 @@ export {
 	JsonCompatible, 
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
-	NodeChangedData, 
+	NodeChangedData,
+	NodeChangedDataAlpha,
+	NodeChangedDataDelta,
+	NodeChangedDataProperties,
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
@@ -129,7 +136,8 @@ export {
 	TableSchema, 
 	TreeBeta, 
 	TreeBranch, 
-	TreeChangeEventsBeta, 
+	TreeChangeEventsBeta,
+	TreeChangeEventsAlpha,
 	TreeEncodingOptions, 
 	TreeRecordNode, 
 	TreeRecordNodeUnsafe, 
@@ -150,11 +158,11 @@ export {
 	// #region @alpha APIs
 	AllowedTypesFullUnsafe, 
 	ArrayNodeCustomizableSchema, 
+	ArrayNodeCustomizableSchemaAlpha, 
 	ArrayNodeCustomizableSchemaUnsafe, 
 	ArrayNodePojoEmulationSchema, 
 	ArrayNodeSchema, 
 	ArrayPlaceAnchor, 
-	BranchableTree, 
 	ChangeMetadata, 
 	CodecName, 
 	CodecWriteOptions, 
@@ -252,9 +260,9 @@ export {
 	TransactionResultFailed, 
 	TransactionResultSuccess, 
 	TreeAlpha, 
+	TreeArrayNodeAlpha, 
 	TreeBranchAlpha, 
 	TreeBranchEvents, 
-	TreeBranchFork, 
 	TreeCompressionStrategy, 
 	TreeContextAlpha, 
 	TreeIdentifierUtils, 
@@ -293,7 +301,6 @@ export {
 	exportCompatibilitySchemaSnapshot, 
 	extractPersistedSchema, 
 	generateSchemaFromSimpleSchema, 
-	getBranch, 
 	getJsonSchema, 
 	getSimpleSchema, 
 	importCompatibilitySchemaSnapshot, 

package/src/entrypoints/beta.ts

@@ -5,7 +5,7 @@
 
 /*
  * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate entrypoints" in @fluid-tools/build-cli.
+ * Generated by "generate:entrypoint-sources".
  */
 
 export {
@@ -115,7 +115,7 @@ export {
 	JsonCompatible, 
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
-	NodeChangedData, 
+	NodeChangedData,
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 

package/src/entrypoints/legacy.ts

@@ -5,7 +5,7 @@
 
 /*
  * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate entrypoints" in @fluid-tools/build-cli.
+ * Generated by "generate:entrypoint-sources".
  */
 
 export {
@@ -102,6 +102,10 @@ export {
 	AnnotatedAllowedTypeUnsafe, 
 	AnnotatedAllowedTypes, 
 	AnnotatedAllowedTypesUnsafe, 
+	ArrayNodeDeltaOp, 
+	ArrayNodeInsertOp, 
+	ArrayNodeRemoveOp, 
+	ArrayNodeRetainOp, 
 	CodecWriteOptionsBeta, 
 	ConciseTree, 
 	ExtensibleUnionNode, 
@@ -115,7 +119,10 @@ export {
 	JsonCompatible, 
 	JsonCompatibleObject, 
 	KeyEncodingOptions, 
-	NodeChangedData, 
+	NodeChangedData,
+	NodeChangedDataAlpha,
+	NodeChangedDataDelta,
+	NodeChangedDataProperties,
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
@@ -129,7 +136,8 @@ export {
 	TableSchema, 
 	TreeBeta, 
 	TreeBranch, 
-	TreeChangeEventsBeta, 
+	TreeChangeEventsBeta,
+	TreeChangeEventsAlpha,
 	TreeEncodingOptions, 
 	TreeRecordNode, 
 	TreeRecordNodeUnsafe, 

package/src/entrypoints/public.ts

@@ -5,7 +5,7 @@
 
 /*
  * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate entrypoints" in @fluid-tools/build-cli.
+ * Generated by "generate:entrypoint-sources".
  */
 
 export {

package/src/feature-libraries/changeAtomIdCodec.ts

@@ -3,23 +3,23 @@
  * Licensed under the MIT License.
  */
 
-import type { IJsonCodec } from "../codec/index.js";
+import type { JsonCodecPart } from "../codec/index.js";
 import type {
 	ChangeAtomId,
 	ChangeEncodingContext,
-	EncodedChangeAtomId,
-	EncodedRevisionTag,
 	RevisionTag,
+	RevisionTagSchema,
 } from "../core/index.js";
 
+import { EncodedChangeAtomId } from "./modular-schema/index.js";
+
 export function makeChangeAtomIdCodec(
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
-): IJsonCodec<ChangeAtomId, EncodedChangeAtomId, EncodedChangeAtomId, ChangeEncodingContext> {
+): JsonCodecPart<ChangeAtomId, typeof EncodedChangeAtomId, ChangeEncodingContext> {
 	return {
 		encode(changeAtomId: ChangeAtomId, context: ChangeEncodingContext): EncodedChangeAtomId {
 			return changeAtomId.revision === undefined || changeAtomId.revision === context.revision
@@ -34,5 +34,6 @@ export function makeChangeAtomIdCodec(
 					}
 				: { localId: changeAtomId, revision: context.revision };
 		},
+		encodedSchema: EncodedChangeAtomId,
 	};
 }

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

@@ -41,6 +41,7 @@ import {
 	getLast,
 	getOrAddEmptyToMap,
 	hasSome,
+	type Breakable,
 } from "../../util/index.js";
 
 import { BasicChunk, BasicChunkCursor, type SiblingsOrKey } from "./basicChunk.js";
@@ -85,9 +86,9 @@ export class ChunkedForest implements IEditableForest {
 		return this.roots.fields.size === 0;
 	}
 
-	public clone(schema: TreeStoredSchemaSubscription, anchors: AnchorSet): ChunkedForest {
+	public clone(schema: TreeStoredSchemaSubscription, _breaker?: Breakable): ChunkedForest {
 		this.roots.referenceAdded();
-		return new ChunkedForest(this.roots, schema, this.chunker.clone(schema), anchors);
+		return new ChunkedForest(this.roots, schema, this.chunker.clone(schema));
 	}
 
 	public chunkField(cursor: ITreeCursorSynchronous): TreeChunk[] {

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

@@ -40,8 +40,10 @@ import {
 import type { IncrementalDecoder } from "./codecs.js";
 import {
 	type EncodedAnyShape,
-	type EncodedChunkShape,
-	type EncodedFieldBatch,
+	type EncodedChunkShapeV1OrV2,
+	type EncodedChunkShapeV2,
+	type EncodedFieldBatchV1OrV2,
+	type EncodedFieldBatchV2,
 	type EncodedIncrementalChunkShape,
 	type EncodedInlineArrayShape,
 	type EncodedNestedArrayShape,
@@ -49,7 +51,7 @@ import {
 	type EncodedValueShape,
 	FieldBatchFormatVersion,
 	SpecialField,
-} from "./format.js";
+} from "./format/index.js";
 
 export interface IdDecodingContext {
 	idCompressor: IIdCompressor;
@@ -62,7 +64,7 @@ export interface IdDecodingContext {
  * Decode `chunk` into a TreeChunk.
  */
 export function decode(
-	chunk: EncodedFieldBatch,
+	chunk: EncodedFieldBatchV1OrV2,
 	idDecodingContext: { idCompressor: IIdCompressor; originatorId: SessionId },
 	incrementalDecoder?: IncrementalDecoder,
 ): TreeChunk[] {
@@ -75,8 +77,8 @@ export function decode(
 }
 
 const decoderLibrary = new DiscriminatedUnionDispatcher<
-	EncodedChunkShape,
-	[context: DecoderContext<EncodedChunkShape>],
+	EncodedChunkShapeV1OrV2,
+	[context: DecoderContext<EncodedChunkShapeV1OrV2>],
 	ChunkDecoder
 >({
 	a(shape: EncodedNestedArrayShape, context): ChunkDecoder {
@@ -91,8 +93,11 @@ const decoderLibrary = new DiscriminatedUnionDispatcher<
 	d(shape: EncodedAnyShape): ChunkDecoder {
 		return anyDecoder;
 	},
-	e(shape: EncodedIncrementalChunkShape, cache): ChunkDecoder {
-		return new IncrementalChunkDecoder(cache);
+	e(
+		shape: EncodedIncrementalChunkShape,
+		context: DecoderContext<EncodedChunkShapeV2>,
+	): ChunkDecoder {
+		return new IncrementalChunkDecoder(context);
 	},
 });
 
@@ -242,14 +247,14 @@ export class InlineArrayDecoder implements ChunkDecoder {
  * Decoder for {@link EncodedIncrementalChunkShape}s.
  */
 export class IncrementalChunkDecoder implements ChunkDecoder {
-	public constructor(private readonly context: DecoderContext<EncodedChunkShape>) {}
+	public constructor(private readonly context: DecoderContext<EncodedChunkShapeV2>) {}
 	public decode(_: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {
 		assert(
 			this.context.incrementalDecoder !== undefined,
 			0xc27 /* incremental decoder not available for incremental field decoding */,
 		);
 
-		const chunkDecoder = (batch: EncodedFieldBatch): TreeChunk => {
+		const chunkDecoder = (batch: EncodedFieldBatchV2): TreeChunk => {
 			assert(
 				batch.version >= FieldBatchFormatVersion.v2,
 				0xc9f /* Unsupported FieldBatchFormatVersion for incremental chunks; must be v2 or higher */,
@@ -292,10 +297,10 @@ type BasicFieldDecoder = (
 ) => [FieldKey, TreeChunk];
 
 /**
- * Get a decoder for fields of a provided (via `shape` and `context`) {@link EncodedChunkShape}.
+ * Get a decoder for fields of a provided (via `shape` and `context`).
  */
 function fieldDecoder(
-	context: DecoderContext<EncodedChunkShape>,
+	context: DecoderContext<EncodedChunkShapeV1OrV2>,
 	key: FieldKey,
 	shape: number,
 ): BasicFieldDecoder {
@@ -314,7 +319,7 @@ export class NodeDecoder implements ChunkDecoder {
 	private readonly fieldDecoders: readonly BasicFieldDecoder[];
 	public constructor(
 		private readonly shape: EncodedNodeShape,
-		private readonly context: DecoderContext<EncodedChunkShape>,
+		private readonly context: DecoderContext<EncodedChunkShapeV1OrV2>,
 	) {
 		this.type = shape.type === undefined ? undefined : context.identifier(shape.type);
 

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

@@ -17,7 +17,7 @@ import {
 } from "./chunkCodecUtilities.js";
 import type { IdDecodingContext } from "./chunkDecoding.js";
 import type { IncrementalDecoder } from "./codecs.js";
-import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./formatGeneric.js";
+import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./format/index.js";
 
 /**
  * General purpose shape based tree decoder which gets its support for specific shapes from the caller.

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

@@ -14,8 +14,7 @@ import {
 	type DeduplicationTable,
 	jsonMinimizingFilter,
 } from "./chunkCodecUtilities.js";
-import type { FieldBatchFormatVersion } from "./format.js";
-import type { EncodedFieldBatchGeneric } from "./formatGeneric.js";
+import type { FieldBatchFormatVersion, EncodedFieldBatchGeneric } from "./format/index.js";
 
 /**
  * An identifier which can be compressed using {@link Counter}.

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,