@fluidframework/tree 2.41.0 → 2.43.0-343119

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

@@ -7,7 +7,6 @@ import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
-	type MapTree,
 	type TreeFieldStoredSchema,
 	LeafNodeStoredSchema,
 	ObjectNodeStoredSchema,
@@ -16,6 +15,8 @@ import {
 	type SchemaAndPolicy,
 } from "../../core/index.js";
 import { allowsValue } from "../valueUtilities.js";
+import type { MapTreeFieldViewGeneric, MinimalMapTreeNodeView } from "../mapTreeCursor.js";
+import { iterableHasSome, mapIterable } from "../../util/index.js";
 
 export enum SchemaValidationError {
 	Field_KindNotInSchemaPolicy,
@@ -45,7 +46,7 @@ export function inSchemaOrThrow(maybeError: SchemaValidationError | undefined):
  * Deeply checks that the provided node complies with the schema based on its identifier.
  */
 export function isNodeInSchema(
-	node: MapTree,
+	node: MinimalMapTreeNodeView,
 	schemaAndPolicy: SchemaAndPolicy,
 ): SchemaValidationError | undefined {
 	// Validate the schema declared by the node exists
@@ -57,7 +58,7 @@ export function isNodeInSchema(
 	// Validate the node is well formed according to its schema
 
 	if (schema instanceof LeafNodeStoredSchema) {
-		if (node.fields.size !== 0) {
+		if (iterableHasSome(node.fields)) {
 			return SchemaValidationError.LeafNode_FieldsNotAllowed;
 		}
 		if (!allowsValue(schema.leafValue, node.value)) {
@@ -69,7 +70,7 @@ export function isNodeInSchema(
 		}
 
 		if (schema instanceof ObjectNodeStoredSchema) {
-			const uncheckedFieldsFromNode = new Set(node.fields.keys());
+			const uncheckedFieldsFromNode = new Set(mapIterable(node.fields, ([key, field]) => key));
 			for (const [fieldKey, fieldSchema] of schema.objectNodeFields) {
 				const nodeField = node.fields.get(fieldKey) ?? [];
 				const fieldInSchemaResult = isFieldInSchema(nodeField, fieldSchema, schemaAndPolicy);
@@ -86,7 +87,7 @@ export function isNodeInSchema(
 				return SchemaValidationError.ObjectNode_FieldNotInSchema;
 			}
 		} else if (schema instanceof MapNodeStoredSchema) {
-			for (const field of node.fields.values()) {
+			for (const [_key, field] of node.fields) {
 				const fieldInSchemaResult = isFieldInSchema(field, schema.mapFields, schemaAndPolicy);
 				if (fieldInSchemaResult !== undefined) {
 					return fieldInSchemaResult;
@@ -104,7 +105,7 @@ export function isNodeInSchema(
  * Deeply checks that the nodes comply with the field schema and included schema.
  */
 export function isFieldInSchema(
-	childNodes: readonly MapTree[],
+	childNodes: MapTreeFieldViewGeneric<MinimalMapTreeNodeView>,
 	schema: TreeFieldStoredSchema,
 	schemaAndPolicy: SchemaAndPolicy,
 ): SchemaValidationError | undefined {

package/src/feature-libraries/detachedFieldIndexSummarizer.ts

@@ -6,6 +6,7 @@
 import { bufferToString } from "@fluid-internal/client-utils";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type {
+	IExperimentalIncrementalSummaryContext,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -32,23 +33,15 @@ export class DetachedFieldIndexSummarizer implements Summarizable {
 
 	public constructor(private readonly detachedFieldIndex: DetachedFieldIndex) {}
 
-	public getAttachSummary(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-	): ISummaryTreeWithStats {
+	public summarize(props: {
+		stringify: SummaryElementStringifier;
+		fullTree?: boolean;
+		trackState?: boolean;
+		telemetryContext?: ITelemetryContext;
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext;
+	}): ISummaryTreeWithStats {
 		const data = this.detachedFieldIndex.encode();
-		return createSingleBlobSummary(detachedFieldIndexBlobKey, stringify(data));
-	}
-
-	public async summarize(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-	): Promise<ISummaryTreeWithStats> {
-		return this.getAttachSummary(stringify, fullTree, trackState, telemetryContext);
+		return createSingleBlobSummary(detachedFieldIndexBlobKey, props.stringify(data));
 	}
 
 	public async load(

package/src/feature-libraries/flex-tree/context.ts

@@ -54,16 +54,12 @@ export interface FlexTreeContext {
 }
 
 /**
- * A common context of a "forest" of FlexTrees.
- * It handles group operations like transforming cursors into anchors for edits.
+ * Subset of a hydrated context which can be used in more cases (like before the root and events are set up).
  */
-export interface FlexTreeHydratedContext extends FlexTreeContext {
-	readonly events: Listenable<ForestEvents>;
+export interface FlexTreeHydratedContextMinimal {
 	/**
-	 * Gets the root field of the tree.
+	 * The {@link NodeIdentifierManager} responsible for allocating and compressing identifiers for nodes in this context.
 	 */
-	get root(): FlexTreeField;
-
 	readonly nodeKeyManager: NodeIdentifierManager;
 
 	/**
@@ -72,6 +68,20 @@ export interface FlexTreeHydratedContext extends FlexTreeContext {
 	readonly checkout: ITreeCheckout;
 }
 
+/**
+ * A common context of a "forest" of FlexTrees.
+ * It handles group operations like transforming cursors into anchors for edits.
+ */
+export interface FlexTreeHydratedContext
+	extends FlexTreeContext,
+		FlexTreeHydratedContextMinimal {
+	readonly events: Listenable<ForestEvents>;
+	/**
+	 * Gets the root field of the tree.
+	 */
+	get root(): FlexTreeField;
+}
+
 /**
  * Creating multiple flex tree contexts for the same branch, and thus with the same underlying AnchorSet does not work due to how TreeNode caching works.
  * This slot is used to detect if one already exists and error if creating a second.

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -5,12 +5,10 @@
 
 import {
 	type AnchorNode,
-	type ExclusiveMapTree,
 	type FieldKey,
 	type FieldKindIdentifier,
 	type ITreeCursorSynchronous,
 	type NormalizedFieldUpPath,
-	type TreeNodeSchemaIdentifier,
 	type TreeValue,
 	anchorSlot,
 } from "../../core/index.js";
@@ -20,15 +18,21 @@ import type {
 	ValueFieldEditBuilder,
 	OptionalFieldEditBuilder,
 } from "../default-schema/index.js";
+import type {
+	MapTreeFieldViewGeneric,
+	MapTreeNodeViewGeneric,
+	MinimalFieldMap,
+	MinimalMapTreeNodeView,
+} from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 
-import type { FlexTreeContext } from "./context.js";
+import type { FlexTreeContext, FlexTreeHydratedContext } from "./context.js";
 
 /**
  * An anchor slot which records the {@link FlexTreeNode} associated with that anchor, if there is one.
  * @remarks This always points to a "real" {@link FlexTreeNode} (i.e. a `LazyTreeNode`), never to a "raw" node.
  */
-export const flexTreeSlot = anchorSlot<FlexTreeNode>();
+export const flexTreeSlot = anchorSlot<HydratedFlexTreeNode>();
 
 /**
  * Indicates that an object is a flex tree.
@@ -75,6 +79,14 @@ export interface FlexTreeEntity {
 	 * A common context of FlexTrees.
 	 */
 	readonly context: FlexTreeContext;
+
+	/**
+	 * Get a cursor for the underlying data.
+	 * @remarks
+	 * This cursor might be one the node uses in its implementation, and thus must be returned to its original location before using any other APIs to interact with the tree.
+	 * Must not be held onto across edits or any other tree API use.
+	 */
+	borrowCursor(): ITreeCursorSynchronous;
 }
 
 /**
@@ -98,6 +110,10 @@ export enum TreeStatus {
 	 * Nodes can enter this state for multiple reasons:
 	 * - The node was removed and nothing (e.g. undo/redo history) kept it from being cleaned up.
 	 * - The {@link TreeView} was disposed or had a schema change which made the tree incompatible.
+	 *
+	 * Deleted nodes' contents should not be observed or edited. This includes functionality exposed via {@link (Tree:variable)},
+	 * with the exception of {@link TreeNodeApi.status}.
+	 *
 	 * @privateRemarks
 	 * There was planned work (AB#17948) to make the first reason a node could become "Deleted" impossible,
 	 * at least as an opt in feature,
@@ -138,14 +154,9 @@ export enum TreeStatus {
  * @remarks
  * All editing is actually done via {@link FlexTreeField}s: the nodes are immutable other than that they contain mutable fields.
  */
-export interface FlexTreeNode extends FlexTreeEntity {
+export interface FlexTreeNode extends FlexTreeEntity, MapTreeNodeViewGeneric<FlexTreeNode> {
 	readonly [flexTreeMarker]: FlexTreeEntityKind.Node;
 
-	/**
-	 * Value stored on this node.
-	 */
-	readonly value?: TreeValue;
-
 	/**
 	 * Gets a field of this node, if it is not empty.
 	 */
@@ -164,20 +175,24 @@ export interface FlexTreeNode extends FlexTreeEntity {
 
 	/**
 	 * The field this tree is in, and the index within that field.
+	 * @remarks
+	 * The behavior of this at the root (especially removed and unhydrated roots) is currently not very consistent.
+	 * Since very little relies on this, limit what it exposes to reduce the potential impact of inconsistent root handling.
 	 */
-	readonly parentField: { readonly parent: FlexTreeField; readonly index: number };
+	readonly parentField: {
+		readonly parent: Pick<FlexTreeField, "parent" | "schema" | "key">;
+		readonly index: number;
+	};
 
-	boxedIterator(): IterableIterator<FlexTreeField>;
+	/**
+	 * The non-empty fields on this node.
+	 */
+	readonly fields: MinimalFieldMap<FlexTreeField>;
 
 	/**
-	 * The anchor node associated with this node
-	 *
-	 * @remarks
-	 * The ref count keeping this alive is owned by the FlexTreeNode:
-	 * if holding onto this anchor for longer than the FlexTreeNode might be alive,
-	 * a separate Anchor (and thus ref count) must be allocated to keep it alive.
+	 * The non-empty fields on this node.
 	 */
-	readonly anchorNode: AnchorNode;
+	[Symbol.iterator](): IterableIterator<FlexTreeField>;
 
 	/**
 	 * Returns an iterable of keys for non-empty fields.
@@ -190,18 +205,31 @@ export interface FlexTreeNode extends FlexTreeEntity {
 	keys(): IterableIterator<FieldKey>;
 
 	/**
-	 * Schema for this entity.
-	 * If well-formed, it must follow this schema.
+	 * If true, this node is a {@link HydratedFlexTreeNode}.
+	 *
+	 * If false, this node is unhydrated.
 	 */
-	readonly schema: TreeNodeSchemaIdentifier;
+	isHydrated(): this is HydratedFlexTreeNode;
+}
 
+/**
+ * A FlexTreeNode that is hydrated, meaning it is associated with a {@link FlexTreeHydratedContext}.
+ */
+export interface HydratedFlexTreeNode extends FlexTreeNode {
 	/**
-	 * Get a cursor for the underlying data.
+	 * {@inheritDoc FlexTreeNode.context}
+	 */
+	readonly context: FlexTreeHydratedContext;
+
+	/**
+	 * The anchor node associated with this node
+	 *
 	 * @remarks
-	 * This cursor might be one the node uses in its implementation, and thus must be returned to its original location before using any other APIs to interact with the tree.
-	 * Must not be held onto across edits or any other tree API use.
+	 * The ref count keeping this alive is owned by the FlexTreeNode:
+	 * if holding onto this anchor for longer than the FlexTreeNode might be alive,
+	 * a separate Anchor (and thus ref count) must be allocated to keep it alive.
 	 */
-	borrowCursor(): ITreeCursorSynchronous;
+	readonly anchorNode: AnchorNode;
 }
 
 /**
@@ -222,7 +250,7 @@ export interface FlexTreeNode extends FlexTreeEntity {
  * All content in the tree is accessible without down-casting, but if the schema is known,
  * the schema aware API may be more ergonomic.
  */
-export interface FlexTreeField extends FlexTreeEntity {
+export interface FlexTreeField extends FlexTreeEntity, MapTreeFieldViewGeneric<FlexTreeNode> {
 	readonly [flexTreeMarker]: FlexTreeEntityKind.Field;
 
 	/**
@@ -247,8 +275,6 @@ export interface FlexTreeField extends FlexTreeEntity {
 	 */
 	is<TKind extends FlexFieldKind>(kind: TKind): this is FlexTreeTypedField<TKind>;
 
-	boxedIterator(): IterableIterator<FlexTreeNode>;
-
 	/**
 	 * Gets a node of this field by its index without unboxing.
 	 * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.
@@ -278,12 +304,12 @@ export interface FlexTreeField extends FlexTreeEntity {
 /**
  * Typed tree for inserting as the content of a field.
  */
-export type FlexibleFieldContent = ExclusiveMapTree[];
+export type FlexibleFieldContent = readonly FlexibleNodeContent[];
 
 /**
  * Tree for inserting as a node.
  */
-export type FlexibleNodeContent = ExclusiveMapTree;
+export type FlexibleNodeContent = MinimalMapTreeNodeView;
 
 /**
  * {@link FlexTreeField} that stores a sequence of children.
@@ -329,8 +355,6 @@ export interface FlexTreeSequenceField extends FlexTreeField {
 	 * Get an editor for this sequence.
 	 */
 	readonly editor: SequenceFieldEditBuilder<FlexibleFieldContent>;
-
-	boxedIterator(): IterableIterator<FlexTreeNode>;
 }
 
 /**

package/src/feature-libraries/flex-tree/index.ts

@@ -17,21 +17,17 @@ export {
 	FlexTreeEntityKind,
 	isFlexTreeNode,
 	flexTreeSlot,
+	type FlexibleNodeContent,
+	type FlexibleFieldContent,
+	type HydratedFlexTreeNode,
 } from "./flexTreeTypes.js";
 
-export {
-	visitBipartiteIterableTree,
-	Skip,
-	visitBipartiteIterableTreeWithState,
-	visitIterableTree,
-	visitIterableTreeWithState,
-} from "./navigation.js";
-
 export {
 	type FlexTreeContext,
 	type FlexTreeHydratedContext,
 	Context,
 	ContextSlot,
+	type FlexTreeHydratedContextMinimal,
 } from "./context.js";
 
 export { type FlexTreeNodeEvents } from "./treeEvents.js";

package/src/feature-libraries/flex-tree/lazyEntity.ts

@@ -6,6 +6,7 @@
 import { assert } from "@fluidframework/core-utils/internal";
 
 import {
+	type ITreeCursorSynchronous,
 	type ITreeSubscriptionCursor,
 	ITreeSubscriptionCursorState,
 	TreeNavigationResult,
@@ -48,7 +49,10 @@ export abstract class LazyEntity<TAnchor = unknown> implements FlexTreeEntity, I
 		this.context.withAnchors.add(this);
 	}
 
-	public abstract boxedIterator(): IterableIterator<FlexTreeEntity>;
+	public borrowCursor(): ITreeCursorSynchronous {
+		return this.cursor as ITreeCursorSynchronous;
+	}
+
 	public abstract get [flexTreeMarker](): FlexTreeEntityKind;
 
 	public [disposeSymbol](): void {

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -19,6 +19,7 @@ import {
 	type TreeNavigationResult,
 	inCursorNode,
 	iterateCursorField,
+	mapCursorField,
 	rootFieldKey,
 } from "../../core/index.js";
 import { disposeSymbol, getOrCreate } from "../../util/index.js";
@@ -37,12 +38,14 @@ import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
-	type FlexTreeNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
 	type FlexTreeTypedField,
 	type FlexTreeUnknownUnboxed,
+	type FlexibleFieldContent,
+	type FlexibleNodeContent,
+	type HydratedFlexTreeNode,
 	TreeStatus,
 	flexTreeMarker,
 	flexTreeSlot,
@@ -159,7 +162,7 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 		return this.schema === kind.identifier;
 	}
 
-	public get parent(): FlexTreeNode | undefined {
+	public get parent(): HydratedFlexTreeNode | undefined {
 		if (this.anchor.parent === undefined) {
 			return undefined;
 		}
@@ -193,7 +196,7 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 		);
 	}
 
-	public boxedAt(index: number): FlexTreeNode | undefined {
+	public boxedAt(index: number): HydratedFlexTreeNode | undefined {
 		const finalIndex = indexForAt(index, this.length);
 
 		if (finalIndex === undefined) {
@@ -204,19 +207,15 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 	}
 
 	public map<U>(callbackfn: (value: FlexTreeUnknownUnboxed, index: number) => U): U[] {
-		return Array.from(this, callbackfn);
+		return mapCursorField(this.cursor, (cursor) =>
+			callbackfn(unboxedFlexNode(this.context, cursor, this.anchor), cursor.fieldIndex),
+		);
 	}
 
-	public boxedIterator(): IterableIterator<FlexTreeNode> {
+	public [Symbol.iterator](): IterableIterator<HydratedFlexTreeNode> {
 		return iterateCursorField(this.cursor, (cursor) => makeTree(this.context, cursor));
 	}
 
-	public [Symbol.iterator](): IterableIterator<FlexTreeUnknownUnboxed> {
-		return iterateCursorField(this.cursor, (cursor) =>
-			unboxedFlexNode(this.context, cursor, this.anchor),
-		);
-	}
-
 	public getFieldPath(): NormalizedFieldUpPath {
 		return { parent: this.parent?.anchorNode, field: this.key };
 	}
@@ -263,7 +262,7 @@ export class LazySequence extends LazyField implements FlexTreeSequenceField {
 		return this.map((x) => x);
 	}
 
-	public editor: SequenceFieldEditBuilder<ExclusiveMapTree[]> = {
+	public editor: SequenceFieldEditBuilder<FlexibleFieldContent> = {
 		insert: (index, newContent) => {
 			this.sequenceEditor().insert(index, cursorForMapTreeField(newContent));
 		},
@@ -279,7 +278,7 @@ export class LazySequence extends LazyField implements FlexTreeSequenceField {
 }
 
 export class LazyValueField extends LazyField implements FlexTreeRequiredField {
-	public editor: ValueFieldEditBuilder<ExclusiveMapTree> = {
+	public editor: ValueFieldEditBuilder<FlexibleNodeContent> = {
 		set: (newContent) => {
 			this.valueFieldEditor().set(cursorForMapTreeField([newContent]));
 		},

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -10,7 +10,6 @@ import {
 	type AnchorNode,
 	CursorLocationType,
 	type FieldKey,
-	type ITreeCursorSynchronous,
 	type FieldKindIdentifier,
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
@@ -28,7 +27,7 @@ import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
-	type FlexTreeNode,
+	type HydratedFlexTreeNode,
 	flexTreeMarker,
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
@@ -63,7 +62,7 @@ function cleanupTree(anchor: AnchorNode): void {
 /**
  * Lazy implementation of {@link FlexTreeNode}.
  */
-export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
+export class LazyTreeNode extends LazyEntity<Anchor> implements HydratedFlexTreeNode {
 	public get [flexTreeMarker](): FlexTreeEntityKind.Node {
 		return FlexTreeEntityKind.Node;
 	}
@@ -75,21 +74,21 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 
 	public constructor(
 		context: Context,
-		public readonly schema: TreeNodeSchemaIdentifier,
+		public readonly type: TreeNodeSchemaIdentifier,
 		cursor: ITreeSubscriptionCursor,
 		public readonly anchorNode: AnchorNode,
 		anchor: Anchor,
 	) {
 		super(context, cursor, anchor);
 		this.storedSchema =
-			context.schema.nodeSchema.get(this.schema) ?? fail(0xb14 /* missing schema */);
+			context.schema.nodeSchema.get(this.type) ?? fail(0xb14 /* missing schema */);
 		assert(cursor.mode === CursorLocationType.Nodes, 0x783 /* must be in nodes mode */);
 		anchorNode.slots.set(flexTreeSlot, this);
 		this.#removeDeleteCallback = anchorNode.events.on("afterDestroy", cleanupTree);
 	}
 
-	public borrowCursor(): ITreeCursorSynchronous {
-		return this.cursor as ITreeCursorSynchronous;
+	public isHydrated(): this is HydratedFlexTreeNode {
+		return true;
 	}
 
 	protected override tryMoveCursorToAnchor(
@@ -111,6 +110,20 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 		return this.cursor.value;
 	}
 
+	public readonly fields: Pick<Map<FieldKey, FlexTreeField>, typeof Symbol.iterator | "get"> =
+		{
+			get: (key: FieldKey): FlexTreeField | undefined => this.tryGetField(key),
+			[Symbol.iterator]: (): IterableIterator<[FieldKey, FlexTreeField]> =>
+				mapCursorFields(this.cursor, (cursor) => {
+					const key: FieldKey = cursor.getFieldKey();
+					const pair: [FieldKey, FlexTreeField] = [
+						key,
+						makeField(this.context, this.storedSchema.getFieldSchema(key).kind, cursor),
+					];
+					return pair;
+				}).values(),
+		};
+
 	public tryGetField(fieldKey: FieldKey): FlexTreeField | undefined {
 		const schema = this.storedSchema.getFieldSchema(fieldKey);
 		return inCursorField(this.cursor, fieldKey, (cursor) => {
@@ -128,7 +141,7 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 		});
 	}
 
-	public boxedIterator(): IterableIterator<FlexTreeField> {
+	public [Symbol.iterator](): IterableIterator<FlexTreeField> {
 		return mapCursorFields(this.cursor, (cursor) =>
 			makeField(
 				this.context,

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -8,12 +8,13 @@ import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type {
+	IExperimentalIncrementalSummaryContext,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
 import { createSingleBlobSummary } from "@fluidframework/shared-object-base/internal";
 
-import { type ICodecOptions, noopValidator } from "../../codec/index.js";
+import type { CodecWriteOptions } from "../../codec/index.js";
 import {
 	type DeltaDetachedNodeBuild,
 	type DeltaFieldChanges,
@@ -60,9 +61,10 @@ export class ForestSummarizer implements Summarizable {
 		private readonly revisionTagCodec: RevisionTagCodec,
 		fieldBatchCodec: FieldBatchCodec,
 		private readonly encoderContext: FieldBatchEncodingContext,
-		options: ICodecOptions = { jsonValidator: noopValidator },
+		options: CodecWriteOptions,
 		private readonly idCompressor: IIdCompressor,
 	) {
+		// TODO: this should take in CodecWriteOptions, and use it to pick the write version.
 		this.codec = makeForestSummarizerCodec(options, fieldBatchCodec);
 	}
 
@@ -94,22 +96,14 @@ export class ForestSummarizer implements Summarizable {
 		return stringify(encoded);
 	}
 
-	public getAttachSummary(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-	): ISummaryTreeWithStats {
-		return createSingleBlobSummary(treeBlobKey, this.getTreeString(stringify));
-	}
-
-	public async summarize(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-	): Promise<ISummaryTreeWithStats> {
-		return createSingleBlobSummary(treeBlobKey, this.getTreeString(stringify));
+	public summarize(props: {
+		stringify: SummaryElementStringifier;
+		fullTree?: boolean;
+		trackState?: boolean;
+		telemetryContext?: ITelemetryContext;
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext;
+	}): ISummaryTreeWithStats {
+		return createSingleBlobSummary(treeBlobKey, this.getTreeString(props.stringify));
 	}
 
 	public async load(

package/src/feature-libraries/index.ts

@@ -15,6 +15,12 @@ export {
 	cursorForMapTreeNode,
 	mapTreeFromCursor,
 	mapTreeFieldFromCursor,
+	type MinimalMapTreeNodeView,
+	mapTreeFieldsWithField,
+	mapTreeWithField,
+	type MapTreeFieldViewGeneric,
+	type MapTreeNodeViewGeneric,
+	type MinimalFieldMap,
 } from "./mapTreeCursor.js";
 export { buildForest } from "./object-forest/index.js";
 export {
@@ -152,7 +158,6 @@ export {
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
-	Skip,
 	type FlexTreeContext,
 	type FlexTreeHydratedContext,
 	type FlexTreeTypedField,
@@ -174,6 +179,10 @@ export {
 	treeStatusFromAnchorCache,
 	indexForAt,
 	FlexTreeEntityKind,
+	type FlexibleNodeContent,
+	type FlexibleFieldContent,
+	type FlexTreeHydratedContextMinimal,
+	type HydratedFlexTreeNode,
 } from "./flex-tree/index.js";
 
 export { TreeCompressionStrategy } from "./treeCompressionUtils.js";