@fluid-experimental/tree 0.59.3003 → 0.59.4000

package/src/id-compressor/IdCompressor.ts

@@ -31,7 +31,7 @@ import {
 	AttributionId,
 } from '../Identifiers';
 import { assertIsStableId, assertIsUuidString, isStableId } from '../UuidUtilities';
-import { AppendOnlyDoublySortedMap, AppendOnlySortedMap } from './AppendOnlySortedMap';
+import { AppendOnlySortedMap } from './AppendOnlySortedMap';
 import { getIds } from './IdRange';
 import {
 	numericUuidEquals,
@@ -54,6 +54,7 @@ import type {
 	UnackedLocalId,
 	VersionedSerializedIdCompressor,
 } from './persisted-types';
+import { SessionIdNormalizer } from './SessionIdNormalizer';
 
 /**
  * A cluster of final (sequenced via consensus), sequentially allocated compressed IDs.
@@ -91,6 +92,11 @@ interface IdCluster {
 	 * 		string are created by different sessions before any have been finalized. This can occur due to concurrency or offline.
 	 * 		In this case, the string is stored for the final ID that got sequenced first, and that final ID is stored associated with
 	 * 		all subsequent final IDs with the same override.
+	 * When a final ID which is safely reserved via consensus as part of a cluster (but is not yet sequenced) is allocated with an
+	 * override, this collection will be temporarily inaccurate as it will not contain an entry for that final ID. This absence indicates
+	 * the uncertainty about what the final ID associated with that override will be after finalizing the range (which could change due
+	 * to unification of a concurrent duplicate override). This table will be adjusted to reflect the override when that final ID is
+	 * finalized via consensus, and decompression will use `clustersAndOverridesInversion` until that point.
 	 */
 	overrides?: Map<FinalCompressedId, string | UnifiedOverride>;
 }
@@ -154,31 +160,6 @@ export function isLocalId(id: CompressedId): id is LocalCompressedId {
 	return id < 0;
 }
 
-/**
- * A object for retrieving the session-space IDs for a range of IDs.
- * Optimized to avoid allocating an array of IDs.
- */
-export interface IdRange {
-	/**
-	 * The length of the ID range.
-	 */
-	readonly length: number;
-
-	/**
-	 * Returns the ID in range at the provided index.
-	 */
-	get(index: number): SessionSpaceCompressedId;
-}
-
-/**
- * A serializable descriptor of a range of session-space IDs.
- * The contained IDs must be retrieved by calling `getIdsFromRange`, which returns an `IdRange`.
- */
-export interface IdRangeDescriptor<TId extends LocalCompressedId | OpSpaceCompressedId> {
-	readonly first: TId;
-	readonly count: number;
-}
-
 /**
  * A cluster in `clustersAndOverridesInversion`, which is mapped from the first stable ID in a cluster.
  */
@@ -352,15 +333,21 @@ export class IdCompressor {
 	private readonly localOverrides = new AppendOnlySortedMap<LocalCompressedId, string>(compareFiniteNumbersReversed);
 
 	/**
-	 * Maps local IDs to the cluster they belong to (if any). This can be used to efficiently convert a local ID to a
-	 * final ID by finding an entry \<= a given local ID (to find the cluster it is associated with) and checking
-	 * it against `numFinalizedLocalIds`.
+	 * Maps local IDs to the final ID they are associated with (if any), and maps final IDs to the corresponding local ID (if any).
+	 * This is used to efficiently compute normalization. This map can be thought of as mapping ranges of "optimistic uncertainty"
+	 * (local IDs) to the result of consensus (reserved ranges of final IDs, a.k.a. clusters). Any given range of local IDs
+	 * does not necessarily span an entire cluster, as some session-space IDs may be allocated *after* a cluster has been allocated
+	 * but before it is full. In this case, there is no uncertainty, as the range of final IDs was reserved when the cluster was created.
+	 * However, there is always a range of local IDs with size \>= 1 associated with the beginning of every cluster, as clusters are only
+	 * created *after* they are needed and thus there is some period of uncertainty after local IDs have been handed out but before the
+	 * range containing them has been finalized. There may also be ranges of local IDs that do not start at the beginning of a
+	 * cluster; this happens when a cluster is expanded instead of allocating a new one.
+	 * Additionally, session space IDs associated with an override string will also always be local IDs, because there is uncertainty as
+	 * to whether another client simultaneously allocated the same override and could get sequenced first (a.k.a. unification) and its
+	 * final ID would be associated with that override.
+	 * See `SessionIdNormalizer` for more.
 	 */
-	private readonly localIdToCluster: AppendOnlyDoublySortedMap<
-		LocalCompressedId,
-		[FinalCompressedId, IdCluster],
-		FinalCompressedId
-	> = new AppendOnlyDoublySortedMap(compareFiniteNumbersReversed, (value) => value[0], compareFiniteNumbers);
+	private sessionIdNormalizer = new SessionIdNormalizer<IdCluster>();
 
 	/**
 	 * Contains entries for cluster base UUIDs and override strings (both local and final).
@@ -383,13 +370,6 @@ export class IdCompressor {
 		compareFiniteNumbers
 	);
 
-	/**
-	 * Helper comparator for searching append-only sorted maps.
-	 */
-	private static overrideComparator<T extends number>(search: T, element: readonly [T, unknown]): number {
-		return compareFiniteNumbers(search, element[0]);
-	}
-
 	/**
 	 * @param localSessionId - the `IdCompressor`'s current local session ID.
 	 * @param reservedIdCount - the number of IDs that will be known by this compressor without relying on consensus.
@@ -467,11 +447,8 @@ export class IdCompressor {
 	/**
 	 * Returns an iterable of all IDs created by this compressor.
 	 */
-	public *getAllIdsFromLocalSession(): IterableIterator<SessionSpaceCompressedId> {
-		// TODO: this will change when final IDs are returned eagerly
-		for (let i = 1; i <= this.localIdCount; i++) {
-			yield -i as LocalCompressedId;
-		}
+	public getAllIdsFromLocalSession(): IterableIterator<SessionSpaceCompressedId> {
+		return this.sessionIdNormalizer[Symbol.iterator]();
 	}
 
 	/**
@@ -482,74 +459,16 @@ export class IdCompressor {
 		if (isLocalId(opSpaceNormalizedId)) {
 			return this.attributionId;
 		}
-		const [_, cluster] =
-			this.getClusterForFinalId(opSpaceNormalizedId) ?? fail('Cluster does not exist for final ID');
-
-		return cluster.session.attributionId;
-	}
-
-	/**
-	 * Provides the session-space IDs corresponding to a range of IDs.
-	 * See `IdRange` for more details.
-	 */
-	public getIdsFromRange(
-		rangeDescriptor: IdRangeDescriptor<SessionSpaceCompressedId>,
-		sessionId: SessionId
-	): IdRange {
-		const { first, count } = rangeDescriptor;
-		if (sessionId === this.localSessionId) {
-			return {
-				length: count,
-				get: (index: number) => {
-					if (index < 0 || index >= count) {
-						fail('Index out of bounds of range.');
-					}
-					return (first - index) as LocalCompressedId;
-				},
-			};
-		} else {
-			const session = this.sessions.get(sessionId) ?? fail('Unknown session, range may not be finalized.');
-			const firstNumericUuid = incrementUuid(session.sessionUuid, -first - 1);
-			const firstFinal =
-				this.compressNumericUuid(firstNumericUuid) ??
-				fail('Remote range must be finalized before getting IDs.');
-			assert(
-				isFinalId(firstFinal),
-				'ID from a remote session ID must have final form, as overrides are impossible by definition.'
-			);
-			const [baseFinalId, cluster] = this.getClusterForFinalId(firstFinal) ?? fail();
-			const numIdsRemainingInFirstCluster = cluster.capacity - (firstFinal - baseFinalId);
-			let pivotFinal: FinalCompressedId | undefined;
-			if (count > numIdsRemainingInFirstCluster) {
-				const compressedPivot = this.compressNumericUuid(
-					incrementUuid(firstNumericUuid, numIdsRemainingInFirstCluster)
-				);
-				// Looking up the actual cluster can be avoided, as it is guaranteed that at most one new cluster will be
-				// created when finalizing a range (regardless of size) due to the expansion optimization.
-				if (compressedPivot === undefined || isLocalId(compressedPivot)) {
-					fail(
-						'ID from a remote session ID must have final form, as overrides are impossible by definition.'
-					);
-				} else {
-					pivotFinal = compressedPivot;
-				}
+		const closestCluster = this.getClusterForFinalId(opSpaceNormalizedId);
+		if (closestCluster === undefined) {
+			if (this.sessionIdNormalizer.getCreationIndex(opSpaceNormalizedId) !== undefined) {
+				return this.attributionId;
+			} else {
+				fail('Cluster does not exist for final ID');
 			}
-
-			return {
-				length: count,
-				get: (index: number) => {
-					if (index < 0 || index >= count) {
-						fail('Index out of bounds of range.');
-					}
-					if (index < numIdsRemainingInFirstCluster) {
-						return (firstFinal + index) as FinalCompressedId & SessionSpaceCompressedId;
-					} else {
-						return ((pivotFinal ?? fail('Pivot must exist if range spans clusters.')) +
-							(index - numIdsRemainingInFirstCluster)) as FinalCompressedId & SessionSpaceCompressedId;
-					}
-				},
-			};
 		}
+		const [_, cluster] = closestCluster;
+		return cluster.session.attributionId;
 	}
 
 	/**
@@ -636,19 +555,35 @@ export class IdCompressor {
 			cluster: undefined,
 			clusterBase: undefined,
 		};
+		const currentClusterExists = currentCluster !== undefined && currentBaseFinalId !== undefined;
 
-		const normalizedLastFinalized = session.lastFinalizedLocalId ?? 0;
-		const { first: newFirstFinalizedLocalId, last: newLastFinalizedLocalId } = ids;
-		assert(newFirstFinalizedLocalId === normalizedLastFinalized - 1, 'Ranges finalized out of order.');
+		const normalizedLastFinalizedLocal = session.lastFinalizedLocalId ?? 0;
+		const { first: newFirstFinalizedLocal, last: newLastFinalizedLocal } = ids;
+		assert(newFirstFinalizedLocal === normalizedLastFinalizedLocal - 1, 'Ranges finalized out of order.');
 
 		// The total number of session-local IDs to finalize
-		const finalizeCount = normalizedLastFinalized - newLastFinalizedLocalId;
+		const finalizeCount = normalizedLastFinalizedLocal - newLastFinalizedLocal;
 		assert(finalizeCount >= 1, 'Cannot finalize an empty range.');
 
 		let initialClusterCount = 0;
 		let remainingCount = finalizeCount;
 		let newBaseUuid: NumericUuid | undefined;
-		if (currentCluster !== undefined && currentBaseFinalId !== undefined) {
+		if (currentClusterExists) {
+			if (isLocal) {
+				const lastKnownFinal =
+					this.sessionIdNormalizer.getLastFinalId() ??
+					fail('Cluster exists but normalizer does not have an entry for it.');
+				const lastFinalInCluster = (currentBaseFinalId +
+					Math.min(currentCluster.count + finalizeCount, currentCluster.capacity) -
+					1) as FinalCompressedId;
+				if (lastFinalInCluster > lastKnownFinal) {
+					this.sessionIdNormalizer.addFinalIds(
+						(lastKnownFinal + 1) as FinalCompressedId,
+						lastFinalInCluster,
+						currentCluster
+					);
+				}
+			}
 			initialClusterCount = currentCluster.count;
 			const remainingCapacity = currentCluster.capacity - initialClusterCount;
 			const overflow = remainingCount - remainingCapacity;
@@ -668,6 +603,21 @@ export class IdCompressor {
 						'The number of allocated final IDs must not exceed the JS maximum safe integer.'
 					);
 					this.checkClusterForCollision(currentCluster);
+					if (isLocal) {
+						// Example with cluster size of 3:
+						// Ids generated so far:   -1  1  2 -4 -5  <-- note positive numbers are eager finals
+						//         Cluster:      [  0  1  2 ]
+						// ~ finalizing happens, causing expansion ~
+						//        Cluster:       [  0  1  2  3  4  5 ]
+						// corresponding locals:   -1       -4
+						//      lastFinalizedLocalId^              ^newLastFinalizedLocalId = -6
+						//                  overflow = 2:    ----
+						//                       localIdPivot^
+						//                    lastFinalizedFinal^
+						const lastFinalizedFinal = (currentBaseFinalId + currentCluster.count - 1) as FinalCompressedId;
+						const finalPivot = (lastFinalizedFinal - overflow + 1) as FinalCompressedId;
+						this.sessionIdNormalizer.addFinalIds(finalPivot, lastFinalizedFinal, currentCluster);
+					}
 				}
 			} else {
 				// The range cannot be fully allocated in the existing cluster, so allocate any space left in it and
@@ -710,10 +660,11 @@ export class IdCompressor {
 			};
 
 			const usedCapacity = finalizeCount - remainingCount;
-			localIdPivot = (newFirstFinalizedLocalId - usedCapacity) as LocalCompressedId;
+			localIdPivot = (newFirstFinalizedLocal - usedCapacity) as LocalCompressedId;
 
 			if (isLocal) {
-				this.localIdToCluster.append(localIdPivot, [newBaseFinalId, newCluster]);
+				const lastFinalizedFinal = (newBaseFinalId + newCluster.count - 1) as FinalCompressedId;
+				this.sessionIdNormalizer.addFinalIds(newBaseFinalId, lastFinalizedFinal, newCluster);
 			}
 
 			this.checkClusterForCollision(newCluster);
@@ -737,11 +688,8 @@ export class IdCompressor {
 				const [overriddenLocal, override] = overrides[i];
 				// Note: recall that local IDs are negative
 				assert(i === 0 || overriddenLocal < overrides[i - 1][0], 'Override IDs must be in sorted order.');
-				assert(overriddenLocal < normalizedLastFinalized, 'Ranges finalized out of order.');
-				assert(
-					overriddenLocal >= newLastFinalizedLocalId,
-					'Malformed range: override ID ahead of range start.'
-				);
+				assert(overriddenLocal < normalizedLastFinalizedLocal, 'Ranges finalized out of order.');
+				assert(overriddenLocal >= newLastFinalizedLocal, 'Malformed range: override ID ahead of range start.');
 				let cluster: IdCluster;
 				let overriddenFinal: FinalCompressedId;
 				if (localIdPivot !== undefined && overriddenLocal <= localIdPivot) {
@@ -761,7 +709,7 @@ export class IdCompressor {
 					cluster = currentCluster;
 					overriddenFinal = (currentBaseFinalId +
 						initialClusterCount +
-						(normalizedLastFinalized - overriddenLocal) -
+						(normalizedLastFinalizedLocal - overriddenLocal) -
 						1) as FinalCompressedId;
 				}
 				cluster.overrides ??= new Map();
@@ -831,7 +779,7 @@ export class IdCompressor {
 			}
 		}
 
-		session.lastFinalizedLocalId = newLastFinalizedLocalId;
+		session.lastFinalizedLocalId = newLastFinalizedLocal;
 	}
 
 	private checkClusterForCollision(cluster: IdCluster): void {
@@ -926,9 +874,9 @@ export class IdCompressor {
 			(IdCompressor.isStableInversionKey(inversionKey) ? inversionKey : undefined);
 
 		if (override !== undefined) {
-			const localId = this.getLocalIdForStableId(override);
-			if (localId !== undefined) {
-				return localId;
+			const sessionSpaceId = this.getCompressedIdForStableId(override);
+			if (sessionSpaceId !== undefined) {
+				return sessionSpaceId;
 			}
 		}
 
@@ -974,44 +922,51 @@ export class IdCompressor {
 	 * @returns an existing ID if one already exists for `override`, and a new local ID otherwise. The returned ID is in session space.
 	 */
 	public generateCompressedId(override?: string): SessionSpaceCompressedId {
-		// If any ID exists for this override (locally or remotely allocated), return it (after ensuring it is in session-space).
+		let overrideInversionKey: InversionKey | undefined;
 		if (override !== undefined) {
-			const inversionKey = IdCompressor.createInversionKey(override);
-			const existingIds = this.getExistingIdsForNewOverride(inversionKey, false);
+			overrideInversionKey = IdCompressor.createInversionKey(override);
+			const existingIds = this.getExistingIdsForNewOverride(overrideInversionKey, false);
 			if (existingIds !== undefined) {
 				return typeof existingIds === 'number' ? existingIds : existingIds[0];
-			} else {
-				const newLocalId = this.generateNextLocalId();
-				this.localOverrides.append(newLocalId, override);
-				// Since the local ID was just created, it is in both session and op space
-				const compressionMapping = newLocalId as UnackedLocalId;
-				this.clustersAndOverridesInversion.set(inversionKey, compressionMapping);
-				return newLocalId;
 			}
-		} else {
-			return this.generateNextLocalId();
 		}
-	}
 
-	/**
-	 * Generates a range of compressed IDs.
-	 * This should ONLY be called to generate IDs for local operations.
-	 * @param count - the number of IDs to generate, must be \> 0.
-	 * @returns a persistable descriptor of the ID range.
-	 */
-	public generateCompressedIdRange(count: number): IdRangeDescriptor<LocalCompressedId> {
-		assert(count > 0, 'Must generate a nonzero number of IDs.');
-		assert(
-			count <= Number.MAX_SAFE_INTEGER,
-			'The number of allocated local IDs must not exceed the JS maximum safe integer.'
-		);
-		const first = this.generateNextLocalId();
-		this.localIdCount += count - 1;
-		return { first, count };
-	}
+		// Bump local counter regardless, then attempt to optimistically return a final ID.
+		// If the local session has reserved a cluster range via consensus, it is safe to hand out final IDs prior to
+		// finalizing the range that includes these locals.
+		const newLocalId = -++this.localIdCount as LocalCompressedId;
+		const { currentClusterDetails } = this.localSession;
+		const { sessionIdNormalizer } = this;
+		let eagerFinalId: (FinalCompressedId & SessionSpaceCompressedId) | undefined;
+		let cluster: IdCluster | undefined;
+		if (currentClusterDetails !== undefined) {
+			const { clusterBase } = currentClusterDetails;
+			cluster = currentClusterDetails.cluster;
+			const lastFinalKnown = sessionIdNormalizer.getLastFinalId();
+			if (lastFinalKnown !== undefined && lastFinalKnown - clusterBase + 1 < cluster.capacity) {
+				eagerFinalId = (lastFinalKnown + 1) as FinalCompressedId & SessionSpaceCompressedId;
+			}
+		}
 
-	private generateNextLocalId(): LocalCompressedId {
-		return -++this.localIdCount as LocalCompressedId;
+		if (overrideInversionKey !== undefined) {
+			const registeredLocal = sessionIdNormalizer.addLocalId();
+			assert(registeredLocal === newLocalId, 'TODO');
+			if (eagerFinalId !== undefined) {
+				sessionIdNormalizer.addFinalIds(eagerFinalId, eagerFinalId, cluster ?? fail());
+			}
+			this.localOverrides.append(newLocalId, override ?? fail());
+			// Since the local ID was just created, it is in both session and op space
+			const compressionMapping = newLocalId as UnackedLocalId;
+			this.clustersAndOverridesInversion.set(overrideInversionKey, compressionMapping);
+		} else if (eagerFinalId !== undefined) {
+			sessionIdNormalizer.addFinalIds(eagerFinalId, eagerFinalId, cluster ?? fail());
+			return eagerFinalId;
+		} else {
+			const registeredLocal = sessionIdNormalizer.addLocalId();
+			assert(registeredLocal === newLocalId, 'TODO');
+		}
+
+		return newLocalId;
 	}
 
 	/**
@@ -1032,6 +987,11 @@ export class IdCompressor {
 		if (isFinalId(id)) {
 			const possibleCluster = this.getClusterForFinalId(id);
 			if (possibleCluster === undefined) {
+				// It may be an unfinalized eager final ID, so check with normalizer to get the offset from the session UUID
+				const creationIndex = this.sessionIdNormalizer.getCreationIndex(id);
+				if (creationIndex !== undefined) {
+					return stableIdFromNumericUuid(this.localSession.sessionUuid, creationIndex);
+				}
 				return undefined;
 			} else {
 				const [baseFinalId, cluster] = possibleCluster;
@@ -1099,12 +1059,6 @@ export class IdCompressor {
 					if (IdCompressor.isUnfinalizedOverride(compressionMapping)) {
 						return compressionMapping;
 					} else {
-						const cluster = compressionMapping.cluster;
-						assert(
-							IdCompressor.tryGetOverride(cluster, compressionMapping.originalOverridingFinal) !==
-								undefined,
-							'No override for cluster marked as having one.'
-						);
 						return (
 							compressionMapping.associatedLocalId ??
 							(compressionMapping.originalOverridingFinal as SessionSpaceCompressedId)
@@ -1136,9 +1090,9 @@ export class IdCompressor {
 
 		if (isStable) {
 			// May have already computed the numeric UUID, so avoid recomputing if possible
-			const localId = this.getLocalIdForStableId(numericUuid ?? inversionKey);
-			if (localId !== undefined) {
-				return localId;
+			const sessionSpaceId = this.getCompressedIdForStableId(numericUuid ?? inversionKey);
+			if (sessionSpaceId !== undefined) {
+				return sessionSpaceId;
 			}
 		}
 		return undefined;
@@ -1153,13 +1107,20 @@ export class IdCompressor {
 		if (isFinalId(id)) {
 			return id;
 		}
+
 		// Check if this local ID has not been allocated yet
 		if (-id > this.localIdCount) {
 			fail('Supplied local ID was not created by this compressor.');
 		}
-		// Check if this local ID has not been finalized yet
+
+		// Check if this local ID has not been finalized yet.
+		// Comparing lastFinalizedLocalId is a safe check for eager final IDs because the local IDs corresponding to them
+		// are never handed out to a consumer, and thus could not be passed into this method.
 		const { lastFinalizedLocalId } = this.localSession;
 		if (lastFinalizedLocalId === undefined || id < lastFinalizedLocalId) {
+			// Eager final IDs do not have overrides in the cluster until finalizing
+			// This means that using the normalizer to get the final/cluster associated would succeed but would not have the override,
+			// so checking localOverrides first is necessary.
 			const override = this.localOverrides.get(id);
 			if (override !== undefined) {
 				const inversionKey = IdCompressor.createInversionKey(override);
@@ -1175,10 +1136,9 @@ export class IdCompressor {
 			}
 			return id as OpSpaceCompressedId;
 		}
-		const [localBase, [finalBase, cluster]] =
-			this.localIdToCluster.getPairOrNextLower(id) ??
+		const [correspondingFinal, cluster] =
+			this.sessionIdNormalizer.getFinalId(id) ??
 			fail('Locally created cluster should be added to the map when allocated');
-		const correspondingFinal = (finalBase + (localBase - id)) as FinalCompressedId;
 		if (cluster.overrides) {
 			const override = cluster.overrides.get(correspondingFinal);
 			if (typeof override === 'object' && override.originalOverridingFinal !== undefined) {
@@ -1207,33 +1167,27 @@ export class IdCompressor {
 	 */
 	public normalizeToSessionSpace(id: FinalCompressedId): SessionSpaceCompressedId;
 
-	public normalizeToSessionSpace(id: OpSpaceCompressedId, originSessionId?: SessionId): SessionSpaceCompressedId {
-		const isLocalSession = originSessionId === this.localSessionId;
+	public normalizeToSessionSpace(id: OpSpaceCompressedId, sessionIdIfLocal?: SessionId): SessionSpaceCompressedId {
 		if (isLocalId(id)) {
-			if (isLocalSession) {
+			if (sessionIdIfLocal === undefined || sessionIdIfLocal === this.localSessionId) {
 				const localIndex = -id;
 				if (localIndex > this.localIdCount) {
 					fail('Supplied local ID was not created by this compressor.');
 				}
 				return id;
 			} else {
-				const session = this.sessions.get(originSessionId ?? fail());
-				if (session === undefined) {
+				const session =
+					this.sessions.get(sessionIdIfLocal) ??
 					fail('No IDs have ever been finalized by the supplied session.');
-				}
 				const localCount = -id;
 				const numericUuid = incrementUuid(session.sessionUuid, localCount - 1);
 				return this.compressNumericUuid(numericUuid) ?? fail('ID is not known to this compressor.');
 			}
 		}
 
-		const closestResult = this.localIdToCluster.getPairOrNextLowerByValue(id);
-		if (closestResult !== undefined) {
-			const [localBase, [finalBase, cluster]] = closestResult;
-			const indexInCluster = id - finalBase;
-			if (indexInCluster < cluster.count) {
-				return (localBase - indexInCluster) as LocalCompressedId;
-			}
+		const normalizedId = this.sessionIdNormalizer.getSessionSpaceId(id);
+		if (normalizedId !== undefined) {
+			return normalizedId;
 		}
 
 		// Check for a unified override finalized first by another session but to which the local session
@@ -1276,14 +1230,19 @@ export class IdCompressor {
 		return sessionSpaceId;
 	}
 
-	private getLocalIdForStableId(stableId: StableId | NumericUuid): LocalCompressedId | undefined {
+	/**
+	 * Returns a compressed ID for the supplied stable ID if it was created by the local session, and undefined otherwise.
+	 */
+	private getCompressedIdForStableId(stableId: StableId | NumericUuid): SessionSpaceCompressedId | undefined {
 		const numericUuid = typeof stableId === 'string' ? numericUuidFromStableId(stableId) : stableId;
-		const offset = getPositiveDelta(numericUuid, this.localSession.sessionUuid, this.localIdCount - 1);
-		if (offset === undefined) {
-			return undefined;
+		const creationIndex = getPositiveDelta(numericUuid, this.localSession.sessionUuid, this.localIdCount - 1);
+		if (creationIndex !== undefined) {
+			const sessionSpaceId = this.sessionIdNormalizer.getIdByCreationIndex(creationIndex);
+			if (sessionSpaceId !== undefined) {
+				return sessionSpaceId;
+			}
 		}
-
-		return (-offset - 1) as LocalCompressedId;
+		return undefined;
 	}
 
 	private getClusterForFinalId(
@@ -1324,6 +1283,13 @@ export class IdCompressor {
 			) {
 				return false;
 			}
+			if (
+				!this.sessionIdNormalizer.equals(other.sessionIdNormalizer, (a, b) =>
+					IdCompressor.idClustersEqual(a, b, false, compareLocalState)
+				)
+			) {
+				return false;
+			}
 		} else {
 			for (const [keyA, valueA] of this.sessions) {
 				const valueB = other.sessions.get(keyA);
@@ -1588,6 +1554,7 @@ export class IdCompressor {
 					localIdCount: this.localIdCount,
 					overrides: [...this.localOverrides.entries()].map((entry) => [...entry]),
 					lastTakenLocalId: this.lastTakenLocalId,
+					sessionNormalizer: this.sessionIdNormalizer.serialize(),
 				};
 			}
 
@@ -1714,12 +1681,6 @@ export class IdCompressor {
 
 			const lastFinalizedNormalized = lastFinalizedLocalId ?? 0;
 			const clusterBase = compressor.nextClusterBaseFinalId;
-			if (serializedLocalState !== undefined && sessionId === compressor.localSessionId) {
-				compressor.localIdToCluster.append((lastFinalizedNormalized - 1) as LocalCompressedId, [
-					clusterBase,
-					cluster,
-				]);
-			}
 
 			session.lastFinalizedLocalId = (lastFinalizedNormalized - count) as LocalCompressedId;
 			session.currentClusterDetails = { clusterBase, cluster };
@@ -1777,6 +1738,18 @@ export class IdCompressor {
 			}
 		}
 
+		if (serializedLocalState !== undefined) {
+			compressor.sessionIdNormalizer = SessionIdNormalizer.deserialize(
+				serializedLocalState.sessionNormalizer,
+				(finalId) => {
+					const [_, cluster] =
+						compressor.finalIdToCluster.getPairOrNextLower(finalId) ??
+						fail('Final in serialized normalizer was never created.');
+					return cluster;
+				}
+			);
+		}
+
 		assert(
 			compressor.localSession.lastFinalizedLocalId === undefined ||
 				compressor.localIdCount >= -compressor.localSession.lastFinalizedLocalId