@fluidframework/tree 2.81.1 → 2.83.0

package/src/shared-tree/treeCheckout.ts

@@ -388,6 +388,14 @@ export class TreeCheckout implements ITreeCheckoutFork {
 
 	private editLock: EditLock;
 
+	/**
+	 * User-defined label associated with the transaction whose commit is currently being produced for this checkout.
+	 *
+	 * @remarks
+	 * This label is used to implement {@link TreeCheckout.runWithTransactionLabel}.
+	 */
+	private transactionLabel?: unknown;
+
 	private readonly views = new Set<TreeView<ImplicitFieldSchema>>();
 
 	/**
@@ -439,6 +447,34 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		this.registerForBranchEvents();
 	}
 
+	/**
+	 * Helper method for {@link SchematizingSimpleTreeView.runTransaction} to properly clear transaction labels once the function completes.
+	 *
+	 * @remarks
+	 * The label is stored during the execution of the function and will be included in the {@link ChangeMetadata} of the transaction.
+	 *
+	 * Labels supplied to nested transactions are ignored - only the outermost transaction label is ever used.
+	 *
+	 * @param fn - The function to execute. It receives the user provided transaction label as an optional parameter.
+	 * @param label - The label to associate with the outermost transaction.
+	 * @returns The result of executing `fn`.
+	 */
+	public runWithTransactionLabel<TLabel, TResult>(
+		fn: (label?: TLabel) => TResult,
+		label: TLabel | undefined,
+	): TResult {
+		// If a transaction label is already set, nesting is occurring, so we should not override it.
+		if (this.transactionLabel !== undefined) {
+			return fn(this.transactionLabel as TLabel);
+		}
+		this.transactionLabel = label;
+		try {
+			return fn(this.transactionLabel as TLabel);
+		} finally {
+			this.transactionLabel = undefined;
+		}
+	}
+
 	public get removedRoots(): ReadOnlyDetachedFieldIndex {
 		return this._removedRoots;
 	}
@@ -464,16 +500,23 @@ export class TreeCheckout implements ITreeCheckoutFork {
 				: undefined;
 			// When each transaction is started, make a restorable checkpoint of the current state of removed roots
 			const restoreRemovedRoots = this._removedRoots.createCheckpoint();
-			return (result) => {
+			return (result, viewUpdate: SharedTreeChange | undefined) => {
+				const newHead = this.#transaction.branch.getHead();
 				switch (result) {
 					case TransactionResult.Abort: {
 						restoreRemovedRoots();
+						if (viewUpdate !== undefined) {
+							this.applyChange(viewUpdate, newHead.revision);
+						}
 						break;
 					}
 					case TransactionResult.Commit: {
+						if (viewUpdate !== undefined) {
+							this.applyChange(viewUpdate, newHead.revision);
+						}
 						if (!this.transaction.isInProgress()) {
 							// The changes in a transaction squash commit have already applied to the checkout and are known to be valid, so we can validate the squash commit automatically.
-							this.validateCommit(this.#transaction.branch.getHead());
+							this.validateCommit(newHead);
 						}
 						break;
 					}
@@ -554,9 +597,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 							originatorId: this.idCompressor.localSessionId,
 							revision,
 						};
-						const encodedChange = this.changeFamily.codecs
-							.resolve(4)
-							.json.encode(change, context);
+						const encodedChange = this.changeFamily.codecs.resolve(4).encode(change, context);
 
 						assert(
 							commit.parent !== undefined,
@@ -570,6 +611,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 						} satisfies SerializedChange;
 					},
 					getRevertible: (onDisposed) => getRevertible?.(onDisposed),
+					label: this.transactionLabel,
 				};
 
 				this.#events.emit("changed", metadata, getRevertible);
@@ -577,7 +619,10 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			}
 		} else if (this.isRemoteChangeEvent(event)) {
 			// TODO: figure out how to plumb through commit kind info for remote changes
-			this.#events.emit("changed", { isLocal: false, kind: CommitKind.Default });
+			this.#events.emit("changed", {
+				isLocal: false,
+				kind: CommitKind.Default,
+			});
 		}
 	};
 
@@ -619,7 +664,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			originatorId: this.idCompressor.localSessionId,
 			revision,
 		};
-		const decodedChange = this.changeFamily.codecs.resolve(4).json.decode(change, context);
+		const decodedChange = this.changeFamily.codecs.resolve(4).decode(change, context);
 		this.applyChange(decodedChange, revision);
 	}
 

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

@@ -6,7 +6,7 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 
-import type { IJsonCodec, IMultiFormatCodec } from "../codec/index.js";
+import type { IJsonCodec } from "../codec/index.js";
 import type {
 	ChangeEncodingContext,
 	EncodedRevisionTag,
@@ -32,7 +32,7 @@ export interface EditManagerEncodingContext {
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function encodeCommit<TChangeset, T extends Commit<TChangeset>>(
-	changeCodec: IMultiFormatCodec<
+	changeCodec: IJsonCodec<
 		TChangeset,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,
@@ -54,13 +54,13 @@ function encodeCommit<TChangeset, T extends Commit<TChangeset>>(
 			idCompressor: context.idCompressor,
 			revision: undefined,
 		}),
-		change: changeCodec.json.encode(commit.change, { ...context, revision: commit.revision }),
+		change: changeCodec.encode(commit.change, { ...context, revision: commit.revision }),
 	};
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function decodeCommit<TChangeset, T extends EncodedCommit<JsonCompatibleReadOnly>>(
-	changeCodec: IMultiFormatCodec<
+	changeCodec: IJsonCodec<
 		TChangeset,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,
@@ -84,12 +84,12 @@ function decodeCommit<TChangeset, T extends EncodedCommit<JsonCompatibleReadOnly
 	return {
 		...commit,
 		revision,
-		change: changeCodec.json.decode(commit.change, { ...context, revision }),
+		change: changeCodec.decode(commit.change, { ...context, revision }),
 	};
 }
 
 export function encodeSharedBranch<TChangeset>(
-	changeCodec: IMultiFormatCodec<
+	changeCodec: IJsonCodec<
 		TChangeset,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,
@@ -160,7 +160,7 @@ export function encodeSharedBranch<TChangeset>(
 }
 
 export function decodeSharedBranch<TChangeset>(
-	changeCodec: IMultiFormatCodec<
+	changeCodec: IJsonCodec<
 		TChangeset,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,

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

@@ -5,12 +5,7 @@
 
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-import {
-	type ICodecOptions,
-	type IJsonCodec,
-	type IMultiFormatCodec,
-	withSchemaValidation,
-} from "../codec/index.js";
+import { type ICodecOptions, type IJsonCodec, withSchemaValidation } from "../codec/index.js";
 import type {
 	ChangeEncodingContext,
 	EncodedRevisionTag,
@@ -29,7 +24,7 @@ export interface EditManagerEncodingContext {
 }
 
 export function makeV1CodecWithVersion<TChangeset>(
-	changeCodec: IMultiFormatCodec<
+	changeCodec: IJsonCodec<
 		TChangeset,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,
@@ -49,9 +44,7 @@ export function makeV1CodecWithVersion<TChangeset>(
 	JsonCompatibleReadOnly,
 	EditManagerEncodingContext
 > {
-	const format = EncodedEditManager(
-		changeCodec.json.encodedSchema ?? JsonCompatibleReadOnlySchema,
-	);
+	const format = EncodedEditManager(changeCodec.encodedSchema ?? JsonCompatibleReadOnlySchema);
 
 	const codec: IJsonCodec<
 		SummaryData<TChangeset>,

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

@@ -6,12 +6,7 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-import {
-	type ICodecOptions,
-	type IJsonCodec,
-	type IMultiFormatCodec,
-	withSchemaValidation,
-} from "../codec/index.js";
+import { type ICodecOptions, type IJsonCodec, withSchemaValidation } from "../codec/index.js";
 import type {
 	ChangeEncodingContext,
 	EncodedRevisionTag,
@@ -36,7 +31,7 @@ export interface EditManagerEncodingContext {
 }
 
 export function makeSharedBranchesCodecWithVersion<TChangeset>(
-	changeCodec: IMultiFormatCodec<
+	changeCodec: IJsonCodec<
 		TChangeset,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,
@@ -56,9 +51,7 @@ export function makeSharedBranchesCodecWithVersion<TChangeset>(
 	JsonCompatibleReadOnly,
 	EditManagerEncodingContext
 > {
-	const format = EncodedEditManager(
-		changeCodec.json.encodedSchema ?? JsonCompatibleReadOnlySchema,
-	);
+	const format = EncodedEditManager(changeCodec.encodedSchema ?? JsonCompatibleReadOnlySchema);
 
 	const codec: IJsonCodec<
 		SummaryData<TChangeset>,

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

@@ -126,7 +126,7 @@ export class EditManagerSummarizer<TChangeset>
 			0x42c /* There should not already be stored EditManager data when loading from summary */,
 		);
 
-		const summary = parse(bufferToString(schemaBuffer, "utf-8")) as JsonCompatibleReadOnly;
+		const summary = parse(bufferToString(schemaBuffer, "utf8")) as JsonCompatibleReadOnly;
 		const data = this.codec.decode(summary, { idCompressor: this.idCompressor });
 		this.editManager.loadSummaryData(data);
 	}

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

@@ -4,7 +4,7 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { type TAnySchema, Type } from "@sinclair/typebox";
+import type { TAnySchema } from "@sinclair/typebox";
 
 import { type ICodecOptions, type IJsonCodec, withSchemaValidation } from "../codec/index.js";
 import type {
@@ -14,6 +14,7 @@ import type {
 	RevisionTag,
 } from "../core/index.js";
 import type { JsonCompatibleReadOnly } from "../util/index.js";
+import { JsonCompatibleReadOnlySchema } from "../util/index.js";
 
 import type { MessageEncodingContext } from "./messageCodecs.js";
 import type { MessageFormatVersion } from "./messageFormat.js";
@@ -43,12 +44,12 @@ export function makeV1ToV4CodecWithVersion<TChangeset>(
 > {
 	return withSchemaValidation<
 		DecodedMessage<TChangeset>,
-		TAnySchema,
+		TAnySchema | typeof JsonCompatibleReadOnlySchema,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,
 		MessageEncodingContext
 	>(
-		Message(changeCodec.encodedSchema ?? Type.Any()),
+		Message(changeCodec.encodedSchema ?? JsonCompatibleReadOnlySchema),
 		{
 			encode: (decoded: DecodedMessage<TChangeset>, context: MessageEncodingContext) => {
 				assert(decoded.type === "commit", 0xc68 /* Only commit messages are supported */);

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

@@ -146,9 +146,7 @@ export function makeMessageCodecs<TChangeset>(
 			case unbrand(MessageFormatVersion.v3):
 			case unbrand(MessageFormatVersion.v4):
 			case unbrand(MessageFormatVersion.v6): {
-				const changeCodec = changeCodecs.resolve(
-					dependentChangeFormatVersion.lookup(version),
-				).json;
+				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
 					version,
 					makeV1ToV4CodecWithVersion(changeCodec, revisionTagCodec, options, version),
@@ -158,9 +156,7 @@ export function makeMessageCodecs<TChangeset>(
 				return [version, makeDiscontinuedCodecVersion(options, version, "2.74.0")];
 			}
 			case unbrand(MessageFormatVersion.vSharedBranches): {
-				const changeCodec = changeCodecs.resolve(
-					dependentChangeFormatVersion.lookup(version),
-				).json;
+				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
 					version,
 					makeSharedBranchesCodecWithVersion(changeCodec, revisionTagCodec, options, version),

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

@@ -9,13 +9,17 @@ import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
+	diffHistories,
 	findAncestor,
+	findCommonAncestor,
+	mintCommit,
+	rebaseBranch,
 	tagChange,
 	type ChangeFamilyEditor,
 	type GraphCommit,
 	type RevisionTag,
 } from "../core/index.js";
-import { getLast, getOrCreate, hasSome } from "../util/index.js";
+import { getLast, getOrCreate } from "../util/index.js";
 
 import type { SharedTreeBranch, SharedTreeBranchEvents } from "./branch.js";
 
@@ -42,6 +46,8 @@ export interface Transactor {
 	 * Start a new transaction.
 	 * If a transaction is already in progress when this new transaction starts, then this transaction will be "nested" inside of it,
 	 * i.e. the outer transaction will still be in progress after this new transaction is committed or aborted.
+	 * @param isAsync - Whether the transaction is asynchronous.
+	 * An error will be thrown if an asynchronous transaction is started while a synchronous transaction is in progress.
 	 *
 	 * @remarks Asynchronous transactions are not supported on the root checkout,
 	 * since it is always kept up-to-date with the latest remote edits and the results of this rebasing (which might invalidate
@@ -55,7 +61,7 @@ export interface Transactor {
 	 * @privateRemarks There is currently no enforcement that asynchronous transactions don't happen on the root checkout.
 	 * AB#6488 tracks adding some enforcement to make it more clear to application authors that this is not supported.
 	 */
-	start(): void;
+	start(isAsync: boolean): void;
 	/**
 	 * Close this transaction by squashing its edits and committing them as a single edit.
 	 * If this is the root checkout and there are no ongoing transactions remaining, the squashed edit will be submitted to Fluid.
@@ -126,12 +132,22 @@ export type OnPush = () => Callbacks | void;
  */
 export type OnPop = (result: TransactionResult) => void;
 
+/**
+ * A frame in the transaction stack.
+ */
+interface TransactionStackFrame {
+	/** The callbacks provided when this transaction frame was pushed onto the stack. */
+	readonly callbacks: Callbacks;
+	/** Whether this transaction frame is asynchronous. */
+	readonly isAsync: boolean;
+}
+
 /**
  * An implementation of {@link Transactor} that uses a stack to manage transactions.
  * @remarks Using a stack allows transactions to nest - i.e. an inner transaction may be started while an outer transaction is already in progress.
  */
 export class TransactionStack implements Transactor, IDisposable {
-	readonly #stack: Callbacks[] = [];
+	readonly #stack: TransactionStackFrame[] = [];
 	readonly #onPush?: OnPush;
 
 	readonly #events = createEmitter<TransactionEvents>();
@@ -157,11 +173,20 @@ export class TransactionStack implements Transactor, IDisposable {
 		return this.#stack.length > 0;
 	}
 
-	public start(): void {
+	public start(isAsync: boolean): void {
 		this.ensureNotDisposed();
-		const onPushCurrent = hasSome(this.#stack) ? getLast(this.#stack).onPush : this.#onPush;
+		const last = getLast(this.#stack);
+		if (last !== undefined && !last.isAsync && isAsync) {
+			throw new UsageError(
+				"An asynchronous transaction cannot be started while a synchronous transaction is in progress.",
+			);
+		}
+		const onPushCurrent = last === undefined ? this.#onPush : last.callbacks.onPush;
 		const { onPush, onPop } = onPushCurrent?.() ?? {};
-		this.#stack.push({ onPop, onPush: onPush ?? onPushCurrent });
+		this.#stack.push({
+			callbacks: { onPop, onPush: onPush ?? onPushCurrent },
+			isAsync,
+		});
 		this.#events.emit("started");
 	}
 
@@ -171,7 +196,7 @@ export class TransactionStack implements Transactor, IDisposable {
 			throw new UsageError("No transaction to commit");
 		}
 		this.#events.emit("committing");
-		this.#stack.pop()?.onPop?.(TransactionResult.Commit);
+		this.#stack.pop()?.callbacks.onPop?.(TransactionResult.Commit);
 	}
 
 	public abort(): void {
@@ -180,7 +205,7 @@ export class TransactionStack implements Transactor, IDisposable {
 			throw new UsageError("No transaction to abort");
 		}
 		this.#events.emit("aborting");
-		this.#stack.pop()?.onPop?.(TransactionResult.Abort);
+		this.#stack.pop()?.callbacks.onPop?.(TransactionResult.Abort);
 	}
 
 	public dispose(): void {
@@ -198,6 +223,19 @@ export class TransactionStack implements Transactor, IDisposable {
 	}
 }
 
+/**
+ * A function that will be called when a transaction is popped from the {@link SquashingTransactionStack | stack}.
+ * @remarks This function runs just after the transaction ends, so if this is the end of an outermost (not nested) transaction then {@link Transactor.isInProgress} will be false during its execution.
+ * @param result - The result of the transaction.
+ * @param viewUpdate - The change that needs to be applied to the view to keep it up-to-date with the branch after the transaction ends.
+ * This is needed in asynchronous transactions where new commits have been added to the branch while the transaction was in progress.
+ * This will be `undefined` if no such change is necessary.
+ */
+export type OnPopWithViewUpdate<TChange> = (
+	result: TransactionResult,
+	viewUpdate: TChange | undefined,
+) => void;
+
 /**
  * An implementation of {@link Transactor} that {@link TransactionStack | uses a stack} and a {@link SharedTreeBranch | branch} to manage transactions.
  * @remarks Given a branch, this class will fork the branch when a transaction begins and squash the forked branch back into the original branch when the transaction ends.
@@ -270,14 +308,14 @@ export class SquashingTransactionStack<
 	public constructor(
 		public readonly branch: SharedTreeBranch<TEditor, TChange>,
 		mintRevisionTag: () => RevisionTag,
-		onPush?: () => OnPop | void,
+		onPush?: () => OnPopWithViewUpdate<TChange> | void,
 	) {
 		super(
 			// Invoked when an outer transaction starts
 			(): Callbacks => {
 				// Keep track of the commit that each transaction was on when it started
-				// TODO:#8603: This may need to be computed differently if we allow rebasing during a transaction.
 				const startHead = this.activeBranch.getHead();
+				const rebaser = this.branch.changeFamily.rebaser;
 				const outerOnPop = onPush?.();
 				let transactionRevision: RevisionTag | undefined;
 				const transactionBranch = this.branch.fork(
@@ -287,33 +325,97 @@ export class SquashingTransactionStack<
 				);
 				this.setTransactionBranch(transactionBranch);
 				transactionBranch.editor.enterTransaction();
+
 				// Invoked when an outer transaction ends
 				const onOuterTransactionPop: OnPop = (result) => {
 					assert(!this.isInProgress(), 0xcae /* The outer transaction should be ending */);
 					transactionBranch.editor.exitTransaction();
+
+					const sourcePath: GraphCommit<TChange>[] = [];
+					const targetPath: GraphCommit<TChange>[] = [];
+					const ancestor = findCommonAncestor(
+						[startHead, sourcePath],
+						[branch.getHead(), targetPath],
+					);
+					assert(ancestor !== undefined, 0xcce /* branches must be related */);
+
+					const transactionSteps: GraphCommit<TChange>[] = [];
+					findAncestor(
+						[transactionBranch.getHead(), transactionSteps],
+						(c) => c === startHead,
+					);
+
+					let viewUpdate: TChange | undefined;
 					switch (result) {
 						case TransactionResult.Abort: {
-							// When a transaction is aborted, roll back all the transaction's changes on the current branch
+							// When a transaction is aborted, roll back all the transaction's changes on the current branch.
+							// It is important that this happens before and separately from updating the view because the `TreeCheckout` needs to
+							// revert some internal (state to match what it was before the transaction began) before applying the view update (if any).
 							transactionBranch.removeAfter(startHead);
+							// If changes were made on `branch` since the transaction began, the view will need to be updated to reflect those changes.
+							if (targetPath.length > 0) {
+								viewUpdate = diffHistories(
+									rebaser,
+									startHead,
+									this.branch.getHead(),
+									mintRevisionTag,
+								);
+							}
 							break;
 						}
 						case TransactionResult.Commit: {
-							// ...squash all the new commits on the transaction branch into a new commit on the original branch
-							const removedCommits: GraphCommit<TChange>[] = [];
-							findAncestor(
-								[transactionBranch.getHead(), removedCommits],
-								(c) => c === startHead,
-							);
-							if (removedCommits.length > 0) {
-								for (const commit of removedCommits) {
+							if (transactionSteps.length > 0) {
+								assert(
+									transactionRevision !== undefined,
+									0xccf /* Expected transaction revision in the presence of transaction steps */,
+								);
+								for (const commit of transactionSteps) {
 									assert(
 										commit.revision === transactionRevision,
 										0xcaf /* Unexpected commit in transaction */,
 									);
 								}
-								const squash = this.branch.changeFamily.rebaser.compose(removedCommits);
-								this.branch.apply(tagChange(squash, transactionRevision));
+								// Squash all the new commits on the transaction branch into a new commit on the original branch
+								const squash = rebaser.compose(transactionSteps);
+
+								if (targetPath.length === 0) {
+									// No changes were made on the original branch since the transaction began
+									// The transaction commit can be applied directly
+									this.branch.apply(tagChange(squash, transactionRevision));
+									// The view is already up-to-date so there's nothing more to do
+								} else {
+									// Some changes were made on `branch` since the transaction began
+									const unrebasedHead = mintCommit(startHead, {
+										change: squash,
+										revision: transactionRevision,
+									});
+									// We need to rebase the transaction commit on top of the new changes
+									const rebased = rebaseBranch(
+										mintRevisionTag,
+										rebaser,
+										unrebasedHead,
+										branch.getHead(),
+									);
+									assert(
+										rebased.newSourceHead.revision === transactionRevision,
+										0xcd0 /* The transaction commit should be rebased to the tip */,
+									);
+									this.branch.apply(rebased.newSourceHead);
+									viewUpdate = rebased.sourceChange;
+								}
+							} else {
+								if (targetPath.length > 0) {
+									// Changes were made on `branch` since the transaction began.
+									// The view will need to be updated to reflect those changes.
+									viewUpdate = diffHistories(
+										rebaser,
+										startHead,
+										this.branch.getHead(),
+										mintRevisionTag,
+									);
+								}
 							}
+
 							break;
 						}
 						default: {
@@ -322,7 +424,7 @@ export class SquashingTransactionStack<
 					}
 					transactionBranch.dispose();
 					this.setTransactionBranch(undefined);
-					outerOnPop?.(result);
+					outerOnPop?.(result, viewUpdate);
 				};
 				// Invoked when a nested transaction begins
 				const onNestedTransactionPush: OnPush = () => {
@@ -346,7 +448,7 @@ export class SquashingTransactionStack<
 									unreachableCase(result);
 								}
 							}
-							nestedOuterOnPop?.(result);
+							nestedOuterOnPop?.(result, undefined);
 						},
 					};
 				};

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

@@ -99,11 +99,12 @@ export abstract class VersionedSummarizer<TVersion extends number> implements Su
 	): Promise<void> {
 		let version: TVersion | undefined;
 		if (await services.contains(summarizablesMetadataKey)) {
-			const metadata = await readAndParseSnapshotBlob<SharedTreeSummarizableMetadata>(
+			const metadata = (await readAndParseSnapshotBlob(
 				summarizablesMetadataKey,
 				services,
 				(contents) => parse(contents),
-			);
+				// TODO: this type cast should use a codec to validate the data instead of just type casting.
+			)) as SharedTreeSummarizableMetadata;
 			version = metadata.version as TVersion;
 			if (!this.supportedVersions.has(version)) {
 				throw new UsageError(`Cannot read version ${version} of shared tree summary.`);

package/src/simple-tree/api/index.ts

@@ -53,6 +53,7 @@ export {
 	adaptEnum,
 	enumFromStrings,
 	singletonSchema,
+	createCustomizedFluidFrameworkScopedFactory,
 } from "./schemaCreationUtilities.js";
 export {
 	getIdentifierFromNode,
@@ -180,7 +181,7 @@ export {
 	exportCompatibilitySchemaSnapshot,
 	importCompatibilitySchemaSnapshot,
 	checkCompatibility,
-	checkSchemaCompatibilitySnapshots,
+	snapshotSchemaCompatibility,
 	type SnapshotFileSystem,
-	type SchemaCompatibilitySnapshotsOptions,
+	type SnapshotSchemaCompatibilityOptions,
 } from "./snapshotCompatibilityChecker.js";

package/src/simple-tree/api/schemaCreationUtilities.ts

@@ -17,6 +17,7 @@ import type {
 } from "../core/index.js";
 
 import type { SchemaFactory, ScopedSchemaName } from "./schemaFactory.js";
+import { SchemaFactoryBeta } from "./schemaFactoryBeta.js";
 
 /*
  * This file does two things:
@@ -247,9 +248,8 @@ export function enumFromStrings<
 	type MembersUnion = Members[number];
 
 	// Get all keys of the Members tuple which are numeric strings as union of numbers:
-	type Indexes = Extract<keyof Members, `${number}`> extends `${infer N extends number}`
-		? N
-		: never;
+	type Indexes =
+		Extract<keyof Members, `${number}`> extends `${infer N extends number}` ? N : never;
 
 	type TOut = {
 		[Index in Indexes as Members[Index]]: ReturnType<
@@ -298,11 +298,11 @@ function _enumFromStrings2<TScope extends string, const Members extends readonly
 	factory: SchemaFactory<TScope>,
 	members: Members,
 ) {
-	const enumObject: {
+	const enumObject = Object.create(null) as {
 		[key in keyof Members as Members[key] extends string
 			? Members[key]
 			: string]: Members[key] extends string ? Members[key] : string;
-	} = Object.create(null);
+	};
 	for (const name of members) {
 		Object.defineProperty(enumObject, name, {
 			enumerable: true,
@@ -314,3 +314,33 @@ function _enumFromStrings2<TScope extends string, const Members extends readonly
 
 	return adaptEnum(factory, enumObject);
 }
+
+function createCustomizedScopedFactory<
+	TUserScope extends string,
+	TCreatorDomain extends string,
+>(
+	inputSchemaFactory: SchemaFactoryBeta<TUserScope>,
+	creatorDomain: TCreatorDomain,
+): SchemaFactoryBeta<`${TCreatorDomain}<${TUserScope}>`> {
+	return new SchemaFactoryBeta(`${creatorDomain}<${inputSchemaFactory.scope}>`);
+}
+
+/**
+ * Declare a SchemaFactory for use in cases where the Fluid Framework's code creates the schema and owns its schema compatibility (and thus scope)
+ * but it is parameterized by user provided data, the `TUserScope`.
+ * @remarks
+ * This should allow future logic in {@link generateSchemaFromSimpleSchema} to recognize these schema as ones defined by Fluid Framework,
+ * and special case them to provide better APIs and maintain data invariants.
+ */
+export function createCustomizedFluidFrameworkScopedFactory<
+	TUserScope extends string,
+	TCreatorDomain extends string,
+>(
+	inputSchemaFactory: SchemaFactoryBeta<TUserScope>,
+	fluidDomainSuffix: TCreatorDomain,
+): SchemaFactoryBeta<`com.fluidframework.${TCreatorDomain}<${TUserScope}>`> {
+	return createCustomizedScopedFactory(
+		inputSchemaFactory,
+		`com.fluidframework.${fluidDomainSuffix}` as const,
+	);
+}

package/src/simple-tree/api/simpleTreeIndex.ts

@@ -149,7 +149,7 @@ export function createSimpleTreeIndex<
 	isKeyValid: (key: TreeIndexKey) => key is TKey,
 	indexableSchema?: readonly TreeNodeSchema[],
 ): SimpleTreeIndex<TKey, TValue> {
-	const indexableSchemaMap = new Map();
+	const indexableSchemaMap = new Map<string, TreeNodeSchema>();
 	if (indexableSchema === undefined) {
 		walkFieldSchema(view.schema, {
 			node: (schemus) => indexableSchemaMap.set(schemus.identifier, schemus),