@fluidframework/tree 2.100.0 → 2.101.0

package/src/core/change-family/changeFamily.ts

@@ -7,6 +7,8 @@ import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 
 import type { ICodecFamily, IJsonCodec } from "../../codec/index.js";
 import type { SchemaAndPolicy } from "../../core/index.js";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Referenced by doc comments
+import type { FieldBatchEncodingContext } from "../../feature-libraries/index.js";
 import type { JsonCompatibleReadOnly } from "../../util/index.js";
 import type { ChangeRebaser, RevisionTag, TaggedChange } from "../rebase/index.js";
 
@@ -25,6 +27,29 @@ export interface ChangeEncodingContext {
 	readonly revision: RevisionTag | undefined;
 	readonly idCompressor: IIdCompressor;
 	readonly schema?: SchemaAndPolicy;
+	/**
+	 * `true` when this context is encoding to or decoding from a summary blob.
+	 * `false` when this context is for an op (or any other non-summary path,
+	 * including utility encoders that aren't tied to persistence).
+	 *
+	 * @remarks
+	 * Used to gate decode-time recovery behavior — for example, healing of
+	 * unresolvable identifier IDs — that should only run when loading a
+	 * (possibly broken) attach-summary blob, never when applying ops.
+	 */
+	readonly isSummary: boolean;
+	/**
+	 * If `true`, identifier values that the local id-compressor cannot resolve
+	 * during decode are healed into deterministic stable UUIDs instead of
+	 * throwing. See {@link FieldBatchEncodingContext.healUnresolvableIdentifiersOnDecode}.
+	 * Only takes effect when `isSummary` is also `true`.
+	 */
+	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	/**
+	 * The SharedTree's shared-object id, used as input to the deterministic
+	 * UUID derivation when {@link healUnresolvableIdentifiersOnDecode} triggers.
+	 */
+	readonly sharedObjectId?: string;
 }
 
 export type ChangeFamilyCodec<TChange> = IJsonCodec<

package/src/core/tree/detachedFieldIndexCodecV1.ts

@@ -61,6 +61,8 @@ class MajorCodec implements IJsonCodec<Major, EncodedRevisionTag> {
 			originatorId: this.revisionTagCodec.localSessionId,
 			idCompressor: this.idCompressor,
 			revision: undefined,
+			// DetachedFieldIndex codecs are only used by the summarizer.
+			isSummary: true,
 		});
 	}
 }

package/src/core/tree/detachedFieldIndexCodecV2.ts

@@ -49,6 +49,8 @@ class MajorCodec implements IJsonCodec<Major> {
 			originatorId: this.revisionTagCodec.localSessionId,
 			idCompressor: this.idCompressor,
 			revision: undefined,
+			// DetachedFieldIndex codecs are only used by the summarizer.
+			isSummary: true,
 		});
 	}
 }

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

@@ -9,6 +9,7 @@ import type {
 	OpSpaceCompressedId,
 	SessionId,
 } from "@fluidframework/id-compressor";
+import { v5 as uuidV5 } from "uuid";
 
 import { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
 import type {
@@ -37,7 +38,8 @@ import {
 	decode as genericDecode,
 	readStreamIdentifier,
 } from "./chunkDecodingGeneric.js";
-import type { IncrementalDecoder } from "./codecs.js";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Referenced by doc comments
+import type { FieldBatchEncodingContext, IncrementalDecoder } from "./codecs.js";
 import {
 	type EncodedAnyShape,
 	type EncodedChunkShapeV1OrV2,
@@ -59,13 +61,32 @@ export interface IdDecodingContext {
 	 * The creator of any local Ids to be decoded.
 	 */
 	originatorId: SessionId;
+	/**
+	 * {@inheritdoc FieldBatchEncodingContext.isSummary}
+	 */
+	isSummary: boolean;
+	/**
+	 * See {@link FieldBatchEncodingContext.healUnresolvableIdentifiersOnDecode}.
+	 */
+	healUnresolvableIdentifiersOnDecode?: boolean;
+	/**
+	 * See {@link FieldBatchEncodingContext.sharedObjectId}.
+	 */
+	sharedObjectId?: 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.
  */
 export function decode(
 	chunk: EncodedFieldBatchV1OrV2,
-	idDecodingContext: { idCompressor: IIdCompressor; originatorId: SessionId },
+	idDecodingContext: IdDecodingContext,
 	incrementalDecoder?: IncrementalDecoder,
 ): TreeChunk[] {
 	return genericDecode(
@@ -126,15 +147,43 @@ 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;
-			return typeof streamValue === "number"
-				? idCompressor.decompress(
-						idCompressor.normalizeToSessionSpace(
-							streamValue as OpSpaceCompressedId,
-							idDecodingContext.originatorId,
-						),
-					)
-				: streamValue;
+			// 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).
+			// TODO: isFinalId should probably be exported from id-compressor and that could be used to do the narrowing here.
+			if (idDecodingContext.isSummary === true && streamValue < 0) {
+				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,
+				),
+			);
 		} else {
 			// EncodedCounter case:
 			unreachableCase(shape, "decoding values as deltas is not yet supported");

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

@@ -106,6 +106,33 @@ export interface FieldBatchEncodingContext {
 	 * This will be defined if incremental encoding is supported and enabled.
 	 */
 	readonly incrementalEncoderDecoder?: IncrementalEncoderDecoder;
+	/**
+	 * `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.
+	 */
+	readonly isSummary: boolean;
+	/**
+	 * 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}.
+	 */
+	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	/**
+	 * 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.
+	 */
+	readonly sharedObjectId?: string;
 }
 /**
  * @remarks
@@ -125,6 +152,7 @@ function makeFieldBatchCodecForVersion(
 		fieldBatch: FieldBatch,
 		idCompressor: IIdCompressor,
 		incrementalEncoder: IncrementalEncoder | undefined,
+		isSummary: boolean,
 	) => EncodedFieldBatchV1OrV2,
 	encodedFieldBatchType: TSchema,
 ): CodecAndSchema<FieldBatch, FieldBatchEncodingContext> {
@@ -167,6 +195,7 @@ function makeFieldBatchCodecForVersion(
 							data,
 							context.idCompressor,
 							incrementalEncoder,
+							context.isSummary,
 						);
 					}
 
@@ -190,6 +219,9 @@ function makeFieldBatchCodecForVersion(
 				{
 					idCompressor: context.idCompressor,
 					originatorId: context.originatorId,
+					isSummary: context.isSummary,
+					healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
+					sharedObjectId: context.sharedObjectId,
 				},
 				context.incrementalEncoderDecoder,
 			).map((chunk) => chunk.cursor());

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

@@ -26,7 +26,8 @@ import {
 	Shape as ShapeGeneric,
 	updateShapesAndIdentifiersEncoding,
 } from "./chunkEncodingGeneric.js";
-import type { IncrementalEncoder } from "./codecs.js";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Referenced by doc comments
+import type { FieldBatchEncodingContext, IncrementalEncoder } from "./codecs.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
 	type EncodedAnyShape,
@@ -535,6 +536,10 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		 */
 		public readonly incrementalEncoder: IncrementalEncoder | undefined,
 		public readonly version: FieldBatchFormatVersion,
+		/**
+		 * See {@link FieldBatchEncodingContext.isSummary}.
+		 */
+		public readonly isSummary: boolean,
 	) {}
 
 	public nodeEncoderFromSchema(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {

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

@@ -77,7 +77,15 @@ export class NodeShapeBasedEncoder
 			if (isStableId(cursor.value)) {
 				const sessionSpaceCompressedId = context.idCompressor.tryRecompress(cursor.value);
 				if (sessionSpaceCompressedId !== undefined) {
-					return context.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
+					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.
+					// TODO: isFinalId should probably be exported from id-compressor and that could be used to do the narrowing here.
+					if (!context.isSummary || opSpaceId >= 0) {
+						return opSpaceId;
+					}
 				}
 			}
 		}

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

@@ -54,6 +54,8 @@ export function schemaCompressedEncodeV1(
 	policy: SchemaPolicy,
 	fieldBatch: FieldBatch,
 	idCompressor: IIdCompressor,
+	_incrementalEncoder: IncrementalEncoder | undefined,
+	isSummary: boolean,
 ): EncodedFieldBatchV1 {
 	const encoded: EncodedFieldBatchV1OrV2 = schemaCompressedEncode(
 		schema,
@@ -62,6 +64,7 @@ export function schemaCompressedEncodeV1(
 		idCompressor,
 		undefined /* incrementalEncoder */,
 		brand(FieldBatchFormatVersion.v1),
+		isSummary,
 	);
 	// Since incrementalEncoder was not provided, no V2 features should be used, and this cast should be safe.
 	return encoded as EncodedFieldBatchV1;
@@ -78,6 +81,7 @@ export function schemaCompressedEncodeV2(
 	fieldBatch: FieldBatch,
 	idCompressor: IIdCompressor,
 	incrementalEncoder: IncrementalEncoder | undefined,
+	isSummary: boolean,
 ): EncodedFieldBatchV2 {
 	return schemaCompressedEncode(
 		schema,
@@ -86,6 +90,7 @@ export function schemaCompressedEncodeV2(
 		idCompressor,
 		incrementalEncoder,
 		brand(FieldBatchFormatVersion.v2),
+		isSummary,
 	);
 }
 
@@ -106,10 +111,11 @@ function schemaCompressedEncode(
 	idCompressor: IIdCompressor,
 	incrementalEncoder: IncrementalEncoder | undefined,
 	version: FieldBatchFormatVersion,
+	isSummary: boolean,
 ): EncodedFieldBatchV1OrV2 {
 	return compressedEncode(
 		fieldBatch,
-		buildContext(schema, policy, idCompressor, incrementalEncoder, version),
+		buildContext(schema, policy, idCompressor, incrementalEncoder, version, isSummary),
 	);
 }
 
@@ -119,6 +125,7 @@ export function buildContext(
 	idCompressor: IIdCompressor,
 	incrementalEncoder: IncrementalEncoder | undefined,
 	version: FieldBatchFormatVersion,
+	isSummary: boolean,
 ): EncoderContext {
 	const context: EncoderContext = new EncoderContext(
 		(fieldBuilder: FieldEncodeBuilder, schemaName: TreeNodeSchemaIdentifier) =>
@@ -129,6 +136,7 @@ export function buildContext(
 		idCompressor,
 		incrementalEncoder,
 		version,
+		isSummary,
 	);
 	return context;
 }

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

@@ -3,33 +3,17 @@
  * Licensed under the MIT License.
  */
 
-import { type Static, type TAnySchema, type TSchema, Type } from "@sinclair/typebox";
-
 // Many of the return types in this module are intentionally derived, rather than explicitly specified.
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 
-/**
- * Note: TS doesn't easily support extracting a generic function's return type until 4.7:
- * https://github.com/microsoft/TypeScript/pull/47607
- * This type is a workaround and can be removed once we're on a version of typescript which
- * supports expressions more like:
- * `Static<ReturnType<typeof EncodedGenericChange<Schema>>>`
- */
-class Wrapper<T extends TSchema> {
-	public encodedGenericChange(e: T) {
-		return EncodedGenericChange<T>(e);
-	}
-	public encodedGenericChangeset(e: T) {
-		return EncodedGenericChangeset<T>(e);
-	}
-}
+import { type Static, type TAnySchema, type TSchema, Type } from "@sinclair/typebox";
 
 export const EncodedGenericChange = <NodeChangesetSchema extends TSchema>(
 	tNodeChangeset: NodeChangesetSchema,
 ) => Type.Tuple([Type.Number({ minimum: 0, multipleOf: 1 }), tNodeChangeset]);
 
 export type EncodedGenericChange<Schema extends TSchema = TAnySchema> = Static<
-	ReturnType<Wrapper<Schema>["encodedGenericChange"]>
+	ReturnType<typeof EncodedGenericChange<Schema>>
 >;
 
 export const EncodedGenericChangeset = <NodeChangesetSchema extends TSchema>(
@@ -37,7 +21,5 @@ export const EncodedGenericChangeset = <NodeChangesetSchema extends TSchema>(
 ) => Type.Array(EncodedGenericChange(tNodeChangeset));
 
 export type EncodedGenericChangeset<Schema extends TSchema = TAnySchema> = Static<
-	ReturnType<Wrapper<Schema>["encodedGenericChangeset"]>
+	ReturnType<typeof EncodedGenericChangeset<Schema>>
 >;
-
-/* eslint-enable @typescript-eslint/explicit-function-return-type */

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

@@ -330,6 +330,7 @@ export function encodeDetachedNodes(
 					schema: context.schema,
 					originatorId: context.originatorId,
 					idCompressor: context.idCompressor,
+					isSummary: context.isSummary,
 				}),
 			};
 }
@@ -353,6 +354,9 @@ export function decodeDetachedNodes(
 		encodeType: chunkCompressionStrategy,
 		originatorId: context.originatorId,
 		idCompressor: context.idCompressor,
+		isSummary: context.isSummary,
+		healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
+		sharedObjectId: context.sharedObjectId,
 	});
 	const getChunk = (index: number): TreeChunk => {
 		assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.100.0";
+export const pkgVersion = "2.101.0";

package/src/shared-tree/independentView.ts

@@ -238,6 +238,8 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 			idCompressor,
 			originatorId: idCompressor.localSessionId, // Is this right? If so, why is is needed?
 			schema: { schema: newSchema, policy: defaultSchemaPolicy },
+			// Not a summary blob — this is a synthetic decode of inline content.
+			isSummary: false,
 		};
 		const fieldCursors = fieldBatchCodec.decode(
 			options.content.tree as JsonCompatibleReadOnly,

package/src/shared-tree/sharedTree.ts

@@ -246,6 +246,11 @@ export class SharedTreeKernel
 			encodeType: options.treeEncodeType,
 			originatorId: idCompressor.localSessionId,
 			idCompressor,
+			// ForestSummarizer is the only consumer of this context, and it
+			// only invokes the codec in summary encode / load paths.
+			isSummary: true,
+			healUnresolvableIdentifiersOnDecode: options.healUnresolvableIdentifiersOnDecode,
+			sharedObjectId: sharedObject.id,
 		};
 		const forestSummarizer = new ForestSummarizer(
 			forest,
@@ -570,7 +575,41 @@ export function getCodecTreeForSharedTreeFormat(
  * Configuration options for SharedTree.
  * @beta @input
  */
-export type SharedTreeOptionsBeta = ForestOptions & Partial<CodecWriteOptionsBeta>;
+export interface SharedTreeOptionsBeta extends ForestOptions, Partial<CodecWriteOptionsBeta> {
+	/**
+	 * When `true`, when an improperly encoded identifier is encountered in a summary,
+	 * a new identifier will be generated instead of throwing an error.
+	 *
+	 * @defaultValue `false`
+	 *
+	 * @remarks
+	 * The intended use is recovering documents whose attach summary was persisted
+	 * with unresolvable node identifiers (a SharedTree-attaches-to-already-attached-container
+	 * scenario). Without this flag enabled, a client opening such a document will throw at summary load time.
+	 * With this flag enabled, unresolvable identifiers are replaced at decode time with stable UUIDs
+	 * derived deterministically from the data store id and the unresolvable op-space integer,
+	 * so every reader of the same blob (other than the originator) agrees on the resulting in-memory id.
+	 * Healed identifiers are written back out at the next summary in their stable UUID form,
+	 * so the inconsistency does not need to be re-healed on every load.
+	 *
+	 * Off by default because enabling it for documents that are not actually corrupt
+	 * would mask genuine bugs that otherwise surface as decode failures.
+	 *
+	 * This mitigation is also not perfect as the client that originated the non-finalized
+	 * will not apply the same "healing" and will continue to use the original identifier.
+	 * The difference in identifiers between the originating client and subsequent clients that load
+	 * the document is not ideal but generally benign to Fluid. However, it may have application-level
+	 * consequences (e.g. if the application stores the identifiers elsewhere, either in other parts of
+	 * Fluid data or externally). Applications should consider whether this risk is acceptable before
+	 * enabling this option.
+	 *
+	 * @privateRemarks
+	 * "Unresolvable" in the public-facing remarks corresponds to non-finalized short IDs persisted without
+	 * any corresponding context for their originating session. See id-compressor internal documentation
+	 * for more details.
+	 */
+	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+}
 
 /**
  * Configuration options for SharedTree with alpha features.
@@ -724,6 +763,7 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
 	disposeForksAfterTransaction: true,
 	shouldEncodeIncrementally: defaultIncrementalEncodingPolicy,
 	enableSharedBranches: false,
+	healUnresolvableIdentifiersOnDecode: false,
 	writeVersionOverrides: new Map(),
 	allowPossiblyIncompatibleWriteVersionOverrides: false,
 };

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -194,6 +194,7 @@ function makeSharedTreeChangeCodec(
 								schema: schemaAndPolicy,
 								idCompressor: context.idCompressor,
 								revision: context.revision,
+								isSummary: context.isSummary,
 							}),
 						});
 					} else if (decodedChange.type === "schema") {

package/src/shared-tree/treeAlpha.ts

@@ -954,6 +954,8 @@ export const TreeAlpha: TreeAlpha = {
 			idCompressor,
 			originatorId: idCompressor.localSessionId, // TODO: Why is this needed?
 			schema: { schema: storedSchema, policy: defaultSchemaPolicy },
+			// Not a summary blob — this is `TreeAlpha`'s ad-hoc encoder.
+			isSummary: false,
 		};
 		const result = codec.encode(batch, context);
 		// TODO: codecs should better track which ones can contain handles, and which cannot. When done properly, casts like this can be removed.

package/src/shared-tree/treeCheckout.ts

@@ -750,6 +750,7 @@ export class TreeCheckout implements ITreeCheckout {
 							idCompressor: this.idCompressor,
 							originatorId: this.idCompressor.localSessionId,
 							revision,
+							isSummary: false,
 						};
 						const encodedChange = this.changeFamily.codecs.resolve(4).encode(change, context);
 
@@ -820,6 +821,7 @@ export class TreeCheckout implements ITreeCheckout {
 			idCompressor: this.idCompressor,
 			originatorId: this.idCompressor.localSessionId,
 			revision,
+			isSummary: false,
 		};
 		const decodedChange = this.changeFamily.codecs.resolve(4).decode(change, context);
 		// Apply the change to the branch, but _not_ the `activeBranch` - we do not support squashing serialized commits in a transaction.

package/src/shared-tree-core/editManagerCodecs.ts

@@ -36,6 +36,9 @@ import { EditManagerFormatVersion } from "./editManagerFormatCommons.js";
 export interface EditManagerEncodingContext {
 	idCompressor: IIdCompressor;
 	readonly schema?: SchemaAndPolicy;
+	readonly isSummary: boolean;
+	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	readonly sharedObjectId?: string;
 }
 
 /**

package/src/shared-tree-core/editManagerCodecsCommons.ts

@@ -28,6 +28,20 @@ import type {
 export interface EditManagerEncodingContext {
 	idCompressor: IIdCompressor;
 	readonly schema?: SchemaAndPolicy;
+	/**
+	 * See {@link ChangeEncodingContext.isSummary}. EditManager codec callers
+	 * always set this to `true` (the codec is only invoked for summaries),
+	 * but it is carried explicitly so downstream codecs can read it.
+	 */
+	readonly isSummary: boolean;
+	/**
+	 * See {@link ChangeEncodingContext.healUnresolvableIdentifiersOnDecode}.
+	 */
+	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	/**
+	 * See {@link ChangeEncodingContext.sharedObjectId}.
+	 */
+	readonly sharedObjectId?: string;
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -53,6 +67,7 @@ function encodeCommit<TChangeset, T extends Commit<TChangeset>>(
 			originatorId: commit.sessionId,
 			idCompressor: context.idCompressor,
 			revision: undefined,
+			isSummary: context.isSummary,
 		}),
 		change: changeCodec.encode(commit.change, { ...context, revision: commit.revision }),
 	};
@@ -79,6 +94,7 @@ function decodeCommit<TChangeset, T extends EncodedCommit<JsonCompatibleReadOnly
 		originatorId: commit.sessionId,
 		idCompressor: context.idCompressor,
 		revision: undefined,
+		isSummary: context.isSummary,
 	});
 
 	return {
@@ -112,6 +128,7 @@ export function encodeSharedBranch<TChangeset>(
 				idCompressor: context.idCompressor,
 				schema: context.schema,
 				revision: undefined,
+				isSummary: context.isSummary,
 			}),
 		),
 		peers: Array.from(data.peerLocalBranches.entries(), ([sessionId, branch]) => [
@@ -121,6 +138,7 @@ export function encodeSharedBranch<TChangeset>(
 					originatorId: sessionId,
 					idCompressor: context.idCompressor,
 					revision: undefined,
+					isSummary: context.isSummary,
 				}),
 				commits: branch.commits.map((commit) =>
 					encodeCommit(changeCodec, revisionTagCodec, commit, {
@@ -128,6 +146,7 @@ export function encodeSharedBranch<TChangeset>(
 						idCompressor: context.idCompressor,
 						schema: context.schema,
 						revision: undefined,
+						isSummary: context.isSummary,
 					}),
 				),
 			},
@@ -154,6 +173,7 @@ export function encodeSharedBranch<TChangeset>(
 			originatorId,
 			idCompressor: context.idCompressor,
 			revision: undefined,
+			isSummary: context.isSummary,
 		});
 	}
 	return json;
@@ -186,6 +206,9 @@ export function decodeSharedBranch<TChangeset>(
 					originatorId: commit.sessionId,
 					idCompressor: context.idCompressor,
 					revision: undefined,
+					isSummary: context.isSummary,
+					healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
+					sharedObjectId: context.sharedObjectId,
 				}),
 		),
 		peerLocalBranches: new Map(
@@ -196,6 +219,7 @@ export function decodeSharedBranch<TChangeset>(
 						originatorId: sessionId,
 						idCompressor: context.idCompressor,
 						revision: undefined,
+						isSummary: context.isSummary,
 					}),
 					commits: branch.commits.map((commit) =>
 						// TODO: sort out EncodedCommit vs Commit, and make this type check without `as`.
@@ -207,6 +231,10 @@ export function decodeSharedBranch<TChangeset>(
 								originatorId: commit.sessionId,
 								idCompressor: context.idCompressor,
 								revision: undefined,
+								isSummary: context.isSummary,
+								healUnresolvableIdentifiersOnDecode:
+									context.healUnresolvableIdentifiersOnDecode,
+								sharedObjectId: context.sharedObjectId,
 							},
 						),
 					),
@@ -239,6 +267,7 @@ export function decodeSharedBranch<TChangeset>(
 			originatorId,
 			idCompressor: context.idCompressor,
 			revision: undefined,
+			isSummary: context.isSummary,
 		});
 	}
 	return data;

package/src/shared-tree-core/editManagerCodecsV1toV4.ts

@@ -25,6 +25,9 @@ import { EncodedEditManager } from "./editManagerFormatV1toV4.js";
 export interface EditManagerEncodingContext {
 	idCompressor: IIdCompressor;
 	readonly schema?: SchemaAndPolicy;
+	readonly isSummary: boolean;
+	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	readonly sharedObjectId?: string;
 }
 
 /**

package/src/shared-tree-core/editManagerCodecsVSharedBranches.ts

@@ -29,6 +29,9 @@ import { EncodedEditManager } from "./editManagerFormatVSharedBranches.js";
 export interface EditManagerEncodingContext {
 	idCompressor: IIdCompressor;
 	readonly schema?: SchemaAndPolicy;
+	readonly isSummary: boolean;
+	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	readonly sharedObjectId?: string;
 }
 
 export function makeSharedBranchesCodecWithVersion<TChangeset>(