@fluidframework/tree 2.114.0 → 2.115.0

package/src/text/textDomainFormatted.ts

@@ -54,7 +54,7 @@ import {
 	charactersFromString,
 	expensiveInternalValidationAssert,
 	processCharactersChangedDelta,
-	type TextAsTree,
+	type PlainText,
 } from "./textDomain.js";
 
 /**
@@ -95,7 +95,7 @@ export class StringTextAtomNode
 		 */
 		content: SchemaFactory.required([SchemaFactory.string], { key: EmptyKey }),
 	})
-	implements FormattedTextAsTree.TextAtom
+	implements FormattedText.TextAtom
 {
 	public static fromCharacter(value: string): StringTextAtomNode {
 		const character = oneFromIterable(charactersFromString(value));
@@ -115,16 +115,19 @@ export class StringTextAtomNode
 
 /**
  * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
+ *
  * @remarks
  * This is generic over formatting an embedded object/atom types.
- * See {@link FormattedTextAsTreeDefault} for a default parameterization.
+ *
  * @privateRemarks
+ * See {@link FormattedTextDefault} for an example parameterization.
+ *
  * TODO:
  * - Add more comprehensive tests for generic parameterizations other than default.
  * - Sort out API around overwriting subsets of formatting information.
- * @internal
+ * @alpha
  */
-export namespace FormattedTextAsTree {
+export namespace FormattedText {
 	/**
 	 * Creates a schema for a formatted text node, parameterized by the formatting and the embedded object (atom) types.
 	 *
@@ -133,16 +136,17 @@ export namespace FormattedTextAsTree {
 	 * This scope is used to distinguish different usages of `createSchema` from each-other, and must be kept the same between versions for nodes to remain compatible.
 	 * It must be different to distinguish different formatted text schema within the same document.
 	 * @param formatSchema - Schema describing the formatting associated with each atom of text.
-	 * Use an {@link NodeKind.Object|Object node} to support {@link FormattedTextAsTree.Members.formatRange}.
-	 * @param extraAtoms - Additional atom schema to allow as text content beyond the built-in {@link FormattedTextAsTree.(StringTextAtom:variable)}.
+	 * Use an {@link NodeKind.Object|Object node} to support {@link FormattedText.Members.formatRange}.
+	 * @param extraAtoms - Additional atom schema to allow as text content beyond the built-in {@link FormattedText.(StringTextAtom:variable)}.
 	 * Use this to embed richer content (for example line breaks or inline objects) alongside plain characters.
 	 * @param defaultFormatInsertable - The formatting applied to text inserted via non-formatted APIs
-	 * (for example {@link FormattedTextAsTree.Members.insertAt} and {@link FormattedTextAsTree.Statics.fromString} when no explicit format is provided).
-	 * @returns The schema for the formatted text node, whose nodes implement {@link FormattedTextAsTree.Members} and whose statics implement {@link FormattedTextAsTree.Statics}.
-	 * @remarks
-	 * See {@link FormattedTextAsTreeDefault} for a default parameterization of this factory.
+	 * (for example {@link FormattedText.Members.insertAt} and {@link FormattedText.Statics.fromString} when no explicit format is provided).
+	 * @returns The schema for the formatted text node, whose nodes implement {@link FormattedText.Members} and whose statics implement {@link FormattedText.Statics}.
+	 *
 	 * @privateRemarks
-	 * TODO: The choice to always include the built-in {@link FormattedTextAsTree.(StringTextAtom:variable)} is a design decision that should be re-evaluated before stabilizing.
+	 * See {@link FormattedTextDefault} for an example parameterization of this factory.
+	 *
+	 * TODO: The choice to always include the built-in {@link FormattedText.(StringTextAtom:variable)} is a design decision that should be re-evaluated before stabilizing.
 	 */
 	export function createSchema<
 		const TUserScope extends string,
@@ -302,7 +306,7 @@ export namespace FormattedTextAsTree {
 					);
 					return [key, value] as const;
 				});
-				this.#editRange(start, end, "FormattedTextAsTree.formatRange", (atom) => {
+				this.#editRange(start, end, "FormattedText.formatRange", (atom) => {
 					const formatNode: TreeNode | TreeValue = atom.format;
 					const atomFormatSchema = TreeStatic.schema(formatNode);
 					if (!isObjectNodeSchema(atomFormatSchema)) {
@@ -338,7 +342,7 @@ export namespace FormattedTextAsTree {
 				format?: InsertableTreeFieldFromImplicitField<FormatSchema>,
 			): void {
 				const node = getFormatNode(format);
-				this.#editRange(start, end, "FormattedTextAsTree.reformat", (atom) => {
+				this.#editRange(start, end, "FormattedText.reformat", (atom) => {
 					atom.format = cloneFormat(node);
 				});
 			}
@@ -375,7 +379,7 @@ export namespace FormattedTextAsTree {
 			}
 
 			/**
-			 * Returns the {@link  FormattedTextAsTree.TextAtom.content} at the given atom index, or `undefined` if out of bounds.
+			 * Returns the {@link  FormattedText.TextAtom.content} at the given atom index, or `undefined` if out of bounds.
 			 */
 			private getAtomCharacterAt(index: number): string | undefined {
 				const atom = this.content[index];
@@ -384,7 +388,7 @@ export namespace FormattedTextAsTree {
 			}
 
 			public onCharactersChanged(
-				callback: (ops: readonly TextAsTree.TextOp[] | undefined) => void,
+				callback: (ops: readonly PlainText.TextOp[] | undefined) => void,
 			): () => void {
 				return TreeAlpha.on(this.content, "nodeChanged", ({ delta }) =>
 					processCharactersChangedDelta(
@@ -396,7 +400,7 @@ export namespace FormattedTextAsTree {
 			}
 
 			public onContentChanged(
-				callback: (ops: readonly TextAsTree.TextOp[] | undefined) => void,
+				callback: (ops: readonly PlainText.TextOp[] | undefined) => void,
 			): () => void {
 				return TreeAlpha.on(this.content, "treeChanged", ({ delta }) =>
 					processCharactersChangedDelta(
@@ -487,7 +491,7 @@ export namespace FormattedTextAsTree {
 							// TODO: we could optimize this for constant cases via an optional symbol on the atom schema holding the constant.
 							// A less general optimization could just include cases for build in types with constant values
 							// (like below commented code: currently this would cause a cyclical dependency but could be refactored).
-							// case FormattedTextAsTree.StringLineAtom.identifier: {
+							// case FormattedText.StringLineAtom.identifier: {
 							// 	content = "\n";
 							// 	break;
 							// }
@@ -524,12 +528,12 @@ export namespace FormattedTextAsTree {
 			}
 
 			public getString(startIndex: number, endIndex: number = this.length): string {
-				validateIndexRange(startIndex, endIndex, this, "FormattedTextAsTree.getString");
+				validateIndexRange(startIndex, endIndex, this, "FormattedText.getString");
 				return this.getCharactersSubarray(startIndex, endIndex).join("");
 			}
 
 			public getUniformRun(startIndex: number, endIndex: number = this.length): number {
-				validateIndexRange(startIndex, endIndex, this, "FormattedTextAsTree.getUniformRun");
+				validateIndexRange(startIndex, endIndex, this, "FormattedText.getUniformRun");
 				if (endIndex === startIndex) {
 					throw new UsageError("endIndex must be greater than startIndex for getUniformRun.");
 				}
@@ -602,8 +606,8 @@ export namespace FormattedTextAsTree {
 		/**
 		 * Schema for a text node.
 		 * @remarks
-		 * See {@link FormattedTextAsTree.Members} for the API.
-		 * See {@link FormattedTextAsTree.Statics} for static APIs on this Schema, including construction.
+		 * See {@link FormattedText.Members} for the API.
+		 * See {@link FormattedText.Statics} for static APIs on this Schema, including construction.
 		 * @privateRemarks
 		 * eraseSchemaDetailsSubclassable risks user's defining subclass members which collide with internals.
 		 * Ideally we would generate private members for non-public properties, but TypeScript does not support this.
@@ -629,7 +633,7 @@ export namespace FormattedTextAsTree {
 	 * This is implemented {@link StringAtom}, but we avoid leaking the fact this is a TreeNode in the API surface to
 	 * preserve more future flexibility.
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export interface FormattedAtom<TFormat, TText> {
 		/**
@@ -648,8 +652,8 @@ export namespace FormattedTextAsTree {
 	 * Portion of a string.
 	 * @remarks
 	 * Additional kinds of text atoms (also known as embedded objects) which can occur inside a string can implement this.
-	 * The schema for them can then be provided to {@link FormattedTextAsTree.createSchema}.
-	 * @internal
+	 * The schema for them can then be provided to {@link FormattedText.createSchema}.
+	 * @alpha
 	 */
 	export interface TextAtom {
 		/**
@@ -659,14 +663,14 @@ export namespace FormattedTextAsTree {
 	}
 
 	/**
-	 * Static factory functions for {@link FormattedTextAsTree.(StringTextAtom:variable)}.
+	 * Static factory functions for {@link FormattedText.(StringTextAtom:variable)}.
 	 * @privateRemarks
 	 * We type-erase `StringTextAtom` and only provide these static factories for construction
 	 * to reduce the chance of someone accidentally creating a text atom for a string other than a single unicode code point.
 	 * Other strings should work, but our intention is to provide no type-safe API which can produce them, so an application can take their lack of existence as an invariant if they want.
 	 * It is still however possible to produce them, like export/import round trips with editing in the middle of the process, or collaboration with an equivalent schema which doesn't enforce this invariant.
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export interface StringTextAtomStatics {
 		/**
@@ -682,18 +686,18 @@ export namespace FormattedTextAsTree {
 	}
 
 	/**
-	 * Schema for a {@link FormattedTextAsTree.(StringTextAtom:variable)} node.
+	 * Schema for a {@link FormattedText.(StringTextAtom:variable)} node.
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export const StringTextAtom = eraseSchemaDetails<TextAtom, StringTextAtomStatics>()(
 		StringTextAtomNode,
 	);
 
 	/**
-	 * Node for the {@link FormattedTextAsTree.(StringTextAtom:variable)} schema.
+	 * Node for the {@link FormattedText.(StringTextAtom:variable)} schema.
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export type StringTextAtom = ErasedNode<
 		TextAtom,
@@ -703,7 +707,7 @@ export namespace FormattedTextAsTree {
 	/**
 	 * Statics for formatted text nodes.
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export interface Statics<TTree, FormatSchema extends ImplicitAllowedTypes> {
 		/**
@@ -729,23 +733,23 @@ export namespace FormattedTextAsTree {
 	 * (which often operates on something in between unicode code points and grapheme clusters)
 	 * and navigation/selection (which typically uses grapheme clusters).
 	 *
-	 * @see {@link FormattedTextAsTree.Statics.fromString} for construction.
-	 * @see {@link FormattedTextAsTree.createSchema} for creating schemas whose nodes implement this.
+	 * @see {@link FormattedText.Statics.fromString} for construction.
+	 * @see {@link FormattedText.createSchema} for creating schemas whose nodes implement this.
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export interface Members<
 		FormatSchema extends ImplicitAllowedTypes,
 		ExtraAtomsSchema extends readonly LazyItem<
 			TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>
 		>[],
-	> extends TextAsTree.Members {
+	> extends PlainText.Members {
 		/**
-		 * {@link TextAsTree.Members.insertAt} with optional formatting to apply to all additional characters,
+		 * {@link PlainText.Members.insertAt} with optional formatting to apply to all additional characters,
 		 * and allowing an array of atoms instead of a string.
-		 * @param format - Optional formatting to apply to all additional characters. If not specified, the default formatting (from {@link FormattedTextAsTree.createSchema}) will be used.
+		 * @param format - Optional formatting to apply to all additional characters. If not specified, the default formatting (from {@link FormattedText.createSchema}) will be used.
 		 * @remarks
-		 * Use {@link FormattedTextAsTree.Members.insertWithFormattingAt} if you need to specify formatting for atom independently.
+		 * Use {@link FormattedText.Members.insertWithFormattingAt} if you need to specify formatting for atom independently.
 		 * @override
 		 */
 		insertAt(
@@ -761,7 +765,7 @@ export namespace FormattedTextAsTree {
 		 * @remarks
 		 * This iterator matches the behavior of {@link (TreeArrayNode:interface)} with respect to edits during iteration.
 		 *
-		 * For more efficient access, use {@link FormattedTextAsTree.Members.getUniformRun} and {@link FormattedTextAsTree.Members.getString} to access ranges of characters
+		 * For more efficient access, use {@link FormattedText.Members.getUniformRun} and {@link FormattedText.Members.getString} to access ranges of characters
 		 * to avoid having to inspect the formatting on every atom.
 		 * @privateRemarks
 		 * Currently this is implemented by a node and changes with the text over time.
@@ -777,7 +781,7 @@ export namespace FormattedTextAsTree {
 		 * Insert a range of characters into the string based on character index.
 		 * @remarks
 		 * See {@link (TreeArrayNode:interface).insertAt} for more details on the behavior.
-		 * See {@link FormattedTextAsTree.Statics.fromString} for how the `additionalCharacters` string is broken into characters.
+		 * See {@link FormattedText.Statics.fromString} for how the `additionalCharacters` string is broken into characters.
 		 * @privateRemarks
 		 * If we provide ways to customize character boundaries, that could be handled here by taking in an Iterable<string> instead of a string.
 		 * Doing this currently would enable insertion of text with different character boundaries than the existing text,
@@ -827,13 +831,13 @@ export namespace FormattedTextAsTree {
 		 * @param endIndex - The ending index (exclusive) of the range to format.
 		 * @param format - The formatting to replace the formatting of the indicated range with.
 		 * For each atom, `format` will be cloned and assigned to the atom's format, overwriting any existing formatting.
-		 * If not specified the `defaultFormat` from {@link FormattedTextAsTree.createSchema} will be used.
+		 * If not specified the `defaultFormat` from {@link FormattedText.createSchema} will be used.
 		 * @remarks
 		 * The start and end behave the same as in {@link (TreeArrayNode:interface).removeRange}.
 		 *
 		 * This is typically used to normalize formatting, like resetting the formatting of a range to default settings.
 		 * @privateRemarks
-		 * See notes on {@link FormattedTextAsTree.Members.formatRange} for future optimization opportunities.
+		 * See notes on {@link FormattedText.Members.formatRange} for future optimization opportunities.
 		 */
 		reformat(
 			startIndex?: number | undefined,
@@ -857,14 +861,14 @@ export namespace FormattedTextAsTree {
 		/**
 		 * Subscribe to all content changes on this text node, including both shallow
 		 * changes (inserts/removes) and deep changes (formatting updates on existing characters).
-		 * @param callback - Called after each change with a sequence of {@link TextAsTree.TextOp}s describing what changed,
+		 * @param callback - Called after each change with a sequence of {@link PlainText.TextOp}s describing what changed,
 		 * or `undefined` when a delta could not be computed (e.g. during a schema upgrade).
 		 * @returns A cleanup function that unsubscribes the callback when called.
 		 * @remarks
-		 * Unlike {@link TextAsTree.Members.onCharactersChanged} which only fires on
+		 * Unlike {@link PlainText.Members.onCharactersChanged} which only fires on
 		 * shallow changes (inserts and removes), this method also fires on deep changes —
 		 * formatting property updates on existing characters.
-		 * The {@link TextAsTree.TextRetainOp.formattingChanged} flag on retain ops
+		 * The {@link PlainText.TextRetainOp.formattingChanged} flag on retain ops
 		 * indicates which character ranges had formatting updates.
 		 *
 		 * All counts in the delivered ops are in Unicode code points, not UTF-16 code units.
@@ -872,14 +876,14 @@ export namespace FormattedTextAsTree {
 		 * corresponds to two UTF-16 code units — convert before using the counts as string indices.
 		 */
 		onContentChanged(
-			callback: (ops: readonly TextAsTree.TextOp[] | undefined) => void,
+			callback: (ops: readonly PlainText.TextOp[] | undefined) => void,
 		): () => void;
 	}
 
 	/**
-	 * Insertable shape for a formatted text atom used by {@link FormattedTextAsTree.Members.insertWithFormattingAt}.
+	 * Insertable shape for a formatted text atom used by {@link FormattedText.Members.insertWithFormattingAt}.
 	 * @input
-	 * @internal
+	 * @alpha
 	 */
 	export interface FormattedAtomInsertable<TFormat, TContent> {
 		readonly content: TContent;
@@ -890,7 +894,7 @@ export namespace FormattedTextAsTree {
 	 * Schema identifier for the a generic formatted text schema.
 	 * @privateRemarks
 	 * Eventually this should probably be given a better name and/or made a system type in a system namespace.
-	 * @internal
+	 * @alpha
 	 */
 	export type FormattedTextSchemaIdentifier<TUserScope extends string> = ScopedSchemaName<
 		`com.fluidframework.text.formatted<${TUserScope}>`,
@@ -903,7 +907,7 @@ export namespace FormattedTextAsTree {
 	 * This is just schema for the text atom {@link AllowedTypes},
 	 * and does not include the actual formatting (which is higher up in the tree).
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export type TextAtomSchemas<
 		ExtraAtomsSchema extends readonly LazyItem<
@@ -914,7 +918,7 @@ export namespace FormattedTextAsTree {
 	/**
 	 * A generic type for a formatted text schema.
 	 * @sealed
-	 * @internal
+	 * @alpha
 	 */
 	export type FormattedTextSchema<
 		TUserScope extends string,

package/src/text/textDomainFormattedDefault.ts

@@ -9,7 +9,7 @@ import type {
 	InsertableTreeNodeFromImplicitAllowedTypes,
 } from "../simple-tree/index.js";
 
-import { FormattedTextAsTree } from "./textDomainFormatted.js";
+import { FormattedText } from "./textDomainFormatted.js";
 
 /**
  * Schema factory for default formatted text types which are not generic.
@@ -25,21 +25,18 @@ const defaultFormat = {
 } as const;
 
 /**
- * A default parameterization of the generic {@link FormattedTextAsTree} with hard-coded assumptions about what kind of embedded content and what kind of formatting is supported.
+ * A default parameterization of the generic {@link FormattedText} with hard-coded assumptions about what kind of embedded content and what kind of formatting is supported.
  * @remarks
- * It is unlikely this meets the needs of most users, but it can serve as an unstable example of how to use the generic {@link FormattedTextAsTree}.
+ * It is unlikely this meets the needs of most users, but it can serve as an unstable example of how to use the generic {@link FormattedText}.
  * @internal
  */
-export namespace FormattedTextAsTreeDefault {
+export namespace FormattedTextDefault {
 	/**
 	 * Portion of a string with formatting.
 	 * @sealed
 	 * @internal
 	 */
-	export type FormattedAtom = FormattedTextAsTree.FormattedAtom<
-		CharacterFormat,
-		StringAtomContent
-	>;
+	export type FormattedAtom = FormattedText.FormattedAtom<CharacterFormat, StringAtomContent>;
 
 	/**
 	 * Formatting options for characters.
@@ -74,7 +71,7 @@ export namespace FormattedTextAsTreeDefault {
 		"codeBlock",
 	]);
 	/**
-	 * {@inheritdoc FormattedTextAsTreeDefault.(LineTag:variable)}
+	 * {@inheritdoc FormattedTextDefault.(LineTag:variable)}
 	 * @sealed
 	 * @internal
 	 */
@@ -104,12 +101,9 @@ export namespace FormattedTextAsTreeDefault {
 	 * @sealed
 	 * @internal
 	 */
-	export const StringAtomContent = [
-		FormattedTextAsTree.StringTextAtom,
-		StringLineAtom,
-	] as const;
+	export const StringAtomContent = [FormattedText.StringTextAtom, StringLineAtom] as const;
 	/**
-	 * {@inheritdoc FormattedTextAsTreeDefault.(StringAtomContent:variable)}
+	 * {@inheritdoc FormattedTextDefault.(StringAtomContent:variable)}
 	 * @sealed
 	 * @internal
 	 */
@@ -120,17 +114,14 @@ export namespace FormattedTextAsTreeDefault {
 	 * @sealed
 	 * @internal
 	 */
-	export type Statics<TTree = Tree> = FormattedTextAsTree.Statics<
-		TTree,
-		typeof CharacterFormat
-	>;
+	export type Statics<TTree = Tree> = FormattedText.Statics<TTree, typeof CharacterFormat>;
 
 	/**
-	 * Insertable shape for a formatted text atom used by {@link FormattedTextAsTree.Members.insertWithFormattingAt}.
+	 * Insertable shape for a formatted text atom used by {@link FormattedText.Members.insertWithFormattingAt}.
 	 * @sealed
 	 * @internal
 	 */
-	export type FormattedAtomInsertable = FormattedTextAsTree.FormattedAtom<
+	export type FormattedAtomInsertable = FormattedText.FormattedAtom<
 		InsertableTreeNodeFromImplicitAllowedTypes<typeof CharacterFormat>,
 		InsertableTreeNodeFromImplicitAllowedTypes<TextAtomSchemas>
 	>;
@@ -142,15 +133,15 @@ export namespace FormattedTextAsTreeDefault {
 	 * @sealed
 	 * @internal
 	 */
-	export type TextAtomSchemas = FormattedTextAsTree.TextAtomSchemas<[typeof StringLineAtom]>;
+	export type TextAtomSchemas = FormattedText.TextAtomSchemas<[typeof StringLineAtom]>;
 
 	/**
-	 * The schema produced using {@link FormattedTextAsTree.createSchema} with hard-coded assumptions
+	 * The schema produced using {@link FormattedText.createSchema} with hard-coded assumptions
 	 * about what kind of embedded content and what kind of formatting is supported.
 	 * @sealed
 	 * @internal
 	 */
-	export class Tree extends FormattedTextAsTree.createSchema(
+	export class Tree extends FormattedText.createSchema(
 		sf,
 		CharacterFormat,
 		[StringLineAtom],

package/src/util/compressedIds.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { LogLevel, type ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import type {
 	IIdCompressor,
@@ -166,6 +167,12 @@ export interface IdentifierHealingConfig {
 	 * same session offsets.
 	 */
 	readonly sharedObjectId: string;
+
+	/**
+	 * Optional logger used by {@link forceDecodeEncodedIdWithoutSession} to record telemetry
+	 * when the heal-on-decode recovery path is taken (a non-final identifier is healed).
+	 */
+	readonly logger?: ITelemetryBaseLogger;
 }
 
 /**
@@ -177,6 +184,16 @@ export interface IdentifierHealingConfig {
  * deterministic v5 UUID string — *not* a `StableId`, since that brand requires
  * v4, but still a valid identifier value; the `string` arm of the return type
  * covers this case.
+ *
+ * The recovery (heal) path only occurs because of a prior bug where non-finalized identifiers were
+ * written into summaries. When {@link IdentifierHealingConfig.logger} is supplied, a telemetry event
+ * is recorded on that path so heals can be observed in the wild. The error/throw path is intentionally
+ * not instrumented here: the thrown exception is expected to surface via the application's own error
+ * telemetry, and should never be silently swallowed.
+ *
+ * @param id - The op-space compressed ID to decode.
+ * @param idCompressor - The ID compressor used to normalize the ID.
+ * @param healing - Heal-on-decode configuration. Presence enables healing of non-final IDs.
  */
 export function forceDecodeEncodedIdWithoutSession(
 	id: OpSpaceCompressedId,
@@ -189,7 +206,19 @@ export function forceDecodeEncodedIdWithoutSession(
 	}
 	// `id` is a non-final op-space compressed id.
 	if (healing !== undefined) {
-		return uuidV5(`${healing.sharedObjectId}|${id}`, healingNamespace);
+		const healed = uuidV5(`${healing.sharedObjectId}|${id}`, healingNamespace);
+		healing.logger?.send(
+			{
+				category: "generic",
+				eventName: "HealUnresolvableIdentifierOnDecode",
+			},
+			// This telemetry should be very low-volume (and possibly never happen at all),
+			// as should only occur when loading documents that were corrupted by a now fixed bug and have not been re-summarized since healing was added.
+			// It is useful for monitoring and diagnosing for this to be reported in the same cases in which the error case would be reported,
+			// which is the essential level.
+			LogLevel.essential,
+		);
+		return healed;
 	}
 	throw new Error(
 		"Summary could not be loaded due to an incorrectly encoded identifier. See SharedTreeOptionsBeta.healUnresolvableIdentifiersOnDecode for mitigation.",
@@ -261,9 +290,13 @@ export interface IdDecoderOptionsWithOriginator {
  */
 export class IdDecodingContext {
 	/**
-	 * 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).
+	 * Whether this context resolves identifiers using an originator session ID.
+	 * @remarks
+	 * Consulted by {@link FieldBatchDecodingContext} to prevent using an originator-based
+	 * decoder in incremental chunks (which may come from other sessions, making such a
+	 * decoder wrong there).
 	 */
-	protected readonly hasOriginatorSessionId: boolean;
+	public readonly hasOriginatorSessionId: boolean;
 
 	/**
 	 * Compressor which can decompress session-space identifiers from {@link resolveEncodedId} as needed.