@fluidframework/tree 2.51.0 → 2.53.0-350190

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

@@ -30,7 +30,7 @@ import {
 	type EncodedAnyShape,
 	type EncodedChunkShape,
 	type EncodedFieldBatch,
-	type EncodedNestedArray,
+	type EncodedNestedArrayShape,
 	type EncodedValueShape,
 	SpecialField,
 	version,
@@ -41,18 +41,18 @@ import {
  *
  * Optimized for encoded size and encoding performance.
  *
- * Most of the compression strategy comes from the policy provided via `cache`.
+ * Most of the compression strategy comes from the policy provided via `context`.
  */
 export function compressedEncode(
 	fieldBatch: FieldBatch,
-	cache: EncoderCache,
+	context: EncoderContext,
 ): EncodedFieldBatch {
 	const batchBuffer: BufferFormat[] = [];
 
 	// Populate buffer, including shape and identifier references
 	for (const cursor of fieldBatch) {
 		const buffer: BufferFormat = [];
-		anyFieldEncoder.encodeField(cursor, cache, buffer);
+		anyFieldEncoder.encodeField(cursor, context, buffer);
 		batchBuffer.push(buffer);
 	}
 	return updateShapesAndIdentifiersEncoding(version, batchBuffer);
@@ -91,7 +91,7 @@ export interface NodeEncoder extends Encoder {
 	 */
 	encodeNode(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void;
 }
@@ -105,7 +105,7 @@ export interface NodesEncoder extends Encoder {
 	 */
 	encodeNodes(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void;
 }
@@ -119,7 +119,7 @@ export interface FieldEncoder extends Encoder {
 	 */
 	encodeField(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void;
 }
@@ -132,10 +132,10 @@ export function asFieldEncoder(encoder: NodeEncoder): FieldEncoder {
 	return {
 		encodeField(
 			cursor: ITreeCursorSynchronous,
-			shapes: EncoderCache,
+			context: EncoderContext,
 			outputBuffer: BufferFormat,
 		): void {
-			forEachNode(cursor, () => encoder.encodeNode(cursor, shapes, outputBuffer));
+			forEachNode(cursor, () => encoder.encodeNode(cursor, context, outputBuffer));
 		},
 		shape: encoder.shape,
 	};
@@ -148,10 +148,10 @@ export function asNodesEncoder(encoder: NodeEncoder): NodesEncoder {
 	return {
 		encodeNodes(
 			cursor: ITreeCursorSynchronous,
-			shapes: EncoderCache,
+			context: EncoderContext,
 			outputBuffer: BufferFormat,
 		): void {
-			encoder.encodeNode(cursor, shapes, outputBuffer);
+			encoder.encodeNode(cursor, context, outputBuffer);
 			cursor.nextNode();
 		},
 		shape: encoder.shape,
@@ -182,32 +182,32 @@ export class AnyShape extends ShapeGeneric<EncodedChunkShape> {
 
 	public static encodeField(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
-		shape: FieldEncoder,
+		encoder: FieldEncoder,
 	): void {
-		outputBuffer.push(shape.shape);
-		shape.encodeField(cursor, cache, outputBuffer);
+		outputBuffer.push(encoder.shape);
+		encoder.encodeField(cursor, context, outputBuffer);
 	}
 
 	public static encodeNode(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
-		shape: NodeEncoder,
+		encoder: NodeEncoder,
 	): void {
-		outputBuffer.push(shape.shape);
-		shape.encodeNode(cursor, cache, outputBuffer);
+		outputBuffer.push(encoder.shape);
+		encoder.encodeNode(cursor, context, outputBuffer);
 	}
 
 	public static encodeNodes(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
-		shape: NodesEncoder,
+		encoder: NodesEncoder,
 	): void {
-		outputBuffer.push(shape.shape);
-		shape.encodeNodes(cursor, cache, outputBuffer);
+		outputBuffer.push(encoder.shape);
+		encoder.encodeNodes(cursor, context, outputBuffer);
 	}
 }
 
@@ -217,12 +217,12 @@ export class AnyShape extends ShapeGeneric<EncodedChunkShape> {
 export const anyNodeEncoder: NodeEncoder = {
 	encodeNode(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void {
 		// TODO: Fast path uniform chunk content.
-		const shape = cache.shapeFromTree(cursor.type);
-		AnyShape.encodeNode(cursor, cache, outputBuffer, shape);
+		const shape = context.nodeEncoderFromSchema(cursor.type);
+		AnyShape.encodeNode(cursor, context, outputBuffer, shape);
 	},
 
 	shape: AnyShape.instance,
@@ -234,25 +234,25 @@ export const anyNodeEncoder: NodeEncoder = {
 export const anyFieldEncoder: FieldEncoder = {
 	encodeField(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void {
 		// TODO: Fast path uniform chunks.
 
 		if (cursor.getFieldLength() === 0) {
-			const shape = InlineArrayShape.empty;
-			AnyShape.encodeField(cursor, cache, outputBuffer, shape);
+			const shape = InlineArrayEncoder.empty;
+			AnyShape.encodeField(cursor, context, outputBuffer, shape);
 		} else if (cursor.getFieldLength() === 1) {
 			// Fast path chunk of size one size one at least: skip nested array.
 			cursor.enterNode(0);
-			anyNodeEncoder.encodeNode(cursor, cache, outputBuffer);
+			anyNodeEncoder.encodeNode(cursor, context, outputBuffer);
 			cursor.exitNode();
 		} else {
 			// TODO: more efficient encoding for common cases.
 			// Could try to find more specific shape compatible with all children than `anyNodeEncoder`.
 
-			const shape = cache.nestedArray(anyNodeEncoder);
-			AnyShape.encodeField(cursor, cache, outputBuffer, shape);
+			const shape = context.nestedArrayEncoder(anyNodeEncoder);
+			AnyShape.encodeField(cursor, context, outputBuffer, shape);
 		}
 	},
 
@@ -260,20 +260,23 @@ export const anyFieldEncoder: FieldEncoder = {
 };
 
 /**
- * Encodes a chunk using {@link EncodedInlineArray}.
+ * Encodes a chunk using {@link EncodedInlineArrayShape}.
+ * @remarks
+ * 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 InlineArrayShape
+export class InlineArrayEncoder
 	extends ShapeGeneric<EncodedChunkShape>
 	implements NodesEncoder, FieldEncoder
 {
-	public static readonly empty: InlineArrayShape = new InlineArrayShape(0, {
+	public static readonly empty: InlineArrayEncoder = new InlineArrayEncoder(0, {
 		get shape() {
 			// Not actually used, makes count work without adding an additional shape.
-			return InlineArrayShape.empty;
+			return InlineArrayEncoder.empty;
 		},
 		encodeNodes(
 			cursor: ITreeCursorSynchronous,
-			shapes: EncoderCache,
+			context: EncoderContext,
 			outputBuffer: BufferFormat,
 		): void {
 			fail(0xb4d /* Empty array should not encode any nodes */);
@@ -292,19 +295,19 @@ export class InlineArrayShape
 
 	public encodeNodes(
 		cursor: ITreeCursorSynchronous,
-		shapes: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void {
 		// Linter is wrong about this loop being for-of compatible.
 		// eslint-disable-next-line @typescript-eslint/prefer-for-of
 		for (let index = 0; index < this.length; index++) {
-			this.inner.encodeNodes(cursor, shapes, outputBuffer);
+			this.inner.encodeNodes(cursor, context, outputBuffer);
 		}
 	}
 
 	public encodeField(
 		cursor: ITreeCursorSynchronous,
-		shapes: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void {
 		// Its possible individual items from this array encode multiple nodes, so don't assume === here.
@@ -313,7 +316,7 @@ export class InlineArrayShape
 			0x73c /* unexpected length for fixed length array */,
 		);
 		cursor.firstNode();
-		this.encodeNodes(cursor, shapes, outputBuffer);
+		this.encodeNodes(cursor, context, outputBuffer);
 		assert(
 			cursor.mode === CursorLocationType.Fields,
 			0x73d /* should return to fields mode when finished encoding */,
@@ -345,9 +348,15 @@ export class InlineArrayShape
 }
 
 /**
- * Encodes a field as a nested array with the {@link EncodedNestedArray} shape.
+ * Encodes a field as a nested array with the {@link EncodedNestedArrayShape} shape.
+ * @remarks
+ * 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 NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements FieldEncoder {
+export class NestedArrayEncoder
+	extends ShapeGeneric<EncodedChunkShape>
+	implements FieldEncoder
+{
 	public readonly shape: Shape;
 
 	public constructor(public readonly inner: NodeEncoder) {
@@ -357,7 +366,7 @@ export class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements
 
 	public encodeField(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void {
 		const buffer: BufferFormat = [];
@@ -365,7 +374,7 @@ export class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements
 		const length = cursor.getFieldLength();
 		forEachNode(cursor, () => {
 			const before = buffer.length;
-			this.inner.encodeNode(cursor, cache, buffer);
+			this.inner.encodeNode(cursor, context, buffer);
 			allNonZeroSize &&= buffer.length - before !== 0;
 		});
 		if (buffer.length === 0) {
@@ -385,7 +394,7 @@ export class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements
 		identifiers: DeduplicationTable<string>,
 		shapes: DeduplicationTable<Shape>,
 	): EncodedChunkShape {
-		const shape: EncodedNestedArray =
+		const shape: EncodedNestedArrayShape =
 			shapes.valueToIndex.get(this.inner.shape) ??
 			fail(0xb4f /* index for shape not found in table */);
 		return {
@@ -436,46 +445,60 @@ export function encodeValue(
 	}
 }
 
-export class EncoderCache implements TreeShaper, FieldShaper {
-	private readonly shapesFromSchema: Map<TreeNodeSchemaIdentifier, NodeEncoder> = new Map();
-	private readonly nestedArrays: Map<NodeEncoder, NestedArrayShape> = new Map();
+/**
+ * Provides common contextual information during encoding, like schema and policy settings.
+ * Also, provides a cache to avoid duplicating equivalent shapes during a batch of encode operations.
+ * To avoid Shape duplication, any Shapes used in the encoding should either be:
+ * - Singletons defined in a static scope.
+ * - Cached in this object for future reuse such that all equivalent Shapes are deduplicated.
+ */
+export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
+	private readonly nodeEncodersFromSchema: Map<TreeNodeSchemaIdentifier, NodeEncoder> =
+		new Map();
+	private readonly nestedArrayEncoders: Map<NodeEncoder, NestedArrayEncoder> = new Map();
 	public constructor(
-		private readonly treeEncoder: TreeShapePolicy,
-		private readonly fieldEncoder: FieldShapePolicy,
+		private readonly nodeEncoderFromPolicy: NodeEncoderPolicy,
+		private readonly fieldEncoderFromPolicy: FieldEncoderPolicy,
 		public readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		public readonly idCompressor: IIdCompressor,
 	) {}
 
-	public shapeFromTree(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {
-		return getOrCreate(this.shapesFromSchema, schemaName, () =>
-			this.treeEncoder(this, schemaName),
+	public nodeEncoderFromSchema(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {
+		return getOrCreate(this.nodeEncodersFromSchema, schemaName, () =>
+			this.nodeEncoderFromPolicy(this, schemaName),
 		);
 	}
 
-	public nestedArray(inner: NodeEncoder): NestedArrayShape {
-		return getOrCreate(this.nestedArrays, inner, () => new NestedArrayShape(inner));
+	public fieldEncoderFromSchema(fieldSchema: TreeFieldStoredSchema): FieldEncoder {
+		return new LazyFieldEncoder(this, fieldSchema, this.fieldEncoderFromPolicy);
 	}
 
-	public shapeFromField(field: TreeFieldStoredSchema): FieldEncoder {
-		return new LazyFieldEncoder(this, field, this.fieldEncoder);
+	public nestedArrayEncoder(inner: NodeEncoder): NestedArrayEncoder {
+		return getOrCreate(this.nestedArrayEncoders, inner, () => new NestedArrayEncoder(inner));
 	}
 }
 
-export interface TreeShaper {
-	shapeFromTree(schemaName: TreeNodeSchemaIdentifier): NodeEncoder;
+export interface NodeEncodeBuilder {
+	nodeEncoderFromSchema(schemaName: TreeNodeSchemaIdentifier): NodeEncoder;
 }
 
-export interface FieldShaper {
-	shapeFromField(field: TreeFieldStoredSchema): FieldEncoder;
+export interface FieldEncodeBuilder {
+	fieldEncoderFromSchema(schema: TreeFieldStoredSchema): FieldEncoder;
 }
 
-export type FieldShapePolicy = (
-	treeShaper: TreeShaper,
-	field: TreeFieldStoredSchema,
+/**
+ * The policy for building a {@link FieldEncoder} for a field.
+ */
+export type FieldEncoderPolicy = (
+	nodeBuilder: NodeEncodeBuilder,
+	schema: TreeFieldStoredSchema,
 ) => FieldEncoder;
 
-export type TreeShapePolicy = (
-	fieldShaper: FieldShaper,
+/**
+ * The policy for building a {@link NodeEncoder} for a node.
+ */
+export type NodeEncoderPolicy = (
+	fieldBuilder: FieldEncodeBuilder,
 	schemaName: TreeNodeSchemaIdentifier,
 ) => NodeEncoder;
 
@@ -483,21 +506,21 @@ class LazyFieldEncoder implements FieldEncoder {
 	private encoderLazy: FieldEncoder | undefined;
 
 	public constructor(
-		public readonly cache: TreeShaper,
-		public readonly field: TreeFieldStoredSchema,
-		private readonly fieldEncoder: FieldShapePolicy,
+		public readonly nodeBuilder: NodeEncodeBuilder,
+		public readonly fieldSchema: TreeFieldStoredSchema,
+		private readonly fieldEncoderFromPolicy: FieldEncoderPolicy,
 	) {}
 	public encodeField(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat,
 	): void {
-		this.encoder.encodeField(cursor, cache, outputBuffer);
+		this.encoder.encodeField(cursor, context, outputBuffer);
 	}
 
 	private get encoder(): FieldEncoder {
 		if (this.encoderLazy === undefined) {
-			this.encoderLazy = this.fieldEncoder(this.cache, this.field);
+			this.encoderLazy = this.fieldEncoderFromPolicy(this.nodeBuilder, this.fieldSchema);
 		}
 		return this.encoderLazy;
 	}

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

@@ -24,12 +24,12 @@ export const validVersions = new Set([version]);
  * Top level length is implied from length of data array.
  * All content are of this shape.
  */
-export const EncodedNestedArray = ShapeIndex;
+export const EncodedNestedArrayShape = ShapeIndex;
 
 /**
  * Inline array.
  */
-export const EncodedInlineArray = Type.Object(
+export const EncodedInlineArrayShape = Type.Object(
 	{
 		length: Count,
 		/**
@@ -123,7 +123,7 @@ export enum SpecialField {
  * In the future other value shape formats may be added, likely as objects.
  *
  * @remarks
- * See {@link EncodedTreeShape} for usage.
+ * See {@link EncodedNodeShape} for usage.
  */
 export const EncodedValueShape = Type.Union([
 	Type.Boolean(),
@@ -134,7 +134,7 @@ export const EncodedValueShape = Type.Union([
 ]);
 export type EncodedValueShape = undefined | Static<typeof EncodedValueShape>;
 
-export const EncodedTreeShape = Type.Object(
+export const EncodedNodeShape = Type.Object(
 	{
 		/**
 		 * If not provided, inlined in data.
@@ -157,24 +157,30 @@ export const EncodedTreeShape = Type.Object(
 );
 
 /**
- * Discriminated union of chunk shapes.
+ * 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
+ * single unit in a specific format represented by one of the shapes in this union.
+ *
+ * The concept of "chunk" is same for the tree data in memory and in the encoded wire format.
+ * The physical representation of the chunk may differ, but the logical structure remains the same.
+ * This is similar to other such concepts in the system.
  *
  * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
  */
 export const EncodedChunkShape = Type.Object(
 	{
 		/**
-		 * {@link EncodedNestedArray} union member.
+		 * {@link EncodedNestedArrayShape} union member.
 		 */
-		a: Type.Optional(EncodedNestedArray),
+		a: Type.Optional(EncodedNestedArrayShape),
 		/**
-		 * {@link EncodedInlineArray} union member.
+		 * {@link EncodedInlineArrayShape} union member.
 		 */
-		b: Type.Optional(EncodedInlineArray),
+		b: Type.Optional(EncodedInlineArrayShape),
 		/**
-		 * {@link EncodedTreeShape} union member.
+		 * {@link EncodedNodeShape} union member.
 		 */
-		c: Type.Optional(EncodedTreeShape),
+		c: Type.Optional(EncodedNodeShape),
 		/**
 		 * {@link EncodedAnyShape} union member.
 		 */
@@ -185,9 +191,9 @@ export const EncodedChunkShape = Type.Object(
 
 export type EncodedChunkShape = Static<typeof EncodedChunkShape>;
 
-export type EncodedNestedArray = Static<typeof EncodedNestedArray>;
-export type EncodedInlineArray = Static<typeof EncodedInlineArray>;
-export type EncodedTreeShape = Static<typeof EncodedTreeShape>;
+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 const EncodedFieldBatch = EncodedFieldBatchGeneric(version, EncodedChunkShape);

package/src/feature-libraries/chunked-forest/codec/{nodeShape.ts → nodeEncoder.ts}

@@ -18,7 +18,7 @@ import { brand } from "../../../util/index.js";
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import { type BufferFormat, IdentifierToken, Shape } from "./chunkEncodingGeneric.js";
 import {
-	type EncoderCache,
+	type EncoderContext,
 	type FieldEncoder,
 	type KeyedFieldEncoder,
 	type NodeEncoder,
@@ -26,9 +26,15 @@ import {
 } from "./compressedEncode.js";
 import type { EncodedChunkShape, EncodedFieldShape, EncodedValueShape } from "./format.js";
 
-export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
+/**
+ * Encodes a node with the {@link EncodedNodeShape} shape.
+ * @remarks
+ * 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 {
 	/**
-	 * Set of keys for fields that are encoded using {@link NodeShape.specializedFieldEncoders}.
+	 * Set of keys for fields that are encoded using {@link NodeShapeBasedEncoder.specializedFieldEncoders}.
 	 * TODO: Ensure uniform chunks, encoding and identifier generation sort fields the same.
 	 */
 	private readonly specializedFieldKeys: Set<FieldKey>;
@@ -39,17 +45,17 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 		/**
 		 * Encoders for a specific set of fields, by key, in the order they will be encoded.
 		 * These are fields for which specialized encoding is provided as an optimization.
-		 * Using these for a given field instead of falling back to {@link NodeShape.specializedFieldEncoders} is often more efficient:
+		 * Using these for a given field instead of falling back to {@link NodeShapeBasedEncoder.specializedFieldEncoders} is often more efficient:
 		 * this avoids the need to explicitly include the key and shape in the encoded data for each node instance.
 		 * Instead, this information is here, and thus is encoded only once as part of the node shape.
 		 * These encoders will be used, even if the field they apply to is empty (which can add overhead for fields which are usually empty).
 		 *
-		 * Any fields not included here will be encoded using {@link NodeShape.otherFieldsEncoder}.
-		 * If {@link NodeShape.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
+		 * Any fields not included here will be encoded using {@link NodeShapeBasedEncoder.otherFieldsEncoder}.
+		 * If {@link NodeShapeBasedEncoder.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
 		 */
 		public readonly specializedFieldEncoders: readonly KeyedFieldEncoder[],
 		/**
-		 * Encoder for all other fields that are not in {@link NodeShape.specializedFieldEncoders}. These fields must
+		 * Encoder for all other fields that are not in {@link NodeShapeBasedEncoder.specializedFieldEncoders}. These fields must
 		 * be encoded after the specialized fields.
 		 */
 		public readonly otherFieldsEncoder: undefined | FieldEncoder,
@@ -58,13 +64,13 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 		this.specializedFieldKeys = new Set(this.specializedFieldEncoders.map((f) => f.key));
 	}
 
-	private getValueToEncode(cursor: ITreeCursorSynchronous, cache: EncoderCache): Value {
+	private getValueToEncode(cursor: ITreeCursorSynchronous, context: EncoderContext): Value {
 		if (this.value === 0) {
 			assert(typeof cursor.value === "string", 0x9aa /* identifier must be type string */);
 			if (isStableId(cursor.value)) {
-				const sessionSpaceCompressedId = cache.idCompressor.tryRecompress(cursor.value);
+				const sessionSpaceCompressedId = context.idCompressor.tryRecompress(cursor.value);
 				if (sessionSpaceCompressedId !== undefined) {
-					return cache.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
+					return context.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
 				}
 			}
 		}
@@ -73,7 +79,7 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 
 	public encodeNode(
 		cursor: ITreeCursorSynchronous,
-		cache: EncoderCache,
+		context: EncoderContext,
 		outputBuffer: BufferFormat<EncodedChunkShape>,
 	): void {
 		if (this.type === undefined) {
@@ -81,10 +87,10 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 		} else {
 			assert(cursor.type === this.type, 0x741 /* type must match shape */);
 		}
-		encodeValue(this.getValueToEncode(cursor, cache), this.value, outputBuffer);
+		encodeValue(this.getValueToEncode(cursor, context), this.value, outputBuffer);
 		for (const fieldEncoder of this.specializedFieldEncoders) {
 			cursor.enterField(brand(fieldEncoder.key));
-			fieldEncoder.encoder.encodeField(cursor, cache, outputBuffer);
+			fieldEncoder.encoder.encodeField(cursor, context, outputBuffer);
 			cursor.exitField();
 		}
 
@@ -98,7 +104,7 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 					0x742 /* had extra local fields when shape does not support them */,
 				);
 				otherFieldsBuffer.push(new IdentifierToken(key));
-				this.otherFieldsEncoder.encodeField(cursor, cache, otherFieldsBuffer);
+				this.otherFieldsEncoder.encodeField(cursor, context, otherFieldsBuffer);
 			}
 		});
 
@@ -139,7 +145,7 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 		}
 	}
 
-	public get shape(): NodeShape {
+	public get shape(): Shape<EncodedChunkShape> {
 		return this;
 	}
 }
@@ -175,10 +181,10 @@ function encodeOptionalIdentifier(
 }
 
 function encodeOptionalFieldShape(
-	shape: FieldEncoder | undefined,
+	encoder: FieldEncoder | undefined,
 	shapes: DeduplicationTable<Shape<EncodedChunkShape>>,
 ): number | undefined {
-	return shape === undefined ? undefined : dedupShape(shape.shape, shapes);
+	return encoder === undefined ? undefined : dedupShape(encoder.shape, shapes);
 }
 
 function dedupShape(