@fluidframework/tree 2.41.0 → 2.43.0-343119

package/src/core/schema-stored/formatV2.ts

@@ -0,0 +1,78 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+
+import { JsonCompatibleReadOnlySchema } from "../../util/index.js";
+import {
+	FieldKindIdentifierSchema,
+	PersistedValueSchema,
+	TreeNodeSchemaIdentifierSchema,
+} from "./formatV1.js";
+import { unionOptions } from "../../codec/index.js";
+
+export const PersistedMetadataFormat = Type.Optional(JsonCompatibleReadOnlySchema);
+
+const FieldSchemaFormatBase = Type.Object({
+	kind: FieldKindIdentifierSchema,
+	types: Type.Array(TreeNodeSchemaIdentifierSchema),
+	metadata: PersistedMetadataFormat,
+});
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+export const FieldSchemaFormat = Type.Composite([FieldSchemaFormatBase], noAdditionalProps);
+
+/**
+ * Format for the content of a {@link TreeNodeStoredSchema}.
+ *
+ * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
+ */
+export const TreeNodeSchemaUnionFormat = Type.Object(
+	{
+		/**
+		 * Object node union member.
+		 */
+		object: Type.Optional(Type.Record(Type.String(), FieldSchemaFormat)),
+		/**
+		 * Map node union member.
+		 */
+		map: Type.Optional(FieldSchemaFormat),
+		/**
+		 * Leaf node union member.
+		 */
+		leaf: Type.Optional(Type.Enum(PersistedValueSchema)),
+	},
+	unionOptions,
+);
+
+export type TreeNodeSchemaUnionFormat = Static<typeof TreeNodeSchemaUnionFormat>;
+
+/**
+ * Format for {@link TreeNodeStoredSchema}.
+ *
+ * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
+ */
+export const TreeNodeSchemaDataFormat = Type.Object(
+	{
+		/**
+		 * Node kind specific data.
+		 */
+		kind: TreeNodeSchemaUnionFormat,
+
+		// Data in common for all TreeNode schemas:
+		/**
+		 * Leaf node union member.
+		 */
+		metadata: PersistedMetadataFormat,
+	},
+	noAdditionalProps,
+);
+
+export type TreeNodeSchemaDataFormat = Static<typeof TreeNodeSchemaDataFormat>;
+
+export type FieldSchemaFormat = Static<typeof FieldSchemaFormat>;
+
+export type PersistedMetadataFormat = Static<typeof PersistedMetadataFormat>;

package/src/core/schema-stored/index.ts

@@ -18,7 +18,8 @@ export {
 	ObjectNodeStoredSchema,
 	MapNodeStoredSchema,
 	decodeFieldSchema,
-	encodeFieldSchema,
+	encodeFieldSchemaV1,
+	encodeFieldSchemaV2,
 	storedSchemaDecodeDispatcher,
 	type SchemaAndPolicy,
 	type SchemaPolicy,
@@ -37,3 +38,5 @@ export type { TreeNodeSchemaIdentifier, FieldKey, FieldKindIdentifier } from "./
 
 import * as schemaFormatV1 from "./formatV1.js";
 export { schemaFormatV1 };
+import * as schemaFormatV2 from "./formatV2.js";
+export { schemaFormatV2 };

package/src/core/schema-stored/schema.ts

@@ -6,16 +6,27 @@
 import { fail } from "@fluidframework/core-utils/internal";
 
 import { DiscriminatedUnionDispatcher } from "../../codec/index.js";
-import { type MakeNominal, brand, invertMap } from "../../util/index.js";
+import {
+	type JsonCompatibleReadOnlyObject,
+	type MakeNominal,
+	brand,
+	invertMap,
+} from "../../util/index.js";
 
 import {
 	type FieldKey,
 	type FieldKindIdentifier,
-	type FieldSchemaFormat,
+	type FieldSchemaFormat as FieldSchemaFormatV1,
 	PersistedValueSchema,
-	type TreeNodeSchemaDataFormat,
+	type TreeNodeSchemaDataFormat as TreeNodeSchemaDataFormatV1,
 	type TreeNodeSchemaIdentifier,
 } from "./formatV1.js";
+import type {
+	FieldSchemaFormat as FieldSchemaFormatV2,
+	PersistedMetadataFormat,
+	TreeNodeSchemaUnionFormat,
+	TreeNodeSchemaDataFormat as TreeNodeSchemaDataFormatV2,
+} from "./formatV2.js";
 import type { Multiplicity } from "./multiplicity.js";
 
 /**
@@ -23,8 +34,14 @@ import type { Multiplicity } from "./multiplicity.js";
  */
 export enum SchemaVersion {
 	v1 = 1,
+	/**
+	 * Adds persisted metadata to the node schema and field schema.
+	 */
+	v2 = 2,
 }
 
+type FieldSchemaFormat = FieldSchemaFormatV1 | FieldSchemaFormatV2;
+
 /**
  * Schema for what {@link TreeLeafValue} is allowed on a Leaf node.
  * @privateRemarks
@@ -128,6 +145,15 @@ export interface TreeFieldStoredSchema {
 	 * If not specified, types are unconstrained.
 	 */
 	readonly types: TreeTypeSet;
+
+	/**
+	 * Portion of the metadata which can be persisted.
+	 * @remarks
+	 * Discarded when encoding to {@link SchemaFormatVersion.V1}.
+	 * @privateRemarks
+	 * This field corresponds to the `metadata` field in the persisted schema format.
+	 */
+	readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined;
 }
 
 /**
@@ -151,6 +177,7 @@ export const storedEmptyFieldSchema: TreeFieldStoredSchema = {
 	kind: brand(forbiddenFieldKindIdentifier),
 	// This type set also forces the field to be empty not not allowing any types as all.
 	types: new Set(),
+	persistedMetadata: undefined,
 };
 
 /**
@@ -164,12 +191,21 @@ export abstract class TreeNodeStoredSchema {
 	protected _typeCheck!: MakeNominal;
 
 	/**
-	 * @privateRemarks
-	 * Returns TreeNodeSchemaDataFormat.
-	 * This is uses an opaque type to avoid leaking these types out of the package,
-	 * and is runtime validated by the codec.
+	 * Constructor for a TreeNodeStoredSchema.
+	 * @param metadata - Persisted metadata for this node schema.
+	 */
+	public constructor(public readonly metadata: PersistedMetadataFormat | undefined) {}
+
+	/**
+	 * Encode in the v1 schema format.
 	 */
-	public abstract encode(): TreeNodeSchemaDataFormat;
+	public abstract encodeV1(): TreeNodeSchemaDataFormatV1;
+
+	/**
+	 * Encode in the v2 schema format.
+	 * @remarks Post-condition: if metadata was specified on the input schema, it will be present in the output.
+	 */
+	public abstract encodeV2(): TreeNodeSchemaDataFormatV2;
 
 	/**
 	 * Returns the schema for the provided field.
@@ -190,11 +226,35 @@ export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
 	 */
 	public constructor(
 		public readonly objectNodeFields: ReadonlyMap<FieldKey, TreeFieldStoredSchema>,
+		metadata?: PersistedMetadataFormat | undefined,
 	) {
-		super();
+		super(metadata);
+	}
+
+	public override encodeV1(): TreeNodeSchemaDataFormatV1 {
+		const fieldsObject: Record<string, FieldSchemaFormat> =
+			this.encodeFieldsObject(encodeFieldSchemaV1);
+
+		return {
+			object: fieldsObject,
+		};
+	}
+
+	public override encodeV2(): TreeNodeSchemaDataFormatV2 {
+		const fieldsObject: Record<string, FieldSchemaFormat> =
+			this.encodeFieldsObject(encodeFieldSchemaV2);
+		const kind = { object: fieldsObject };
+
+		return { kind, metadata: this.metadata };
 	}
 
-	public override encode(): TreeNodeSchemaDataFormat {
+	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
+		return this.objectNodeFields.get(field) ?? storedEmptyFieldSchema;
+	}
+
+	private encodeFieldsObject(
+		encodeFieldSchema: (storedFieldSchema: TreeFieldStoredSchema) => FieldSchemaFormat,
+	): Record<string, FieldSchemaFormat> {
 		const fieldsObject: Record<string, FieldSchemaFormat> = Object.create(null);
 		// Sort fields to ensure output is identical for for equivalent schema (since field order is not considered significant).
 		// This makes comparing schema easier, and ensures chunk reuse for schema summaries isn't needlessly broken.
@@ -208,13 +268,7 @@ export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
 				),
 			});
 		}
-		return {
-			object: fieldsObject,
-		};
-	}
-
-	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
-		return this.objectNodeFields.get(field) ?? storedEmptyFieldSchema;
+		return fieldsObject;
 	}
 }
 
@@ -229,16 +283,24 @@ export class MapNodeStoredSchema extends TreeNodeStoredSchema {
 	 * since no nodes can ever be in schema if you use `FieldKind.Value` here
 	 * (that would require infinite children).
 	 */
-	public constructor(public readonly mapFields: TreeFieldStoredSchema) {
-		super();
+	public constructor(
+		public readonly mapFields: TreeFieldStoredSchema,
+		metadata?: PersistedMetadataFormat | undefined,
+	) {
+		super(metadata);
 	}
 
-	public override encode(): TreeNodeSchemaDataFormat {
+	public override encodeV1(): TreeNodeSchemaDataFormatV1 {
 		return {
-			map: encodeFieldSchema(this.mapFields),
+			map: encodeFieldSchemaV1(this.mapFields),
 		};
 	}
 
+	public override encodeV2(): TreeNodeSchemaDataFormatV2 {
+		const kind = { map: encodeFieldSchemaV2(this.mapFields) };
+		return { kind, metadata: this.metadata };
+	}
+
 	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
 		return this.mapFields;
 	}
@@ -260,36 +322,54 @@ export class LeafNodeStoredSchema extends TreeNodeStoredSchema {
 	 * This is simply one approach that can work for modeling them in the internal schema representation.
 	 */
 	public constructor(public readonly leafValue: ValueSchema) {
-		super();
+		// No metadata for leaf nodes.
+		super(undefined);
 	}
 
-	public override encode(): TreeNodeSchemaDataFormat {
+	public override encodeV1(): TreeNodeSchemaDataFormatV1 {
 		return {
 			leaf: encodeValueSchema(this.leafValue),
 		};
 	}
 
+	public override encodeV2(): TreeNodeSchemaDataFormatV2 {
+		return {
+			// No metadata for leaf nodes, so don't emit a metadata field.
+			kind: {
+				leaf: encodeValueSchema(this.leafValue),
+			},
+		};
+	}
+
 	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
 		return storedEmptyFieldSchema;
 	}
 }
 
+/**
+ * Decoder wrapper function for {@link TreeNodeStoredSchema} implementations.
+ * Curries the constructor so that the caller can inject metadata.
+ */
+type StoredSchemaDecoder = (
+	metadata: PersistedMetadataFormat | undefined,
+) => TreeNodeStoredSchema;
+
 export const storedSchemaDecodeDispatcher: DiscriminatedUnionDispatcher<
-	TreeNodeSchemaDataFormat,
+	TreeNodeSchemaUnionFormat,
 	[],
-	TreeNodeStoredSchema
+	StoredSchemaDecoder
 > = new DiscriminatedUnionDispatcher({
-	leaf: (data: PersistedValueSchema) => new LeafNodeStoredSchema(decodeValueSchema(data)),
-	object: (
-		data: Record<TreeNodeSchemaIdentifier, FieldSchemaFormat>,
-	): TreeNodeStoredSchema => {
+	leaf: (data: PersistedValueSchema) => (metadata) =>
+		new LeafNodeStoredSchema(decodeValueSchema(data)),
+	object: (data: Record<TreeNodeSchemaIdentifier, FieldSchemaFormat>) => (metadata) => {
 		const map = new Map();
 		for (const [key, value] of Object.entries(data)) {
 			map.set(key, decodeFieldSchema(value));
 		}
-		return new ObjectNodeStoredSchema(map);
+		return new ObjectNodeStoredSchema(map, metadata);
 	},
-	map: (data: FieldSchemaFormat) => new MapNodeStoredSchema(decodeFieldSchema(data)),
+	map: (data: FieldSchemaFormat) => (metadata) =>
+		new MapNodeStoredSchema(decodeFieldSchema(data), metadata),
 });
 
 const valueSchemaEncode = new Map([
@@ -310,7 +390,7 @@ function decodeValueSchema(inMemory: PersistedValueSchema): ValueSchema {
 	return valueSchemaDecode.get(inMemory) ?? fail(0xae9 /* missing ValueSchema */);
 }
 
-export function encodeFieldSchema(schema: TreeFieldStoredSchema): FieldSchemaFormat {
+export function encodeFieldSchemaV1(schema: TreeFieldStoredSchema): FieldSchemaFormatV1 {
 	return {
 		kind: schema.kind,
 		// Types are sorted by identifier to improve stability of persisted data to increase chance of schema blob reuse.
@@ -318,11 +398,21 @@ export function encodeFieldSchema(schema: TreeFieldStoredSchema): FieldSchemaFor
 	};
 }
 
-export function decodeFieldSchema(schema: FieldSchemaFormat): TreeFieldStoredSchema {
+export function encodeFieldSchemaV2(schema: TreeFieldStoredSchema): FieldSchemaFormatV2 {
+	const fieldSchema: FieldSchemaFormatV1 = encodeFieldSchemaV1(schema);
+
+	// Omit metadata from the output if it is undefined
+	return schema.persistedMetadata !== undefined
+		? { ...fieldSchema, metadata: schema.persistedMetadata }
+		: { ...fieldSchema };
+}
+
+export function decodeFieldSchema(schema: FieldSchemaFormatV2): TreeFieldStoredSchema {
 	const out: TreeFieldStoredSchema = {
 		// TODO: maybe provide actual FieldKind objects here, error on unrecognized kinds.
 		kind: schema.kind,
 		types: new Set(schema.types),
+		persistedMetadata: schema.metadata,
 	};
 	return out;
 }

package/src/core/tree/detachedFieldIndex.ts

@@ -6,7 +6,12 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-import { type ICodecOptions, type IJsonCodec, noopValidator } from "../../codec/index.js";
+import {
+	type CodecWriteOptions,
+	FluidClientVersion,
+	type IJsonCodec,
+	noopValidator,
+} from "../../codec/index.js";
 import {
 	type IdAllocator,
 	type JsonCompatibleReadOnly,
@@ -55,7 +60,7 @@ export class DetachedFieldIndex {
 	> = new Map();
 
 	private readonly codec: IJsonCodec<DetachedFieldSummaryData, Format>;
-	private readonly options: ICodecOptions;
+	private readonly options: CodecWriteOptions;
 
 	/**
 	 * The process for loading `DetachedFieldIndex` data from a summary is split into two steps:
@@ -76,9 +81,13 @@ export class DetachedFieldIndex {
 		private rootIdAllocator: IdAllocator<ForestRootId>,
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly idCompressor: IIdCompressor,
-		options?: ICodecOptions,
+		options?: CodecWriteOptions,
 	) {
-		this.options = options ?? { jsonValidator: noopValidator };
+		this.options = options ?? {
+			jsonValidator: noopValidator,
+			oldestCompatibleClient: FluidClientVersion.v2_0,
+		};
+		// TODO: this should take in CodecWriteOptions, and use it to pick the write version.
 		this.codec = makeDetachedNodeToFieldCodec(revisionTagCodec, this.options, idCompressor);
 	}
 

package/src/core/tree/mapTree.ts

@@ -3,6 +3,9 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/core-utils/internal";
+
+import type { MinimalMapTreeNodeView } from "../../feature-libraries/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
 import type { NodeData } from "./types.js";
@@ -36,17 +39,32 @@ export interface ExclusiveMapTree extends NodeData, MapTree {
  * @privateRemarks This is implemented iteratively (rather than recursively, which is much simpler)
  * to avoid the possibility of a stack overflow for very deep trees.
  */
-export function deepCopyMapTree(mapTree: MapTree): ExclusiveMapTree {
-	type Next = [fields: ExclusiveMapTree["fields"], sourceFields: MapTree["fields"]];
+export function deepCopyMapTree(mapTree: MinimalMapTreeNodeView): ExclusiveMapTree {
+	type Next = [
+		fields: ExclusiveMapTree["fields"],
+		sourceFields: MinimalMapTreeNodeView["fields"],
+	];
+	function create(
+		child: MinimalMapTreeNodeView,
+		fields: ExclusiveMapTree["fields"],
+	): ExclusiveMapTree {
+		return {
+			type: child.type,
+			...(child.value !== undefined ? { value: child.value } : {}),
+			fields,
+		};
+	}
+
 	const rootFields: ExclusiveMapTree["fields"] = new Map();
 	const nexts: Next[] = [[rootFields, mapTree.fields]];
 	for (let next = nexts.pop(); next !== undefined; next = nexts.pop()) {
 		const [fields, sourceFields] = next;
 		for (const [key, field] of sourceFields) {
+			assert(field.length > 0, 0xbb3 /* invalid map tree: empty field */);
 			if (field.length > 0) {
 				const newField: ExclusiveMapTree[] = [];
 				for (const child of field) {
-					const childClone: ExclusiveMapTree = { ...child, fields: new Map() };
+					const childClone = create(child, new Map());
 					newField.push(childClone);
 					nexts.push([childClone.fields, child.fields]);
 				}
@@ -55,8 +73,5 @@ export function deepCopyMapTree(mapTree: MapTree): ExclusiveMapTree {
 		}
 	}
 
-	return {
-		...mapTree,
-		fields: rootFields,
-	};
+	return create(mapTree, rootFields);
 }

package/src/core/tree/visitorUtils.ts

@@ -5,7 +5,7 @@
 
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-import type { ICodecOptions } from "../../codec/index.js";
+import type { CodecWriteOptions } from "../../codec/index.js";
 import { type IdAllocator, idAllocatorFromMaxId } from "../../util/index.js";
 import type { RevisionTag, RevisionTagCodec } from "../rebase/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
@@ -21,7 +21,7 @@ export function makeDetachedFieldIndex(
 	prefix: string = "Temp",
 	revisionTagCodec: RevisionTagCodec,
 	idCompressor: IIdCompressor,
-	options?: ICodecOptions,
+	options?: CodecWriteOptions,
 ): DetachedFieldIndex {
 	return new DetachedFieldIndex(
 		prefix,

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

@@ -43,13 +43,14 @@ export type BufferFormat<TEncodedShape> = (
 )[];
 
 /**
- * Replace shapes and identifiers in buffer and any nested arrays.
+ * Takes already encoded content in `buffer` and deeply searches, replacing each `IdentifierToken` and `Shape`
+ * with references to their encodings in the returned `EncodedFieldBatchGeneric`.
  *
  * This looks inside nested arrays (including transitively) but not inside objects.
  *
  * Note that this modifies `buffer` to avoid having to copy it.
  */
-export function handleShapesAndIdentifiers<TEncodedShape>(
+export function updateShapesAndIdentifiersEncoding<TEncodedShape>(
 	version: number,
 	buffer: BufferFormat<TEncodedShape>[],
 	identifierFilter: CounterFilter<string> = jsonMinimizingFilter,
@@ -68,6 +69,9 @@ export function handleShapesAndIdentifiers<TEncodedShape>(
 		}
 	};
 
+	// A collection of all arrays transitively reachable (via arrays) from buffer.
+	// These are all the arrays whose contents are searched for shapes and identifiers which are then replaced
+	// with references. This uses a breadth first traversal, but the actual order is not important.
 	const arrays: BufferFormat<TEncodedShape>[] = [buffer];
 	for (const array of arrays) {
 		for (const item of array) {
@@ -93,9 +97,9 @@ export function handleShapesAndIdentifiers<TEncodedShape>(
 
 	// Traverse shape graph, discovering and counting all shape to shape and shape to identifier references.
 	{
-		let item: Shape<TEncodedShape> | undefined;
-		while ((item = shapeToCount.pop()) !== undefined) {
-			item.count(identifiers, shapeDiscovered);
+		let shape: Shape<TEncodedShape> | undefined;
+		while ((shape = shapeToCount.pop()) !== undefined) {
+			shape.countReferencedShapesAndIdentifiers(identifiers, shapeDiscovered);
 		}
 	}
 
@@ -143,8 +147,8 @@ export function handleShapesAndIdentifiers<TEncodedShape>(
  * Comparison by content would be difficult due to shape containing references to other shapes.
  *
  * @privateRemarks
- * Unlike with identifiers, conversion from the initial form (this class / IdentifierToken) is done by the `encodeShape` method, not by general purpose logic in `handleShapesAndIdentifiers`.
- * For `handleShapesAndIdentifiers` to do the conversion without help from `encodeShape`,
+ * Unlike with identifiers, conversion from the initial form (this class / IdentifierToken) is done by the `encodeShape` method, not by general purpose logic in `updateShapesAndIdentifiersEncoding`.
+ * For `updateShapesAndIdentifiersEncoding` to do the conversion without help from `encodeShape`,
  * instances of this Shape class would have to either be or output an object that is identical to the `TEncodedShape` format except with all shape references as object references instead of indexes.
  * Those objects would have to be deeply traversed looking for shape objects to replace with reference indexes.
  * This is possible, but making it type safe would involve generating derived types from the `TEncodedShape` deeply replacing any shape references, as well as requiring deep traversal of all objects in the encoded output.
@@ -152,18 +156,19 @@ export function handleShapesAndIdentifiers<TEncodedShape>(
  */
 export abstract class Shape<TEncodedShape> {
 	/**
-	 * Count this shape's contents.
+	 * Enumerate all contents of this shape that can get replaced with references (for better compression/deduplication) during encoding.
+	 * This currently includes shapes and identifiers.
 	 *
 	 * Used to discover referenced shapes (to ensure they are included in the `shapes` passed to `encodeShape`),
 	 * as well as count usages of shapes and identifiers for more efficient dictionary encoding. See {@link Counter}.
 	 *
-	 * @param shapes - must be invoked with each directly referenced shape (which must provided to `encodeShape`).
+	 * @param shapeDiscovered - must be invoked with each directly referenced shape (which must be provided to `encodeShape`).
 	 * Can be invoked multiple times if a shape is referenced more than once for more efficient dictionary encoding.
 	 * Should not be invoked with `this` unless this shape references itself.
 	 */
-	public abstract count(
+	public abstract countReferencedShapesAndIdentifiers(
 		identifiers: Counter<string>,
-		shapes: (shape: Shape<TEncodedShape>) => void,
+		shapeDiscovered: (shape: Shape<TEncodedShape>) => void,
 	): void;
 
 	/**

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

@@ -23,7 +23,7 @@ import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import {
 	type BufferFormat as BufferFormatGeneric,
 	Shape as ShapeGeneric,
-	handleShapesAndIdentifiers,
+	updateShapesAndIdentifiersEncoding,
 } from "./chunkEncodingGeneric.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
@@ -55,7 +55,7 @@ export function compressedEncode(
 		anyFieldEncoder.encodeField(cursor, cache, buffer);
 		batchBuffer.push(buffer);
 	}
-	return handleShapesAndIdentifiers(version, batchBuffer);
+	return updateShapesAndIdentifiersEncoding(version, batchBuffer);
 }
 
 export type BufferFormat = BufferFormatGeneric<EncodedChunkShape>;
@@ -175,7 +175,10 @@ export class AnyShape extends ShapeGeneric<EncodedChunkShape> {
 		return { d: encodedAnyShape };
 	}
 
-	public count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void {}
+	public countReferencedShapesAndIdentifiers(
+		identifiers: Counter<string>,
+		shapeDiscovered: (shape: Shape) => void,
+	): void {}
 
 	public static encodeField(
 		cursor: ITreeCursorSynchronous,
@@ -329,8 +332,11 @@ export class InlineArrayShape
 		};
 	}
 
-	public count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void {
-		shapes(this.inner.shape);
+	public countReferencedShapesAndIdentifiers(
+		identifiers: Counter<string>,
+		shapeDiscovered: (shape: Shape) => void,
+	): void {
+		shapeDiscovered(this.inner.shape);
 	}
 
 	public get shape(): this {
@@ -387,8 +393,11 @@ export class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements
 		};
 	}
 
-	public count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void {
-		shapes(this.inner.shape);
+	public countReferencedShapesAndIdentifiers(
+		identifiers: Counter<string>,
+		shapeDiscovered: (shape: Shape) => void,
+	): void {
+		shapeDiscovered(this.inner.shape);
 	}
 }
 

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

@@ -121,9 +121,9 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 		};
 	}
 
-	public count(
+	public countReferencedShapesAndIdentifiers(
 		identifiers: Counter<string>,
-		shapes: (shape: Shape<EncodedChunkShape>) => void,
+		shapeDiscovered: (shape: Shape<EncodedChunkShape>) => void,
 	): void {
 		if (this.type !== undefined) {
 			identifiers.add(this.type);
@@ -131,11 +131,11 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 
 		for (const fieldEncoder of this.specializedFieldEncoders) {
 			identifiers.add(fieldEncoder.key);
-			shapes(fieldEncoder.encoder.shape);
+			shapeDiscovered(fieldEncoder.encoder.shape);
 		}
 
 		if (this.otherFieldsEncoder !== undefined) {
-			shapes(this.otherFieldsEncoder.shape);
+			shapeDiscovered(this.otherFieldsEncoder.shape);
 		}
 	}
 

package/src/feature-libraries/default-schema/defaultEditBuilder.ts

@@ -434,8 +434,9 @@ export interface OptionalFieldEditBuilder<TContent> {
 }
 
 /**
+ * Edit builder for the sequence field kind.
  */
-export interface SequenceFieldEditBuilder<TContent> {
+export interface SequenceFieldEditBuilder<TContent, TRemoved = void> {
 	/**
 	 * Issues a change which inserts the `newContent` at the given `index`.
 	 * @param index - the index at which to insert the `newContent`.
@@ -448,7 +449,7 @@ export interface SequenceFieldEditBuilder<TContent> {
 	 * @param index - The index of the first removed element.
 	 * @param count - The number of elements to remove.
 	 */
-	remove(index: number, count: number): void;
+	remove(index: number, count: number): TRemoved;
 }
 
 /**