@fluidframework/tree 2.51.0 → 2.53.0-350190

package/src/core/tree/detachedFieldIndexCodecCommon.ts

@@ -0,0 +1,87 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	type ICodecOptions,
+	type IJsonCodec,
+	makeVersionedValidatedCodec,
+} from "../../codec/index.js";
+import { hasSingle } from "../../util/index.js";
+
+import {
+	Format,
+	type EncodedRootsForRevision,
+	type RootRanges,
+} from "./detachedFieldIndexFormatCommon.js";
+import type {
+	DetachedField,
+	DetachedFieldSummaryData,
+	Major,
+} from "./detachedFieldIndexTypes.js";
+import type { Static, TSchema } from "@sinclair/typebox";
+
+// Return type is intentionally derived.
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function makeDetachedFieldIndexCodecFromMajorCodec<
+	TEncodedRevisionTag,
+	TEncodedRevisionTagSchema extends TSchema,
+	TVersion extends number,
+>(
+	options: ICodecOptions,
+	majorCodec: IJsonCodec<Major, TEncodedRevisionTag>,
+	version: TVersion,
+	encodedRevisionTagSchema: TEncodedRevisionTagSchema,
+) {
+	const formatSchema = Format(version, encodedRevisionTagSchema);
+	return makeVersionedValidatedCodec(options, new Set([version]), formatSchema, {
+		encode: (data: DetachedFieldSummaryData): Static<typeof formatSchema> => {
+			const rootsForRevisions: EncodedRootsForRevision[] = [];
+			for (const [major, innerMap] of data.data) {
+				const encodedRevision = majorCodec.encode(major);
+				const rootRanges: RootRanges = [];
+				for (const [minor, detachedField] of innerMap) {
+					rootRanges.push([minor, detachedField.root]);
+				}
+				if (hasSingle(rootRanges)) {
+					const firstRootRange = rootRanges[0];
+					const rootsForRevision: EncodedRootsForRevision = [
+						encodedRevision,
+						firstRootRange[0],
+						firstRootRange[1],
+					];
+					rootsForRevisions.push(rootsForRevision);
+				} else {
+					const rootsForRevision: EncodedRootsForRevision = [encodedRevision, rootRanges];
+					rootsForRevisions.push(rootsForRevision);
+				}
+			}
+			const encoded: Static<typeof formatSchema> = {
+				version,
+				data: rootsForRevisions,
+				maxId: data.maxId,
+			};
+			return encoded;
+		},
+		decode: (parsed: Static<typeof formatSchema>): DetachedFieldSummaryData => {
+			const map = new Map();
+			for (const rootsForRevision of parsed.data) {
+				const innerMap = new Map<number, DetachedField>();
+				if (rootsForRevision.length === 2) {
+					for (const [minor, root] of rootsForRevision[1]) {
+						innerMap.set(minor, { root });
+					}
+				} else {
+					innerMap.set(rootsForRevision[1], { root: rootsForRevision[2] });
+				}
+				const revision = rootsForRevision[0] as TEncodedRevisionTag;
+				map.set(majorCodec.decode(revision), innerMap);
+			}
+			return {
+				data: map,
+				maxId: parsed.maxId,
+			};
+		},
+	});
+}

package/src/core/tree/{detachedFieldIndexCodec.ts → detachedFieldIndexCodecV1.ts}

@@ -6,27 +6,19 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
+import type { ICodecOptions, IJsonCodec } from "../../codec/index.js";
 import {
-	type ICodecOptions,
-	type IJsonCodec,
-	makeVersionedValidatedCodec,
-} from "../../codec/index.js";
-import { hasSingle } from "../../util/index.js";
-import type { EncodedRevisionTag, RevisionTagCodec, RevisionTag } from "../rebase/index.js";
+	type EncodedRevisionTag,
+	type RevisionTagCodec,
+	type RevisionTag,
+	RevisionTagSchema,
+} from "../rebase/index.js";
 
-import {
-	type EncodedRootsForRevision,
-	Format,
-	type RootRanges,
-	version,
-} from "./detachedFieldIndexFormat.js";
-import type {
-	DetachedField,
-	DetachedFieldSummaryData,
-	Major,
-} from "./detachedFieldIndexTypes.js";
+import { type FormatV1, version1 } from "./detachedFieldIndexFormatV1.js";
+import type { DetachedFieldSummaryData, Major } from "./detachedFieldIndexTypes.js";
+import { makeDetachedFieldIndexCodecFromMajorCodec } from "./detachedFieldIndexCodecCommon.js";
 
-class MajorCodec implements IJsonCodec<Major> {
+class MajorCodec implements IJsonCodec<Major, EncodedRevisionTag> {
 	public constructor(
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly options: ICodecOptions,
@@ -48,6 +40,10 @@ class MajorCodec implements IJsonCodec<Major> {
 		 * This assert is valid because the revision for an acked edit will have already been finalized, and a revision
 		 * for a local-only edit will be finalizable at summarization time (local edits can only occur on a summarizing client
 		 * if they're created while detached, and local ids made while detached are finalized before generating the attach summary).
+		 *
+		 * WARNING: the above is true when the whole container transitions from detached to attached,
+		 * but not when the container is already attached and it's just the shared-tree that is attaching.
+		 * The assert below will fail in such a scenario. This is addressed in the v2 codec.
 		 */
 		assert(
 			id === "root" || id >= 0,
@@ -69,58 +65,16 @@ class MajorCodec implements IJsonCodec<Major> {
 	}
 }
 
-export function makeDetachedNodeToFieldCodec(
+export function makeDetachedNodeToFieldCodecV1(
 	revisionTagCodec: RevisionTagCodec,
 	options: ICodecOptions,
 	idCompressor: IIdCompressor,
-): IJsonCodec<DetachedFieldSummaryData, Format> {
+): IJsonCodec<DetachedFieldSummaryData, FormatV1> {
 	const majorCodec = new MajorCodec(revisionTagCodec, options, idCompressor);
-	return makeVersionedValidatedCodec(options, new Set([version]), Format, {
-		encode: (data: DetachedFieldSummaryData): Format => {
-			const rootsForRevisions: EncodedRootsForRevision[] = [];
-			for (const [major, innerMap] of data.data) {
-				const encodedRevision = majorCodec.encode(major);
-				const rootRanges: RootRanges = [];
-				for (const [minor, detachedField] of innerMap) {
-					rootRanges.push([minor, detachedField.root]);
-				}
-				if (hasSingle(rootRanges)) {
-					const firstRootRange = rootRanges[0];
-					const rootsForRevision: EncodedRootsForRevision = [
-						encodedRevision,
-						firstRootRange[0],
-						firstRootRange[1],
-					];
-					rootsForRevisions.push(rootsForRevision);
-				} else {
-					const rootsForRevision: EncodedRootsForRevision = [encodedRevision, rootRanges];
-					rootsForRevisions.push(rootsForRevision);
-				}
-			}
-			const encoded: Format = {
-				version,
-				data: rootsForRevisions,
-				maxId: data.maxId,
-			};
-			return encoded;
-		},
-		decode: (parsed: Format): DetachedFieldSummaryData => {
-			const map = new Map();
-			for (const rootsForRevision of parsed.data) {
-				const innerMap = new Map<number, DetachedField>();
-				if (rootsForRevision.length === 2) {
-					for (const [minor, root] of rootsForRevision[1]) {
-						innerMap.set(minor, { root });
-					}
-				} else {
-					innerMap.set(rootsForRevision[1], { root: rootsForRevision[2] });
-				}
-				map.set(majorCodec.decode(rootsForRevision[0]), innerMap);
-			}
-			return {
-				data: map,
-				maxId: parsed.maxId,
-			};
-		},
-	});
+	return makeDetachedFieldIndexCodecFromMajorCodec(
+		options,
+		majorCodec,
+		version1,
+		RevisionTagSchema,
+	);
 }

package/src/core/tree/detachedFieldIndexCodecV2.ts

@@ -0,0 +1,72 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor, StableId } from "@fluidframework/id-compressor";
+
+import type { ICodecOptions, IJsonCodec } from "../../codec/index.js";
+import type { EncodedRevisionTag, RevisionTagCodec, RevisionTag } from "../rebase/index.js";
+
+import {
+	type FormatV2,
+	StableOrFinalRevisionTag,
+	version2,
+} from "./detachedFieldIndexFormatV2.js";
+import type { DetachedFieldSummaryData, Major } from "./detachedFieldIndexTypes.js";
+import { makeDetachedFieldIndexCodecFromMajorCodec } from "./detachedFieldIndexCodecCommon.js";
+import { isStableId } from "@fluidframework/id-compressor/internal";
+
+class MajorCodec implements IJsonCodec<Major> {
+	public constructor(
+		private readonly revisionTagCodec: RevisionTagCodec,
+		private readonly options: ICodecOptions,
+		private readonly idCompressor: IIdCompressor,
+	) {}
+
+	public encode(major: Major): EncodedRevisionTag | StableId {
+		assert(major !== undefined, 0xbfb /* Unexpected undefined revision */);
+		const id = this.revisionTagCodec.encode(major);
+
+		if (id !== "root" && id < 0) {
+			/**
+			 * This code path handles the case where the major revision is not finalized.
+			 * This can happen the SharedTree is being attached to an already attached container.
+			 */
+			assert(major !== "root", 0xbfc /* Major revision cannot be 'root' */);
+			const long = this.idCompressor.decompress(major);
+			return long;
+		}
+		return id;
+	}
+
+	public decode(major: EncodedRevisionTag | StableId): RevisionTag {
+		assert(
+			major === "root" || (typeof major === "string" && isStableId(major)) || major >= 0,
+			0xbfd /* Expected root, stable, or final compressed id */,
+		);
+		if (typeof major === "string" && isStableId(major)) {
+			return this.idCompressor.recompress(major);
+		}
+		return this.revisionTagCodec.decode(major, {
+			originatorId: this.revisionTagCodec.localSessionId,
+			idCompressor: this.idCompressor,
+			revision: undefined,
+		});
+	}
+}
+
+export function makeDetachedNodeToFieldCodecV2(
+	revisionTagCodec: RevisionTagCodec,
+	options: ICodecOptions,
+	idCompressor: IIdCompressor,
+): IJsonCodec<DetachedFieldSummaryData, FormatV2> {
+	const majorCodec = new MajorCodec(revisionTagCodec, options, idCompressor);
+	return makeDetachedFieldIndexCodecFromMajorCodec(
+		options,
+		majorCodec,
+		version2,
+		StableOrFinalRevisionTag,
+	);
+}

package/src/core/tree/detachedFieldIndexCodecs.ts

@@ -0,0 +1,44 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+
+import {
+	type CodecWriteOptions,
+	FluidClientVersion,
+	type ICodecFamily,
+	type IJsonCodec,
+	makeCodecFamily,
+	makeVersionDispatchingCodec,
+} from "../../codec/index.js";
+import type { RevisionTagCodec } from "../rebase/index.js";
+
+import { version1 } from "./detachedFieldIndexFormatV1.js";
+import { version2 } from "./detachedFieldIndexFormatV2.js";
+import { makeDetachedNodeToFieldCodecV1 } from "./detachedFieldIndexCodecV1.js";
+import { makeDetachedNodeToFieldCodecV2 } from "./detachedFieldIndexCodecV2.js";
+import type { DetachedFieldSummaryData } from "./detachedFieldIndexTypes.js";
+
+export function makeDetachedFieldIndexCodec(
+	revisionTagCodec: RevisionTagCodec,
+	options: CodecWriteOptions,
+	idCompressor: IIdCompressor,
+): IJsonCodec<DetachedFieldSummaryData> {
+	const family = makeDetachedFieldIndexCodecFamily(revisionTagCodec, options, idCompressor);
+	const writeVersion =
+		options.oldestCompatibleClient < FluidClientVersion.v2_52 ? version1 : version2;
+	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
+}
+
+export function makeDetachedFieldIndexCodecFamily(
+	revisionTagCodec: RevisionTagCodec,
+	options: CodecWriteOptions,
+	idCompressor: IIdCompressor,
+): ICodecFamily<DetachedFieldSummaryData> {
+	return makeCodecFamily([
+		[version1, makeDetachedNodeToFieldCodecV1(revisionTagCodec, options, idCompressor)],
+		[version2, makeDetachedNodeToFieldCodecV2(revisionTagCodec, options, idCompressor)],
+	]);
+}

package/src/core/tree/{detachedFieldIndexFormat.ts → detachedFieldIndexFormatCommon.ts}

@@ -3,15 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { type Static, Type } from "@sinclair/typebox";
+import { type Static, type TSchema, Type } from "@sinclair/typebox";
 
 import { brandedNumberType } from "../../util/index.js";
-import { RevisionTagSchema } from "../rebase/index.js";
 
 import type { ForestRootId } from "./detachedFieldIndexTypes.js";
 
-export const version = 1.0;
-
 /**
  * The ID of a detached node. Is not globally unique on.
  * A `RevisionTag` + `DetachId` pair is globally unique and eventually consistent across clients.
@@ -22,7 +19,10 @@ export const DetachId = Type.Number({ multipleOf: 1 });
  * The ID of a root node in the forest associated with the owning checkout. Is unique for that forest.
  * Is not consistent across clients.
  */
-const ForestRootIdSchema = brandedNumberType<ForestRootId>({ minimum: -1, multipleOf: 1 });
+export const ForestRootIdSchema = brandedNumberType<ForestRootId>({
+	minimum: -1,
+	multipleOf: 1,
+});
 
 /**
  * A mapping from a range of the detached node IDs the corresponding range root IDs.
@@ -43,21 +43,30 @@ export type RootRanges = Static<typeof RootRanges>;
 /**
  * For all the roots detached in a revision, represents a mapping from the detached node ID to corresponding root ID.
  */
-export const EncodedRootsForRevision = Type.Union([
-	// Used to represent a revision in which more than one node were detached
-	Type.Tuple([RevisionTagSchema, RootRanges]),
-	// Used to represent a revision in which a single node was detached
-	Type.Tuple([RevisionTagSchema, DetachId, ForestRootIdSchema]),
-]);
-export type EncodedRootsForRevision = Static<typeof EncodedRootsForRevision>;
-
-export const Format = Type.Object(
-	{
-		version: Type.Literal(version),
-		data: Type.Array(EncodedRootsForRevision),
-		maxId: ForestRootIdSchema,
-	},
-	{ additionalProperties: false },
-);
-
-export type Format = Static<typeof Format>;
+// Return type is intentionally derived.
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const EncodedRootsForRevision = <Schema extends TSchema>(tRevisionTag: Schema) =>
+	Type.Union([
+		// Used to represent a revision in which more than one node were detached
+		Type.Tuple([tRevisionTag, RootRanges]),
+		// Used to represent a revision in which a single node was detached
+		Type.Tuple([tRevisionTag, DetachId, ForestRootIdSchema]),
+	]);
+export type EncodedRootsForRevision = Static<ReturnType<typeof EncodedRootsForRevision>>;
+
+export const Format = <TVersion extends number, TRevisionTagSchema extends TSchema>(
+	tVersion: TVersion,
+	tRevisionTag: TRevisionTagSchema,
+	// Return type is intentionally derived.
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+) =>
+	Type.Object(
+		{
+			version: Type.Literal(tVersion),
+			data: Type.Array(EncodedRootsForRevision(tRevisionTag)),
+			maxId: ForestRootIdSchema,
+		},
+		{ additionalProperties: false },
+	);
+
+export type Format = Static<ReturnType<typeof Format>>;

package/src/core/tree/detachedFieldIndexFormatV1.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { Static } from "@sinclair/typebox";
+
+import { Format } from "./detachedFieldIndexFormatCommon.js";
+import { RevisionTagSchema } from "../rebase/index.js";
+
+export const version1 = 1.0;
+
+export const FormatV1 = Format(version1, RevisionTagSchema);
+
+export type FormatV1 = Static<typeof FormatV1>;

package/src/core/tree/detachedFieldIndexFormatV2.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Type, type Static } from "@sinclair/typebox";
+
+import { Format } from "./detachedFieldIndexFormatCommon.js";
+import { RevisionTagSchema, StableIdSchema } from "../rebase/index.js";
+
+export const version2 = 2.0;
+
+export const StableOrFinalRevisionTag = Type.Union([RevisionTagSchema, StableIdSchema]);
+
+export const FormatV2 = Format(version2, StableOrFinalRevisionTag);
+
+export type FormatV2 = Static<typeof FormatV2>;

package/src/feature-libraries/chunked-forest/codec/README.md

@@ -19,7 +19,7 @@ A few implementations are included which make different choices here:
 
 -   [uncompressedEncode.ts](uncompressedEncode.ts): the simplest implementation, which captures nothing in the shape and does no Dictionary Coding of identifiers.
     This makes for more human readable data as well as a simple reference implementation.
--   [compressedEncode.ts](compressedEncode.ts): some utilities for actual compressed encoding, but does not contain any advanced strategies (instead they must be provided to it via the `EncoderCache`)
+-   [compressedEncode.ts](compressedEncode.ts): some utilities for actual compressed encoding, but does not contain any advanced strategies (instead they must be provided to it via the `EncoderContext`)
 -   [schemaBasedEncode.ts](schemaBasedEncode.ts): a strategy for compressedEncode using schema to infer commonly used shapes.
 
 ### Future Optimizations

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

@@ -41,9 +41,9 @@ import {
 	type EncodedAnyShape,
 	type EncodedChunkShape,
 	type EncodedFieldBatch,
-	type EncodedInlineArray,
-	type EncodedNestedArray,
-	type EncodedTreeShape,
+	type EncodedInlineArrayShape,
+	type EncodedNestedArrayShape,
+	type EncodedNodeShape,
 	type EncodedValueShape,
 	SpecialField,
 } from "./format.js";
@@ -72,17 +72,17 @@ export function decode(
 
 const decoderLibrary = new DiscriminatedUnionDispatcher<
 	EncodedChunkShape,
-	[cache: DecoderContext<EncodedChunkShape>],
+	[context: DecoderContext<EncodedChunkShape>],
 	ChunkDecoder
 >({
-	a(shape: EncodedNestedArray, cache): ChunkDecoder {
+	a(shape: EncodedNestedArrayShape, context): ChunkDecoder {
 		return new NestedArrayDecoder(shape);
 	},
-	b(shape: EncodedInlineArray, cache): ChunkDecoder {
+	b(shape: EncodedInlineArrayShape, context): ChunkDecoder {
 		return new InlineArrayDecoder(shape);
 	},
-	c(shape: EncodedTreeShape, cache): ChunkDecoder {
-		return new TreeDecoder(shape, cache);
+	c(shape: EncodedNodeShape, context): ChunkDecoder {
+		return new NodeDecoder(shape, context);
 	},
 	d(shape: EncodedAnyShape): ChunkDecoder {
 		return anyDecoder;
@@ -180,10 +180,10 @@ export function aggregateChunks(input: TreeChunk[]): TreeChunk {
 }
 
 /**
- * Decoder for {@link EncodedNestedArray}s.
+ * Decoder for {@link EncodedNestedArrayShape}s.
  */
 export class NestedArrayDecoder implements ChunkDecoder {
-	public constructor(private readonly shape: EncodedNestedArray) {}
+	public constructor(private readonly shape: EncodedNestedArrayShape) {}
 	public decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {
 		const decoder = decoders[this.shape] ?? oob();
 
@@ -213,10 +213,10 @@ export class NestedArrayDecoder implements ChunkDecoder {
 }
 
 /**
- * Decoder for {@link EncodedInlineArray}s.
+ * Decoder for {@link EncodedInlineArrayShape}s.
  */
 export class InlineArrayDecoder implements ChunkDecoder {
-	public constructor(private readonly shape: EncodedInlineArray) {}
+	public constructor(private readonly shape: EncodedInlineArrayShape) {}
 	public decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {
 		const length = this.shape.length;
 		const decoder = decoders[this.shape.shape] ?? oob();
@@ -248,14 +248,14 @@ type BasicFieldDecoder = (
 ) => [FieldKey, TreeChunk];
 
 /**
- * Get a decoder for fields of a provided (via `shape` and `cache`) {@link EncodedChunkShape}.
+ * Get a decoder for fields of a provided (via `shape` and `context`) {@link EncodedChunkShape}.
  */
 function fieldDecoder(
-	cache: DecoderContext<EncodedChunkShape>,
+	context: DecoderContext<EncodedChunkShape>,
 	key: FieldKey,
 	shape: number,
 ): BasicFieldDecoder {
-	assertValidIndex(shape, cache.shapes);
+	assertValidIndex(shape, context.shapes);
 	return (decoders, stream) => {
 		const decoder = decoders[shape] ?? oob();
 		return [key, decoder.decode(decoders, stream)];
@@ -263,30 +263,30 @@ function fieldDecoder(
 }
 
 /**
- * Decoder for {@link EncodedTreeShape}s.
+ * Decoder for {@link EncodedNodeShape}s.
  */
-export class TreeDecoder implements ChunkDecoder {
+export class NodeDecoder implements ChunkDecoder {
 	private readonly type?: TreeNodeSchemaIdentifier;
 	private readonly fieldDecoders: readonly BasicFieldDecoder[];
 	public constructor(
-		private readonly shape: EncodedTreeShape,
-		private readonly cache: DecoderContext<EncodedChunkShape>,
+		private readonly shape: EncodedNodeShape,
+		private readonly context: DecoderContext<EncodedChunkShape>,
 	) {
-		this.type = shape.type === undefined ? undefined : cache.identifier(shape.type);
+		this.type = shape.type === undefined ? undefined : context.identifier(shape.type);
 
 		const fieldDecoders: BasicFieldDecoder[] = [];
 		for (const [fieldKey, fieldShape] of shape.fields ?? []) {
-			const key: FieldKey = cache.identifier(fieldKey);
-			fieldDecoders.push(fieldDecoder(cache, key, fieldShape));
+			const key: FieldKey = context.identifier(fieldKey);
+			fieldDecoders.push(fieldDecoder(context, key, fieldShape));
 		}
 		this.fieldDecoders = fieldDecoders;
 	}
 	public decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {
 		const type: TreeNodeSchemaIdentifier =
-			this.type ?? readStreamIdentifier(stream, this.cache);
+			this.type ?? readStreamIdentifier(stream, this.context);
 		// TODO: Consider typechecking against stored schema in here somewhere.
 
-		const value = readValue(stream, this.shape.value, this.cache.idDecodingContext);
+		const value = readValue(stream, this.shape.value, this.context.idDecodingContext);
 		const fields: Map<FieldKey, TreeChunk[]> = new Map();
 
 		// Helper to add fields, but with unneeded array chunks removed.
@@ -309,7 +309,7 @@ export class TreeDecoder implements ChunkDecoder {
 			const decoder = decoders[this.shape.extraFields] ?? oob();
 			const inner = readStreamStream(stream);
 			while (inner.offset !== inner.data.length) {
-				const key: FieldKey = readStreamIdentifier(inner, this.cache);
+				const key: FieldKey = readStreamIdentifier(inner, this.context);
 				addField(key, decoder.decode(decoders, inner));
 			}
 		}

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

@@ -21,13 +21,17 @@ import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./formatGeneri
 /**
  * General purpose shape based tree decoder which gets its support for specific shapes from the caller.
  */
-export function decode<TEncodedShape extends object, TCache>(
-	decoderLibrary: DiscriminatedUnionDispatcher<TEncodedShape, [cache: TCache], ChunkDecoder>,
-	cache: TCache,
+export function decode<TEncodedShape extends object, TContext>(
+	decoderLibrary: DiscriminatedUnionDispatcher<
+		TEncodedShape,
+		[context: TContext],
+		ChunkDecoder
+	>,
+	context: TContext,
 	batch: EncodedFieldBatchGeneric<TEncodedShape>,
 	rootDecoder: ChunkDecoder,
 ): TreeChunk[] {
-	const decoders = batch.shapes.map((shape) => decoderLibrary.dispatch(shape, cache));
+	const decoders = batch.shapes.map((shape) => decoderLibrary.dispatch(shape, context));
 	const chunks: TreeChunk[] = [];
 	for (const field of batch.data) {
 		const stream = { data: field, offset: 0 };
@@ -70,12 +74,12 @@ export class DecoderContext<TEncodedShape = unknown> {
  */
 export function readStreamIdentifier<T extends string & BrandedType<string, string>>(
 	stream: StreamCursor,
-	cache: DecoderContext,
+	context: DecoderContext,
 ): T {
 	const content = readStream(stream);
 	assert(
 		typeof content === "number" || typeof content === "string",
 		0x73b /* content to be a number or string */,
 	);
-	return cache.identifier(content);
+	return context.identifier(content);
 }