@fluid-experimental/tree 0.59.2001 → 0.59.3000

package/lib/id-compressor/IdCompressor.js

@@ -4,10 +4,11 @@
  */
 /* eslint-disable @typescript-eslint/restrict-plus-operands */
 import BTree from 'sorted-btree';
-import { assert, assertNotUndefined, compareFiniteNumbers, compareMaps, compareStrings, fail, setPropertyIfDefined, } from '../Common';
+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 { getIds } from './IdRange';
-import { numericUuidEquals, getPositiveDelta, incrementUuid, numericUuidFromStableId, stableIdFromNumericUuid, isStableId, assertIsStableId, ensureSessionUuid, } from './NumericUuid';
+import { numericUuidEquals, getPositiveDelta, incrementUuid, numericUuidFromStableId, stableIdFromNumericUuid, ensureSessionUuid, } from './NumericUuid';
 /**
  * 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.
@@ -98,14 +99,17 @@ const nonStableOverridePrefix = '\ue15e'; // A character in the Private Use Area
  */
 export class IdCompressor {
     /**
-     * @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. The reserved ID count
-     * for a given session must be constant for any compressor that contains IDs from that session (i.e. any DDS that uses the ID
-     * compressor must have the same reservedIdCount forever). Compressors with different reserved ID counts will fail to synchronize their
-     * IDs.
-     * @param attributionInfo information used by other clients to attribute IDs made by this client
+     * @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.
+     * The reserved ID count for a given session must be constant for any compressor that contains IDs from that session
+     * (i.e. any DDS that uses the ID compressor must have the same reservedIdCount forever). Compressors with different
+     * reserved ID counts will fail to synchronize their IDs.
+     * @param attributionId - a UUID that identifies the user of this instance of the compressor. IDs created by this
+     * compressor will be associated with this UUID and can be queried later via `attributeID`. If no UUID is provided,
+     * this compressor will generate its own. An `AttributionId` is an `UuidString` which may be validated via
+     * {@link isUuidString} or generated via {@link generateStableId}.
      */
-    constructor(localSessionId, reservedIdCount, attributionInfo) {
+    constructor(localSessionId, reservedIdCount, attributionId) {
         this.localSessionId = localSessionId;
         this.reservedIdCount = reservedIdCount;
         /**
@@ -114,14 +118,10 @@ export class IdCompressor {
          */
         this.newClusterCapacity = defaultClusterCapacity;
         /**
-         * Session ID -> data about the session's current cluster.
+         * Session ID -\> data about the session's current cluster.
          * Sessions are mutable, and thus should only be created via `createSession`.
          */
         this.sessions = new Map();
-        /**
-         * Boolean to track whether attribution has been sent with an ID range yet. Prevents unnecessary bloat of ranges.
-         */
-        this.sentAttributionInfo = false;
         /**
          * The base final ID of the next cluster to be created.
          */
@@ -137,10 +137,10 @@ 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
+         * final ID by finding an entry \<= a given local ID (to find the cluster it is associated with) and checking
          * it against `numFinalizedLocalIds`.
          */
-        this.localIdToCluster = new AppendOnlyDoublySortedMap(compareFiniteNumbersReversed, (value) => value[0], IdCompressor.overrideComparator);
+        this.localIdToCluster = new AppendOnlyDoublySortedMap(compareFiniteNumbersReversed, (value) => value[0], compareFiniteNumbers);
         /**
          * 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.
@@ -156,7 +156,10 @@ export class IdCompressor {
          */
         this.finalIdToCluster = new AppendOnlySortedMap(compareFiniteNumbers);
         assert(reservedIdCount >= 0, 'reservedIdCount must be non-negative');
-        this.localSession = this.createSession(localSessionId, attributionInfo);
+        if (attributionId !== undefined) {
+            assertIsUuidString(attributionId);
+        }
+        this.localSession = this.createSession(localSessionId, attributionId);
         if (reservedIdCount > 0) {
             const clusterCapacity = this.clusterCapacity;
             this.clusterCapacity = reservedIdCount;
@@ -164,7 +167,7 @@ export class IdCompressor {
                 sessionId: reservedSessionId,
                 ids: {
                     last: -reservedIdCount,
-                    overrides: [[-1, legacySharedTreeInitialTreeId]],
+                    overrides: [[-1, legacySharedTreeInitialTreeId]], // Kludge: see `initialTreeId`
                 },
             };
             // Reserved final IDs are implicitly finalized and no one locally created them, so finalizing immediately is safe.
@@ -187,6 +190,12 @@ export class IdCompressor {
         assert(value <= IdCompressor.maxClusterSize, 'Clusters must not exceed max cluster size');
         this.newClusterCapacity = value;
     }
+    /**
+     * The UUID used for attribution of identities created by this compressor
+     */
+    get attributionId() {
+        return this.localSession.attributionId;
+    }
     /**
      * Helper comparator for searching append-only sorted maps.
      */
@@ -196,31 +205,28 @@ export class IdCompressor {
     /**
      * Creates a session object for the supplied ID.
      * Must only be called once per ID.
-     * @param sessionId the ID for the session
+     * @param sessionId - the ID for the session
      * @returns the session object for the supplied ID
      */
-    createSession(sessionId, attributionInfo) {
+    createSession(sessionId, attributionId) {
+        assert(!this.clustersAndOverridesInversion.has(sessionId));
         const existingSession = this.sessions.get(sessionId);
         if (existingSession !== undefined) {
             fail('createSession must only be called once for each session ID.');
         }
         const sessionUuid = numericUuidFromStableId(sessionId);
-        assert(!this.clustersAndOverridesInversion.has(sessionId));
         const session = {
             sessionUuid,
             currentClusterDetails: undefined,
             lastFinalizedLocalId: undefined,
+            attributionId: attributionId !== null && attributionId !== void 0 ? attributionId : sessionId,
         };
-        setPropertyIfDefined(attributionInfo, session, 'attributionInfo');
         this.sessions.set(sessionId, session);
         return session;
     }
-    tryGetSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
     /**
      * Return the nth reserved ID.
-     * @param index the index of the ID to return
+     * @param index - the index of the ID to return
      */
     getReservedId(index) {
         if (index < 0 || index >= this.reservedIdCount) {
@@ -240,16 +246,16 @@ export class IdCompressor {
         }
     }
     /**
-     * Returns the attribution info associated with the compressor that created the ID, if it exists.
+     * 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.localSession.attributionInfo;
+            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.attributionInfo;
+        return cluster.session.attributionId;
     }
     /**
      * Provides the session-space IDs corresponding to a range of IDs.
@@ -270,7 +276,7 @@ export class IdCompressor {
             };
         }
         else {
-            const session = (_a = this.tryGetSession(sessionId)) !== null && _a !== void 0 ? _a : fail('Unknown session, range may not be finalized.');
+            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.');
@@ -316,15 +322,15 @@ export class IdCompressor {
         const lastLocalInRange = -this.localIdCount;
         const lastTakenNormalized = (_a = this.lastTakenLocalId) !== null && _a !== void 0 ? _a : 0;
         assert(lastLocalInRange <= lastTakenNormalized);
+        // The attribution ID is sent with each range, but it can be elided after the first IDs are allocated.
+        const sendAttributionId = this.lastTakenLocalId === undefined;
         let ids;
         if (lastLocalInRange !== lastTakenNormalized) {
             const firstLocalInRange = (lastTakenNormalized - 1);
-            const localOverrides = [
+            const overrides = [
                 ...this.localOverrides.getRange((lastTakenNormalized - 1), lastLocalInRange),
             ];
-            if (localOverrides.length > 0) {
-                // Cast: typecript 4.4.4 doesn't infer that `localOverrides` has at least one element and is therefore an `Overrides`
-                const overrides = localOverrides;
+            if (hasLength(overrides, 1)) {
                 assert(overrides[0][0] <= firstLocalInRange);
                 assert(overrides[overrides.length - 1][0] >= lastLocalInRange);
                 ids = {
@@ -344,9 +350,8 @@ export class IdCompressor {
             this.lastTakenLocalId = lastLocalInRange;
         }
         const range = { sessionId: this.localSessionId };
-        if (!this.sentAttributionInfo) {
-            setPropertyIfDefined(this.localSession.attributionInfo, range, 'attributionInfo');
-            this.sentAttributionInfo = true;
+        if (this.attributionId !== this.localSessionId && sendAttributionId) {
+            range.attributionId = this.attributionId;
         }
         if (ids === undefined) {
             return range;
@@ -357,15 +362,14 @@ export class IdCompressor {
     }
     /**
      * Finalizes the supplied range of IDs (which may be from either a remote or local session).
-     * @param range the range of session-local IDs to finalize.
+     * @param range - the range of session-local IDs to finalize.
      */
     finalizeCreationRange(range) {
-        var _a, _b;
-        const { sessionId, attributionInfo } = range;
+        var _a, _b, _c;
+        const { sessionId, attributionId } = range;
         const isLocal = sessionId === this.localSessionId;
-        let session = this.tryGetSession(sessionId);
-        assert(range.attributionInfo === undefined || session === undefined || isLocal, 'Attribution info can only be supplied on initial range for a session, and never modified.');
-        session !== null && session !== void 0 ? session : (session = this.createSession(sessionId, attributionInfo));
+        const session = (_a = this.sessions.get(sessionId)) !== null && _a !== void 0 ? _a : this.createSession(sessionId, attributionId);
+        assert(range.attributionId === undefined || range.attributionId === session.attributionId, "A session's attribution ID may never be modified.");
         const ids = getIds(range);
         if (ids === undefined) {
             return;
@@ -375,7 +379,7 @@ export class IdCompressor {
             cluster: undefined,
             clusterBase: undefined,
         };
-        const normalizedLastFinalized = (_a = session.lastFinalizedLocalId) !== null && _a !== void 0 ? _a : 0;
+        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.');
         // The total number of session-local IDs to finalize
@@ -481,9 +485,8 @@ export class IdCompressor {
                         (normalizedLastFinalized - overriddenLocal) -
                         1);
                 }
-                (_b = cluster.overrides) !== null && _b !== void 0 ? _b : (cluster.overrides = new Map());
+                (_c = cluster.overrides) !== null && _c !== void 0 ? _c : (cluster.overrides = new Map());
                 const inversionKey = IdCompressor.createInversionKey(override);
-                // TODO: This cast can be removed on typescript 4.6
                 const existingIds = this.getExistingIdsForNewOverride(inversionKey, true);
                 let overrideForCluster;
                 let associatedLocal;
@@ -578,7 +581,6 @@ export class IdCompressor {
         return typeof compressionMapping === 'number';
     }
     static createInversionKey(inversionKey) {
-        // TODO: This cast can be removed on typescript 4.6
         return isStableId(inversionKey) ? inversionKey : `${nonStableOverridePrefix}${inversionKey}`;
     }
     static isStableInversionKey(inversionKey) {
@@ -638,7 +640,7 @@ export class IdCompressor {
     }
     /**
      * Check if `a` might be within `range` of `b`, where both are treated as hex numbers.
-     * @param range an integer
+     * @param range - an integer
      */
     static uuidsMightCollide(a, b, range) {
         // Check if any of the UUIDs in the cluster collide (i.e. any in [base, base + capacity)).
@@ -668,7 +670,7 @@ export class IdCompressor {
     /**
      * Generates a new compressed ID or returns an existing one.
      * This should ONLY be called to generate IDs for local operations.
-     * @param override Specifies a specific string to be associated with the returned compressed ID.
+     * @param override - Specifies a specific string to be associated with the returned compressed ID.
      * Performance note: assigning override strings incurs a performance overhead.
      * @returns an existing ID if one already exists for `override`, and a new local ID otherwise. The returned ID is in session space.
      */
@@ -696,7 +698,7 @@ export class IdCompressor {
     /**
      * 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.
+     * @param count - the number of IDs to generate, must be \> 0.
      * @returns a persistable descriptor of the ID range.
      */
     generateCompressedIdRange(count) {
@@ -711,7 +713,7 @@ export class IdCompressor {
     }
     /**
      * Decompresses a previously compressed ID into a UUID or override string.
-     * @param id the compressed ID to be decompressed.
+     * @param id - the compressed ID to be decompressed.
      * @returns the UUID or override string associated with the compressed ID. Fails if the ID was not generated by this compressor.
      */
     decompress(id) {
@@ -720,7 +722,7 @@ export class IdCompressor {
     }
     /**
      * Attempts to decompress a previously compressed ID into a UUID or override string.
-     * @param id the compressed ID to be decompressed.
+     * @param id - the compressed ID to be decompressed.
      * @returns the UUID or override string associated with the compressed ID, or undefined if the ID was not generated by this compressor.
      */
     tryDecompress(id) {
@@ -762,7 +764,7 @@ export class IdCompressor {
     }
     /**
      * Recompresses a decompressed ID, which could be a UUID or an override string.
-     * @param uncompressed the UUID or override string to recompress.
+     * @param uncompressed - the UUID or override string to recompress.
      * @returns the `CompressedId` associated with `uncompressed`. Fails if it has not been previously compressed by this compressor.
      */
     recompress(uncompressed) {
@@ -771,7 +773,7 @@ export class IdCompressor {
     }
     /**
      * Attempts to recompresses a decompressed ID, which could be a UUID or an override string.
-     * @param uncompressed the UUID or override string to recompress,
+     * @param uncompressed - the UUID or override string to recompress,
      * @returns the `CompressedId` associated with `uncompressed` or undefined if it has not been previously compressed by this compressor.
      */
     tryRecompress(uncompressed) {
@@ -784,7 +786,6 @@ export class IdCompressor {
     recompressInternal(uncompressed, uncompressedUuidNumeric) {
         var _a, _b;
         let numericUuid = uncompressedUuidNumeric;
-        // TODO: This cast can be removed on typescript 4.6, and should give improved typesafety.
         const inversionKey = IdCompressor.createInversionKey(uncompressed);
         const isStable = IdCompressor.isStableInversionKey(inversionKey);
         const closestMatch = this.clustersAndOverridesInversion.getPairOrNextLower(inversionKey, reusedArray);
@@ -827,7 +828,6 @@ export class IdCompressor {
         }
         if (isStable) {
             // May have already computed the numeric UUID, so avoid recomputing if possible
-            // TODO: This cast can be removed on typescript 4.6
             const localId = this.getLocalIdForStableId(numericUuid !== null && numericUuid !== void 0 ? numericUuid : inversionKey);
             if (localId !== undefined) {
                 return localId;
@@ -837,7 +837,7 @@ export class IdCompressor {
     }
     /**
      * Normalizes a session space ID into op space.
-     * @param id the local ID to normalize.
+     * @param id - the local ID to normalize.
      * @returns the ID in op space.
      */
     normalizeToOpSpace(id) {
@@ -887,7 +887,7 @@ export class IdCompressor {
                 return id;
             }
             else {
-                const session = this.tryGetSession(originSessionId !== null && originSessionId !== void 0 ? originSessionId : fail());
+                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.');
                 }
@@ -942,8 +942,7 @@ export class IdCompressor {
         return sessionSpaceId;
     }
     getLocalIdForStableId(stableId) {
-        // TODO: This cast can be removed on typescript 4.6
-        const numericUuid = (typeof stableId === 'string' ? numericUuidFromStableId(stableId) : stableId);
+        const numericUuid = typeof stableId === 'string' ? numericUuidFromStableId(stableId) : stableId;
         const offset = getPositiveDelta(numericUuid, this.localSession.sessionUuid, this.localIdCount - 1);
         if (offset === undefined) {
             return undefined;
@@ -962,15 +961,15 @@ export class IdCompressor {
         return possibleCluster;
     }
     /**
-     * @returns if `other` is equal to this `IdCompressor`. The equality check includes local session state.
-     * @testOnly
+     * @returns if `other` is equal to this `IdCompressor`. The equality check includes local session state only if specified.
+     * \@testOnly
      */
     equals(other, compareLocalState) {
         if (compareLocalState) {
             if (this.localIdCount !== other.localIdCount ||
                 this.localSessionId !== other.localSessionId ||
                 this.lastTakenLocalId !== other.lastTakenLocalId ||
-                this.sentAttributionInfo !== other.sentAttributionInfo) {
+                this.attributionId !== other.attributionId) {
                 return false;
             }
             if (!this.localOverrides.equals(other.localOverrides, (a, b) => a === b)) {
@@ -1052,7 +1051,7 @@ export class IdCompressor {
         return diff === undefined;
     }
     static sessionDataEqual(a, b, checkCluster = true, compareLocalState = true) {
-        if (a.attributionInfo !== b.attributionInfo ||
+        if (a.attributionId !== b.attributionId ||
             !numericUuidEquals(a.sessionUuid, b.sessionUuid) ||
             a.lastFinalizedLocalId !== b.lastFinalizedLocalId) {
             return false;
@@ -1101,6 +1100,8 @@ export class IdCompressor {
         var _a;
         const serializedSessions = [];
         const sessionIdToSessionIndex = new Map();
+        const attributionIdToAttributionIndex = new Map();
+        let serializedAttributionIds;
         for (const [sessionId, session] of this.sessions) {
             const isLocalSession = sessionId === this.localSessionId;
             const includeSession = sessionId !== reservedSessionId && // Ignore reserved clusters, but
@@ -1108,8 +1109,10 @@ export class IdCompressor {
                     (isLocalSession && withSession)); // include the un-acked local session if requested
             if (includeSession) {
                 const sessionData = [sessionId];
-                if (session.attributionInfo !== undefined) {
-                    sessionData.push(session.attributionInfo);
+                if (session.attributionId !== sessionId) {
+                    // As an optimization, don't include the attributionId if it is its default (the sessionId)
+                    // Get the index into the array for the given attribution ID. If it doesn't exist, push it onto the array and update the map.
+                    sessionData.push(getOrCreate(attributionIdToAttributionIndex, session.attributionId, (id) => (serializedAttributionIds !== null && serializedAttributionIds !== void 0 ? serializedAttributionIds : (serializedAttributionIds = [])).push(id) - 1));
                 }
                 sessionIdToSessionIndex.set(sessionId, serializedSessions.length);
                 serializedSessions.push(sessionData);
@@ -1156,6 +1159,7 @@ export class IdCompressor {
             sessions: serializedSessions,
             clusters: serializedClusters,
         };
+        setPropertyIfDefined(serializedAttributionIds, serializedIdCompressor, 'attributionIds');
         if (withSession) {
             const serializedWithSession = serializedIdCompressor;
             serializedWithSession.localSessionIndex = serializedWithSession.sessions.findIndex(([sessionId]) => sessionId === this.localSessionId);
@@ -1164,40 +1168,41 @@ export class IdCompressor {
                     localIdCount: this.localIdCount,
                     overrides: [...this.localOverrides.entries()].map((entry) => [...entry]),
                     lastTakenLocalId: this.lastTakenLocalId,
-                    sentAttributionInfo: this.sentAttributionInfo,
                 };
             }
             return serializedWithSession;
         }
         return serializedIdCompressor;
     }
-    static deserialize(serialized, newSessionIdMaybe, attributionInfoMaybe) {
-        const hasSession = hasOngoingSession(serialized);
+    static deserialize(...args) {
+        const [serialized, newSessionIdMaybe, attributionIdMaybe] = args;
+        const { clusterCapacity, reservedIdCount, sessions: serializedSessions, clusters: serializedClusters, attributionIds: serializedAttributionIds, } = serialized;
         let localSessionId;
-        let attributionInfo;
+        let attributionId;
         let serializedLocalState;
-        if (hasSession) {
-            assert(newSessionIdMaybe === undefined && attributionInfoMaybe === undefined);
-            // TODO: This cast can be removed on typescript 4.6
-            [localSessionId, attributionInfo] =
-                serialized.sessions[serialized.localSessionIndex];
-            // TODO: This cast can be removed on typescript 4.6
-            serializedLocalState = serialized.localState;
+        if (newSessionIdMaybe === undefined) {
+            // Alias of serialized, but known to be a SerializedIdCompressorWithOngoingSession
+            const [serializedWithSession] = args;
+            const serializedSessionData = serializedSessions[serializedWithSession.localSessionIndex];
+            localSessionId = serializedSessionData[0];
+            const attributionIndex = serializedSessionData[1];
+            if (attributionIndex !== undefined) {
+                assert(serializedAttributionIds !== undefined && serializedAttributionIds.length > attributionIndex);
+                attributionId = serializedAttributionIds[attributionIndex];
+            }
+            serializedLocalState = serializedWithSession.localState;
         }
         else {
-            assert(newSessionIdMaybe !== undefined);
             localSessionId = newSessionIdMaybe;
-            attributionInfo = attributionInfoMaybe;
+            attributionId = attributionIdMaybe;
         }
-        const { clusterCapacity, reservedIdCount, sessions: serializedSessions, clusters: serializedClusters, } = serialized;
-        const compressor = new IdCompressor(localSessionId, reservedIdCount, attributionInfo);
+        const compressor = new IdCompressor(localSessionId, reservedIdCount, attributionId);
         compressor.clusterCapacity = clusterCapacity;
         const localOverridesInverse = new Map();
         if (serializedLocalState !== undefined) {
             // Do this part of local rehydration first since the cluster map population needs to query to local overrides
             compressor.localIdCount = serializedLocalState.localIdCount;
             compressor.lastTakenLocalId = serializedLocalState.lastTakenLocalId;
-            compressor.sentAttributionInfo = serializedLocalState.sentAttributionInfo;
             if (serializedLocalState.overrides !== undefined) {
                 for (const [localId, override] of serializedLocalState.overrides) {
                     compressor.localOverrides.append(localId, override);
@@ -1208,13 +1213,18 @@ export class IdCompressor {
         }
         const sessionInfos = [];
         for (const serializedSession of serializedSessions) {
-            const [sessionId, attributionInfo] = serializedSession;
+            const [sessionId, attributionIndex] = serializedSession;
             if (sessionId === localSessionId) {
-                assert(hasSession, 'Cannot resume existing session.');
+                assert(hasOngoingSession(serialized), 'Cannot resume existing session.');
                 sessionInfos.push({ session: compressor.localSession, sessionId });
             }
             else {
-                const session = compressor.createSession(sessionId, attributionInfo);
+                let attributionId;
+                if (attributionIndex !== undefined) {
+                    assert(serializedAttributionIds !== undefined && serializedAttributionIds.length > attributionIndex, 'AttributionId index out of bounds');
+                    attributionId = serializedAttributionIds[attributionIndex];
+                }
+                const session = compressor.createSession(sessionId, attributionId);
                 sessionInfos.push({ session, sessionId });
             }
         }
@@ -1321,10 +1331,8 @@ function deserializeCluster(serializedCluster) {
     return {
         sessionIndex,
         capacity,
-        // TODO: This cast can be removed on typescript 4.6
-        count: (hasCount ? countOrOverrides : capacity),
-        // TODO: This cast can be removed on typescript 4.6
-        overrides: (hasCount ? overrides : countOrOverrides),
+        count: hasCount ? countOrOverrides : capacity,
+        overrides: hasCount ? overrides : countOrOverrides,
     };
 }
 /**
@@ -1334,10 +1342,4 @@ function deserializeCluster(serializedCluster) {
  * lookup results should be extracted from the tuple immediately after invocation.
  */
 const reusedArray = [];
-/**
- * A numeric comparator used for sorting in descending order.
- */
-function compareFiniteNumbersReversed(a, b) {
-    return b - a;
-}
 //# sourceMappingURL=IdCompressor.js.map