@fluid-experimental/tree 0.59.2001 → 0.59.3000

package/src/SharedTree.ts

@@ -25,9 +25,17 @@ import {
 import { ITelemetryLogger, ITelemetryProperties } from '@fluidframework/common-definitions';
 import { ChildLogger, ITelemetryLoggerPropertyBags, PerformanceEvent } from '@fluidframework/telemetry-utils';
 import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
-import { assert, assertNotUndefined, fail, copyPropertyIfDefined } from './Common';
+import { assert, assertNotUndefined, fail, copyPropertyIfDefined, noop } from './Common';
 import { EditHandle, EditLog, getNumberOfHandlesFromEditLogSummary, OrderedEditSet } from './EditLog';
-import { EditId, NodeId, StableNodeId, DetachedSequenceId, OpSpaceNodeId, isDetachedSequenceId } from './Identifiers';
+import {
+	EditId,
+	NodeId,
+	StableNodeId,
+	DetachedSequenceId,
+	OpSpaceNodeId,
+	isDetachedSequenceId,
+	AttributionId,
+} from './Identifiers';
 import { initialTree } from './InitialTree';
 import {
 	CachingLogViewer,
@@ -88,6 +96,75 @@ import { TransactionInternal } from './TransactionInternal';
 import { IdCompressor, createSessionId } from './id-compressor';
 import { convertEditIds } from './IdConversion';
 import { MutableStringInterner } from './StringInterner';
+import { nilUuid } from './UuidUtilities';
+
+/**
+ * The write format and associated options used to construct a `SharedTree`
+ * @public
+ */
+export type SharedTreeArgs<WF extends WriteFormat = WriteFormat> = [writeFormat: WF, options?: SharedTreeOptions<WF>];
+
+/**
+ * The type of shared tree options for a given write format
+ * @public
+ */
+export type SharedTreeOptions<
+	WF extends WriteFormat,
+	HistoryCompatibility extends 'Forwards' | 'None' = 'Forwards'
+> = Omit<
+	WF extends WriteFormat.v0_0_2
+		? SharedTreeOptions_0_0_2
+		: WF extends WriteFormat.v0_1_1
+		? SharedTreeOptions_0_1_1
+		: never,
+	HistoryCompatibility extends 'Forwards' ? 'summarizeHistory' : never
+>;
+
+/**
+ * Configuration options for a SharedTree with write format 0.0.2
+ * @public
+ */
+export interface SharedTreeOptions_0_0_2 {
+	/**
+	 * Determines if the history is included in summaries.
+	 *
+	 * Warning: enabling history summarization incurs a permanent cost in the document. It is not possible to disable history summarization
+	 * later once it has been enabled, and thus the history cannot be safely deleted.
+	 *
+	 * On 0.1.1 documents, due to current code limitations, this parameter is only impactful for newly created documents.
+	 * `SharedTree`s which load existing documents will summarize history if and only if the loaded summary included history.
+	 *
+	 * The technical limitations here relate to clients with mixed versions collaborating.
+	 * In the future we may allow modification of whether or not a particular document saves history, but only via a consensus mechanism.
+	 * See the skipped test in SharedTreeFuzzTests.ts for more details on this issue.
+	 * See docs/Breaking-Change-Migration for more details on the consensus scheme.
+	 */
+	summarizeHistory?: boolean;
+}
+
+/**
+ * Configuration options for a SharedTree with write format 0.1.1
+ * @public
+ */
+export interface SharedTreeOptions_0_1_1 {
+	/**
+	 * Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
+	 *
+	 * Warning: enabling history summarization incurs a permanent cost in the document. It is not possible to disable history summarization
+	 * later once it has been enabled, and thus the history cannot be safely deleted.
+	 *
+	 * On 0.1.1 documents, due to current code limitations, this parameter is only impactful for newly created documents.
+	 * `SharedTree`s which load existing documents will summarize history if and only if the loaded summary included history.
+	 *
+	 * The technical limitations here relate to clients with mixed versions collaborating.
+	 * In the future we may allow modification of whether or not a particular document saves history, but only via a consensus mechanism.
+	 * See the skipped test in SharedTreeFuzzTests.ts for more details on this issue.
+	 * See docs/Breaking-Change-Migration for more details on the consensus scheme.
+	 */
+	summarizeHistory?: false | { uploadEditChunks: boolean };
+	/** a UUID that identifies the user of this tree; all node IDs generated by this tree will be associated with this UUID */
+	attributionId?: AttributionId;
+}
 
 /**
  * Factory for SharedTree.
@@ -109,20 +186,20 @@ export class SharedTreeFactory implements IChannelFactory {
 		packageVersion: '0.1',
 	};
 
+	private readonly args: SharedTreeArgs;
+
 	/**
 	 * Get a factory for SharedTree to register with the data store.
 	 * @param writeFormat - Determines the format version the SharedTree will write ops and summaries in. See [the write format
 	 * documentation](../docs/Write-Format.md) for more information.
-	 * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
-	 * See the [breaking change migration documentation](docs/Breaking-Change-Migration) for more details on this scheme.
-	 * @param expensiveValidation - Enables expensive asserts on SharedTree.
+	 * @param options - Configuration options for this tree
 	 * @returns A factory that creates `SharedTree`s and loads them from storage.
 	 */
-	constructor(
-		private readonly writeFormat: WriteFormat,
-		private readonly summarizeHistory: false | { uploadEditChunks: boolean } = false,
-		private expensiveValidation = false
-	) {}
+	constructor(...args: SharedTreeArgs<WriteFormat.v0_0_2>);
+	constructor(...args: SharedTreeArgs<WriteFormat.v0_1_1>);
+	constructor(...args: SharedTreeArgs) {
+		this.args = args;
+	}
 
 	/**
 	 * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
@@ -157,22 +234,22 @@ export class SharedTreeFactory implements IChannelFactory {
 	 * @param runtime - data store runtime that owns the new SharedTree
 	 * @param id - optional name for the SharedTree
 	 */
-	public create(runtime: IFluidDataStoreRuntime, id: string, expensiveValidation: boolean = false): SharedTree {
-		this.expensiveValidation = expensiveValidation;
+	public create(runtime: IFluidDataStoreRuntime, id: string): SharedTree {
 		const sharedTree = this.createSharedTree(runtime, id);
 		sharedTree.initializeLocal();
 		return sharedTree;
 	}
 
 	private createSharedTree(runtime: IFluidDataStoreRuntime, id: string): SharedTree {
-		const sharedTree = new SharedTree(
-			runtime,
-			id,
-			this.writeFormat,
-			this.summarizeHistory,
-			this.expensiveValidation
-		);
-		return sharedTree;
+		const [writeFormat] = this.args;
+		switch (writeFormat) {
+			case WriteFormat.v0_0_2:
+				return new SharedTree(runtime, id, ...(this.args as SharedTreeArgs<WriteFormat.v0_0_2>));
+			case WriteFormat.v0_1_1:
+				return new SharedTree(runtime, id, ...(this.args as SharedTreeArgs<WriteFormat.v0_1_1>));
+			default:
+				fail('Unknown write format');
+		}
 	}
 }
 
@@ -281,35 +358,56 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 
 	/**
 	 * Get a factory for SharedTree to register with the data store.
-	 * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
-	 *
-	 * On 0.1.1 documents, due to current code limitations, this parameter is only impactful for newly created documents.
-	 * `SharedTree`s which load existing documents will summarize history if and only if the loaded summary included history.
-	 *
-	 * The technical limitations here relate to clients with mixed versions collaborating.
-	 * In the future we may allow modification of whether or not a particular document saves history, but only via a consensus mechanism.
-	 * See the skipped test in SharedTreeFuzzTests.ts for more details on this issue.
-	 * See docs/Breaking-Change-Migration for more details on the consensus scheme.
 	 * @param writeFormat - Determines the format version the SharedTree will write ops and summaries in.
 	 * This format may be updated to a newer (supported) version at runtime if a collaborating shared-tree
 	 * that was initialized with a newer write version connects to the session. Care must be taken when changing this value,
 	 * as a staged rollout must of occurred such that all collaborating clients must have the code to read at least the version
 	 * written.
 	 * See [the write format documentation](../docs/Write-Format.md) for more information.
+	 * @param options - Configuration options for this tree
 	 * @returns A factory that creates `SharedTree`s and loads them from storage.
 	 */
-	public static getFactory(
-		writeFormat: WriteFormat,
-		summarizeHistory: false | { uploadEditChunks: boolean } = false
-	): SharedTreeFactory {
+	public static getFactory(...args: SharedTreeArgs<WriteFormat.v0_0_2>): SharedTreeFactory;
+
+	public static getFactory(...args: SharedTreeArgs<WriteFormat.v0_1_1>): SharedTreeFactory;
+
+	public static getFactory(...args: SharedTreeArgs): SharedTreeFactory {
+		const [writeFormat] = args;
 		// 	On 0.1.1 documents, due to current code limitations, all clients MUST agree on the value of `summarizeHistory`.
 		//  Note that this means staged rollout changing this value should not be attempted.
 		//  It is possible to update shared-tree to correctly handle such a staged rollout, but that hasn't been implemented.
 		//  See the skipped test in SharedTreeFuzzTests.ts for more details on this issue.
-		return new SharedTreeFactory(writeFormat, summarizeHistory);
+		switch (writeFormat) {
+			case WriteFormat.v0_0_2:
+				return new SharedTreeFactory(...(args as SharedTreeArgs<WriteFormat.v0_0_2>));
+			case WriteFormat.v0_1_1:
+				return new SharedTreeFactory(...(args as SharedTreeArgs<WriteFormat.v0_1_1>));
+			default:
+				fail('Unknown write format');
+		}
+	}
+
+	/**
+	 * The UUID used for attribution of nodes created by this SharedTree. All shared trees with a write format of 0.1.1 or
+	 * greater have a unique attribution ID which may be configured in the constructor. All other shared trees (i.e. those
+	 * with a write format of 0.0.2) use the nil UUID as their attribution ID.
+	 * @public
+	 */
+	public get attributionId(): AttributionId {
+		switch (this.writeFormat) {
+			case WriteFormat.v0_0_2:
+				return nilUuid;
+			default: {
+				const { attributionId } = this.idCompressor;
+				if (attributionId === ghostSessionId) {
+					return nilUuid;
+				}
+				return attributionId;
+			}
+		}
 	}
 
-	private idCompressor: IdCompressor = new IdCompressor(createSessionId(), reservedIdCount);
+	private idCompressor: IdCompressor;
 	private readonly idNormalizer: NodeIdNormalizer<OpSpaceNodeId> & { tree: SharedTree } = {
 		tree: this,
 		get localSessionId() {
@@ -375,25 +473,46 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	private summarizeHistory: boolean;
 	private uploadEditChunks: boolean;
 
+	private getHistoryPolicy(options: SharedTreeOptions<WriteFormat, 'Forwards' | 'None'>): {
+		summarizeHistory: boolean;
+		uploadEditChunks: boolean;
+	} {
+		const noCompatOptions = options as SharedTreeOptions<WriteFormat, 'None'>;
+		if (typeof noCompatOptions.summarizeHistory === 'object') {
+			return {
+				summarizeHistory: true,
+				uploadEditChunks: noCompatOptions.summarizeHistory.uploadEditChunks,
+			};
+		} else {
+			return {
+				summarizeHistory: noCompatOptions.summarizeHistory ?? false,
+				uploadEditChunks: false,
+			};
+		}
+	}
+
 	/**
-	 * Create a new SharedTreeFactory.
+	 * Create a new SharedTree.
 	 * @param runtime - The runtime the SharedTree will be associated with
 	 * @param id - Unique ID for the SharedTree
 	 * @param writeFormat - Determines the format version the SharedTree will write ops and summaries in. See [the write format
 	 * documentation](../docs/Write-Format.md) for more information.
-	 * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
-	 * @param expensiveValidation - Enable expensive asserts.
+	 * @param options - Configuration options for this tree
 	 */
+	public constructor(runtime: IFluidDataStoreRuntime, id: string, ...args: SharedTreeArgs<WriteFormat.v0_0_2>);
+
+	public constructor(runtime: IFluidDataStoreRuntime, id: string, ...args: SharedTreeArgs<WriteFormat.v0_1_1>);
+
 	public constructor(
 		runtime: IFluidDataStoreRuntime,
 		id: string,
 		private writeFormat: WriteFormat,
-		summarizeHistory: false | { uploadEditChunks: boolean } = false,
-		private readonly expensiveValidation = false
+		options: SharedTreeOptions<typeof writeFormat> = {}
 	) {
 		super(id, runtime, SharedTreeFactory.Attributes);
-		this.summarizeHistory = summarizeHistory === false ? false : true;
-		this.uploadEditChunks = summarizeHistory === false ? false : summarizeHistory.uploadEditChunks;
+		const historyPolicy = this.getHistoryPolicy(options);
+		this.summarizeHistory = historyPolicy.summarizeHistory;
+		this.uploadEditChunks = historyPolicy.uploadEditChunks;
 
 		// This code is somewhat duplicated from OldestClientObserver because it currently depends on the container runtime
 		// which SharedTree does not have access to.
@@ -412,13 +531,15 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 			sharedTreeTelemetryProperties
 		);
 
+		const attributionId = (options as SharedTreeOptions<WriteFormat.v0_1_1>).attributionId;
+		this.idCompressor = new IdCompressor(createSessionId(), reservedIdCount, attributionId);
 		const { editLog, cachingLogViewer } = this.initializeNewEditLogFromSummary(
 			{
 				editChunks: [],
 				editIds: [],
 			},
 			undefined,
-			this.idCompressor, // TODO: Attribution info
+			this.idCompressor,
 			this.processEditResult,
 			this.processSequencedEditResult,
 			WriteFormat.v0_1_1
@@ -429,6 +550,11 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 		this.encoder_0_1_1 = new SharedTreeEncoder_0_1_1(this.summarizeHistory);
 	}
 
+	/**
+	 * The write format version currently used by this `SharedTree`. This is always initialized to the write format
+	 * passed to the tree's constructor, but it may automatically upgrade over time (e.g. when connected to another
+	 * SharedTree with a higher write format, or when loading a summary with a higher write format).
+	 */
 	public getWriteFormat(): WriteFormat {
 		return this.writeFormat;
 	}
@@ -555,6 +681,26 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 		return this.idCompressor.tryRecompress(id) as NodeId | undefined;
 	}
 
+	/**
+	 * Returns the attribution ID associated with the SharedTree that generated the given node ID. This is generally only useful for clients
+	 * with a write format of 0.1.1 or greater since older clients cannot be given an attribution ID and will always use the default
+	 * `attributionId` of the tree.
+	 * @public
+	 */
+	public attributeNodeId(id: NodeId): AttributionId {
+		switch (this.writeFormat) {
+			case WriteFormat.v0_0_2:
+				return nilUuid;
+			default: {
+				const attributionId = this.idCompressor.attributeId(id);
+				if (attributionId === ghostSessionId) {
+					return nilUuid;
+				}
+				return attributionId;
+			}
+		}
+	}
+
 	/**
 	 * @returns the edit history of the tree.
 	 * @public
@@ -570,9 +716,19 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	}
 
 	/**
-	 * Uploads the edit chunk and sends the chunk starting revision along with the resulting handle as an op.
+	 * Uploads the edit chunk and submits a `SharedTreeHandleOp`.
+	 * This method is fire-and-forget and will swallow any errors that occur during upload or the `onUploadComplete` hook.
+	 * If the upload or op submission does fail then a future client will attempt the submission instead.
 	 */
-	private async uploadEditChunk(
+	private uploadEditChunk(
+		edits: readonly EditWithoutId<ChangeInternal>[],
+		startRevision: number,
+		onUploadComplete?: () => void
+	): void {
+		this.uploadEditChunkAsync(edits, startRevision).then(onUploadComplete).catch(noop);
+	}
+
+	private async uploadEditChunkAsync(
 		edits: readonly EditWithoutId<ChangeInternal>[],
 		startRevision: number
 	): Promise<void> {
@@ -734,7 +890,10 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 		let convertedSummary: SummaryContents;
 		switch (loadedSummaryVersion) {
 			case WriteFormat.v0_0_2:
-				convertedSummary = this.encoder_0_0_2.decodeSummary(summary as SharedTreeSummary_0_0_2);
+				convertedSummary = this.encoder_0_0_2.decodeSummary(
+					summary as SharedTreeSummary_0_0_2,
+					this.attributionId
+				);
 				break;
 			case WriteFormat.v0_1_1: {
 				const typedSummary = summary as SharedTreeSummary;
@@ -746,7 +905,7 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 					this.encoder_0_1_1 = new SharedTreeEncoder_0_1_1(this.summarizeHistory);
 				}
 
-				convertedSummary = this.encoder_0_1_1.decodeSummary(summary as SharedTreeSummary);
+				convertedSummary = this.encoder_0_1_1.decodeSummary(summary as SharedTreeSummary, this.attributionId);
 				break;
 			}
 			default:
@@ -860,7 +1019,6 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 			editLog,
 			RevisionView.fromTree(initialTree, this),
 			knownRevisions,
-			this.expensiveValidation,
 			editStatusCallback,
 			sequencedEditResultCallback,
 			0
@@ -877,14 +1035,10 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	private uploadCatchUpBlobs(): void {
 		if (this.writeFormat !== WriteFormat.v0_0_2 && this.uploadEditChunks) {
 			for (const [startRevision, chunk] of this.editLog.getEditChunksReadyForUpload()) {
-				this.uploadEditChunk(chunk, startRevision)
-					.then(() => {
-						this.emit(SharedTreeDiagnosticEvent.CatchUpBlobUploaded);
-						this.logger.sendTelemetryEvent({ eventName: 'CatchUpBlobUpload', chunkSize: chunk.length });
-					})
-					// It is safe to swallow errors from edit chunk upload because the next summary load will
-					// do another attempt to upload the edit chunks that couldn't previously be uploaded
-					.catch((error) => {});
+				this.uploadEditChunk(chunk, startRevision, () => {
+					this.emit(SharedTreeDiagnosticEvent.CatchUpBlobUploaded);
+					this.logger.sendTelemetryEvent({ eventName: 'CatchUpBlobUpload', chunkSize: chunk.length });
+				});
 			}
 		}
 	}
@@ -947,7 +1101,7 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 		// Update ops should only be processed if they're not the same version.
 		if (sameVersion) {
 			if (type === SharedTreeOpType.Handle) {
-				const { editHandle, startRevision } = op as SharedTreeHandleOp;
+				const { editHandle, startRevision } = op;
 				const baseHandle = this.deserializeHandle(editHandle);
 				const decodedHandle: EditHandle<ChangeInternal> = {
 					get: async () => {
@@ -964,11 +1118,9 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 				this.editLog.processEditChunkHandle(decodedHandle, startRevision);
 			} else if (type === SharedTreeOpType.Edit) {
 				if (op.version === WriteFormat.v0_1_1) {
-					// TODO: This cast can be removed on typescript 4.6
-					this.idCompressor.finalizeCreationRange((op as SharedTreeEditOp).idRange);
+					this.idCompressor.finalizeCreationRange(op.idRange);
 				}
-				// TODO: This cast can be removed on typescript 4.6
-				const edit = this.parseSequencedEdit(op as SharedTreeEditOp | SharedTreeEditOp_0_0_2);
+				const edit = this.parseSequencedEdit(op);
 				if (op.version === WriteFormat.v0_1_1) {
 					this.internStringsFromEdit(edit);
 				}
@@ -1056,16 +1208,12 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 					const [startRevision, chunk] = lastPair;
 					const edits = assertNotUndefined(chunk.edits);
 					if (edits.length === this.editLog.editsPerChunk) {
-						this.uploadEditChunk(edits, startRevision)
-							.then(() => {
-								this.logger.sendTelemetryEvent({
-									eventName: 'EditChunkUpload',
-									chunkSize: edits.length,
-								});
-							})
-							// It is safe to swallow errors from edit chunk upload because the next summary load will
-							// do another attempt to upload the edit chunks that couldn't previously be uploaded
-							.catch((error) => {});
+						this.uploadEditChunk(edits, startRevision, () => {
+							this.logger.sendTelemetryEvent({
+								eventName: 'EditChunkUpload',
+								chunkSize: edits.length,
+							});
+						});
 					}
 				}
 			}
@@ -1116,7 +1264,7 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 		this.interner = new MutableStringInterner([initialTree.definition]);
 		const oldIdCompressor = this.idCompressor;
 		// Create the IdCompressor that will be used after the upgrade
-		const newIdCompressor = new IdCompressor(createSessionId(), reservedIdCount); // TODO: attribution info
+		const newIdCompressor = new IdCompressor(createSessionId(), reservedIdCount, this.attributionId);
 		const newContext = getNodeIdContext(newIdCompressor);
 		// Generate all local IDs in the new compressor that were in the old compressor and preserve their UUIDs.
 		// This will allow the client to continue to use local IDs that were allocated pre-upgrade
@@ -1131,7 +1279,7 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 			}
 		};
 		// Construct a temporary "ghost" compressor which is used to generate final IDs that will be consistent across all upgrading clients
-		const ghostIdCompressor = new IdCompressor(ghostSessionId, reservedIdCount); // TODO: attribution info
+		const ghostIdCompressor = new IdCompressor(ghostSessionId, reservedIdCount);
 		const ghostContext = getNodeIdContext(ghostIdCompressor);
 		if (this.summarizeHistory) {
 			// All clients have the full history, and can therefore all "generate" the same final IDs for every ID in the history
@@ -1303,8 +1451,7 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	private applyEditLocally(edit: Edit<ChangeInternal>, message: ISequencedDocumentMessage | undefined): void {
 		const isSequenced = message !== undefined;
 		if (isSequenced) {
-			// TODO: This cast can be removed on typescript 4.6
-			this.editLog.addSequencedEdit(edit, message as ISequencedDocumentMessage);
+			this.editLog.addSequencedEdit(edit, message);
 		} else {
 			this.editLog.addLocalEdit(edit);
 		}

package/src/SharedTreeEncoder.ts

@@ -7,7 +7,7 @@ import { IsoBuffer } from '@fluidframework/common-utils';
 import { assert, fail } from './Common';
 import { EditLog } from './EditLog';
 import { convertTreeNodes, newEdit } from './EditUtilities';
-import { DetachedSequenceId, FinalNodeId, OpSpaceNodeId, TraitLabel } from './Identifiers';
+import { AttributionId, DetachedSequenceId, FinalNodeId, OpSpaceNodeId, TraitLabel } from './Identifiers';
 import { initialTree } from './InitialTree';
 import {
 	ContextualizedNodeIdNormalizer,
@@ -151,19 +151,22 @@ export class SharedTreeEncoder_0_1_1 {
 	/**
 	 * Decodes an encoded summary.
 	 */
-	public decodeSummary({
-		editHistory,
-		currentTree: compressedTree,
-		internedStrings,
-		idCompressor: serializedIdCompressor,
-		version,
-	}: SharedTreeSummary): SummaryContents {
+	public decodeSummary(
+		{
+			editHistory,
+			currentTree: compressedTree,
+			internedStrings,
+			idCompressor: serializedIdCompressor,
+			version,
+		}: SharedTreeSummary,
+		attributionId: AttributionId
+	): SummaryContents {
 		assert(version === WriteFormat.v0_1_1, `Invalid summary version to decode: ${version}, expected: 0.1.1`);
 		assert(typeof editHistory === 'object', '0.1.1 summary encountered with non-object edit history.');
 
 		const idCompressor = hasOngoingSession(serializedIdCompressor)
 			? IdCompressor.deserialize(serializedIdCompressor)
-			: IdCompressor.deserialize(serializedIdCompressor, createSessionId()); // TODO attribution
+			: IdCompressor.deserialize(serializedIdCompressor, createSessionId(), attributionId);
 
 		const interner = new MutableStringInterner(internedStrings);
 		const sequencedNormalizer = sequencedIdNormalizer(getNodeIdContext(idCompressor));
@@ -371,9 +374,12 @@ export class SharedTreeEncoder_0_0_2 {
 	/**
 	 * Decodes an encoded summary.
 	 */
-	public decodeSummary({ currentTree, sequencedEdits }: SharedTreeSummary_0_0_2): SummaryContents {
+	public decodeSummary(
+		{ currentTree, sequencedEdits }: SharedTreeSummary_0_0_2,
+		attributionId?: AttributionId
+	): SummaryContents {
 		assert(sequencedEdits !== undefined, '0.0.2 summary encountered with missing sequencedEdits field.');
-		const idCompressor = new IdCompressor(createSessionId(), reservedIdCount);
+		const idCompressor = new IdCompressor(createSessionId(), reservedIdCount, attributionId);
 		const idGenerator = getNodeIdContext(idCompressor);
 		const generateId = (id) => idGenerator.generateNodeId(id);
 

package/src/TreeCompressor.ts

@@ -135,16 +135,14 @@ export class InterningTreeCompressor<TPlaceholder extends DetachedSequenceId | n
 					compressedTraits = payloadTraits;
 				}
 			} else {
-				// TODO: This cast can be removed on typescript 4.6
-				compressedTraits = idOrPayloadTraits as typeof compressedTraits;
+				compressedTraits = idOrPayloadTraits;
 			}
 		}
 
 		const definition =
 			typeof maybeInternedDefinition === 'string'
 				? maybeInternedDefinition
-				: // TODO: This cast can be removed on typescript 4.6
-				  (interner.getString(maybeInternedDefinition as number) as Definition);
+				: (interner.getString(maybeInternedDefinition) as Definition);
 
 		let identifier: TId;
 		if (compressedId !== undefined) {

package/src/UuidUtilities.ts

@@ -0,0 +1,123 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { v4, NIL } from 'uuid';
+import { assert } from './Common';
+import { StableId, UuidString } from './Identifiers';
+
+const hexadecimalCharCodes = Array.from('09afAF').map((c) => c.charCodeAt(0)) as [
+	zero: number,
+	nine: number,
+	a: number,
+	f: number,
+	A: number,
+	F: number
+];
+
+function isHexadecimalCharacter(charCode: number): boolean {
+	return (
+		(charCode >= hexadecimalCharCodes[0] && charCode <= hexadecimalCharCodes[1]) ||
+		(charCode >= hexadecimalCharCodes[2] && charCode <= hexadecimalCharCodes[3]) ||
+		(charCode >= hexadecimalCharCodes[4] && charCode <= hexadecimalCharCodes[5])
+	);
+}
+
+/** The null (lowest/all-zeros) UUID */
+export const nilUuid = assertIsUuidString(NIL);
+
+/**
+ * Asserts that the given string is a UUID
+ */
+export function assertIsUuidString(uuidString: string): UuidString {
+	assert(isUuidString(uuidString), `${uuidString} is not an UuidString`);
+	return uuidString;
+}
+
+/**
+ * Returns true iff the given string is a valid UUID-like string of hexadecimal characters
+ * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+ */
+export function isUuidString(str: string): str is UuidString {
+	for (let i = 0; i < str.length; i++) {
+		switch (i) {
+			case 8:
+			case 13:
+			case 18:
+			case 23:
+				if (str.charAt(i) !== '-') {
+					return false;
+				}
+				break;
+
+			default:
+				if (!isHexadecimalCharacter(str.charCodeAt(i))) {
+					return false;
+				}
+				break;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Generate a random stable ID
+ */
+export function generateStableId(): StableId {
+	return assertIsStableId(v4());
+}
+
+/**
+ * Asserts that the given string is a stable ID.
+ */
+export function assertIsStableId(stableId: string): StableId {
+	assert(isStableId(stableId), `${stableId} is not a StableId.`);
+	return stableId;
+}
+
+/**
+ * Returns true iff the given string is a valid Version 4, variant 2 UUID
+ * 'xxxxxxxx-xxxx-4xxx-vxxx-xxxxxxxxxxxx'
+ */
+export function isStableId(str: string): str is StableId {
+	if (str.length !== 36) {
+		return false;
+	}
+
+	for (let i = 0; i < str.length; i++) {
+		switch (i) {
+			case 8:
+			case 13:
+			case 18:
+			case 23:
+				if (str.charAt(i) !== '-') {
+					return false;
+				}
+				break;
+
+			case 14:
+				if (str.charAt(i) !== '4') {
+					return false;
+				}
+				break;
+
+			case 19: {
+				const char = str.charAt(i);
+				if (char !== '8' && char !== '9' && char !== 'a' && char !== 'b') {
+					return false;
+				}
+				break;
+			}
+
+			default:
+				if (!isHexadecimalCharacter(str.charCodeAt(i))) {
+					return false;
+				}
+				break;
+		}
+	}
+
+	return true;
+}