@fluidframework/tree 2.110.0 → 2.111.0

package/src/index.ts

@@ -273,17 +273,21 @@ export {
 	type NodeSchemaMetadata,
 	type SchemaStatics,
 	type ITreeAlpha,
+	type NoChangeConstraint,
+	type NodeInDocumentConstraint,
+	type RunTransactionParamsAlpha,
+	type RunTransactionParamsBeta,
+	type TransactionCallbackStatusAlpha,
+	type TransactionCallbackStatusBeta,
 	type TransactionConstraint,
 	type TransactionConstraintAlpha,
-	type NodeInDocumentConstraint,
-	type NoChangeConstraint,
-	type RunTransactionParams,
-	type VoidTransactionCallbackStatus,
-	type TransactionCallbackStatus,
-	type TransactionResult,
-	type TransactionResultExt,
-	type TransactionResultSuccess,
+	type TransactionPostProcessor,
 	type TransactionResultFailed,
+	type TransactionResultSuccess,
+	type TransactionValueResult,
+	type TransactionVoidResult,
+	type VoidTransactionCallbackStatusAlpha,
+	type VoidTransactionCallbackStatusBeta,
 	rollback,
 	generateSchemaFromSimpleSchema,
 	evaluateLazySchema,
@@ -406,6 +410,7 @@ export { asAlpha, asBeta } from "./api.js";
 export {
 	TextAsTree,
 	FormattedTextAsTree,
+	FormattedTextAsTreeDefault,
 	codePointCount,
 	utf16LengthForCodePoints,
 } from "./text/index.js";

package/src/packageVersion.ts

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

package/src/shared-tree/independentView.ts

@@ -19,9 +19,7 @@ import {
 import {
 	createNodeIdentifierManager,
 	fieldBatchCodecBuilder,
-	type FieldBatchEncodingContext,
-	defaultSchemaPolicy,
-	TreeCompressionStrategy,
+	FieldBatchDecodingContext,
 	defaultIncrementalEncodingPolicy,
 	schemaCodecBuilder,
 } from "../feature-libraries/index.js";
@@ -233,14 +231,11 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 		const fieldBatchCodec = fieldBatchCodecBuilder.buildDecoder(options);
 		const newSchema = schemaCodec.decode(options.content.schema);
 
-		const context: FieldBatchEncodingContext = {
-			encodeType: TreeCompressionStrategy.Compressed,
+		// TreeAlpha.exportCompressed encodes this payload in originatorless-safe form
+		// (finalized compressed ids or strings), so summary-style decode is correct.
+		const context = FieldBatchDecodingContext.forSummary({
 			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,
 			context,

package/src/shared-tree/index.ts

@@ -30,6 +30,7 @@ export {
 	TreeCheckout,
 	type ITreeCheckout,
 	type CheckoutEvents,
+	type TreeTransactor,
 } from "./treeCheckout.js";
 
 export { SchematizingSimpleTreeView } from "./schematizingTreeView.js";

package/src/shared-tree/schematizingTreeView.ts

@@ -41,11 +41,11 @@ import {
 	type ReadSchema,
 	type UnsafeUnknownSchema,
 	type TreeBranchEvents,
-	type VoidTransactionCallbackStatus,
-	type TransactionCallbackStatus,
-	type TransactionResult,
-	type TransactionResultExt,
-	type RunTransactionParams,
+	type VoidTransactionCallbackStatusAlpha,
+	type TransactionCallbackStatusAlpha,
+	type TransactionVoidResult,
+	type TransactionValueResult,
+	type RunTransactionParamsAlpha,
 	HydratedContext,
 	SimpleContextSlot,
 	areImplicitFieldSchemaEqual,
@@ -272,40 +272,40 @@ export class SchematizingSimpleTreeView<
 	}
 
 	public runTransaction<TSuccessValue, TFailureValue>(
-		transaction: () => TransactionCallbackStatus<TSuccessValue, TFailureValue>,
-		params?: RunTransactionParams,
-	): TransactionResultExt<TSuccessValue, TFailureValue>;
+		transaction: () => TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>,
+		params?: RunTransactionParamsAlpha,
+	): TransactionValueResult<TSuccessValue, TFailureValue>;
 	public runTransaction(
-		transaction: () => VoidTransactionCallbackStatus | void,
-		params?: RunTransactionParams,
-	): TransactionResult;
+		transaction: () => VoidTransactionCallbackStatusAlpha | void,
+		params?: RunTransactionParamsAlpha,
+	): TransactionVoidResult;
 	public runTransaction<TSuccessValue, TFailureValue>(
 		transaction: () =>
-			| TransactionCallbackStatus<TSuccessValue, TFailureValue>
-			| VoidTransactionCallbackStatus
+			| TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>
+			| VoidTransactionCallbackStatusAlpha
 			| void,
-		params?: RunTransactionParams,
-	): TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult {
+		params?: RunTransactionParamsAlpha,
+	): TransactionValueResult<TSuccessValue, TFailureValue> | TransactionVoidResult {
 		this.ensureUndisposed();
 		return this.checkout.runTransaction(transaction, params);
 	}
 
 	public runTransactionAsync<TSuccessValue, TFailureValue>(
-		transaction: () => Promise<TransactionCallbackStatus<TSuccessValue, TFailureValue>>,
-		params?: RunTransactionParams,
-	): Promise<TransactionResultExt<TSuccessValue, TFailureValue>>;
+		transaction: () => Promise<TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>>,
+		params?: RunTransactionParamsAlpha,
+	): Promise<TransactionValueResult<TSuccessValue, TFailureValue>>;
 	public runTransactionAsync(
-		transaction: () => Promise<VoidTransactionCallbackStatus | void>,
-		params?: RunTransactionParams,
-	): Promise<TransactionResult>;
+		transaction: () => Promise<VoidTransactionCallbackStatusAlpha | void>,
+		params?: RunTransactionParamsAlpha,
+	): Promise<TransactionVoidResult>;
 	public async runTransactionAsync<TSuccessValue, TFailureValue>(
 		transaction: () => Promise<
-			| TransactionCallbackStatus<TSuccessValue, TFailureValue>
-			| VoidTransactionCallbackStatus
+			| TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>
+			| VoidTransactionCallbackStatusAlpha
 			| void
 		>,
-		params: RunTransactionParams | undefined,
-	): Promise<TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult> {
+		params: RunTransactionParamsAlpha | undefined,
+	): Promise<TransactionValueResult<TSuccessValue, TFailureValue> | TransactionVoidResult> {
 		this.ensureUndisposed();
 		if (this.checkout.transaction.size > 0) {
 			// breaker.break() sets brokenBy synchronously before throwing.

package/src/shared-tree/sharedTree.ts

@@ -45,6 +45,7 @@ import {
 } from "../core/index.js";
 import {
 	DetachedFieldIndexSummarizer,
+	FieldBatchDecodingContext,
 	FieldKinds,
 	ForestSummarizer,
 	SchemaSummarizer,
@@ -58,6 +59,7 @@ import {
 	jsonableTreeFromFieldCursor,
 	makeMitigatedChangeFamily,
 	makeTreeChunker,
+	type FieldBatchEncodingContext,
 	type IncrementalEncodingPolicy,
 } from "../feature-libraries/index.js";
 import { schemaCodecBuilder } from "../feature-libraries/index.js";
@@ -235,24 +237,29 @@ export class SharedTreeKernel
 		);
 		const fieldBatchCodec = fieldBatchCodecBuilder.build(options);
 
-		const encoderContext = {
+		const encoderContext: FieldBatchEncodingContext = {
 			schema: {
 				schema,
 				policy: defaultSchemaPolicy,
 			},
 			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 decoderContext = FieldBatchDecodingContext.forSummary({
+			idCompressor,
+			healing:
+				options.healUnresolvableIdentifiersOnDecode === true
+					? { sharedObjectId: sharedObject.id }
+					: undefined,
+		});
 		const forestSummarizer = new ForestSummarizer(
 			forest,
 			revisionTagCodec,
 			encoderContext,
+			decoderContext,
 			options,
 			idCompressor,
 			initialSequenceNumber,
@@ -603,6 +610,11 @@ export interface SharedTreeOptionsBeta extends ForestOptions, Partial<CodecWrite
 	 * "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.
+	 *
+	 * Internally this boolean is translated into {@link IdentifierHealingConfig} once the shared-object
+	 * id is known (in `SharedTreeCore`'s constructor) and threaded through the codec contexts as a
+	 * single `healing?` field from there on. The presence/absence of that config is the heal-on/heal-off
+	 * discriminator inside the codec layer.
 	 */
 	readonly healUnresolvableIdentifiersOnDecode?: boolean;
 }

package/src/shared-tree/transactionPostProcessor.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { ChangeProcessor } from "../shared-tree-core/index.js";
+import type { TransactionPostProcessor } from "../simple-tree/index.js";
+
+import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
+
+/**
+ * The internal representation of a {@link TransactionPostProcessor}: a {@link ChangeProcessor} over
+ * {@link SharedTreeChange}.
+ * @remarks This is the (non-type-erased) form used internally to apply a transaction's post-processor.
+ */
+export type TransactionPostProcessorInternal = ChangeProcessor<SharedTreeChange>;
+
+/**
+ * Type-erases an internal {@link TransactionPostProcessorInternal | change processor} as a public
+ * {@link TransactionPostProcessor}.
+ * @remarks This is the only sanctioned way to produce a {@link TransactionPostProcessor}. The inverse conversion is
+ * {@link extractTransactionChangeProcessor}.
+ */
+export function createTransactionPostProcessor(
+	processor: TransactionPostProcessorInternal,
+): TransactionPostProcessor {
+	return processor as unknown as TransactionPostProcessor;
+}
+
+/**
+ * Recovers the internal {@link TransactionPostProcessorInternal | change processor} from a type-erased
+ * {@link TransactionPostProcessor}.
+ * @remarks This reverses {@link createTransactionPostProcessor}. It is assumed that only code which produces these
+ * type-erased handles performs this conversion, allowing them to be treated as opaque elsewhere.
+ */
+export function extractTransactionChangeProcessor(
+	postProcessor: TransactionPostProcessor | undefined,
+): TransactionPostProcessorInternal | undefined {
+	return postProcessor as unknown as TransactionPostProcessorInternal;
+}

package/src/shared-tree/treeAlpha.ts

@@ -952,10 +952,10 @@ export const TreeAlpha: TreeAlpha = {
 		const context: FieldBatchEncodingContext = {
 			encodeType: TreeCompressionStrategy.Compressed,
 			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,
+			// Encode using summary-style identifier rules so the payload can be decoded
+			// without any originator session context.
+			isSummary: true,
 		};
 		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

@@ -76,6 +76,7 @@ import {
 	SharedTreeBranch,
 	TransactionResult as InternalTransactionResult,
 	type SharedTreeBranchChange,
+	type SquashingTransactionOptions,
 	type Transactor,
 } from "../shared-tree-core/index.js";
 import {
@@ -88,11 +89,11 @@ import {
 	type TreeBranch,
 	type TreeBranchAlpha,
 	type VerboseTree,
-	type VoidTransactionCallbackStatus,
-	type TransactionCallbackStatus,
-	type TransactionResult,
-	type TransactionResultExt,
-	type RunTransactionParams,
+	type VoidTransactionCallbackStatusAlpha,
+	type TransactionCallbackStatusAlpha,
+	type TransactionVoidResult,
+	type TransactionValueResult,
+	type RunTransactionParamsAlpha,
 	type TransactionConstraintAlpha,
 	type TreeViewAlpha,
 	getInnerNode,
@@ -117,6 +118,7 @@ import { SharedTreeChangeEnricher } from "./sharedTreeChangeEnricher.js";
 import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { ISharedTreeEditor, SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import { extractTransactionChangeProcessor } from "./transactionPostProcessor.js";
 
 /**
  * Yields all defined (non-`undefined`) labels from a {@link LabelTree}, depth-first.
@@ -205,6 +207,11 @@ export interface CheckoutEvents {
 	dispose(): void;
 }
 
+/**
+ * A collection of functions for managing transactions on a {@link ITreeCheckout}.
+ */
+export type TreeTransactor = Transactor<SquashingTransactionOptions<SharedTreeChange>>;
+
 /**
  * Provides a means for interacting with a SharedTree.
  * This includes reading data from the tree and running transactions to mutate the tree.
@@ -251,13 +258,13 @@ export interface ITreeCheckout
 	/**
 	 * A collection of functions for managing transactions.
 	 */
-	readonly transaction: Transactor;
+	readonly transaction: TreeTransactor;
 
 	fork(): ITreeCheckout;
 
 	/**
-	 * 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.
 	 *
 	 * @param newSchema - The new schema to replace the existing schema.
 	 * @param allowNonSupersetSchema - Whether to allow non-superset schemas.
@@ -390,7 +397,7 @@ function getCheckout(context: TreeBranch): TreeCheckout {
  * @param constraintsOnRevert - If true, use {@link ISharedTreeEditor.addNodeExistsConstraintOnRevert}.
  * @param constraints - The constraints to add to the transaction.
  *
- * @see {@link RunTransactionParams.preconditions}.
+ * @see {@link RunTransactionParamsAlpha.preconditions}.
  */
 export function addConstraintsToTransaction(
 	checkout: ITreeCheckout,
@@ -483,9 +490,9 @@ export class TreeCheckout implements ITreeCheckout {
 	private readonly views = new Set<TreeView<ImplicitFieldSchema>>();
 
 	/**
-	 * Set of revertibles maintained for automatic disposal
+	 * Revertibles maintained for automatic disposal
 	 */
-	private readonly revertibles = new Set<RevertibleAlpha>();
+	private readonly revertibles = new Map<RevisionTag, RevertibleAlpha>();
 
 	/**
 	 * Each branch's head commit corresponds to a revertible commit.
@@ -746,7 +753,7 @@ export class TreeCheckout implements ITreeCheckout {
 								revision,
 								this.#transaction.activeBranch.fork(commit),
 							);
-							this.revertibles.add(revertible);
+							this.revertibles.set(revision, revertible);
 							return revertible;
 						};
 
@@ -785,6 +792,11 @@ export class TreeCheckout implements ITreeCheckout {
 				});
 				withinEventContext = false;
 			}
+		} else if (event.type === "remove") {
+			// Commits that are rolled back should no longer be revertible
+			for (const commit of event.removedCommits) {
+				this.revertibles.get(commit.revision)?.dispose();
+			}
 		} else if (this.isRemoteChangeEvent(event)) {
 			// TODO: figure out how to plumb through commit kind info for remote changes
 			this.emitChangedLocked(() => {
@@ -885,49 +897,52 @@ export class TreeCheckout implements ITreeCheckout {
 	}
 
 	public runTransaction<TSuccessValue, TFailureValue>(
-		transaction: () => TransactionCallbackStatus<TSuccessValue, TFailureValue>,
-		params?: RunTransactionParams,
-	): TransactionResultExt<TSuccessValue, TFailureValue>;
+		transaction: () => TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>,
+		params?: RunTransactionParamsAlpha,
+	): TransactionValueResult<TSuccessValue, TFailureValue>;
 	public runTransaction(
-		transaction: () => VoidTransactionCallbackStatus | void,
-		params?: RunTransactionParams,
-	): TransactionResult;
+		transaction: () => VoidTransactionCallbackStatusAlpha | void,
+		params?: RunTransactionParamsAlpha,
+	): TransactionVoidResult;
 	@breakingMethod
 	public runTransaction<TSuccessValue, TFailureValue>(
 		transaction: () =>
-			| TransactionCallbackStatus<TSuccessValue, TFailureValue>
-			| VoidTransactionCallbackStatus
+			| TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>
+			| VoidTransactionCallbackStatusAlpha
 			| void,
-		params?: RunTransactionParams,
-	): TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult {
+		params?: RunTransactionParamsAlpha,
+	): TransactionValueResult<TSuccessValue, TFailureValue> | TransactionVoidResult {
 		this.mountTransaction(params, false);
 		const transactionCallbackStatus = transaction();
 		return this.unmountTransaction(transactionCallbackStatus, params);
 	}
 
 	public runTransactionAsync<TSuccessValue, TFailureValue>(
-		transaction: () => Promise<TransactionCallbackStatus<TSuccessValue, TFailureValue>>,
-		params?: RunTransactionParams,
-	): Promise<TransactionResultExt<TSuccessValue, TFailureValue>>;
+		transaction: () => Promise<TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>>,
+		params?: RunTransactionParamsAlpha,
+	): Promise<TransactionValueResult<TSuccessValue, TFailureValue>>;
 	public runTransactionAsync(
-		transaction: () => Promise<VoidTransactionCallbackStatus | void>,
-		params?: RunTransactionParams,
-	): Promise<TransactionResult>;
+		transaction: () => Promise<VoidTransactionCallbackStatusAlpha | void>,
+		params?: RunTransactionParamsAlpha,
+	): Promise<TransactionVoidResult>;
 	@breakingMethod
 	public async runTransactionAsync<TSuccessValue, TFailureValue>(
 		transaction: () => Promise<
-			| TransactionCallbackStatus<TSuccessValue, TFailureValue>
-			| VoidTransactionCallbackStatus
+			| TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>
+			| VoidTransactionCallbackStatusAlpha
 			| void
 		>,
-		params: RunTransactionParams | undefined,
-	): Promise<TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult> {
+		params: RunTransactionParamsAlpha | undefined,
+	): Promise<TransactionValueResult<TSuccessValue, TFailureValue> | TransactionVoidResult> {
 		this.mountTransaction(params, true);
 		const transactionCallbackStatus = await transaction();
 		return this.unmountTransaction(transactionCallbackStatus, params);
 	}
 
-	private mountTransaction(params: RunTransactionParams | undefined, isAsync: boolean): void {
+	private mountTransaction(
+		params: RunTransactionParamsAlpha | undefined,
+		isAsync: boolean,
+	): void {
 		this.checkNotDisposed();
 		// Starting a transaction is an edit, so it is forbidden from within a change-event
 		// callback (where the edit lock is held), the same as direct edits. For the async
@@ -944,22 +959,24 @@ export class TreeCheckout implements ITreeCheckout {
 			);
 		}
 		this.pushLabelFrame(params?.label);
-		this.transaction.start();
+		this.transaction.start({
+			postProcessor: extractTransactionChangeProcessor(params?.postProcessor),
+		});
 
 		addConstraintsToTransaction(this, false, params?.preconditions);
 	}
 
 	private unmountTransaction<TSuccessValue, TFailureValue>(
 		transactionCallbackStatus:
-			| TransactionCallbackStatus<TSuccessValue, TFailureValue>
-			| VoidTransactionCallbackStatus
+			| TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>
+			| VoidTransactionCallbackStatusAlpha
 			| void,
-		params: RunTransactionParams | undefined,
-	): TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult {
+		params: RunTransactionParamsAlpha | undefined,
+	): TransactionValueResult<TSuccessValue, TFailureValue> | TransactionVoidResult {
 		this.checkNotDisposed();
 		const rollback = transactionCallbackStatus?.rollback;
 		const value = (
-			transactionCallbackStatus as TransactionCallbackStatus<TSuccessValue, TFailureValue>
+			transactionCallbackStatus as TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>
 		)?.value;
 
 		if (rollback === true) {
@@ -1127,7 +1144,7 @@ export class TreeCheckout implements ITreeCheckout {
 						"Unable to dispose a revertible that has already been disposed.",
 					);
 				}
-				checkout.disposeRevertible(revertible, revision);
+				checkout.disposeRevertible(revision);
 				onRevertibleDisposed?.(revertible);
 			},
 		};
@@ -1175,7 +1192,7 @@ export class TreeCheckout implements ITreeCheckout {
 		return this.forest.anchors.locate(anchor);
 	}
 
-	public get transaction(): Transactor {
+	public get transaction(): TreeTransactor {
 		return this.#transaction;
 	}
 	/**
@@ -1380,15 +1397,15 @@ export class TreeCheckout implements ITreeCheckout {
 	}
 
 	private purgeRevertibles(): void {
-		for (const revertible of this.revertibles) {
+		for (const revertible of this.revertibles.values()) {
 			revertible.dispose();
 		}
 	}
 
-	private disposeRevertible(revertible: RevertibleAlpha, revision: RevisionTag): void {
+	private disposeRevertible(revision: RevisionTag): void {
 		this.revertibleCommitBranches.get(revision)?.dispose();
 		this.revertibleCommitBranches.delete(revision);
-		this.revertibles.delete(revertible);
+		this.revertibles.delete(revision);
 	}
 
 	private revertRevertible(

package/src/shared-tree/unhydratedTreeContext.ts

@@ -8,9 +8,9 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import type {
 	TreeContextAlpha,
 	TreeBranchAlpha,
-	RunTransactionParams,
-	TransactionResult,
-	TransactionResultExt,
+	RunTransactionParamsAlpha,
+	TransactionVoidResult,
+	TransactionValueResult,
 	WithValue,
 } from "../simple-tree/index.js";
 
@@ -30,13 +30,16 @@ export class UnhydratedTreeContext implements TreeContextAlpha {
 
 	public runTransaction<TValue>(
 		t: () => WithValue<TValue>,
-		params?: RunTransactionParams,
-	): TransactionResultExt<TValue, TValue>;
-	public runTransaction(t: () => void, _params?: RunTransactionParams): TransactionResult;
+		params?: RunTransactionParamsAlpha,
+	): TransactionValueResult<TValue, TValue>;
+	public runTransaction(
+		t: () => void,
+		_params?: RunTransactionParamsAlpha,
+	): TransactionVoidResult;
 	public runTransaction(
 		t: () => WithValue<unknown> | void,
-		params?: RunTransactionParams,
-	): TransactionResultExt<unknown, unknown> | TransactionResult {
+		params?: RunTransactionParamsAlpha,
+	): TransactionValueResult<unknown, unknown> | TransactionVoidResult {
 		for (const constraint of params?.preconditions ?? []) {
 			assertValidConstraint(constraint, false);
 		}
@@ -50,16 +53,16 @@ export class UnhydratedTreeContext implements TreeContextAlpha {
 
 	public runTransactionAsync<TValue>(
 		t: () => Promise<WithValue<TValue>>,
-		params?: RunTransactionParams,
-	): Promise<TransactionResultExt<TValue, TValue>>;
+		params?: RunTransactionParamsAlpha,
+	): Promise<TransactionValueResult<TValue, TValue>>;
 	public runTransactionAsync(
 		t: () => Promise<void>,
-		params?: RunTransactionParams,
-	): Promise<TransactionResult>;
+		params?: RunTransactionParamsAlpha,
+	): Promise<TransactionVoidResult>;
 	public async runTransactionAsync(
 		t: () => Promise<WithValue<unknown> | void>,
-		params?: RunTransactionParams,
-	): Promise<TransactionResultExt<unknown, unknown> | TransactionResult> {
+		params?: RunTransactionParamsAlpha,
+	): Promise<TransactionValueResult<unknown, unknown> | TransactionVoidResult> {
 		if (this.transactionCount > 0) {
 			throw new UsageError(
 				"An asynchronous transaction cannot be started while another transaction is already in progress.",
@@ -78,7 +81,7 @@ export class UnhydratedTreeContext implements TreeContextAlpha {
 
 	private static wrapTransactionResult<TValue>(
 		value: WithValue<TValue> | void,
-	): TransactionResultExt<TValue, TValue> | TransactionResult {
+	): TransactionValueResult<TValue, TValue> | TransactionVoidResult {
 		if (value?.value !== undefined) {
 			return { success: true, value: value.value };
 		}

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

@@ -24,6 +24,7 @@ import type {
 	RevisionTag,
 	SchemaAndPolicy,
 } from "../core/index.js";
+import type { IdentifierHealingConfig } from "../util/index.js";
 
 import type { SummaryData } from "./editManager.js";
 import { makeV1toV4andV6CodecWithVersion } from "./editManagerCodecsV1toV4.js";
@@ -37,8 +38,8 @@ export interface EditManagerEncodingContext {
 	idCompressor: IIdCompressor;
 	readonly schema?: SchemaAndPolicy;
 	readonly isSummary: boolean;
-	readonly healUnresolvableIdentifiersOnDecode?: boolean;
-	readonly sharedObjectId?: string;
+	/** See {@link IdentifierHealingConfig}. */
+	readonly healing?: IdentifierHealingConfig;
 }
 
 /**

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

@@ -13,7 +13,12 @@ import type {
 	RevisionTag,
 	SchemaAndPolicy,
 } from "../core/index.js";
-import { mapIterable, type JsonCompatibleReadOnly, type Mutable } from "../util/index.js";
+import {
+	mapIterable,
+	type IdentifierHealingConfig,
+	type JsonCompatibleReadOnly,
+	type Mutable,
+} from "../util/index.js";
 
 import { decodeBranchId, encodeBranchId } from "./branchIdCodec.js";
 import type { SharedBranchSummaryData } from "./editManager.js";
@@ -34,14 +39,8 @@ export interface EditManagerEncodingContext {
 	 * 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;
+	/** See {@link IdentifierHealingConfig}. */
+	readonly healing?: IdentifierHealingConfig;
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -207,8 +206,7 @@ export function decodeSharedBranch<TChangeset>(
 					idCompressor: context.idCompressor,
 					revision: undefined,
 					isSummary: context.isSummary,
-					healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
-					sharedObjectId: context.sharedObjectId,
+					healing: context.healing,
 				}),
 		),
 		peerLocalBranches: new Map(
@@ -232,9 +230,7 @@ export function decodeSharedBranch<TChangeset>(
 								idCompressor: context.idCompressor,
 								revision: undefined,
 								isSummary: context.isSummary,
-								healUnresolvableIdentifiersOnDecode:
-									context.healUnresolvableIdentifiersOnDecode,
-								sharedObjectId: context.sharedObjectId,
+								healing: context.healing,
 							},
 						),
 					),