@fluid-experimental/tree 0.58.3000-61081 → 0.59.2000-61729

package/src/SharedTree.ts

@@ -110,13 +110,10 @@ export class SharedTreeFactory implements IChannelFactory {
 
 	/**
 	 * Get a factory for SharedTree to register with the data store.
-	 * @param writeFormat - Determines the format version the SharedTree will write 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 have occurred such that all collaborating clients must have the code to read at least the version
-	 * written.
+	 * @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 docs/Breaking-Change-Migration for more details on this scheme.
+	 * See the [breaking change migration documentation](docs/Breaking-Change-Migration) for more details on this scheme.
 	 * @param expensiveValidation - Enables expensive asserts on SharedTree.
 	 * @returns A factory that creates `SharedTree`s and loads them from storage.
 	 */
@@ -270,7 +267,7 @@ export type SequencedEditAppliedHandler = (args: SequencedEditAppliedEventArgume
 const sharedTreeTelemetryProperties: ITelemetryLoggerPropertyBags = { all: { isSharedTreeEvent: true } };
 
 /**
- * A distributed tree.
+ * A [distributed tree](../Readme.md).
  * @public
  */
 export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeIdContext {
@@ -284,6 +281,7 @@ 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.
 	 *
@@ -291,17 +289,22 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	 * 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 summaries in.
+	 * @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.
 	 * @returns A factory that creates `SharedTree`s and loads them from storage.
 	 */
 	public static getFactory(
 		writeFormat: WriteFormat,
 		summarizeHistory: false | { uploadEditChunks: boolean } = false
 	): SharedTreeFactory {
+		// 	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);
 	}
 
@@ -368,8 +371,6 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 		this.emit(SharedTreeEvent.SequencedEditApplied, eventArguments);
 	};
 
-	public readonly transactionFactory = TransactionInternal.factory;
-
 	private summarizeHistory: boolean;
 	private uploadEditChunks: boolean;
 
@@ -377,7 +378,8 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	 * Create a new SharedTreeFactory.
 	 * @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 summaries in.
+	 * @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.
 	 */
@@ -490,31 +492,64 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	}
 
 	/**
-	 * {@inheritdoc NodeIdGenerator.generateNodeId}
+	 * Generates a node identifier.
+	 * The returned IDs may be used as the identifier of a node in the SharedTree.
+	 * `NodeId`s are *always* unique and stable within the scope of the tree and session that generated them. They are *not* unique within
+	 * a Fluid container, and *cannot* be compared across instances of a SharedTree. They are *not* stable across sessions/lifetimes of a
+	 * SharedTree, and *cannot* be persisted (e.g. stored in payloads, uploaded in blobs, etc.). If stable persistence is needed,
+	 * NodeIdConverter.convertToStableNodeId may be used to return a corresponding UUID that is globally unique and stable.
+	 * @param override - if supplied, calls to `convertToStableNodeId` using the returned node ID will return the override instead of
+	 * the UUID. Calls to `generateNodeId` with the same override always return the same ID. Performance note: passing an override string
+	 * incurs a storage cost that is significantly higher that a node ID without one, and should be avoided if possible.
 	 * @public
 	 */
 	public generateNodeId(override?: string): NodeId {
 		return this.idCompressor.generateCompressedId(override) as NodeId;
 	}
 
-	/** {@inheritdoc NodeIdConverter.convertToStableNodeId} */
+	/**
+	 * Given a NodeId, returns the corresponding stable ID or throws if the supplied node ID was not generated with this tree (`NodeId`s
+	 * may not be used across SharedTree instances, see `generateNodeId` for more).
+	 * The returned value will be a UUID, unless the creation of `id` used an override string (see `generateNodeId` for more).
+	 * The result is safe to persist and re-use across `SharedTree` instances, unlike `NodeId`.
+	 * @public
+	 */
 	public convertToStableNodeId(id: NodeId): StableNodeId {
 		return (this.idCompressor.tryDecompress(id) as StableNodeId) ?? fail('Node id is not known to this SharedTree');
 	}
 
-	/** {@inheritdoc NodeIdConverter.tryConvertToStableNodeId} */
+	/**
+	 * Given a NodeId, attempt to return the corresponding stable ID.
+	 * The returned value will be a UUID, unless the creation of `id` used an override string (see `generateNodeId` for more).
+	 * The returned stable ID is undefined if `id` was never created with this SharedTree. If a stable ID is returned, this does not imply
+	 * that there is a node with `id` in the current revision of the tree, only that `id` was at some point generated by some instance of
+	 * this tree.
+	 * @public
+	 */
 	public tryConvertToStableNodeId(id: NodeId): StableNodeId | undefined {
 		return this.idCompressor.tryDecompress(id) as StableNodeId | undefined;
 	}
 
-	/** {@inheritdoc NodeIdConverter.convertToNodeId} */
+	/**
+	 * Given a stable ID, return the corresponding NodeId or throws if the supplied stable ID was never generated with this tree, either
+	 * as a UUID corresponding to a `NodeId` or as an override passed to `generateNodeId`.
+	 * If a stable ID is returned, this does not imply that there is a node with `id` in the current revision of the tree, only that
+	 * `id` was at some point generated by an instance of this SharedTree.
+	 * @public
+	 */
 	public convertToNodeId(id: StableNodeId): NodeId {
 		return (
 			(this.idCompressor.tryRecompress(id) as NodeId) ?? fail('Stable node id is not known to this SharedTree')
 		);
 	}
 
-	/** {@inheritdoc NodeIdConverter.tryConvertToNodeId} */
+	/**
+	 * Given a stable ID, return the corresponding NodeId or return undefined if the supplied stable ID was never generated with this tree,
+	 * either as a UUID corresponding to a `NodeId` or as an override passed to `generateNodeId`.
+	 * If a stable ID is returned, this does not imply that there is a node with `id` in the current revision of the tree, only that
+	 * `id` was at some point generated by an instance of this SharedTree.
+	 * @public
+	 */
 	public tryConvertToNodeId(id: StableNodeId): NodeId | undefined {
 		return this.idCompressor.tryRecompress(id) as NodeId | undefined;
 	}
@@ -835,7 +870,6 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 			this.expensiveValidation,
 			editStatusCallback,
 			sequencedEditResultCallback,
-			this.transactionFactory,
 			0
 		);
 
@@ -863,7 +897,7 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	}
 
 	/**
-	 * Compares this shared tree to another for equality. Should only be used for correctness testing.
+	 * Compares this shared tree to another for equality. Should only be used for internal correctness testing.
 	 *
 	 * Equality means that the histories as captured by the EditLogs are equivalent.
 	 *
@@ -942,7 +976,9 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 				}
 				// TODO: This cast can be removed on typescript 4.6
 				const edit = this.parseSequencedEdit(op as SharedTreeEditOp | SharedTreeEditOp_0_0_2);
-				this.internStringsFromEdit(edit);
+				if (op.version === WriteFormat.v0_1_1) {
+					this.internStringsFromEdit(edit);
+				}
 				this.processSequencedEdit(edit, typedMessage);
 			}
 		} else if (type === SharedTreeOpType.Update) {
@@ -1083,9 +1119,8 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	}
 
 	private upgradeFrom_0_0_2_to_0_1_1(): void {
-		for (let i = 0; i < this.editLog.numberOfSequencedEdits; i++) {
-			this.internStringsFromEdit(this.editsInternal.getEditInSessionAtIndex(i));
-		}
+		// Reset the string interner, re-populate only with information that there is consensus on
+		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
@@ -1109,11 +1144,20 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 			// All clients have the full history, and can therefore all "generate" the same final IDs for every ID in the history
 			// via the ghost compressor.
 			unifyHistoricalIds(ghostContext);
+			// The same logic applies to string interning, so intern all the strings in the history (superset of those in the current view)
+			for (let i = 0; i < this.editLog.numberOfSequencedEdits; i++) {
+				this.internStringsFromEdit(this.editsInternal.getEditInSessionAtIndex(i));
+			}
 		} else {
 			// Clients do not have the full history, but all share the same current view (sequenced). They can all finalize the same final
 			// IDs for every ID in the view via the ghost compressor.
+			// The same logic applies for the string interner.
 			for (const node of this.logViewer.getRevisionViewInSession(this.editLog.numberOfSequencedEdits)) {
 				ghostContext.generateNodeId(this.convertToStableNodeId(node.identifier));
+				this.interner.getOrCreateInternedId(node.definition);
+				for (const label of [...node.traits.keys()].sort()) {
+					this.interner.getOrCreateInternedId(label);
+				}
 			}
 			// Every node in this client's history can simply be generated in the new compressor as well, preserving the UUID
 			unifyHistoricalIds(newContext);
@@ -1124,12 +1168,16 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	}
 
 	/**
-	 * Add an `Edit` directly.
-	 * External users should use one of the more specialized functions, like applyEdit which handles constructing the actual `Edit` object.
-	 * This is exposed as it is useful for testing, particularly with invalid and malformed Edits.
-	 * @internal
+	 * Applies a set of changes to this tree. The result will be reflected in `SharedTree.currentView`.
+	 * This method does not allow for snapshot isolation, as the changes are always applied to the most recent revision.
+	 * If it is desireable to read from and apply changes to a fixed view that does not change when remote changes arrive, `Checkout`
+	 * should be used instead.
+	 * @public
 	 */
-	public applyEdit(...changes: readonly Change[]): Edit<unknown> {
+	public applyEdit(...changes: Change[]): Edit<unknown>;
+	public applyEdit(changes: Change[]): Edit<unknown>;
+	public applyEdit(headOrChanges: Change | Change[], ...tail: Change[]): Edit<unknown> {
+		const changes = Array.isArray(headOrChanges) ? headOrChanges : [headOrChanges, ...tail];
 		const id = newEditId();
 		const internalEdit: Edit<ChangeInternal> = {
 			id,
@@ -1141,6 +1189,10 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	}
 
 	/**
+	 * Applies a set of internal changes to this tree. The result will be reflected in `SharedTree.currentView`.
+	 * External users should use one of the more specialized functions, like `applyEdit` which handles constructing the actual `Edit`
+	 * and uses public Change types.
+	 * This is exposed for internal use only.
 	 * @internal
 	 */
 	public applyEditInternal(editOrChanges: Edit<ChangeInternal> | readonly ChangeInternal[]): Edit<ChangeInternal> {
@@ -1157,7 +1209,8 @@ export class SharedTree extends SharedObject<ISharedTreeEvents> implements NodeI
 	}
 
 	/**
-	 * Given a newly constructed edit, add any necessary metadata
+	 * Converts a public Change type to an internal representation.
+	 * This is exposed for internal use only.
 	 * @internal
 	 */
 	public internalizeChange(change: Change): ChangeInternal {

package/src/Transaction.ts

@@ -3,6 +3,8 @@
  * Licensed under the MIT License.
  */
 
+import { IErrorEvent } from '@fluidframework/common-definitions';
+import { TypedEventEmitter } from '@fluidframework/common-utils';
 import { ChangeInternal, Edit, EditStatus } from './persisted-types';
 import { newEditId } from './EditUtilities';
 import { TreeView } from './TreeView';
@@ -11,16 +13,32 @@ import { SharedTree } from './SharedTree';
 import { GenericTransaction, TransactionInternal } from './TransactionInternal';
 import { CachingLogViewer } from './LogViewer';
 
+/**
+ * An event emitted by a `Transaction` to indicate a state change. See {@link TransactionEvents} for event argument information.
+ * @public
+ */
+export enum TransactionEvent {
+	/**
+	 * `currentView` has changed from `before` to `after`
+	 */
+	ViewChange = 'viewChange',
+}
+
+/**
+ * Events which may be emitted by `Transaction`
+ */
+export interface TransactionEvents extends IErrorEvent {
+	(event: TransactionEvent.ViewChange, listener: (before: TreeView, after: TreeView) => void);
+}
+
 /**
  * Buffers changes to be applied to an isolated view of a `SharedTree` over time before applying them directly to the tree itself as a
  * single edit
  */
-export class Transaction {
+export class Transaction extends TypedEventEmitter<TransactionEvents> {
 	/** The view of the tree when this transaction was created */
 	public readonly startingView: TreeView;
-
 	private readonly transaction: GenericTransaction;
-	private open: boolean = true;
 
 	/**
 	 * Create a new transaction over the given tree. The tree's `currentView` at this time will become the `startingView` for this
@@ -28,6 +46,7 @@ export class Transaction {
 	 * @param tree - the `SharedTree` that this transaction applies changes to
 	 */
 	public constructor(public readonly tree: SharedTree) {
+		super();
 		const { currentView } = tree;
 		this.transaction = new GenericTransaction(currentView, new TransactionInternal.Policy());
 		this.startingView = currentView;
@@ -38,7 +57,7 @@ export class Transaction {
 	 * be automatically closed by a change in this transaction failing to apply (see `applyChange()`).
 	 */
 	public get isOpen(): boolean {
-		return this.open && this.status === EditStatus.Applied;
+		return this.transaction.isOpen && this.status === EditStatus.Applied;
 	}
 
 	/**
@@ -59,18 +78,26 @@ export class Transaction {
 	/**
 	 * Attempt to apply a sequence of changes in this transaction. The `currentView` will be updated to reflect the new tree state after all
 	 * applied changes. If any change fails to apply, the remaining changes will be ignored and this transaction will be automatically
-	 * closed (see `isOpen`). If this transaction is already closed, this method has no effect.
+	 * closed (see `isOpen`). If this transaction is already closed, this method has no effect. This method will emit a
+	 * `TransactionEvent.ViewChange` event at most once per call.
 	 * @param changes - the changes to apply
 	 * @returns either the `EditStatus` of the given changes or the `EditStatus` of the last change before the transaction was closed
 	 */
-	public apply(change: Change, ...changes: Change[]): EditStatus;
+	public apply(...changes: Change[]): EditStatus;
 	public apply(changes: Change[]): EditStatus;
-	public apply(changeOrChanges: Change | Change[], ...changes: Change[]): EditStatus {
+	public apply(headOrChanges: Change | Change[], ...tail: Change[]): EditStatus {
 		if (this.isOpen) {
-			const changeArray = Array.isArray(changeOrChanges)
-				? [...changeOrChanges, ...changes]
-				: [changeOrChanges, ...changes];
-			this.transaction.applyChanges(changeArray.map((c) => this.tree.internalizeChange(c)));
+			const changes = Array.isArray(headOrChanges) ? headOrChanges : [headOrChanges, ...tail];
+			if (changes.length > 0) {
+				const previousView = this.currentView;
+				this.transaction.applyChanges(changes.map((c) => this.tree.internalizeChange(c)));
+				if (
+					this.listenerCount(TransactionEvent.ViewChange) > 0 &&
+					!previousView.hasEqualForest(this.currentView)
+				) {
+					this.emit(TransactionEvent.ViewChange, previousView, this.currentView);
+				}
+			}
 		}
 		return this.status;
 	}
@@ -81,14 +108,13 @@ export class Transaction {
 	public closeAndCommit(): void {
 		if (this.isOpen) {
 			if (this.transaction.changes.length > 0) {
-				const edit: Edit<ChangeInternal> = { id: newEditId(), changes: this.transaction.changes };
 				const result = this.transaction.close();
+				const edit: Edit<ChangeInternal> = { id: newEditId(), changes: result.changes };
 				if (this.tree.editsInternal instanceof CachingLogViewer) {
 					this.tree.editsInternal.setKnownEditingResult(edit, result);
 				}
 				this.tree.applyEditInternal(edit);
 			}
-			this.open = false;
 		}
 	}
 }

package/src/TransactionInternal.ts

@@ -34,12 +34,6 @@ import { RevisionView, TransactionView } from './RevisionView';
 import { ReconciliationChange, ReconciliationPath } from './ReconciliationPath';
 import { TreeViewNode } from './TreeView';
 
-/**
- * A function which can produce a Transaction from a RevisionView
- * @public
- */
-export type TransactionFactory = (view: RevisionView) => GenericTransaction;
-
 /**
  * Result of applying a transaction.
  * @public
@@ -192,7 +186,7 @@ export class GenericTransaction {
 	private readonly policy: GenericTransactionPolicy;
 	protected readonly before: RevisionView;
 	private state: TransactionState;
-	private isOpen = true;
+	private open = true;
 
 	/**
 	 * Create and open an edit of the provided `TreeView`. After applying 0 or more changes, this editor should be closed via `close()`.
@@ -209,6 +203,11 @@ export class GenericTransaction {
 		};
 	}
 
+	/** Whether or not this transaction has been closed via `close()` */
+	public get isOpen(): boolean {
+		return this.open;
+	}
+
 	/**
 	 * The most up-to-date `TreeView` for this edit. This is the state of the tree after all changes applied so far.
 	 */
@@ -239,8 +238,8 @@ export class GenericTransaction {
 
 	/** @returns the final `EditStatus` and `TreeView` after all changes are applied. */
 	public close(): EditingResult {
-		assert(this.isOpen, 'transaction has already been closed');
-		this.isOpen = false;
+		assert(this.open, 'transaction has already been closed');
+		this.open = false;
 		if (this.state.status === EditStatus.Applied) {
 			const validation = this.policy.validateOnClose(this.state);
 			if (Result.isOk(validation)) {
@@ -337,7 +336,7 @@ export class GenericTransaction {
 	 * @returns this
 	 */
 	public applyChange(change: ChangeInternal, path: ReconciliationPath = []): this {
-		assert(this.isOpen, 'Editor must be open to apply changes.');
+		assert(this.open, 'Editor must be open to apply changes.');
 		if (this.state.status !== EditStatus.Applied) {
 			fail('Cannot apply change to an edit unless all previous changes have applied');
 		}

package/src/TreeCompressor.ts

@@ -7,7 +7,7 @@ import type { Definition, DetachedSequenceId, InternedStringId, OpSpaceNodeId, T
 import type { StringInterner } from './StringInterner';
 import type { CompressedTraits, CompressedPlaceholderTree, PlaceholderTree, Payload } from './persisted-types';
 import type { ContextualizedNodeIdNormalizer } from './NodeIdUtilities';
-import { assert, fail } from './Common';
+import { assert, fail, Mutable } from './Common';
 
 /**
  * Compresses a given {@link PlaceholderTree} into a more compact serializable format.
@@ -122,22 +122,21 @@ export class InterningTreeCompressor<TPlaceholder extends DetachedSequenceId | n
 		}
 
 		let compressedId: TId | undefined;
-		let compressedTraits: CompressedTraits<TId, TPlaceholder> | undefined;
+		let compressedTraits:
+			| [Payload, ...CompressedTraits<TId, TPlaceholder>]
+			| CompressedTraits<TId, TPlaceholder>
+			| undefined;
 		let payload: Payload | undefined;
 		const [maybeInternedDefinition, idOrPayloadTraits, payloadTraits] = node;
 		if (idOrPayloadTraits !== undefined) {
 			if (typeof idOrPayloadTraits === 'number') {
 				compressedId = idOrPayloadTraits;
 				if (payloadTraits !== undefined) {
-					({ compressedTraits, payload } = this.parseTraitsAndPayload(payloadTraits));
+					compressedTraits = payloadTraits;
 				}
 			} else {
 				// TODO: This cast can be removed on typescript 4.6
-				({ compressedTraits, payload } = this.parseTraitsAndPayload(
-					idOrPayloadTraits as
-						| [Payload, ...CompressedTraits<TId, TPlaceholder>]
-						| CompressedTraits<TId, TPlaceholder>
-				));
+				compressedTraits = idOrPayloadTraits as typeof compressedTraits;
 			}
 		}
 
@@ -146,14 +145,30 @@ export class InterningTreeCompressor<TPlaceholder extends DetachedSequenceId | n
 				? maybeInternedDefinition
 				: // TODO: This cast can be removed on typescript 4.6
 				  (interner.getString(maybeInternedDefinition as number) as Definition);
-		const identifier = compressedId ?? (getNextElidedId(this.previousId ?? fail()) as TId);
+
+		let identifier: TId;
+		if (compressedId !== undefined) {
+			identifier = compressedId;
+		} else {
+			const prevId = this.previousId ?? fail();
+			identifier = prevId < 0 ? ((prevId - 1) as TId) : (((prevId as number) + 1) as TId);
+		}
 		this.previousId = identifier;
 
 		const traits = {};
 		if (compressedTraits !== undefined) {
-			for (let i = 0; i < Object.entries(compressedTraits).sort().length; i += 2) {
-				const maybeCompressedLabel = compressedTraits[i] as InternedStringId;
-				const compressedChildren = compressedTraits[i + 1] as (
+			let offset: number;
+			if (compressedTraits.length % 2 === 1) {
+				offset = 1;
+				payload = compressedTraits[0];
+			} else {
+				offset = 0;
+			}
+			const traitsLength = compressedTraits.length - offset;
+			for (let i = 0; i < traitsLength; i += 2) {
+				const offsetIndex = i + offset;
+				const maybeCompressedLabel = compressedTraits[offsetIndex] as InternedStringId;
+				const compressedChildren = compressedTraits[offsetIndex + 1] as (
 					| TPlaceholder
 					| CompressedPlaceholderTree<TId, TPlaceholder>
 				)[];
@@ -170,42 +185,18 @@ export class InterningTreeCompressor<TPlaceholder extends DetachedSequenceId | n
 			}
 		}
 
-		const decompressedNode = {
+		const decompressedNode: Mutable<PlaceholderTree<TPlaceholder>> = {
 			identifier: idNormalizer.normalizeToSessionSpace(identifier),
 			definition,
 			traits,
-			...(payload !== undefined ? { payload } : {}),
 		};
 
-		return decompressedNode;
-	}
-
-	private parseTraitsAndPayload<TId extends OpSpaceNodeId>(
-		traitsAndPayload: [Payload, ...CompressedTraits<TId, TPlaceholder>] | CompressedTraits<TId, TPlaceholder>
-	): {
-		compressedTraits: CompressedTraits<TId, TPlaceholder>;
-		payload?: Payload;
-	} {
-		if (traitsAndPayload.length % 2 === 1) {
-			return {
-				compressedTraits: traitsAndPayload.slice(1),
-				payload: traitsAndPayload[0],
-			};
+		if (payload !== undefined) {
+			decompressedNode.payload = payload;
 		}
 
-		return {
-			compressedTraits: traitsAndPayload,
-		};
-	}
-}
-
-function getNextElidedId<TId extends OpSpaceNodeId>(id: TId): TId {
-	const numericId: number = id;
-	if (numericId < 0) {
-		return (numericId - 1) as TId;
+		return decompressedNode;
 	}
-
-	return (numericId + 1) as TId;
 }
 
 function canElideId<TId extends OpSpaceNodeId>(previousId: TId | undefined, id: TId): boolean {

package/src/TreeView.ts

@@ -291,8 +291,9 @@ export abstract class TreeView {
 
 	private *iterateNodeDescendants(node: TreeViewNode): IterableIterator<TreeViewNode> {
 		yield node;
-		for (const trait of Array.from(node.traits.values()).sort()) {
-			for (const childId of trait) {
+		for (const label of [...node.traits.keys()].sort()) {
+			const trait = node.traits.get(label);
+			for (const childId of trait ?? fail('Expected trait with label')) {
 				const child = this.getViewNode(childId);
 				yield* this.iterateNodeDescendants(child);
 			}

package/src/index.ts

@@ -111,7 +111,6 @@ export {
 export { comparePayloads } from './PayloadUtilities';
 export {
 	TransactionInternal,
-	TransactionFactory,
 	GenericTransaction,
 	GenericTransactionPolicy,
 	EditingResult,