@fluid-experimental/tree 0.59.3003 → 0.59.4000-71128

package/lib/id-compressor/IdCompressor.js

@@ -6,9 +6,10 @@
 import BTree from 'sorted-btree';
 import { assert, hasLength, assertNotUndefined, compareFiniteNumbers, compareFiniteNumbersReversed, compareMaps, compareStrings, fail, getOrCreate, setPropertyIfDefined, } from '../Common';
 import { assertIsStableId, assertIsUuidString, isStableId } from '../UuidUtilities';
-import { AppendOnlyDoublySortedMap, AppendOnlySortedMap } from './AppendOnlySortedMap';
+import { AppendOnlySortedMap } from './AppendOnlySortedMap';
 import { getIds } from './IdRange';
 import { numericUuidEquals, getPositiveDelta, incrementUuid, numericUuidFromStableId, stableIdFromNumericUuid, ensureSessionUuid, } from './NumericUuid';
+import { SessionIdNormalizer } from './SessionIdNormalizer';
 /**
  * Roughly equates to a minimum of 1M sessions before we start allocating 64 bit IDs.
  * This value must *NOT* change without careful consideration to compatibility.
@@ -136,11 +137,21 @@ export class IdCompressor {
          */
         this.localOverrides = new AppendOnlySortedMap(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.
          */
-        this.localIdToCluster = new AppendOnlyDoublySortedMap(compareFiniteNumbersReversed, (value) => value[0], compareFiniteNumbers);
+        this.sessionIdNormalizer = new SessionIdNormalizer();
         /**
          * Contains entries for cluster base UUIDs and override strings (both local and final).
          * As a performance optimization, entries for finalized strings also include the containing cluster object.
@@ -196,12 +207,6 @@ export class IdCompressor {
     get attributionId() {
         return this.localSession.attributionId;
     }
-    /**
-     * Helper comparator for searching append-only sorted maps.
-     */
-    static overrideComparator(search, element) {
-        return compareFiniteNumbers(search, element[0]);
-    }
     /**
      * Creates a session object for the supplied ID.
      * Must only be called once per ID.
@@ -239,77 +244,28 @@ export class IdCompressor {
     /**
      * Returns an iterable of all IDs created by this compressor.
      */
-    *getAllIdsFromLocalSession() {
-        // TODO: this will change when final IDs are returned eagerly
-        for (let i = 1; i <= this.localIdCount; i++) {
-            yield -i;
-        }
+    getAllIdsFromLocalSession() {
+        return this.sessionIdNormalizer[Symbol.iterator]();
     }
     /**
      * Returns the attribution ID associated with the compressor that created the ID
      */
     attributeId(id) {
-        var _a;
         const opSpaceNormalizedId = this.normalizeToOpSpace(id);
         if (isLocalId(opSpaceNormalizedId)) {
             return this.attributionId;
         }
-        const [_, cluster] = (_a = this.getClusterForFinalId(opSpaceNormalizedId)) !== null && _a !== void 0 ? _a : 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.
-     */
-    getIdsFromRange(rangeDescriptor, sessionId) {
-        var _a, _b, _c;
-        const { first, count } = rangeDescriptor;
-        if (sessionId === this.localSessionId) {
-            return {
-                length: count,
-                get: (index) => {
-                    if (index < 0 || index >= count) {
-                        fail('Index out of bounds of range.');
-                    }
-                    return (first - index);
-                },
-            };
-        }
-        else {
-            const session = (_a = this.sessions.get(sessionId)) !== null && _a !== void 0 ? _a : fail('Unknown session, range may not be finalized.');
-            const firstNumericUuid = incrementUuid(session.sessionUuid, -first - 1);
-            const firstFinal = (_b = this.compressNumericUuid(firstNumericUuid)) !== null && _b !== void 0 ? _b : 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] = (_c = this.getClusterForFinalId(firstFinal)) !== null && _c !== void 0 ? _c : fail();
-            const numIdsRemainingInFirstCluster = cluster.capacity - (firstFinal - baseFinalId);
-            let pivotFinal;
-            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) => {
-                    if (index < 0 || index >= count) {
-                        fail('Index out of bounds of range.');
-                    }
-                    if (index < numIdsRemainingInFirstCluster) {
-                        return (firstFinal + index);
-                    }
-                    else {
-                        return ((pivotFinal !== null && pivotFinal !== void 0 ? pivotFinal : fail('Pivot must exist if range spans clusters.')) +
-                            (index - numIdsRemainingInFirstCluster));
-                    }
-                },
-            };
         }
+        const [_, cluster] = closestCluster;
+        return cluster.session.attributionId;
     }
     /**
      * Returns a range of local IDs created by this session in a format for sending to the server for finalizing.
@@ -365,7 +321,7 @@ export class IdCompressor {
      * @param range - the range of session-local IDs to finalize.
      */
     finalizeCreationRange(range) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const { sessionId, attributionId } = range;
         const isLocal = sessionId === this.localSessionId;
         const session = (_a = this.sessions.get(sessionId)) !== null && _a !== void 0 ? _a : this.createSession(sessionId, attributionId);
@@ -379,16 +335,26 @@ export class IdCompressor {
             cluster: undefined,
             clusterBase: undefined,
         };
-        const normalizedLastFinalized = (_b = session.lastFinalizedLocalId) !== null && _b !== void 0 ? _b : 0;
-        const { first: newFirstFinalizedLocalId, last: newLastFinalizedLocalId } = ids;
-        assert(newFirstFinalizedLocalId === normalizedLastFinalized - 1, 'Ranges finalized out of order.');
+        const currentClusterExists = currentCluster !== undefined && currentBaseFinalId !== undefined;
+        const normalizedLastFinalizedLocal = (_b = session.lastFinalizedLocalId) !== null && _b !== void 0 ? _b : 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;
-        if (currentCluster !== undefined && currentBaseFinalId !== undefined) {
+        if (currentClusterExists) {
+            if (isLocal) {
+                const lastKnownFinal = (_c = this.sessionIdNormalizer.getLastFinalId()) !== null && _c !== void 0 ? _c : fail('Cluster exists but normalizer does not have an entry for it.');
+                const lastFinalInCluster = (currentBaseFinalId +
+                    Math.min(currentCluster.count + finalizeCount, currentCluster.capacity) -
+                    1);
+                if (lastFinalInCluster > lastKnownFinal) {
+                    this.sessionIdNormalizer.addFinalIds((lastKnownFinal + 1), lastFinalInCluster, currentCluster);
+                }
+            }
             initialClusterCount = currentCluster.count;
             const remainingCapacity = currentCluster.capacity - initialClusterCount;
             const overflow = remainingCount - remainingCapacity;
@@ -405,6 +371,21 @@ export class IdCompressor {
                     this.nextClusterBaseFinalId = (this.nextClusterBaseFinalId + expansionAmount);
                     assert(this.nextClusterBaseFinalId < Number.MAX_SAFE_INTEGER, '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);
+                        const finalPivot = (lastFinalizedFinal - overflow + 1);
+                        this.sessionIdNormalizer.addFinalIds(finalPivot, lastFinalizedFinal, currentCluster);
+                    }
                 }
             }
             else {
@@ -445,9 +426,10 @@ export class IdCompressor {
                 session,
             };
             const usedCapacity = finalizeCount - remainingCount;
-            localIdPivot = (newFirstFinalizedLocalId - usedCapacity);
+            localIdPivot = (newFirstFinalizedLocal - usedCapacity);
             if (isLocal) {
-                this.localIdToCluster.append(localIdPivot, [newBaseFinalId, newCluster]);
+                const lastFinalizedFinal = (newBaseFinalId + newCluster.count - 1);
+                this.sessionIdNormalizer.addFinalIds(newBaseFinalId, lastFinalizedFinal, newCluster);
             }
             this.checkClusterForCollision(newCluster);
             this.clustersAndOverridesInversion.set(stableIdFromNumericUuid(newCluster.baseUuid), {
@@ -466,8 +448,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;
                 let overriddenFinal;
                 if (localIdPivot !== undefined && overriddenLocal <= localIdPivot) {
@@ -482,10 +464,10 @@ export class IdCompressor {
                     cluster = currentCluster;
                     overriddenFinal = (currentBaseFinalId +
                         initialClusterCount +
-                        (normalizedLastFinalized - overriddenLocal) -
+                        (normalizedLastFinalizedLocal - overriddenLocal) -
                         1);
                 }
-                (_c = cluster.overrides) !== null && _c !== void 0 ? _c : (cluster.overrides = new Map());
+                (_d = cluster.overrides) !== null && _d !== void 0 ? _d : (cluster.overrides = new Map());
                 const inversionKey = IdCompressor.createInversionKey(override);
                 const existingIds = this.getExistingIdsForNewOverride(inversionKey, true);
                 let overrideForCluster;
@@ -551,7 +533,7 @@ export class IdCompressor {
                 }
             }
         }
-        session.lastFinalizedLocalId = newLastFinalizedLocalId;
+        session.lastFinalizedLocalId = newLastFinalizedLocal;
     }
     checkClusterForCollision(cluster) {
         const maxClusterUuid = incrementUuid(cluster.baseUuid, cluster.capacity - 1);
@@ -631,9 +613,9 @@ export class IdCompressor {
         }
         const override = (_a = numericOverride !== null && numericOverride !== void 0 ? numericOverride : stableOverride) !== null && _a !== void 0 ? _a : (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;
             }
         }
         return undefined;
@@ -675,41 +657,50 @@ 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.
      */
     generateCompressedId(override) {
-        // If any ID exists for this override (locally or remotely allocated), return it (after ensuring it is in session-space).
+        let overrideInversionKey;
         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;
-                this.clustersAndOverridesInversion.set(inversionKey, compressionMapping);
-                return newLocalId;
+        }
+        // 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;
+        const { currentClusterDetails } = this.localSession;
+        const { sessionIdNormalizer } = this;
+        let eagerFinalId;
+        let cluster;
+        if (currentClusterDetails !== undefined) {
+            const { clusterBase } = currentClusterDetails;
+            cluster = currentClusterDetails.cluster;
+            const lastFinalKnown = sessionIdNormalizer.getLastFinalId();
+            if (lastFinalKnown !== undefined && lastFinalKnown - clusterBase + 1 < cluster.capacity) {
+                eagerFinalId = (lastFinalKnown + 1);
             }
         }
+        if (overrideInversionKey !== undefined) {
+            const registeredLocal = sessionIdNormalizer.addLocalId();
+            assert(registeredLocal === newLocalId, 'TODO');
+            if (eagerFinalId !== undefined) {
+                sessionIdNormalizer.addFinalIds(eagerFinalId, eagerFinalId, cluster !== null && cluster !== void 0 ? cluster : fail());
+            }
+            this.localOverrides.append(newLocalId, override !== null && override !== void 0 ? override : fail());
+            // Since the local ID was just created, it is in both session and op space
+            const compressionMapping = newLocalId;
+            this.clustersAndOverridesInversion.set(overrideInversionKey, compressionMapping);
+        }
+        else if (eagerFinalId !== undefined) {
+            sessionIdNormalizer.addFinalIds(eagerFinalId, eagerFinalId, cluster !== null && cluster !== void 0 ? cluster : fail());
+            return eagerFinalId;
+        }
         else {
-            return this.generateNextLocalId();
+            const registeredLocal = sessionIdNormalizer.addLocalId();
+            assert(registeredLocal === newLocalId, 'TODO');
         }
-    }
-    /**
-     * 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.
-     */
-    generateCompressedIdRange(count) {
-        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 };
-    }
-    generateNextLocalId() {
-        return -++this.localIdCount;
+        return newLocalId;
     }
     /**
      * Decompresses a previously compressed ID into a UUID or override string.
@@ -730,6 +721,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 {
@@ -797,9 +793,6 @@ export class IdCompressor {
                         return compressionMapping;
                     }
                     else {
-                        const cluster = compressionMapping.cluster;
-                        assert(IdCompressor.tryGetOverride(cluster, compressionMapping.originalOverridingFinal) !==
-                            undefined, 'No override for cluster marked as having one.');
                         return ((_a = compressionMapping.associatedLocalId) !== null && _a !== void 0 ? _a : compressionMapping.originalOverridingFinal);
                     }
                 }
@@ -828,9 +821,9 @@ export class IdCompressor {
         }
         if (isStable) {
             // May have already computed the numeric UUID, so avoid recomputing if possible
-            const localId = this.getLocalIdForStableId(numericUuid !== null && numericUuid !== void 0 ? numericUuid : inversionKey);
-            if (localId !== undefined) {
-                return localId;
+            const sessionSpaceId = this.getCompressedIdForStableId(numericUuid !== null && numericUuid !== void 0 ? numericUuid : inversionKey);
+            if (sessionSpaceId !== undefined) {
+                return sessionSpaceId;
             }
         }
         return undefined;
@@ -849,9 +842,14 @@ export class IdCompressor {
         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);
@@ -864,8 +862,7 @@ export class IdCompressor {
             }
             return id;
         }
-        const [localBase, [finalBase, cluster]] = (_b = this.localIdToCluster.getPairOrNextLower(id)) !== null && _b !== void 0 ? _b : fail('Locally created cluster should be added to the map when allocated');
-        const correspondingFinal = (finalBase + (localBase - id));
+        const [correspondingFinal, cluster] = (_b = this.sessionIdNormalizer.getFinalId(id)) !== null && _b !== void 0 ? _b : fail('Locally created cluster should be added to the map when allocated');
         if (cluster.overrides) {
             const override = cluster.overrides.get(correspondingFinal);
             if (typeof override === 'object' && override.originalOverridingFinal !== undefined) {
@@ -875,11 +872,10 @@ export class IdCompressor {
         }
         return correspondingFinal;
     }
-    normalizeToSessionSpace(id, originSessionId) {
-        var _a, _b, _c;
-        const isLocalSession = originSessionId === this.localSessionId;
+    normalizeToSessionSpace(id, sessionIdIfLocal) {
+        var _a, _b, _c, _d;
         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.');
@@ -887,27 +883,20 @@ export class IdCompressor {
                 return id;
             }
             else {
-                const session = this.sessions.get(originSessionId !== null && originSessionId !== void 0 ? originSessionId : fail());
-                if (session === undefined) {
-                    fail('No IDs have ever been finalized by the supplied session.');
-                }
+                const session = (_a = this.sessions.get(sessionIdIfLocal)) !== null && _a !== void 0 ? _a : fail('No IDs have ever been finalized by the supplied session.');
                 const localCount = -id;
                 const numericUuid = incrementUuid(session.sessionUuid, localCount - 1);
-                return (_a = this.compressNumericUuid(numericUuid)) !== null && _a !== void 0 ? _a : fail('ID is not known to this compressor.');
+                return (_b = this.compressNumericUuid(numericUuid)) !== null && _b !== void 0 ? _b : 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);
-            }
+        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
         // still has an associated local ID.
-        const [_, cluster] = (_b = this.getClusterForFinalId(id)) !== null && _b !== void 0 ? _b : fail('Supplied final ID was not finalized by this compressor.');
-        const override = (_c = cluster.overrides) === null || _c === void 0 ? void 0 : _c.get(id);
+        const [_, cluster] = (_c = this.getClusterForFinalId(id)) !== null && _c !== void 0 ? _c : fail('Supplied final ID was not finalized by this compressor.');
+        const override = (_d = cluster.overrides) === null || _d === void 0 ? void 0 : _d.get(id);
         if (typeof override === 'object' && override.associatedLocalId !== undefined) {
             return override.associatedLocalId;
         }
@@ -941,13 +930,19 @@ export class IdCompressor {
         }
         return sessionSpaceId;
     }
-    getLocalIdForStableId(stableId) {
+    /**
+     * Returns a compressed ID for the supplied stable ID if it was created by the local session, and undefined otherwise.
+     */
+    getCompressedIdForStableId(stableId) {
         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);
+        return undefined;
     }
     getClusterForFinalId(finalId) {
         const possibleCluster = this.finalIdToCluster.getPairOrNextLower(finalId);
@@ -978,6 +973,9 @@ export class IdCompressor {
             if (!compareMaps(this.sessions, other.sessions, (a, b) => IdCompressor.sessionDataEqual(a, b, true, compareLocalState))) {
                 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) {
@@ -1168,6 +1166,7 @@ export class IdCompressor {
                     localIdCount: this.localIdCount,
                     overrides: [...this.localOverrides.entries()].map((entry) => [...entry]),
                     lastTakenLocalId: this.lastTakenLocalId,
+                    sessionNormalizer: this.sessionIdNormalizer.serialize(),
                 };
             }
             return serializedWithSession;
@@ -1241,12 +1240,6 @@ export class IdCompressor {
             };
             const lastFinalizedNormalized = lastFinalizedLocalId !== null && lastFinalizedLocalId !== void 0 ? lastFinalizedLocalId : 0;
             const clusterBase = compressor.nextClusterBaseFinalId;
-            if (serializedLocalState !== undefined && sessionId === compressor.localSessionId) {
-                compressor.localIdToCluster.append((lastFinalizedNormalized - 1), [
-                    clusterBase,
-                    cluster,
-                ]);
-            }
             session.lastFinalizedLocalId = (lastFinalizedNormalized - count);
             session.currentClusterDetails = { clusterBase, cluster };
             compressor.nextClusterBaseFinalId = (compressor.nextClusterBaseFinalId + capacity);
@@ -1296,6 +1289,13 @@ export class IdCompressor {
                 }
             }
         }
+        if (serializedLocalState !== undefined) {
+            compressor.sessionIdNormalizer = SessionIdNormalizer.deserialize(serializedLocalState.sessionNormalizer, (finalId) => {
+                var _a;
+                const [_, cluster] = (_a = compressor.finalIdToCluster.getPairOrNextLower(finalId)) !== null && _a !== void 0 ? _a : fail('Final in serialized normalizer was never created.');
+                return cluster;
+            });
+        }
         assert(compressor.localSession.lastFinalizedLocalId === undefined ||
             compressor.localIdCount >= -compressor.localSession.lastFinalizedLocalId);
         return compressor;