@fluidframework/tree 2.110.0 → 2.111.0

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

@@ -7,10 +7,8 @@ import { assert, unreachableCase, oob } from "@fluidframework/core-utils/interna
 import type {
 	IIdCompressor,
 	OpSpaceCompressedId,
-	SessionId,
+	SessionSpaceCompressedId,
 } from "@fluidframework/id-compressor";
-import { isFinalId } from "@fluidframework/id-compressor/internal";
-import { v5 as uuidV5 } from "uuid";
 
 import { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
 import type {
@@ -19,7 +17,7 @@ import type {
 	Value,
 	TreeChunk,
 } from "../../../core/index.js";
-import { assertValidIndex, brand } from "../../../util/index.js";
+import { assertValidIndex, brand, decompressIdentifierIfNeeded } from "../../../util/index.js";
 import { BasicChunk } from "../basicChunk.js";
 import { emptyChunk } from "../emptyChunk.js";
 import { SequenceChunk } from "../sequenceChunk.js";
@@ -39,8 +37,7 @@ import {
 	decode as genericDecode,
 	readStreamIdentifier,
 } from "./chunkDecodingGeneric.js";
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Referenced by doc comments
-import type { FieldBatchEncodingContext, IncrementalDecoder } from "./codecs.js";
+import type { IncrementalDecoder } from "./codecs.js";
 import {
 	type EncodedAnyShape,
 	type EncodedChunkShape,
@@ -58,32 +55,31 @@ import {
 	supportsIncrementalEncoding,
 } from "./format/index.js";
 
+/**
+ * Context for decoding identifiers.
+ * @remarks
+ * See {@link FieldBatchDecodingContext} for the production implementation of this.
+ *
+ * This intentionally avoids exposing anything which depends on the underlying id-compressor's session ID to avoid confusion with the session ID of the compressor which encoded the data.
+ * If the session ID of the encoder which encoded the data is known, that information is baked into `resolveEncodedId`.
+ */
 export interface IdDecodingContext {
-	idCompressor: IIdCompressor;
-	/**
-	 * The creator of any local Ids to be decoded.
-	 */
-	originatorId: SessionId;
-	/**
-	 * {@inheritdoc FieldBatchEncodingContext.isSummary}
-	 */
-	isSummary: boolean;
 	/**
-	 * See {@link FieldBatchEncodingContext.healUnresolvableIdentifiersOnDecode}.
+	 * Compressor which can decompress session-space identifiers from {@link resolveEncodedId} as needed.
 	 */
-	healUnresolvableIdentifiersOnDecode?: boolean;
+	readonly idCompressor: Pick<IIdCompressor, "decompress">;
 	/**
-	 * See {@link FieldBatchEncodingContext.sharedObjectId}.
+	 * Resolves an encoded op-space identifier to either a session-space ID
+	 * (which {@link idCompressor} can decompress if needed)
+	 * or a string (which passes through unchanged).
+	 * @remarks
+	 * In contexts where non-final identifiers can't be supported (where no originator session is available),
+	 * if a non-final identifier is encountered, this may throw or perform a data healing workaround.
+	 * See {@link FieldBatchDecodingContext.forOp} and {@link FieldBatchDecodingContext.forSummary} for details.
 	 */
-	sharedObjectId?: string;
+	readonly resolveEncodedId: (id: OpSpaceCompressedId) => SessionSpaceCompressedId | string;
 }
 
-/**
- * Random v4 UUID generated as a namespace for the "heal an unresolvable identifier into a stable UUID"
- * path in {@link readValue}. This scheme requires consensus across all clients to function.
- */
-const healingNamespace = "f8a89df3-6882-400f-b913-4c1f6f0157bd";
-
 /**
  * Decode `chunk` into a TreeChunk.
  */
@@ -281,45 +277,20 @@ export function readValue(
 				typeof streamValue === "number" || typeof streamValue === "string",
 				0x997 /* identifier must be string or number. */,
 			);
-			if (typeof streamValue === "string") {
-				return streamValue;
-			}
-			const idCompressor = idDecodingContext.idCompressor;
-			// OpSpaceCompressedIds are negative, and require a session-id to compute their value.
-			// Due to a bug, we have some special casing for them (see below).
-			if (
-				idDecodingContext.isSummary === true &&
-				!isFinalId(streamValue as OpSpaceCompressedId)
-			) {
-				if (
-					idDecodingContext.healUnresolvableIdentifiersOnDecode === true &&
-					idDecodingContext.sharedObjectId !== undefined
-				) {
-					// Documents written before the encode-side fix for non-finalized identifier
-					// values can persist negative op-space IDs that are no
-					// longer resolvable once the originating session's local state has been stripped.
-					// When loading such a summary with the heal-on-decode option on, synthesize a deterministic
-					// stable UUID so all readers of the same blob agree on the resulting value.
-					//
-					// The heal path is intentionally restricted to summary loads — an
-					// unresolvable ID encountered while applying an op should still surface as
-					// an error, since it indicates a real bug rather than a recoverable state.
-					return uuidV5(
-						`${idDecodingContext.sharedObjectId}|${streamValue}`,
-						healingNamespace,
-					);
-				}
-				// See `SharedTreeOptionsBeta.healUnresolvableIdentifiersOnDecode` for details on this error.
-				throw new Error(
-					"Summary could not be loaded due incorrectly encoded identifier. See SharedTreeOptionsBeta.healUnresolvableIdentifiersOnDecode for mitigation.",
-				);
-			}
-			return idCompressor.decompress(
-				idCompressor.normalizeToSessionSpace(
-					streamValue as OpSpaceCompressedId,
-					idDecodingContext.originatorId,
-				),
-			);
+			// Strings (StableId UUIDs, heal-synthesized v5 UUIDs, or arbitrary user
+			// identifier strings) are already in the stored form and pass through.
+			// Op-space compressed ids are resolved by the caller-supplied
+			// `resolveEncodedId`, which encapsulates the originator lookup, finalized-id
+			// normalization, and (for the forest summarizer's heal path) UUIDv5 synthesis.
+			const sessionIdOrString: SessionSpaceCompressedId | string =
+				typeof streamValue === "string"
+					? streamValue
+					: idDecodingContext.resolveEncodedId(streamValue as OpSpaceCompressedId);
+			// Performance:
+			// Currently, we just fully expand the identifier here rather than keeping it in the SessionSpaceCompressedId format.
+			// Avoiding this expansion, and keeping the in memory format using SessionSpaceCompressedId would be a good optimization for the future.
+			// Keeping this optimization possible is why `resolveEncodedId` doesn't simply return a string.
+			return decompressIdentifierIfNeeded(sessionIdOrString, idDecodingContext.idCompressor);
 		} else {
 			// EncodedCounter case:
 			unreachableCase(shape, "decoding values as deltas is not yet supported");

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

@@ -4,7 +4,12 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
+import type {
+	IIdCompressor,
+	OpSpaceCompressedId,
+	SessionId,
+	SessionSpaceCompressedId,
+} from "@fluidframework/id-compressor";
 import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 import type { TSchema } from "@sinclair/typebox";
 
@@ -22,10 +27,15 @@ import {
 	type StoredSchemaCollection,
 	type TreeChunk,
 } from "../../../core/index.js";
-import { brandedNumberType, type Brand } from "../../../util/index.js";
+import {
+	brandedNumberType,
+	forceDecodeEncodedIdWithoutSession,
+	type Brand,
+	type IdentifierHealingConfig,
+} from "../../../util/index.js";
 import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
-import { decode } from "./chunkDecoding.js";
+import { decode, type IdDecodingContext } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
 	EncodedFieldBatchV1,
@@ -97,44 +107,139 @@ export interface IncrementalDecoder {
  */
 export interface IncrementalEncoderDecoder extends IncrementalEncoder, IncrementalDecoder {}
 
+/**
+ * Encode-side context for {@link FieldBatchCodec}.
+ *
+ * Carries only the data the encoder actually consumes. Originator-session
+ * lookup, heal flags, and the incremental *decoder* live on
+ * {@link FieldBatchDecodingContext}.
+ */
 export interface FieldBatchEncodingContext {
 	readonly encodeType: TreeCompressionStrategy;
 	readonly idCompressor: IIdCompressor;
-	readonly originatorId: SessionId;
 	readonly schema?: SchemaAndPolicy;
 	/**
-	 * An encoder / decoder for encoding and decoding of incremental fields.
-	 * This will be defined if incremental encoding is supported and enabled.
+	 * Encoder for incremental fields. Defined when incremental encoding is
+	 * supported and enabled.
 	 */
-	readonly incrementalEncoderDecoder?: IncrementalEncoderDecoder;
+	readonly incrementalEncoder?: IncrementalEncoder;
 	/**
-	 * `true` when encoding to or decoding from a summary blob. `false` for
-	 * op-stream encode/decode paths and for utility encoders that are not
-	 * tied to a persisted document. Healing behavior is gated on this flag.
+	 * `true` when encoding to a summary blob. `false` for op-stream encode
+	 * paths and for utility encoders that aren't tied to a persisted document.
+	 *
+	 * @remarks
+	 * Used by the node encoder to decide whether non-finalized op-space ids
+	 * can be written into the batch (they can't, for summaries).
 	 */
 	readonly isSummary: boolean;
+}
+
+/**
+ * Decode-side context for {@link FieldBatchCodec}.
+ *
+ * Carries the per-call `resolveEncodedId` function that encapsulates the
+ * originator-session lookup and (for the forest-summarizer's legacy heal path)
+ * the deterministic UUIDv5 synthesis. Heal and originator-session flags live
+ * inside that function, not on this context.
+ *
+ * Constructed via one of the two named static factories — {@link forOp} or
+ * {@link forSummary} — depending on the call site's semantics. The constructor
+ * is private; there is no general-purpose builder, because the choice between
+ * op-style and summary-style decoding is load-bearing (different invariants
+ * apply, and bugs in this area are typically the result of conflating them).
+ */
+export class FieldBatchDecodingContext implements IdDecodingContext {
+	private constructor(
+		/**
+		 * Used internally to prevent the use of this decoder in incremental chunks if it has a session id (which would be wrong in those chunks).
+		 */
+		private readonly hasOriginatorSessionId: boolean,
+
+		public readonly idCompressor: Pick<IIdCompressor, "decompress">,
+
+		public readonly resolveEncodedId: (
+			id: OpSpaceCompressedId,
+		) => SessionSpaceCompressedId | string,
+
+		/**
+		 * Decoder for incremental fields. Defined when the encoded batch contains
+		 * incremental chunks. Only populated on summary-style contexts; op-style
+		 * contexts always have this undefined.
+		 */
+		public readonly incrementalDecoder?: IncrementalDecoder,
+	) {}
+
 	/**
-	 * If `true`, when an op-space compressed ID encountered while decoding
-	 * cannot be resolved by the local id-compressor (e.g. the attach-summary
-	 * blob's originator session state was stripped), a deterministic stable
-	 * UUID derived from `sharedObjectId` is returned instead of throwing.
-	 * @remarks
-	 * Off by default. Used only to recover documents whose attach summary was
-	 * written with non-finalized op-space IDs before the encode-side fix
-	 * shipped. Only takes effect when `isSummary` is also `true`.
-	 * See {@link SharedTreeOptionsBeta.healUnresolvableIdentifiersOnDecode}.
+	 * Construct a decode context for an op.
+	 *
+	 * The originator is the session that produced the encoded form (carried
+	 * alongside the op envelope by the caller). Heal-on-decode is *not*
+	 * available — an unresolvable id during op decode indicates a real bug,
+	 * not a recoverable state, so the resolver throws rather than synthesizing
+	 * a UUID. Incremental decoding is not used for ops.
 	 */
-	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	public static forOp(opts: {
+		readonly idCompressor: IIdCompressor;
+		readonly originatorId: SessionId;
+	}): FieldBatchDecodingContext {
+		const { idCompressor, originatorId } = opts;
+		return new FieldBatchDecodingContext(true, idCompressor, (id) =>
+			idCompressor.normalizeToSessionSpace(id, originatorId),
+		);
+	}
+
 	/**
-	 * The SharedTree's shared-object id, used as input to the deterministic
-	 * UUID derivation when `healUnresolvableIdentifiersOnDecode` triggers. Required
-	 * for that path; ignored otherwise.
-	 * @remarks
-	 * This allows us to ensure that multiple attaches,
-	 * in the same or different documents, with the same session offsets, get different UUIDs.
+	 * Construct a decode context for a summary blob.
+	 *
+	 * Summaries must contain only ids resolvable without an originator — either
+	 * finalized op-space ids, or (when {@link IdentifierHealingConfig} is supplied
+	 * via `healing`) non-final ids that get healed into deterministic UUIDv5
+	 * strings. Incremental decoding is attached via {@link withIncrementalDecoder}.
+	 *
+	 * @privateRemarks
+	 * In the future (if adding a summary format which includes the session id),
+	 * this could allow providing an originator ID to allow for op-space compressed identifiers in attach summaries.
+	 * Non-attach summaries should only have finalized compressed identifiers (due to only being made by summary clients which never allocate identifiers since they never edit).
+	 * Since only non-attach summaries can be incremental, incremental summaries should never have non finalized identifiers.
+	 * `withIncrementalDecoder` has logic to guard against cases which expect session-relative identifiers in incremental chunks,
+	 * as does the encoding-side assert in the {@link EncoderContext}.
 	 */
-	readonly sharedObjectId?: string;
+	public static forSummary(opts: {
+		readonly idCompressor: IIdCompressor;
+		readonly healing?: IdentifierHealingConfig;
+	}): FieldBatchDecodingContext {
+		const { idCompressor, healing } = opts;
+		return new FieldBatchDecodingContext(false, idCompressor, (id) =>
+			forceDecodeEncodedIdWithoutSession(id, idCompressor, healing),
+		);
+	}
+
+	/**
+	 * Returns a copy of this context with `incrementalDecoder` swapped in. Used by
+	 * the forest summarizer to attach the per-call incremental builder to a base
+	 * decode context.
+	 */
+	public withIncrementalDecoder(
+		incrementalDecoder: IncrementalDecoder,
+	): FieldBatchDecodingContext {
+		// As different incremental chunks may come from different sessions,
+		// for now we simply enforce that we do not provide an originator session ID
+		// when we might be dealing with incremental chunks.
+		// This mitigates the risk of using incorrect originator session ID identifiers in incremental chunks.
+		// See also private remarks on forSummary.
+		assert(
+			!this.hasOriginatorSessionId,
+			0xd0c /* withIncrementalDecoder can only be called on contexts without an originator session ID */,
+		);
+		return new FieldBatchDecodingContext(
+			false,
+			this.idCompressor,
+			this.resolveEncodedId,
+			incrementalDecoder,
+		);
+	}
 }
+
 /**
  * @remarks
  * Fields in this batch currently don't have field schema for the root, which limits optimizations.
@@ -142,7 +247,8 @@ export interface FieldBatchEncodingContext {
 export type FieldBatchCodec = VersionDispatchingCodec<
 	FieldBatch,
 	FieldBatchEncodingContext,
-	FieldBatchFormatVersion
+	FieldBatchFormatVersion,
+	FieldBatchDecodingContext
 >;
 
 /**
@@ -160,7 +266,7 @@ function makeFieldBatchCodecForVersion(
 		isSummary: boolean,
 	) => EncodedFieldBatchV1OrV2,
 	encodedFieldBatchType: TSchema,
-): CodecAndSchema<FieldBatch, FieldBatchEncodingContext> {
+): CodecAndSchema<FieldBatch, FieldBatchEncodingContext, FieldBatchDecodingContext> {
 	return {
 		encode: (
 			data: FieldBatch,
@@ -185,7 +291,7 @@ function makeFieldBatchCodecForVersion(
 						0xca0 /* Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher */,
 					);
 					// Incremental encoding is only supported for CompressedIncremental.
-					incrementalEncoder = context.incrementalEncoderDecoder;
+					incrementalEncoder = context.incrementalEncoder;
 				}
 				// fallthrough
 				case TreeCompressionStrategy.Compressed: {
@@ -216,20 +322,10 @@ function makeFieldBatchCodecForVersion(
 		},
 		decode: (
 			data: EncodedFieldBatchV1OrV2,
-			context: FieldBatchEncodingContext,
+			context: FieldBatchDecodingContext,
 		): FieldBatch => {
 			// TODO: consider checking data is in schema.
-			return decode(
-				data,
-				{
-					idCompressor: context.idCompressor,
-					originatorId: context.originatorId,
-					isSummary: context.isSummary,
-					healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
-					sharedObjectId: context.sharedObjectId,
-				},
-				context.incrementalEncoderDecoder,
-			).map((chunk) => chunk.cursor());
+			return decode(data, context, context.incrementalDecoder).map((chunk) => chunk.cursor());
 		},
 		schema: encodedFieldBatchType,
 	};

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

@@ -18,7 +18,13 @@ import {
 	type Value,
 	forEachNode,
 } from "../../../core/index.js";
-import { getOrCreate } from "../../../util/index.js";
+import {
+	EncodedIdType,
+	encodePossiblyCompressedId,
+	getOrCreate,
+	type EncodedId,
+	type IdEncodingContext,
+} from "../../../util/index.js";
 
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import {
@@ -520,7 +526,9 @@ export function encodeValue(
  * - 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 {
+export class EncoderContext
+	implements NodeEncodeBuilder, FieldEncodeBuilder, IdEncodingContext
+{
 	private readonly nodeEncodersFromSchema: Map<TreeNodeSchemaIdentifier, NodeEncoder> =
 		new Map();
 	private readonly nestedArrayEncoders: Map<NodeEncoder, NestedArrayEncoder> = new Map();
@@ -528,7 +536,7 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		private readonly nodeEncoderFromPolicy: NodeEncoderPolicy,
 		private readonly fieldEncoderFromPolicy: FieldEncoderPolicy,
 		public readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FieldKindData>,
-		public readonly idCompressor: IIdCompressor,
+		private readonly idCompressor: IIdCompressor,
 		/**
 		 * To be used to encode incremental chunks, if any.
 		 * @remarks
@@ -540,7 +548,27 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		 * See {@link FieldBatchEncodingContext.isSummary}.
 		 */
 		public readonly isSummary: boolean,
-	) {}
+	) {
+		// Currently we never include originator-dependent identifiers in summaries
+		// (there was a bug which violated this for attach-summaries: it has been fixed, see `IdentifierHealingConfig`).
+		// If that ever changes (to allow better compressed attach summaries), we need to take special care with incremental summaries.
+		// This assert guards against data corruption leaking in via missing session information in incremental summaries,
+		// protecting from bugs of potential future optimizations to attach summaries applied to non-attach summaries.
+		// Incremental summaries should have no need for originator-dependent identifiers,
+		// as they can't be attach summaries which are the only ones which should ever have non-final ids.
+		assert(
+			isSummary || incrementalEncoder === undefined,
+			0xd0d /* incrementalEncoder cannot be used when encoding originator-dependent identifiers */,
+		);
+	}
+
+	public encodePossiblyCompressedId(id: string): string | EncodedId<EncodedIdType> {
+		return encodePossiblyCompressedId(
+			id,
+			this.idCompressor,
+			this.isSummary ? EncodedIdType.Originatorless : EncodedIdType.OriginatorDependent,
+		);
+	}
 
 	public nodeEncoderFromSchema(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {
 		return getOrCreate(this.nodeEncodersFromSchema, schemaName, () =>

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

@@ -13,6 +13,7 @@ export type { FieldBatch } from "./fieldBatch.js";
 export {
 	type FieldBatchCodec,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	type IncrementalEncoderDecoder,
 	type IncrementalEncoder,

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

@@ -4,7 +4,6 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
-import { isFinalId, isStableId } from "@fluidframework/id-compressor/internal";
 
 import {
 	type FieldKey,
@@ -24,10 +23,11 @@ import {
 	type NodeEncoder,
 	encodeValue,
 } from "./compressedEncode.js";
-import type {
-	EncodedChunkShape,
-	EncodedFieldShape,
-	EncodedValueShape,
+import {
+	SpecialField,
+	type EncodedChunkShape,
+	type EncodedFieldShape,
+	type EncodedValueShape,
 } from "./format/index.js";
 
 /**
@@ -69,21 +69,9 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 	}
 
 	private getValueToEncode(cursor: ITreeCursorSynchronous, context: EncoderContext): Value {
-		if (this.value === 0) {
+		if (this.value === SpecialField.Identifier) {
 			assert(typeof cursor.value === "string", 0x9aa /* identifier must be type string */);
-			if (isStableId(cursor.value)) {
-				const sessionSpaceCompressedId = context.idCompressor.tryRecompress(cursor.value);
-				if (sessionSpaceCompressedId !== undefined) {
-					const opSpaceId = context.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
-					// Summaries can only contain finalized op-space ids unless they also include the originator's session id somewhere.
-					// This is not the case for forest summaries at the time of writing, so non-finalized ids are instead written using
-					// their long form (by falling through to the original cursor value).
-					// A scenario where such ids can appear in the summary is in the attach summary of a tree being attached to an already-attached container.
-					if (!context.isSummary || isFinalId(opSpaceId)) {
-						return opSpaceId;
-					}
-				}
-			}
+			return context.encodePossiblyCompressedId(cursor.value);
 		}
 		return cursor.value;
 	}

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

@@ -20,7 +20,10 @@ export {
 	type FieldBatch,
 	type FieldBatchCodec,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
+	type IncrementalDecoder,
+	type IncrementalEncoder,
 	type IncrementalEncoderDecoder,
 	type ChunkReferenceId,
 	type IncrementalEncodingPolicy,

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

@@ -16,6 +16,7 @@ import {
 import type { FieldKey, ITreeCursorSynchronous } from "../../core/index.js";
 import {
 	fieldBatchCodecBuilder,
+	type FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 } from "../chunked-forest/index.js";
 
@@ -28,13 +29,14 @@ export type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;
 export type ForestCodec = VersionDispatchingCodec<
 	FieldSet,
 	FieldBatchEncodingContext,
-	ForestFormatVersion
+	ForestFormatVersion,
+	FieldBatchDecodingContext
 >;
 
 function makeForestSummarizerCodec(
 	options: CodecWriteOptions,
 	version: ForestFormatVersion,
-): CodecAndSchema<FieldSet, FieldBatchEncodingContext> {
+): CodecAndSchema<FieldSet, FieldBatchEncodingContext, FieldBatchDecodingContext> {
 	// Performance: Since multiple places (including multiple versions of this codec) use the field batch codec,
 	// we may end up with multiple copies of it, including compiling its format validation multiple times.
 	// This is not ideal, but is not too bad as it is a small fixed number of copies and thus should not be too expensive.
@@ -55,7 +57,7 @@ function makeForestSummarizerCodec(
 				version,
 			};
 		},
-		decode: (data: FormatCommon, context: FieldBatchEncodingContext): FieldSet => {
+		decode: (data: FormatCommon, context: FieldBatchDecodingContext): FieldSet => {
 			const out: Map<FieldKey, ITreeCursorSynchronous> = new Map();
 			const fields = fieldBatchCodec.decode(data.fields, context);
 			assert(data.keys.length === fields.length, 0x891 /* mismatched lengths */);

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

@@ -41,6 +41,7 @@ import {
 import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/chunkTree.js";
 import {
 	defaultIncrementalEncodingPolicy,
+	type FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	type IncrementalEncodingPolicy,
 } from "../chunked-forest/index.js";
@@ -80,6 +81,7 @@ export class ForestSummarizer
 		private readonly forest: IEditableForest,
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly encoderContext: FieldBatchEncodingContext,
+		private readonly decoderContext: FieldBatchDecodingContext,
 		options: CodecWriteOptions,
 		private readonly idCompressor: IIdCompressor,
 		initialSequenceNumber: number,
@@ -160,7 +162,7 @@ export class ForestSummarizer
 		});
 		const encoderContext: FieldBatchEncodingContext = {
 			...this.encoderContext,
-			incrementalEncoderDecoder:
+			incrementalEncoder:
 				incrementalSummaryBehavior === ForestIncrementalSummaryBehavior.Incremental
 					? this.incrementalSummaryBuilder
 					: undefined,
@@ -212,10 +214,7 @@ export class ForestSummarizer
 				parse,
 				// TODO: this type cast assumes there are no handles, which should probably be enforced at runtime or the need for this cast should be removed altogether.
 			)) as JsonCompatibleReadOnly,
-			{
-				...this.encoderContext,
-				incrementalEncoderDecoder: this.incrementalSummaryBuilder,
-			},
+			this.decoderContext.withIncrementalDecoder(this.incrementalSummaryBuilder),
 		);
 		const allocator = idAllocatorFromMaxId();
 		const fieldChanges: [FieldKey, DeltaFieldChanges][] = [];

package/src/feature-libraries/index.ts

@@ -109,11 +109,14 @@ export {
 	FieldBatchFormatVersion,
 	makeTreeChunker,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	emptyChunk,
 	combineChunks,
 	type IncrementalEncodingPolicy,
 	defaultIncrementalEncodingPolicy,
+	type IncrementalDecoder,
+	type IncrementalEncoder,
 } from "./chunked-forest/index.js";
 
 export {

package/src/feature-libraries/modular-schema/modularChangeCodecV1.ts

@@ -35,6 +35,7 @@ import {
 import { newChangeAtomIdBTree, type ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 import {
 	type FieldBatchCodec,
+	FieldBatchDecodingContext,
 	type TreeChunk,
 	chunkFieldSingle,
 	defaultChunkPolicy,
@@ -328,7 +329,6 @@ export function encodeDetachedNodes(
 				trees: fieldsCodec.encode(treesToEncode, {
 					encodeType: chunkCompressionStrategy,
 					schema: context.schema,
-					originatorId: context.originatorId,
 					idCompressor: context.idCompressor,
 					isSummary: context.isSummary,
 				}),
@@ -350,14 +350,18 @@ export function decodeDetachedNodes(
 		return undefined;
 	}
 
-	const chunks = fieldsCodec.decode(encoded.trees, {
-		encodeType: chunkCompressionStrategy,
-		originatorId: context.originatorId,
-		idCompressor: context.idCompressor,
-		isSummary: context.isSummary,
-		healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
-		sharedObjectId: context.sharedObjectId,
-	});
+	const chunks = fieldsCodec.decode(
+		encoded.trees,
+		context.isSummary
+			? FieldBatchDecodingContext.forSummary({
+					idCompressor: context.idCompressor,
+					healing: context.healing,
+				})
+			: FieldBatchDecodingContext.forOp({
+					idCompressor: context.idCompressor,
+					originatorId: context.originatorId,
+				}),
+	);
 	const getChunk = (index: number): TreeChunk => {
 		assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
 		return chunkFieldSingle(chunks[index] ?? oob(), {