@fluidframework/tree 2.72.0 → 2.74.0-365691

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

@@ -23,9 +23,9 @@ import {
 	type TreeChunk,
 	tryGetChunk,
 	type SchemaAndPolicy,
+	type SchemaPolicy,
 } from "../../core/index.js";
 import { getOrCreate } from "../../util/index.js";
-import type { FullSchemaPolicy } from "../modular-schema/index.js";
 import { isStableNodeIdentifier } from "../node-identifier/index.js";
 
 import { BasicChunk } from "./basicChunk.js";
@@ -44,7 +44,7 @@ export interface Disposable {
  */
 export function makeTreeChunker(
 	schema: TreeStoredSchemaSubscription,
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	shouldEncodeIncrementally: IncrementalEncodingPolicy,
 ): IChunker {
 	return new Chunker(
@@ -113,7 +113,7 @@ export class Chunker implements IChunker {
 
 	public constructor(
 		public readonly schema: TreeStoredSchemaSubscription,
-		public readonly policy: FullSchemaPolicy,
+		public readonly policy: SchemaPolicy,
 		public readonly sequenceChunkSplitThreshold: number,
 		public readonly sequenceChunkInlineThreshold: number,
 		public readonly uniformChunkNodeCount: number,

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

@@ -46,6 +46,7 @@ import {
 	type EncodedNestedArrayShape,
 	type EncodedNodeShape,
 	type EncodedValueShape,
+	FieldBatchFormatVersion,
 	SpecialField,
 } from "./format.js";
 import type { IncrementalDecoder } from "./codecs.js";
@@ -246,6 +247,10 @@ export class IncrementalChunkDecoder implements ChunkDecoder {
 		);
 
 		const chunkDecoder = (batch: EncodedFieldBatch): TreeChunk => {
+			assert(
+				batch.version >= FieldBatchFormatVersion.v2,
+				0xc9f /* Unsupported FieldBatchFormatVersion for incremental chunks; must be v2 or higher */,
+			);
 			const context = new DecoderContext(
 				batch.identifiers,
 				batch.shapes,

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

@@ -15,6 +15,7 @@ import {
 	jsonMinimizingFilter,
 } from "./chunkCodecUtilities.js";
 import type { EncodedFieldBatchGeneric } from "./formatGeneric.js";
+import type { FieldBatchFormatVersion } from "./format.js";
 
 /**
  * An identifier which can be compressed using {@link Counter}.
@@ -51,7 +52,7 @@ export type BufferFormat<TEncodedShape> = (
  * Note that this modifies `buffer` to avoid having to copy it.
  */
 export function updateShapesAndIdentifiersEncoding<TEncodedShape>(
-	version: number,
+	version: FieldBatchFormatVersion,
 	buffer: BufferFormat<TEncodedShape>[],
 	identifierFilter: CounterFilter<string> = jsonMinimizingFilter,
 ): EncodedFieldBatchGeneric<TEncodedShape> {

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

@@ -5,10 +5,15 @@
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
+import {
+	getConfigForMinVersionForCollab,
+	lowestMinVersionForCollab,
+} from "@fluidframework/runtime-utils/internal";
 
 import {
 	type CodecTree,
 	type CodecWriteOptions,
+	FluidClientVersion,
 	type IJsonCodec,
 	makeVersionedValidatedCodec,
 } from "../../../codec/index.js";
@@ -24,19 +29,21 @@ import {
 	type Brand,
 	type JsonCompatibleReadOnly,
 } from "../../../util/index.js";
-import {
-	TreeCompressionStrategy,
-	TreeCompressionStrategyExtended,
-	type TreeCompressionStrategyPrivate,
-} from "../../treeCompressionUtils.js";
+import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
 import { decode } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
-import { EncodedFieldBatch, validVersions, FieldBatchFormatVersion } from "./format.js";
-import { schemaCompressedEncode } from "./schemaBasedEncode.js";
-import { uncompressedEncode } from "./uncompressedEncode.js";
+import {
+	type EncodedFieldBatch,
+	validVersions,
+	FieldBatchFormatVersion,
+	EncodedFieldBatchV1,
+	EncodedFieldBatchV2,
+} from "./format.js";
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
 import type { IncrementalEncodingPolicy } from "./incrementalEncodingPolicy.js";
+import { uncompressedEncodeV1, uncompressedEncodeV2 } from "./uncompressedEncode.js";
+import { schemaCompressedEncodeV1, schemaCompressedEncodeV2 } from "./schemaBasedEncode.js";
 
 /**
  * Reference ID for a chunk that is incrementally encoded.
@@ -98,7 +105,7 @@ export interface IncrementalDecoder {
 export interface IncrementalEncoderDecoder extends IncrementalEncoder, IncrementalDecoder {}
 
 export interface FieldBatchEncodingContext {
-	readonly encodeType: TreeCompressionStrategyPrivate;
+	readonly encodeType: TreeCompressionStrategy;
 	readonly idCompressor: IIdCompressor;
 	readonly originatorId: SessionId;
 	readonly schema?: SchemaAndPolicy;
@@ -119,11 +126,6 @@ export type FieldBatchCodec = IJsonCodec<
 	FieldBatchEncodingContext
 >;
 
-/**
- * Get the write version for {@link makeFieldBatchCodec} based on the `minVersionForCollab` version.
- * @privateRemarks
- * TODO: makeFieldBatchCodec (and makeVersionDispatchingCodec transitively) should bake in this versionToFormat logic and the resulting codec can then support use with FluidClientVersion directly.
- */
 /**
  * Convert a MinimumVersionForCollab to write version for {@link FieldBatchCodec}.
  * @param clientVersion - The MinimumVersionForCollab to convert.
@@ -131,8 +133,12 @@ export type FieldBatchCodec = IJsonCodec<
 function clientVersionToFieldBatchVersion(
 	clientVersion: MinimumVersionForCollab,
 ): FieldBatchFormatVersion {
-	// Currently, field batch codec only writes in version 1.
-	return brand(FieldBatchFormatVersion.v1);
+	return brand(
+		getConfigForMinVersionForCollab(clientVersion, {
+			[lowestMinVersionForCollab]: FieldBatchFormatVersion.v1,
+			[FluidClientVersion.v2_73]: FieldBatchFormatVersion.v2,
+		}),
+	);
 }
 
 export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec {
@@ -146,8 +152,27 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 		0x935 /* Invalid write version for FieldBatch codec */,
 	);
 
-	// TODO: use makeVersionDispatchingCodec to support adding more versions in the future.
-	return makeVersionedValidatedCodec(options, validVersions, EncodedFieldBatch, {
+	let uncompressedEncodeFn: typeof uncompressedEncodeV1 | typeof uncompressedEncodeV2;
+	let schemaCompressedEncodeFn:
+		| typeof schemaCompressedEncodeV1
+		| typeof schemaCompressedEncodeV2;
+	let encodedFieldBatchType: typeof EncodedFieldBatchV1 | typeof EncodedFieldBatchV2;
+	switch (writeVersion) {
+		case FieldBatchFormatVersion.v1:
+			uncompressedEncodeFn = uncompressedEncodeV1;
+			schemaCompressedEncodeFn = schemaCompressedEncodeV1;
+			encodedFieldBatchType = EncodedFieldBatchV1;
+			break;
+		case FieldBatchFormatVersion.v2:
+			uncompressedEncodeFn = uncompressedEncodeV2;
+			schemaCompressedEncodeFn = schemaCompressedEncodeV2;
+			encodedFieldBatchType = EncodedFieldBatchV2;
+			break;
+		default:
+			unreachableCase(writeVersion);
+	}
+
+	return makeVersionedValidatedCodec(options, validVersions, encodedFieldBatchType, {
 		encode: (data: FieldBatch, context: FieldBatchEncodingContext): EncodedFieldBatch => {
 			for (const cursor of data) {
 				assert(
@@ -156,27 +181,31 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 				);
 			}
 			let encoded: EncodedFieldBatch;
+			let incrementalEncoder: IncrementalEncoder | undefined;
 			switch (context.encodeType) {
 				case TreeCompressionStrategy.Uncompressed:
-					encoded = uncompressedEncode(data);
+					encoded = uncompressedEncodeFn(data);
 					break;
-				case TreeCompressionStrategyExtended.CompressedIncremental:
+				case TreeCompressionStrategy.CompressedIncremental:
+					assert(
+						writeVersion >= FieldBatchFormatVersion.v2,
+						0xca0 /* Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher */,
+					);
+					// Incremental encoding is only supported for CompressedIncremental.
+					incrementalEncoder = context.incrementalEncoderDecoder;
 				case TreeCompressionStrategy.Compressed:
 					// eslint-disable-next-line unicorn/prefer-ternary
 					if (context.schema !== undefined) {
-						encoded = schemaCompressedEncode(
+						encoded = schemaCompressedEncodeFn(
 							context.schema.schema,
 							context.schema.policy,
 							data,
 							context.idCompressor,
-							// Incremental encoding is only supported for CompressedIncremental.
-							context.encodeType === TreeCompressionStrategyExtended.CompressedIncremental
-								? context.incrementalEncoderDecoder
-								: undefined,
+							incrementalEncoder,
 						);
 					} else {
 						// TODO: consider enabling a somewhat compressed but not schema accelerated encode.
-						encoded = uncompressedEncode(data);
+						encoded = uncompressedEncodeFn(data);
 					}
 
 					break;

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

@@ -9,6 +9,7 @@ import type { IIdCompressor } from "@fluidframework/id-compressor";
 import {
 	CursorLocationType,
 	type FieldKey,
+	type FieldKindData,
 	type FieldKindIdentifier,
 	type ITreeCursorSynchronous,
 	type TreeChunk,
@@ -18,7 +19,6 @@ import {
 	forEachNode,
 } from "../../../core/index.js";
 import { getOrCreate } from "../../../util/index.js";
-import type { FlexFieldKind } from "../../modular-schema/index.js";
 
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import {
@@ -57,7 +57,7 @@ export function compressedEncode(
 		anyFieldEncoder.encodeField(cursor, context, buffer);
 		batchBuffer.push(buffer);
 	}
-	return updateShapesAndIdentifiersEncoding(FieldBatchFormatVersion.v1, batchBuffer);
+	return updateShapesAndIdentifiersEncoding(context.version, batchBuffer);
 }
 
 export type BufferFormat = BufferFormatGeneric<EncodedChunkShape>;
@@ -458,6 +458,10 @@ export const incrementalFieldEncoder: FieldEncoder = {
 			context.incrementalEncoder !== undefined,
 			0xc88 /* incremental encoder must be defined to use incrementalFieldEncoder */,
 		);
+		assert(
+			context.version >= FieldBatchFormatVersion.v2,
+			0xca1 /* Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher */,
+		);
 
 		const chunkReferenceIds = context.incrementalEncoder.encodeIncrementalField(
 			cursor,
@@ -519,7 +523,7 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 	public constructor(
 		private readonly nodeEncoderFromPolicy: NodeEncoderPolicy,
 		private readonly fieldEncoderFromPolicy: FieldEncoderPolicy,
-		public readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+		public readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FieldKindData>,
 		public readonly idCompressor: IIdCompressor,
 		/**
 		 * To be used to encode incremental chunks, if any.
@@ -527,6 +531,7 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		 * See {@link IncrementalEncoder} for more information.
 		 */
 		public readonly incrementalEncoder: IncrementalEncoder | undefined,
+		public readonly version: FieldBatchFormatVersion,
 	) {}
 
 	public nodeEncoderFromSchema(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {

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

@@ -13,13 +13,14 @@ import {
 	IdentifierOrIndex,
 	ShapeIndex,
 } from "./formatGeneric.js";
-import type { Brand } from "../../../util/index.js";
+import { brand, type Brand } from "../../../util/index.js";
 
 /**
  * The format version for the field batch.
  */
 export const FieldBatchFormatVersion = {
 	v1: 1,
+	v2: 2,
 } as const;
 export type FieldBatchFormatVersion = Brand<
 	(typeof FieldBatchFormatVersion)[keyof typeof FieldBatchFormatVersion],
@@ -28,7 +29,7 @@ export type FieldBatchFormatVersion = Brand<
 
 // Compatible versions used for format/version validation.
 // TODO: A proper version update policy will need to be documented.
-export const validVersions = new Set([FieldBatchFormatVersion.v1]);
+export const validVersions = new Set([...Object.values(FieldBatchFormatVersion)]);
 
 /**
  * Top level length is implied from length of data array.
@@ -217,8 +218,17 @@ export type EncodedNodeShape = Static<typeof EncodedNodeShape>;
 export type EncodedAnyShape = Static<typeof EncodedAnyShape>;
 export type EncodedIncrementalChunkShape = Static<typeof EncodedIncrementalChunkShape>;
 
-export const EncodedFieldBatch = EncodedFieldBatchGeneric(
-	FieldBatchFormatVersion.v1,
+export const EncodedFieldBatchV1 = EncodedFieldBatchGeneric(
+	brand<FieldBatchFormatVersion>(FieldBatchFormatVersion.v1),
 	EncodedChunkShape,
 );
+export type EncodedFieldBatchV1 = Static<typeof EncodedFieldBatchV1>;
+
+export const EncodedFieldBatchV2 = EncodedFieldBatchGeneric(
+	brand<FieldBatchFormatVersion>(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/formatGeneric.ts

@@ -4,6 +4,7 @@
  */
 
 import { type Static, type TSchema, Type } from "@sinclair/typebox";
+import type { FieldBatchFormatVersion } from "./format.js";
 
 /**
  * Identifier OR Index of an identifier in the identifier list.
@@ -39,11 +40,14 @@ const EncodedFieldBatchBase = Type.Object(
 
 /**
  * Format for encoding a tree chunk.
- * @param version - format version. Must be changed if there is any change to the generic schema, or the `shape` schema.
+ * @param version - format version.
+ * Must be changed if the previously existing decode logic will not correctly handle the new encoding.
+ * If adding a new encoding version which does not use this format,
+ * this parameter should be retyped to be a union of the subset of FieldBatchFormatVersion values which this supports.
  * @param shape - schema for union of shape format, see {@link DiscriminatedUnionDispatcher}.
  */
 export const EncodedFieldBatchGeneric = <TShapeSchema extends TSchema>(
-	version: number,
+	version: FieldBatchFormatVersion,
 	shape: TShapeSchema,
 	// Return type is intentionally derived.
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -62,4 +66,5 @@ export const EncodedFieldBatchGeneric = <TShapeSchema extends TSchema>(
 export interface EncodedFieldBatchGeneric<TEncodedShape>
 	extends Static<typeof EncodedFieldBatchBase> {
 	shapes: TEncodedShape[];
+	version: FieldBatchFormatVersion;
 }

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

@@ -3,8 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import type { FieldKey, TreeNodeSchemaIdentifier } from "../../../core/index.js";
-
 /**
  * Policy to determine whether a node / field should be incrementally encoded.
  * @param nodeIdentifier - The identifier of the node containing the field.
@@ -16,18 +14,19 @@ import type { FieldKey, TreeNodeSchemaIdentifier } from "../../../core/index.js"
  * but allows reuse of previously encoded unchanged subtrees.
  * Thus it should only be enabled for large subtrees which are modified infrequently.
  * TODO: AB#9068: Measure the actual overhead.
+ * @alpha
  */
 export type IncrementalEncodingPolicy = (
-	nodeIdentifier: TreeNodeSchemaIdentifier | undefined,
-	fieldKey: FieldKey,
+	nodeIdentifier: string | undefined,
+	fieldKey: string,
 ) => boolean;
 
 /**
  * Default policy for incremental encoding is to not encode incrementally.
  */
 export const defaultIncrementalEncodingPolicy: IncrementalEncodingPolicy = (
-	nodeIdentifier: TreeNodeSchemaIdentifier | undefined,
-	fieldKey: FieldKey,
+	nodeIdentifier: string | undefined,
+	fieldKey: string,
 ): boolean => {
 	return false;
 };

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

@@ -3,10 +3,7 @@
  * Licensed under the MIT License.
  */
 
-export {
-	EncodedFieldBatch,
-	type FieldBatchFormatVersion,
-} from "./format.js";
+export { EncodedFieldBatch, FieldBatchFormatVersion } from "./format.js";
 export type { FieldBatch } from "./fieldBatch.js";
 export {
 	type FieldBatchCodec,

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

@@ -16,8 +16,8 @@ import {
 	ValueSchema,
 	Multiplicity,
 	identifierFieldKindIdentifier,
+	type SchemaPolicy,
 } from "../../../core/index.js";
-import type { FullSchemaPolicy } from "../../modular-schema/index.js";
 
 import {
 	EncoderContext,
@@ -31,11 +31,61 @@ import {
 	incrementalFieldEncoder,
 } from "./compressedEncode.js";
 import type { FieldBatch } from "./fieldBatch.js";
-import { type EncodedFieldBatch, type EncodedValueShape, SpecialField } from "./format.js";
+import {
+	type EncodedFieldBatch,
+	type EncodedFieldBatchV1,
+	type EncodedFieldBatchV2,
+	type EncodedValueShape,
+	FieldBatchFormatVersion,
+	SpecialField,
+} from "./format.js";
 import type { IncrementalEncoder } from "./codecs.js";
 import { NodeShapeBasedEncoder } from "./nodeEncoder.js";
 import { defaultIncrementalEncodingPolicy } from "./incrementalEncodingPolicy.js";
-import { oneFromIterable } from "../../../util/index.js";
+import { brand, oneFromIterable } from "../../../util/index.js";
+
+/**
+ * Encode data from `fieldBatch` in into an `EncodedChunk` using {@link FieldBatchFormatVersion.v1}.
+ * @remarks See {@link schemaCompressedEncode} for more details.
+ * This version does not support incremental encoding.
+ */
+export function schemaCompressedEncodeV1(
+	schema: StoredSchemaCollection,
+	policy: SchemaPolicy,
+	fieldBatch: FieldBatch,
+	idCompressor: IIdCompressor,
+): EncodedFieldBatchV1 {
+	return schemaCompressedEncode(
+		schema,
+		policy,
+		fieldBatch,
+		idCompressor,
+		undefined /* incrementalEncoder */,
+		brand(FieldBatchFormatVersion.v1),
+	);
+}
+
+/**
+ * Encode data from `fieldBatch` in into an `EncodedChunk` using {@link FieldBatchFormatVersion.v2}.
+ * @remarks See {@link schemaCompressedEncode} for more details.
+ * Incremental encoding is supported from this version onwards.
+ */
+export function schemaCompressedEncodeV2(
+	schema: StoredSchemaCollection,
+	policy: SchemaPolicy,
+	fieldBatch: FieldBatch,
+	idCompressor: IIdCompressor,
+	incrementalEncoder: IncrementalEncoder | undefined,
+): EncodedFieldBatchV2 {
+	return schemaCompressedEncode(
+		schema,
+		policy,
+		fieldBatch,
+		idCompressor,
+		incrementalEncoder,
+		brand(FieldBatchFormatVersion.v2),
+	);
+}
 
 /**
  * Encode data from `fieldBatch` in into an `EncodedChunk`.
@@ -47,24 +97,26 @@ import { oneFromIterable } from "../../../util/index.js";
  * Optimized for encoded size and encoding performance.
  * TODO: This function should eventually also take in the root FieldSchema to more efficiently compress the nodes.
  */
-export function schemaCompressedEncode(
+function schemaCompressedEncode(
 	schema: StoredSchemaCollection,
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	fieldBatch: FieldBatch,
 	idCompressor: IIdCompressor,
-	incrementalEncoder?: IncrementalEncoder,
+	incrementalEncoder: IncrementalEncoder | undefined,
+	version: FieldBatchFormatVersion,
 ): EncodedFieldBatch {
 	return compressedEncode(
 		fieldBatch,
-		buildContext(schema, policy, idCompressor, incrementalEncoder),
+		buildContext(schema, policy, idCompressor, incrementalEncoder, version),
 	);
 }
 
 export function buildContext(
 	storedSchema: StoredSchemaCollection,
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	idCompressor: IIdCompressor,
-	incrementalEncoder?: IncrementalEncoder,
+	incrementalEncoder: IncrementalEncoder | undefined,
+	version: FieldBatchFormatVersion,
 ): EncoderContext {
 	const context: EncoderContext = new EncoderContext(
 		(fieldBuilder: FieldEncodeBuilder, schemaName: TreeNodeSchemaIdentifier) =>
@@ -74,6 +126,7 @@ export function buildContext(
 		policy.fieldKinds,
 		idCompressor,
 		incrementalEncoder,
+		version,
 	);
 	return context;
 }

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

@@ -8,17 +8,36 @@ import {
 	forEachField,
 	forEachNode,
 } from "../../../core/index.js";
+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";
 
+/**
+ * Encode data from `cursor` in the simplest way supported by `EncodedChunk` using {@link FieldBatchFormatVersion.v1}.
+ * @remarks See {@link uncompressedEncode} for more details.
+ */
+export function uncompressedEncodeV1(batch: FieldBatch): EncodedFieldBatchV1 {
+	return uncompressedEncode(batch, brand(FieldBatchFormatVersion.v1));
+}
+
+/**
+ * Encode data from `cursor` in the simplest way supported by `EncodedChunk` using {@link FieldBatchFormatVersion.v2}.
+ * @remarks See {@link uncompressedEncode} for more details.
+ */
+export function uncompressedEncodeV2(batch: FieldBatch): EncodedFieldBatchV2 {
+	return uncompressedEncode(batch, brand(FieldBatchFormatVersion.v2));
+}
+
 /**
  * Encode data from `cursor` in the simplest way supported by `EncodedChunk`.
  *
@@ -27,10 +46,13 @@ import type { ShapeIndex } from "./formatGeneric.js";
  *
  * This is intended as a simple reference implementation with minimal code and dependencies.
  */
-export function uncompressedEncode(batch: FieldBatch): EncodedFieldBatch {
+function uncompressedEncode(
+	batch: FieldBatch,
+	version: FieldBatchFormatVersion,
+): EncodedFieldBatch {
 	const rootFields = batch.map(encodeSequence);
 	return {
-		version: FieldBatchFormatVersion.v1,
+		version,
 		identifiers: [],
 		// A single shape used to encode all fields.
 		shapes: [{ c: anyNodeShape }, { a: anyArray }],

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

@@ -17,7 +17,7 @@ export {
 export { buildChunkedForest } from "./chunkedForest.js";
 export {
 	EncodedFieldBatch,
-	type FieldBatchFormatVersion,
+	FieldBatchFormatVersion,
 	getCodecTreeForFieldBatchFormat,
 	type FieldBatch,
 	type FieldBatchCodec,