@fluidframework/tree 2.110.0 → 2.112.0

package/src/componentApi.ts

@@ -0,0 +1,354 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { getOrCreate } from "./util/index.js";
+
+/**
+ * Utilities for composing application "components" which contribute to a shared configuration.
+ *
+ * @remarks
+ * Nothing in this namespace is specific to tree schema,
+ * however it is designed to be able to handle the needs of components which work with {@link TreeSchema}.
+ *
+ * This is mainly used to implement "open polymorphism", where the set of allowed types
+ * for a field or collection can be extended by independently authored libraries (components) instead of being
+ * fixed up front.
+ *
+ * This basically amounts to dependency injection, where the "injection" is done at "composition" time to build the schema.
+ *
+ * Tree's schema do not natively support open polymorphism: all possible implementations must be explicitly listed.
+ * These tools work around these limitations by carefully controlling evaluation order:
+ * the source code can be structured in an open polymorphism style which at runtime evaluates into closed polymorphism
+ * by having each component register its implementations into a central collection (typically an
+ * {@link AllowedTypes} array).
+ *
+ * Each component is expressed as a {@link Component.Factory}: a function which receives a lazy reference to the
+ * composed configuration and returns the content that component contributes.
+ * Because the configuration is provided lazily, components may reference (including recursively) types contributed by
+ * other components, as long as nothing evaluates the lazy references until composition has completed.
+ * Use {@link Component.(compose:1)} to combine a set of components into a {@link Component.Composed}.
+ *
+ * See {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/openPolymorphism.integration.ts|openPolymorphism.integration.ts} for worked examples of this pattern.
+ *
+ * @privateRemarks
+ * The examples and integration tests for this pattern live in `openPolymorphism.integration.ts`.
+ * Those tests and the docs here should be kept in sync.
+ *
+ * @alpha
+ */
+export namespace Component {
+	/**
+	 * A function which takes in a lazy configuration and returns the content a component contributes.
+	 *
+	 * @remarks
+	 * The lazy configuration allows the component to reference items from the composed configuration, which can
+	 * include items the component itself contributes (allowing recursive references between components).
+	 *
+	 * The execution of the factory must not evaluate `lazyConfiguration` (doing so will error):
+	 * instead the returned `TComponent` can capture `lazyConfiguration` and evaluate it at a later time
+	 * (after all components have been composed).
+	 *
+	 * @typeParam TComponent - The content a component contributes.
+	 * @typeParam TConfig - The composed configuration type made available to components.
+	 * Defaults to the {@link Component.Composed} produced by composition: the common case where
+	 * components read composed content directly from the composition and no custom configuration type is needed.
+	 *
+	 * @input
+	 * @alpha
+	 */
+	export type Factory<TComponent, TConfig = ComposedDefault<TComponent>> = (
+		lazyConfiguration: () => TConfig,
+	) => TComponent;
+
+	/**
+	 * A function which returns an array of lazy values which each evaluate to `T`.
+	 *
+	 * @remarks
+	 * This mirrors the shape of {@link AllowedTypes} where all of the values are lazy:
+	 * the outer function and inner functions defer evaluation until after composition is complete.
+	 *
+	 * @typeParam T - The type each lazy value evaluates to.
+	 *
+	 * @alpha
+	 */
+	export type LazyArray<T> = () => readonly (() => T)[];
+
+	/**
+	 * Wrap a 0 argument function to cache the result.
+	 * @remarks
+	 * Do not use for impure functions.
+	 *
+	 * Generally {@link Component} utilities have built in caching in most cases,
+	 * but this is occasionally helpful when manually implementing laziness.
+	 *
+	 * Note that this takes a different approach than use in {@link evaluateLazySchema} where the function evaluation is done using a utility that adds caching.
+	 *
+	 * @param factory - The factory function to memoize.
+	 * @returns A function that returns the cached result of the factory.
+	 * @alpha
+	 */
+	export const memoize = <T>(factory: () => T): (() => T) => {
+		let run = false;
+		let cached: T;
+		return () => {
+			if (!run) {
+				cached = factory();
+				run = true;
+			}
+			return cached;
+		};
+	};
+
+	/**
+	 * An item which can be configured (evaluated) against a composed configuration to produce a result.
+	 *
+	 * @remarks
+	 * Use {@link Component.Composed.getConfigured} to evaluate a `Configurable`.
+	 * The result is cached, so a given `Configurable` is only evaluated once per composition.
+	 *
+	 * @typeParam TConfigPartial - The configuration type made available when configuring.
+	 * @typeParam TResult - The result produced by configuring.
+	 * @typeParam TComponent - The content components contribute.
+	 *
+	 * @alpha
+	 */
+	export interface Configurable<TConfigPartial, out TResult, TComponent> {
+		/**
+		 * Produce the configured result.
+		 * @param config - The composed configuration.
+		 * @param components - The composed components.
+		 */
+		configure(
+			config: TConfigPartial,
+			components: Composed<TComponent, TConfigPartial>,
+		): TResult;
+	}
+
+	/**
+	 * Implementation of {@link Component.Composed}.
+	 */
+	class Config<TConfig, TComponent> implements Composed<TComponent, TConfig> {
+		public readonly componentsMap: ReadonlyMap<Factory<TComponent, TConfig>, TComponent>;
+
+		/**
+		 * Cache of results produced by {@link Component.Composed.getConfigured}.
+		 *
+		 * @remarks
+		 * Maps each {@link Component.Configurable} to the result of evaluating it against this composition.
+		 * This ensures a given `Configurable` is only configured once: subsequent lookups return the cached result.
+		 */
+		private readonly evaluatedMap: Map<Configurable<TConfig, unknown, TComponent>, unknown> =
+			new Map();
+
+		/**
+		 * Cache of results produced by {@link Component.Composed.getComposed}.
+		 *
+		 * @remarks
+		 * Maps each composed property to the array produced for it.
+		 * This ensures a given property is only composed once: subsequent lookups return the same array
+		 * (including the same lazy values), so repeated calls with the same property are reference-stable.
+		 */
+		private readonly composedMap: Map<keyof TComponent, readonly unknown[]> = new Map();
+
+		public readonly components: readonly TComponent[];
+
+		public readonly config: TConfig;
+
+		public constructor(
+			allComponents: readonly Factory<TComponent, TConfig>[],
+			lazyConfiguration: (composed: Composed<TComponent, TConfig>) => TConfig,
+		) {
+			// eslint-disable-next-line no-undef-init -- Explicitly undefined: `config` is populated below, after all components have been constructed, and is read lazily via `lazyConfigInner`.
+			let config: TConfig | undefined = undefined;
+			const lazyConfigInner = (): TConfig => {
+				if (config === undefined) {
+					throw new UsageError(
+						"Configuration not yet available: components must not evaluate the lazy configuration during composition.",
+					);
+				}
+				return config;
+			};
+			this.componentsMap = new Map(allComponents.map((c) => [c, c(lazyConfigInner)]));
+			this.components = [...this.componentsMap.values()];
+			config = lazyConfiguration(this);
+			this.config = config;
+		}
+
+		public getComponent<TFactory extends Factory<TComponent, TConfig>>(
+			factory: TFactory,
+		): ReturnType<TFactory> {
+			const found = this.componentsMap.get(factory);
+			if (found === undefined) {
+				throw new UsageError("Requested component not included in this configuration");
+			}
+			return found as ReturnType<TFactory>;
+		}
+
+		public getConfigured<TConfigurable extends Configurable<TConfig, unknown, TComponent>>(
+			configurable: TConfigurable,
+		): ReturnType<TConfigurable["configure"]> {
+			const configured: unknown = getOrCreate(this.evaluatedMap, configurable, (c) => {
+				const result = c.configure(this.config, this);
+				if (result === undefined) {
+					throw new UsageError("Configurable must not return undefined");
+				}
+				return result;
+			});
+			return configured as ReturnType<TConfigurable["configure"]>;
+		}
+
+		public getComposed<
+			TKey extends keyof {
+				[Property in keyof TComponent as TComponent[Property] extends
+					| LazyArray<unknown>
+					| undefined
+					? Property
+					: never]: boolean;
+			},
+		>(
+			property: TKey,
+		): readonly (Exclude<TComponent[TKey], undefined> extends LazyArray<infer U>
+			? () => U
+			: never)[] {
+			const result = getOrCreate(this.composedMap, property, () =>
+				this.components.flatMap((c) => {
+					const prop = c[property] as LazyArray<unknown> | undefined;
+					if (prop === undefined) {
+						return [];
+					}
+					return prop();
+				}),
+			);
+			return result as (Exclude<TComponent[TKey], undefined> extends LazyArray<infer U>
+				? () => U
+				: never)[];
+		}
+	}
+
+	/**
+	 * Combine multiple {@link Component.Factory|components} into a single {@link Component.Composed}.
+	 *
+	 * @remarks
+	 * The {@link Component.Composed} itself is used as the configuration made available to components:
+	 * the simple case where components read composed content directly from the composition.
+	 * To produce a custom aggregated configuration, use the overload which takes a `lazyConfiguration` builder.
+	 *
+	 * @param allComponents - The components to compose.
+	 * @returns The composed components, from which configuration and per-component content can be read.
+	 *
+	 * @typeParam TComponent - The content each component contributes.
+	 *
+	 * @alpha
+	 */
+	export function compose<TComponent>(
+		allComponents: readonly Factory<TComponent>[],
+	): Composed<TComponent>;
+	/**
+	 * Combine multiple {@link Component.Factory|components} into a single {@link Component.Composed}.
+	 *
+	 * @param allComponents - The components to compose.
+	 * @param lazyConfiguration - Builds the composed configuration from the composed components.
+	 * This is invoked once, after all components have been created, and can aggregate content contributed by the
+	 * components (for example via {@link Component.Composed.getComposed}).
+	 * @returns The composed components, from which configuration and per-component content can be read.
+	 *
+	 * @typeParam TComponent - The content each component contributes.
+	 * @typeParam TConfig - The composed configuration type made available to components.
+	 *
+	 * @alpha
+	 */
+	export function compose<TComponent, TConfig>(
+		allComponents: readonly Factory<TComponent, TConfig>[],
+		lazyConfiguration: (composed: Composed<TComponent, TConfig>) => TConfig,
+	): Composed<TComponent, TConfig>;
+	export function compose<TComponent, TConfig>(
+		allComponents: readonly Factory<TComponent, TConfig>[],
+		lazyConfiguration: (composed: Composed<TComponent, TConfig>) => TConfig = (composed) =>
+			composed as unknown as TConfig,
+	): Composed<TComponent, TConfig> {
+		return new Config<TConfig, TComponent>(allComponents, lazyConfiguration);
+	}
+
+	/**
+	 * The default configuration type for a composition.
+	 * Also the type of Composed when using the default composition.
+	 * @privateRemarks
+	 * Declaring this as its own type makes the recursion possible instead of having to list the config parameter as unknown.
+	 * This makes it easier to understand what is going on when seeing this type in the intellisense.
+	 * @sealed @alpha
+	 */
+	export type ComposedDefault<TComponent> = Composed<TComponent, ComposedDefault<TComponent>>;
+
+	/**
+	 * The result of composing multiple components.
+	 *
+	 * @remarks
+	 * Create using {@link Component.(compose:1)}.
+	 *
+	 * @typeParam TComponent - The content each component contributes.
+	 * @typeParam TConfig - The composed configuration type made available to components.
+	 * Defaults to the composition itself: the common case where no custom configuration type is needed.
+	 *
+	 * @sealed @alpha
+	 */
+	export interface Composed<TComponent, TConfig = ComposedDefault<TComponent>> {
+		/**
+		 * The components which were composed.
+		 */
+		readonly components: readonly TComponent[];
+
+		/**
+		 * The configuration which was produced when composing.
+		 */
+		readonly config: TConfig;
+
+		/**
+		 * Get a component by its factory.
+		 *
+		 * @param factory - The factory used to look up the component. Must have been provided when composing.
+		 * @returns The content created by the provided factory.
+		 * This result is cached during composition and not reevaluated.
+		 */
+		getComponent<TFactory extends Factory<TComponent, TConfig>>(
+			factory: TFactory,
+		): ReturnType<TFactory>;
+
+		/**
+		 * Configure a {@link Component.Configurable}.
+		 * @remarks
+		 * The result is cached when first evaluated, so subsequent calls with the same `configurable` return the
+		 * same result.
+		 * @param configurable - The item to configure against this composition.
+		 */
+		getConfigured<TConfigurable extends Configurable<TConfig, unknown, TComponent>>(
+			configurable: TConfigurable,
+		): ReturnType<TConfigurable["configure"]>;
+
+		/**
+		 * Compose the contents of a {@link Component.LazyArray} property from all components.
+		 * @remarks
+		 * The result is cached when first evaluated, so subsequent calls with the same `property` return the
+		 * same result.
+		 * @param property - The property of the components to compose.
+		 * @returns The concatenation of the lazy values contributed by each component for `property`.
+		 * Components which omit the property contribute nothing.
+		 */
+		getComposed<
+			TKey extends keyof {
+				[Property in keyof TComponent as TComponent[Property] extends
+					| LazyArray<unknown>
+					| undefined
+					? Property
+					: never]: boolean;
+			},
+		>(
+			property: TKey,
+		): readonly (Exclude<TComponent[TKey], undefined> extends LazyArray<infer U>
+			? () => U
+			: never)[];
+	}
+}

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

@@ -7,9 +7,7 @@ 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 { IdentifierHealingConfig, JsonCompatibleReadOnly } from "../../util/index.js";
 import type { ChangeRebaser, RevisionTag, TaggedChange } from "../rebase/index.js";
 
 export interface ChangeFamily<TEditor extends ChangeFamilyEditor, TChange> {
@@ -39,17 +37,10 @@ export interface ChangeEncodingContext {
 	 */
 	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}.
+	 * Heal-on-decode workaround configuration. See {@link IdentifierHealingConfig}.
 	 * 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;
+	readonly healing?: IdentifierHealingConfig;
 }
 
 export type ChangeFamilyCodec<TChange> = IJsonCodec<

package/src/core/rebase/types.ts

@@ -236,7 +236,7 @@ export interface LocalChangeMetadata extends CommitMetadata {
 	readonly label?: unknown;
 
 	/**
-	 * A set of {@link RunTransactionParams.label | labels} for all transactions (nested or otherwise)
+	 * A set of {@link RunTransactionParamsBeta.label | labels} for all transactions (nested or otherwise)
 	 * that made up this change.
 	 * This can be used to identify, group, or filter changes — for example, to decide whether a change
 	 * should be included in an undo/redo stack.
@@ -278,7 +278,7 @@ export interface LocalChangeMetadata extends CommitMetadata {
  *
  * @remarks
  * Each transaction contributes a node whose {@link LabelTree.label} is its
- * {@link RunTransactionParams.label | label} (or `undefined` if no label was provided).
+ * {@link RunTransactionParamsBeta.label | label} (or `undefined` if no label was provided).
  * When transactions are nested, inner transaction nodes become {@link LabelTree.sublabels | sublabels}
  * of outer ones.
  *

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

@@ -51,8 +51,8 @@ export interface TreeStoredSchemaSubscription extends TreeStoredSchema {
 export interface MutableTreeStoredSchema extends TreeStoredSchemaSubscription {
 	/**
 	 * Mutates the stored schema.
-	 * Replaces all schema with the provided schema.
-	 * Can over-write preexisting schema, and removes unmentioned schema.
+	 * Replaces all schemas with the provided schema.
+	 * Can overwrite preexisting schemas, and removes unmentioned schemas.
 	 */
 	apply(newSchema: TreeStoredSchema): void;
 }

package/src/entrypoints/alpha.ts

@@ -120,6 +120,7 @@ export {
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
+	RunTransactionParamsBeta, 
 	SchemaFactoryBeta, 
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
@@ -128,6 +129,11 @@ export {
 	SnapshotSchemaCompatibilityOptions, 
 	System_TableSchema, 
 	TableSchema, 
+	TransactionCallbackStatusBeta, 
+	TransactionResultFailed, 
+	TransactionResultSuccess, 
+	TransactionValueResult, 
+	TransactionVoidResult, 
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
@@ -142,6 +148,8 @@ export {
 	UnannotateAllowedTypesList, 
 	UnannotateAllowedTypesListUnsafe, 
 	UnionToTuple, 
+	VoidTransactionCallbackStatusBeta, 
+	WithValue, 
 	adaptEnum, 
 	asBeta, 
 	configuredSharedTreeBeta, 
@@ -170,6 +178,7 @@ export {
 	ChangeMetadata, 
 	CodecName, 
 	CodecWriteOptions, 
+	Component, 
 	CreateIndependentTreeAlphaOptions, 
 	DirtyTreeMap, 
 	DirtyTreeStatus, 
@@ -193,6 +202,7 @@ export {
 	ITreeAlpha, 
 	IncrementalEncodingPolicy, 
 	IndependentViewOptions, 
+	IndependentViewTelemetryOptions, 
 	Insertable, 
 	InsertableContent, 
 	InsertableField, 
@@ -241,7 +251,7 @@ export {
 	RemoteChangeMetadata, 
 	RevertibleAlpha, 
 	RevertibleAlphaFactory, 
-	RunTransactionParams, 
+	RunTransactionParamsAlpha, 
 	SchemaFactoryAlpha, 
 	SchemaStaticsAlpha, 
 	SchemaType, 
@@ -259,13 +269,10 @@ export {
 	SimpleRecordNodeSchema, 
 	SimpleTreeSchema, 
 	TextAsTree, 
-	TransactionCallbackStatus, 
+	TransactionCallbackStatusAlpha, 
 	TransactionConstraintAlpha, 
 	TransactionLabels, 
-	TransactionResult, 
-	TransactionResultExt, 
-	TransactionResultFailed, 
-	TransactionResultSuccess, 
+	TransactionPostProcessor, 
 	TreeAlpha, 
 	TreeArrayNodeAlpha, 
 	TreeBranchAlpha, 
@@ -285,8 +292,7 @@ export {
 	VerboseTree, 
 	VerboseTreeNode, 
 	ViewContent, 
-	VoidTransactionCallbackStatus, 
-	WithValue, 
+	VoidTransactionCallbackStatusAlpha, 
 	allowUnused, 
 	asAlpha, 
 	asTreeViewAlpha, 
@@ -312,6 +318,7 @@ export {
 	incrementalSummaryHint, 
 	independentInitializedView, 
 	independentView, 
+	minimize, 
 	normalizeAllowedTypes, 
 	persistedToSimpleSchema, 
 	replaceConciseTreeHandles, 

package/src/entrypoints/beta.ts

@@ -120,6 +120,7 @@ export {
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
+	RunTransactionParamsBeta, 
 	SchemaFactoryBeta, 
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
@@ -128,6 +129,11 @@ export {
 	SnapshotSchemaCompatibilityOptions, 
 	System_TableSchema, 
 	TableSchema, 
+	TransactionCallbackStatusBeta, 
+	TransactionResultFailed, 
+	TransactionResultSuccess, 
+	TransactionValueResult, 
+	TransactionVoidResult, 
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
@@ -142,6 +148,8 @@ export {
 	UnannotateAllowedTypesList, 
 	UnannotateAllowedTypesListUnsafe, 
 	UnionToTuple, 
+	VoidTransactionCallbackStatusBeta, 
+	WithValue, 
 	adaptEnum, 
 	asBeta, 
 	configuredSharedTreeBeta, 

package/src/entrypoints/legacy.ts

@@ -120,6 +120,7 @@ export {
 	ObjectSchemaOptions, 
 	PopUnion, 
 	RecordNodeInsertableData, 
+	RunTransactionParamsBeta, 
 	SchemaFactoryBeta, 
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
@@ -128,6 +129,11 @@ export {
 	SnapshotSchemaCompatibilityOptions, 
 	System_TableSchema, 
 	TableSchema, 
+	TransactionCallbackStatusBeta, 
+	TransactionResultFailed, 
+	TransactionResultSuccess, 
+	TransactionValueResult, 
+	TransactionVoidResult, 
 	TreeBeta, 
 	TreeBranch, 
 	TreeChangeEventsBeta, 
@@ -142,6 +148,8 @@ export {
 	UnannotateAllowedTypesList, 
 	UnannotateAllowedTypesListUnsafe, 
 	UnionToTuple, 
+	VoidTransactionCallbackStatusBeta, 
+	WithValue, 
 	adaptEnum, 
 	asBeta, 
 	configuredSharedTreeBeta, 

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

@@ -5,12 +5,9 @@
 
 import { assert, unreachableCase, oob } from "@fluidframework/core-utils/internal";
 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 +16,12 @@ import type {
 	Value,
 	TreeChunk,
 } from "../../../core/index.js";
-import { assertValidIndex, brand } from "../../../util/index.js";
+import {
+	assertValidIndex,
+	brand,
+	decompressIdentifierIfNeeded,
+	type IdDecodingContext,
+} from "../../../util/index.js";
 import { BasicChunk } from "../basicChunk.js";
 import { emptyChunk } from "../emptyChunk.js";
 import { SequenceChunk } from "../sequenceChunk.js";
@@ -39,8 +41,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 +59,6 @@ import {
 	supportsIncrementalEncoding,
 } from "./format/index.js";
 
-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}.
-	 */
-	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.
  */
@@ -281,45 +256,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");