@fluid-experimental/tree 0.59.2001 → 0.59.3000

package/dist/id-compressor/IdCompressor.js

@@ -11,6 +11,7 @@ exports.hasOngoingSession = exports.IdCompressor = exports.isLocalId = exports.i
 /* eslint-disable @typescript-eslint/restrict-plus-operands */
 const sorted_btree_1 = __importDefault(require("sorted-btree"));
 const Common_1 = require("../Common");
+const UuidUtilities_1 = require("../UuidUtilities");
 const AppendOnlySortedMap_1 = require("./AppendOnlySortedMap");
 const IdRange_1 = require("./IdRange");
 const NumericUuid_1 = require("./NumericUuid");
@@ -23,7 +24,7 @@ exports.defaultClusterCapacity = 512;
  * The base UUID for the reserved id cluster.
  * This should not be changed without consideration to compatibility.
  */
-const reservedSessionId = NumericUuid_1.ensureSessionUuid(NumericUuid_1.assertIsStableId('decaf40b-3c1a-47f8-a7a1-e8461ddb69ce'));
+const reservedSessionId = (0, NumericUuid_1.ensureSessionUuid)((0, UuidUtilities_1.assertIsStableId)('decaf40b-3c1a-47f8-a7a1-e8461ddb69ce'));
 /**
  * The ID override for the initial tree of a SharedTree. An artifact of an unfortunate typo which included an extraneous '6' on the UUID
  * which must be forever preserved for backwards compatibility.
@@ -106,14 +107,17 @@ const nonStableOverridePrefix = '\ue15e'; // A character in the Private Use Area
  */
 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;
         /**
@@ -122,14 +126,10 @@ class IdCompressor {
          */
         this.newClusterCapacity = exports.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.
          */
@@ -142,13 +142,13 @@ class IdCompressor {
          * Maps local IDs to override strings. This will contain an entry for every override assigned to a local ID generated during
          * the current session, and retains entries for the lifetime of this compressor.
          */
-        this.localOverrides = new AppendOnlySortedMap_1.AppendOnlySortedMap(compareFiniteNumbersReversed);
+        this.localOverrides = new AppendOnlySortedMap_1.AppendOnlySortedMap(Common_1.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 AppendOnlySortedMap_1.AppendOnlyDoublySortedMap(compareFiniteNumbersReversed, (value) => value[0], IdCompressor.overrideComparator);
+        this.localIdToCluster = new AppendOnlySortedMap_1.AppendOnlyDoublySortedMap(Common_1.compareFiniteNumbersReversed, (value) => value[0], Common_1.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.
@@ -163,8 +163,11 @@ class IdCompressor {
          * Can be searched in O(log n) to determine clusters for any final ID.
          */
         this.finalIdToCluster = new AppendOnlySortedMap_1.AppendOnlySortedMap(Common_1.compareFiniteNumbers);
-        Common_1.assert(reservedIdCount >= 0, 'reservedIdCount must be non-negative');
-        this.localSession = this.createSession(localSessionId, attributionInfo);
+        (0, Common_1.assert)(reservedIdCount >= 0, 'reservedIdCount must be non-negative');
+        if (attributionId !== undefined) {
+            (0, UuidUtilities_1.assertIsUuidString)(attributionId);
+        }
+        this.localSession = this.createSession(localSessionId, attributionId);
         if (reservedIdCount > 0) {
             const clusterCapacity = this.clusterCapacity;
             this.clusterCapacity = reservedIdCount;
@@ -172,7 +175,7 @@ class IdCompressor {
                 sessionId: reservedSessionId,
                 ids: {
                     last: -reservedIdCount,
-                    overrides: [[-1, exports.legacySharedTreeInitialTreeId]],
+                    overrides: [[-1, exports.legacySharedTreeInitialTreeId]], // Kludge: see `initialTreeId`
                 },
             };
             // Reserved final IDs are implicitly finalized and no one locally created them, so finalizing immediately is safe.
@@ -191,48 +194,51 @@ class IdCompressor {
      * `IdCompressor.maxClusterSize`.
      */
     set clusterCapacity(value) {
-        Common_1.assert(value > 0, 'Clusters must have a positive capacity');
-        Common_1.assert(value <= IdCompressor.maxClusterSize, 'Clusters must not exceed max cluster size');
+        (0, Common_1.assert)(value > 0, 'Clusters must have a positive capacity');
+        (0, Common_1.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.
      */
     static overrideComparator(search, element) {
-        return Common_1.compareFiniteNumbers(search, element[0]);
+        return (0, Common_1.compareFiniteNumbers)(search, element[0]);
     }
     /**
      * 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) {
+        (0, Common_1.assert)(!this.clustersAndOverridesInversion.has(sessionId));
         const existingSession = this.sessions.get(sessionId);
         if (existingSession !== undefined) {
-            Common_1.fail('createSession must only be called once for each session ID.');
+            (0, Common_1.fail)('createSession must only be called once for each session ID.');
         }
-        const sessionUuid = NumericUuid_1.numericUuidFromStableId(sessionId);
-        Common_1.assert(!this.clustersAndOverridesInversion.has(sessionId));
+        const sessionUuid = (0, NumericUuid_1.numericUuidFromStableId)(sessionId);
         const session = {
             sessionUuid,
             currentClusterDetails: undefined,
             lastFinalizedLocalId: undefined,
+            attributionId: attributionId !== null && attributionId !== void 0 ? attributionId : sessionId,
         };
-        Common_1.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) {
-            Common_1.fail('Reserved Id index out of bounds');
+            (0, Common_1.fail)('Reserved Id index out of bounds');
         }
         // All reserved IDs are contiguous and finalized during the Compressor's construction, therefore they are always the lowest
         // final IDs, beginning at 0
@@ -248,16 +254,16 @@ 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 : Common_1.fail('Cluster does not exist for final ID');
-        return cluster.session.attributionInfo;
+        const [_, cluster] = (_a = this.getClusterForFinalId(opSpaceNormalizedId)) !== null && _a !== void 0 ? _a : (0, Common_1.fail)('Cluster does not exist for final ID');
+        return cluster.session.attributionId;
     }
     /**
      * Provides the session-space IDs corresponding to a range of IDs.
@@ -271,26 +277,26 @@ class IdCompressor {
                 length: count,
                 get: (index) => {
                     if (index < 0 || index >= count) {
-                        Common_1.fail('Index out of bounds of range.');
+                        (0, Common_1.fail)('Index out of bounds of range.');
                     }
                     return (first - index);
                 },
             };
         }
         else {
-            const session = (_a = this.tryGetSession(sessionId)) !== null && _a !== void 0 ? _a : Common_1.fail('Unknown session, range may not be finalized.');
-            const firstNumericUuid = NumericUuid_1.incrementUuid(session.sessionUuid, -first - 1);
-            const firstFinal = (_b = this.compressNumericUuid(firstNumericUuid)) !== null && _b !== void 0 ? _b : Common_1.fail('Remote range must be finalized before getting IDs.');
-            Common_1.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 : Common_1.fail();
+            const session = (_a = this.sessions.get(sessionId)) !== null && _a !== void 0 ? _a : (0, Common_1.fail)('Unknown session, range may not be finalized.');
+            const firstNumericUuid = (0, NumericUuid_1.incrementUuid)(session.sessionUuid, -first - 1);
+            const firstFinal = (_b = this.compressNumericUuid(firstNumericUuid)) !== null && _b !== void 0 ? _b : (0, Common_1.fail)('Remote range must be finalized before getting IDs.');
+            (0, Common_1.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 : (0, Common_1.fail)();
             const numIdsRemainingInFirstCluster = cluster.capacity - (firstFinal - baseFinalId);
             let pivotFinal;
             if (count > numIdsRemainingInFirstCluster) {
-                const compressedPivot = this.compressNumericUuid(NumericUuid_1.incrementUuid(firstNumericUuid, numIdsRemainingInFirstCluster));
+                const compressedPivot = this.compressNumericUuid((0, NumericUuid_1.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)) {
-                    Common_1.fail('ID from a remote session ID must have final form, as overrides are impossible by definition.');
+                    (0, Common_1.fail)('ID from a remote session ID must have final form, as overrides are impossible by definition.');
                 }
                 else {
                     pivotFinal = compressedPivot;
@@ -300,13 +306,13 @@ class IdCompressor {
                 length: count,
                 get: (index) => {
                     if (index < 0 || index >= count) {
-                        Common_1.fail('Index out of bounds of range.');
+                        (0, Common_1.fail)('Index out of bounds of range.');
                     }
                     if (index < numIdsRemainingInFirstCluster) {
                         return (firstFinal + index);
                     }
                     else {
-                        return ((pivotFinal !== null && pivotFinal !== void 0 ? pivotFinal : Common_1.fail('Pivot must exist if range spans clusters.')) +
+                        return ((pivotFinal !== null && pivotFinal !== void 0 ? pivotFinal : (0, Common_1.fail)('Pivot must exist if range spans clusters.')) +
                             (index - numIdsRemainingInFirstCluster));
                     }
                 },
@@ -323,25 +329,25 @@ class IdCompressor {
         var _a;
         const lastLocalInRange = -this.localIdCount;
         const lastTakenNormalized = (_a = this.lastTakenLocalId) !== null && _a !== void 0 ? _a : 0;
-        Common_1.assert(lastLocalInRange <= lastTakenNormalized);
+        (0, Common_1.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;
-                Common_1.assert(overrides[0][0] <= firstLocalInRange);
-                Common_1.assert(overrides[overrides.length - 1][0] >= lastLocalInRange);
+            if ((0, Common_1.hasLength)(overrides, 1)) {
+                (0, Common_1.assert)(overrides[0][0] <= firstLocalInRange);
+                (0, Common_1.assert)(overrides[overrides.length - 1][0] >= lastLocalInRange);
                 ids = {
                     overrides,
                 };
                 const first = firstLocalInRange === overrides[0][0] ? undefined : firstLocalInRange;
                 const last = lastLocalInRange === overrides[overrides.length - 1][0] ? undefined : lastLocalInRange;
-                Common_1.setPropertyIfDefined(first, ids, 'first');
-                Common_1.setPropertyIfDefined(last, ids, 'last');
+                (0, Common_1.setPropertyIfDefined)(first, ids, 'first');
+                (0, Common_1.setPropertyIfDefined)(last, ids, 'last');
             }
             else {
                 ids = {
@@ -352,29 +358,27 @@ class IdCompressor {
             this.lastTakenLocalId = lastLocalInRange;
         }
         const range = { sessionId: this.localSessionId };
-        if (!this.sentAttributionInfo) {
-            Common_1.setPropertyIfDefined(this.localSession.attributionInfo, range, 'attributionInfo');
-            this.sentAttributionInfo = true;
+        if (this.attributionId !== this.localSessionId && sendAttributionId) {
+            range.attributionId = this.attributionId;
         }
         if (ids === undefined) {
             return range;
         }
-        Common_1.assert(this.lastTakenLocalId === -this.localIdCount && this.lastTakenLocalId !== lastTakenNormalized, 'Non-empty range must properly consume local IDs');
+        (0, Common_1.assert)(this.lastTakenLocalId === -this.localIdCount && this.lastTakenLocalId !== lastTakenNormalized, 'Non-empty range must properly consume local IDs');
         range.ids = ids;
         return range;
     }
     /**
      * 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);
-        Common_1.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 ids = IdRange_1.getIds(range);
+        const session = (_a = this.sessions.get(sessionId)) !== null && _a !== void 0 ? _a : this.createSession(sessionId, attributionId);
+        (0, Common_1.assert)(range.attributionId === undefined || range.attributionId === session.attributionId, "A session's attribution ID may never be modified.");
+        const ids = (0, IdRange_1.getIds)(range);
         if (ids === undefined) {
             return;
         }
@@ -383,12 +387,12 @@ 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;
-        Common_1.assert(newFirstFinalizedLocalId === normalizedLastFinalized - 1, 'Ranges finalized out of order.');
+        (0, Common_1.assert)(newFirstFinalizedLocalId === normalizedLastFinalized - 1, 'Ranges finalized out of order.');
         // The total number of session-local IDs to finalize
         const finalizeCount = normalizedLastFinalized - newLastFinalizedLocalId;
-        Common_1.assert(finalizeCount >= 1, 'Cannot finalize an empty range.');
+        (0, Common_1.assert)(finalizeCount >= 1, 'Cannot finalize an empty range.');
         let initialClusterCount = 0;
         let remainingCount = finalizeCount;
         let newBaseUuid;
@@ -407,14 +411,14 @@ class IdCompressor {
                     const expansionAmount = this.newClusterCapacity + overflow;
                     currentCluster.capacity += expansionAmount;
                     this.nextClusterBaseFinalId = (this.nextClusterBaseFinalId + expansionAmount);
-                    Common_1.assert(this.nextClusterBaseFinalId < Number.MAX_SAFE_INTEGER, 'The number of allocated final IDs must not exceed the JS maximum safe integer.');
+                    (0, Common_1.assert)(this.nextClusterBaseFinalId < Number.MAX_SAFE_INTEGER, 'The number of allocated final IDs must not exceed the JS maximum safe integer.');
                     this.checkClusterForCollision(currentCluster);
                 }
             }
             else {
                 // The range cannot be fully allocated in the existing cluster, so allocate any space left in it and
                 // form a new one by incrementing the previous baseUuid
-                newBaseUuid = NumericUuid_1.incrementUuid(currentCluster.baseUuid, currentCluster.capacity);
+                newBaseUuid = (0, NumericUuid_1.incrementUuid)(currentCluster.baseUuid, currentCluster.capacity);
                 currentCluster.count += remainingCapacity;
                 remainingCount -= remainingCapacity;
             }
@@ -436,10 +440,10 @@ class IdCompressor {
         // Need to make a new cluster
         if (newBaseUuid !== undefined) {
             if (remainingCount <= 0) {
-                Common_1.fail('Should not create an empty cluster.');
+                (0, Common_1.fail)('Should not create an empty cluster.');
             }
             if (currentCluster !== undefined && currentCluster.capacity !== currentCluster.count) {
-                Common_1.fail('Cluster must be filled before another is allocated.');
+                (0, Common_1.fail)('Cluster must be filled before another is allocated.');
             }
             newBaseFinalId = this.nextClusterBaseFinalId;
             newCluster = {
@@ -454,13 +458,13 @@ class IdCompressor {
                 this.localIdToCluster.append(localIdPivot, [newBaseFinalId, newCluster]);
             }
             this.checkClusterForCollision(newCluster);
-            this.clustersAndOverridesInversion.set(NumericUuid_1.stableIdFromNumericUuid(newCluster.baseUuid), {
+            this.clustersAndOverridesInversion.set((0, NumericUuid_1.stableIdFromNumericUuid)(newCluster.baseUuid), {
                 clusterBase: newBaseFinalId,
                 cluster: newCluster,
             });
             session.currentClusterDetails = { cluster: newCluster, clusterBase: newBaseFinalId };
             this.nextClusterBaseFinalId = (this.nextClusterBaseFinalId + newCluster.capacity);
-            Common_1.assert(this.nextClusterBaseFinalId < Number.MAX_SAFE_INTEGER, 'The number of allocated final IDs must not exceed the JS maximum safe integer.');
+            (0, Common_1.assert)(this.nextClusterBaseFinalId < Number.MAX_SAFE_INTEGER, 'The number of allocated final IDs must not exceed the JS maximum safe integer.');
             this.finalIdToCluster.append(newBaseFinalId, newCluster);
         }
         // If there are overrides, we must determine which cluster object (current or overflow) each belongs to and add it.
@@ -469,29 +473,28 @@ class IdCompressor {
             for (let i = 0; i < overrides.length; i++) {
                 const [overriddenLocal, override] = overrides[i];
                 // Note: recall that local IDs are negative
-                Common_1.assert(i === 0 || overriddenLocal < overrides[i - 1][0], 'Override IDs must be in sorted order.');
-                Common_1.assert(overriddenLocal < normalizedLastFinalized, 'Ranges finalized out of order.');
-                Common_1.assert(overriddenLocal >= newLastFinalizedLocalId, 'Malformed range: override ID ahead of range start.');
+                (0, Common_1.assert)(i === 0 || overriddenLocal < overrides[i - 1][0], 'Override IDs must be in sorted order.');
+                (0, Common_1.assert)(overriddenLocal < normalizedLastFinalized, 'Ranges finalized out of order.');
+                (0, Common_1.assert)(overriddenLocal >= newLastFinalizedLocalId, 'Malformed range: override ID ahead of range start.');
                 let cluster;
                 let overriddenFinal;
                 if (localIdPivot !== undefined && overriddenLocal <= localIdPivot) {
                     // Override is at or past the pivot, so it is in a new cluster.
-                    Common_1.assert(newCluster !== undefined && newBaseFinalId !== undefined, 'No cluster was created when overflow occurred.');
+                    (0, Common_1.assert)(newCluster !== undefined && newBaseFinalId !== undefined, 'No cluster was created when overflow occurred.');
                     cluster = newCluster;
                     overriddenFinal = (newBaseFinalId + (localIdPivot - overriddenLocal));
                 }
                 else {
                     // Override was finalized into an existing cluster
-                    Common_1.assert(currentCluster !== undefined && currentBaseFinalId !== undefined, 'No cluster exists but IDs were finalized.');
+                    (0, Common_1.assert)(currentCluster !== undefined && currentBaseFinalId !== undefined, 'No cluster exists but IDs were finalized.');
                     cluster = currentCluster;
                     overriddenFinal = (currentBaseFinalId +
                         initialClusterCount +
                         (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;
@@ -511,7 +514,7 @@ class IdCompressor {
                         overrideForCluster = mostFinalExistingOverride;
                     }
                     else {
-                        Common_1.assert(!isLocal || mostFinalExistingOverride === overriddenLocal, 'Cannot have multiple local IDs with identical overrides.');
+                        (0, Common_1.assert)(!isLocal || mostFinalExistingOverride === overriddenLocal, 'Cannot have multiple local IDs with identical overrides.');
                         // This session has created an ID with this override before, but has not finalized it yet. The incoming
                         // range "wins" and will contain the final ID associated with that override, regardless of if that range was
                         // made by this session or not.
@@ -522,7 +525,7 @@ class IdCompressor {
                     // This is the first time this override has been associated with any ID
                     overrideForCluster = override;
                 }
-                Common_1.assert(!cluster.overrides.has(overriddenFinal), 'Cannot add a second override for final id');
+                (0, Common_1.assert)(!cluster.overrides.has(overriddenFinal), 'Cannot add a second override for final id');
                 if (typeof overrideForCluster === 'string') {
                     if (isLocal || associatedLocal === undefined) {
                         cluster.overrides.set(overriddenFinal, override);
@@ -540,14 +543,14 @@ class IdCompressor {
                         override,
                         originalOverridingFinal: overrideForCluster,
                     };
-                    Common_1.setPropertyIfDefined(associatedLocal, unifiedOverride, 'associatedLocalId');
+                    (0, Common_1.setPropertyIfDefined)(associatedLocal, unifiedOverride, 'associatedLocalId');
                     cluster.overrides.set(overriddenFinal, unifiedOverride);
                 }
                 const finalizedOverride = {
                     cluster,
                     originalOverridingFinal: overriddenFinal,
                 };
-                Common_1.setPropertyIfDefined(associatedLocal, finalizedOverride, 'associatedLocalId');
+                (0, Common_1.setPropertyIfDefined)(associatedLocal, finalizedOverride, 'associatedLocalId');
                 const currentOverride = this.clustersAndOverridesInversion.get(inversionKey);
                 if (currentOverride === undefined || IdCompressor.isUnfinalizedOverride(currentOverride)) {
                     // Update the map to contain a finalized override, but never update it with future finalized overrides with
@@ -559,16 +562,16 @@ class IdCompressor {
         session.lastFinalizedLocalId = newLastFinalizedLocalId;
     }
     checkClusterForCollision(cluster) {
-        const maxClusterUuid = NumericUuid_1.incrementUuid(cluster.baseUuid, cluster.capacity - 1);
-        const maxClusterStableId = NumericUuid_1.stableIdFromNumericUuid(maxClusterUuid);
+        const maxClusterUuid = (0, NumericUuid_1.incrementUuid)(cluster.baseUuid, cluster.capacity - 1);
+        const maxClusterStableId = (0, NumericUuid_1.stableIdFromNumericUuid)(maxClusterUuid);
         const closestMatch = this.clustersAndOverridesInversion.getPairOrNextLower(maxClusterStableId);
         if (closestMatch !== undefined) {
             const [inversionKey, compressionMapping] = closestMatch;
             if (!IdCompressor.isClusterInfo(compressionMapping)) {
-                if (NumericUuid_1.isStableId(inversionKey) &&
+                if ((0, UuidUtilities_1.isStableId)(inversionKey) &&
                     IdCompressor.uuidsMightCollide(inversionKey, maxClusterStableId, cluster.capacity)) {
-                    const numericOverride = NumericUuid_1.numericUuidFromStableId(inversionKey);
-                    const delta = NumericUuid_1.getPositiveDelta(maxClusterUuid, numericOverride, cluster.capacity - 1);
+                    const numericOverride = (0, NumericUuid_1.numericUuidFromStableId)(inversionKey);
+                    const delta = (0, NumericUuid_1.getPositiveDelta)(maxClusterUuid, numericOverride, cluster.capacity - 1);
                     if (delta !== undefined) {
                         IdCompressor.failWithCollidingOverride(inversionKey);
                     }
@@ -577,7 +580,7 @@ class IdCompressor {
         }
     }
     static failWithCollidingOverride(override) {
-        Common_1.fail(`Override '${override}' collides with another allocated UUID.`);
+        (0, Common_1.fail)(`Override '${override}' collides with another allocated UUID.`);
     }
     static isClusterInfo(compressionMapping) {
         return compressionMapping.clusterBase !== undefined;
@@ -586,8 +589,7 @@ class IdCompressor {
         return typeof compressionMapping === 'number';
     }
     static createInversionKey(inversionKey) {
-        // TODO: This cast can be removed on typescript 4.6
-        return NumericUuid_1.isStableId(inversionKey) ? inversionKey : `${nonStableOverridePrefix}${inversionKey}`;
+        return (0, UuidUtilities_1.isStableId)(inversionKey) ? inversionKey : `${nonStableOverridePrefix}${inversionKey}`;
     }
     static isStableInversionKey(inversionKey) {
         return inversionKey.charAt(0) !== nonStableOverridePrefix;
@@ -617,8 +619,8 @@ class IdCompressor {
                 stableOverride = inversionKey;
                 const cluster = compressionMapping.cluster;
                 if (IdCompressor.uuidsMightCollide(inversionKey, key, cluster.capacity)) {
-                    numericOverride = NumericUuid_1.numericUuidFromStableId(stableOverride);
-                    const delta = NumericUuid_1.getPositiveDelta(numericOverride, cluster.baseUuid, cluster.capacity - 1);
+                    numericOverride = (0, NumericUuid_1.numericUuidFromStableId)(stableOverride);
+                    const delta = (0, NumericUuid_1.getPositiveDelta)(numericOverride, cluster.baseUuid, cluster.capacity - 1);
                     if (delta !== undefined) {
                         if (isFinalOverride) {
                             IdCompressor.failWithCollidingOverride(inversionKey);
@@ -646,7 +648,7 @@ 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)).
@@ -676,7 +678,7 @@ 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.
      */
@@ -704,12 +706,12 @@ 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) {
-        Common_1.assert(count > 0, 'Must generate a nonzero number of IDs.');
-        Common_1.assert(count <= Number.MAX_SAFE_INTEGER, 'The number of allocated local IDs must not exceed the JS maximum safe integer.');
+        (0, Common_1.assert)(count > 0, 'Must generate a nonzero number of IDs.');
+        (0, Common_1.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 };
@@ -719,16 +721,16 @@ 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) {
         var _a;
-        return (_a = this.tryDecompress(id)) !== null && _a !== void 0 ? _a : Common_1.fail('Compressed ID was not generated by this compressor');
+        return (_a = this.tryDecompress(id)) !== null && _a !== void 0 ? _a : (0, Common_1.fail)('Compressed ID was not generated by this compressor');
     }
     /**
      * 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) {
@@ -746,7 +748,7 @@ class IdCompressor {
                 }
                 else {
                     const offsetInCluster = id - baseFinalId;
-                    return NumericUuid_1.stableIdFromNumericUuid(cluster.baseUuid, offsetInCluster);
+                    return (0, NumericUuid_1.stableIdFromNumericUuid)(cluster.baseUuid, offsetInCluster);
                 }
             }
         }
@@ -764,22 +766,22 @@ class IdCompressor {
                 return localOverride;
             }
             else {
-                return NumericUuid_1.stableIdFromNumericUuid(this.localSession.sessionUuid, idOffset - 1);
+                return (0, NumericUuid_1.stableIdFromNumericUuid)(this.localSession.sessionUuid, idOffset - 1);
             }
         }
     }
     /**
      * 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) {
         var _a;
-        return (_a = this.tryRecompress(uncompressed)) !== null && _a !== void 0 ? _a : Common_1.fail('No such string has ever been compressed');
+        return (_a = this.tryRecompress(uncompressed)) !== null && _a !== void 0 ? _a : (0, Common_1.fail)('No such string has ever been compressed');
     }
     /**
      * 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) {
@@ -792,7 +794,6 @@ 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);
@@ -805,7 +806,7 @@ class IdCompressor {
                     }
                     else {
                         const cluster = compressionMapping.cluster;
-                        Common_1.assert(IdCompressor.tryGetOverride(cluster, compressionMapping.originalOverridingFinal) !==
+                        (0, Common_1.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);
                     }
@@ -816,8 +817,8 @@ class IdCompressor {
                     return undefined;
                 }
                 const { clusterBase: closestBaseFinalId, cluster: closestCluster } = compressionMapping;
-                numericUuid !== null && numericUuid !== void 0 ? numericUuid : (numericUuid = NumericUuid_1.numericUuidFromStableId(inversionKey));
-                const uuidOffset = NumericUuid_1.getPositiveDelta(numericUuid, closestCluster.baseUuid, closestCluster.count - 1);
+                numericUuid !== null && numericUuid !== void 0 ? numericUuid : (numericUuid = (0, NumericUuid_1.numericUuidFromStableId)(inversionKey));
+                const uuidOffset = (0, NumericUuid_1.getPositiveDelta)(numericUuid, closestCluster.baseUuid, closestCluster.count - 1);
                 if (uuidOffset !== undefined) {
                     let targetFinalId = (closestBaseFinalId + uuidOffset);
                     const override = (_b = closestCluster.overrides) === null || _b === void 0 ? void 0 : _b.get(targetFinalId);
@@ -835,7 +836,6 @@ 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;
@@ -845,7 +845,7 @@ 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) {
@@ -855,7 +855,7 @@ class IdCompressor {
         }
         // Check if this local ID has not been allocated yet
         if (-id > this.localIdCount) {
-            Common_1.fail('Supplied local ID was not created by this compressor.');
+            (0, Common_1.fail)('Supplied local ID was not created by this compressor.');
         }
         // Check if this local ID has not been finalized yet
         const { lastFinalizedLocalId } = this.localSession;
@@ -863,7 +863,7 @@ class IdCompressor {
             const override = this.localOverrides.get(id);
             if (override !== undefined) {
                 const inversionKey = IdCompressor.createInversionKey(override);
-                const compressionMapping = (_a = this.clustersAndOverridesInversion.get(inversionKey)) !== null && _a !== void 0 ? _a : Common_1.fail('Bimap is malformed.');
+                const compressionMapping = (_a = this.clustersAndOverridesInversion.get(inversionKey)) !== null && _a !== void 0 ? _a : (0, Common_1.fail)('Bimap is malformed.');
                 if (!IdCompressor.isClusterInfo(compressionMapping) &&
                     !IdCompressor.isUnfinalizedOverride(compressionMapping) &&
                     compressionMapping.associatedLocalId === id) {
@@ -872,7 +872,7 @@ class IdCompressor {
             }
             return id;
         }
-        const [localBase, [finalBase, cluster]] = (_b = this.localIdToCluster.getPairOrNextLower(id)) !== null && _b !== void 0 ? _b : Common_1.fail('Locally created cluster should be added to the map when allocated');
+        const [localBase, [finalBase, cluster]] = (_b = this.localIdToCluster.getPairOrNextLower(id)) !== null && _b !== void 0 ? _b : (0, Common_1.fail)('Locally created cluster should be added to the map when allocated');
         const correspondingFinal = (finalBase + (localBase - id));
         if (cluster.overrides) {
             const override = cluster.overrides.get(correspondingFinal);
@@ -890,18 +890,18 @@ class IdCompressor {
             if (isLocalSession) {
                 const localIndex = -id;
                 if (localIndex > this.localIdCount) {
-                    Common_1.fail('Supplied local ID was not created by this compressor.');
+                    (0, Common_1.fail)('Supplied local ID was not created by this compressor.');
                 }
                 return id;
             }
             else {
-                const session = this.tryGetSession(originSessionId !== null && originSessionId !== void 0 ? originSessionId : Common_1.fail());
+                const session = this.sessions.get(originSessionId !== null && originSessionId !== void 0 ? originSessionId : (0, Common_1.fail)());
                 if (session === undefined) {
-                    Common_1.fail('No IDs have ever been finalized by the supplied session.');
+                    (0, Common_1.fail)('No IDs have ever been finalized by the supplied session.');
                 }
                 const localCount = -id;
-                const numericUuid = NumericUuid_1.incrementUuid(session.sessionUuid, localCount - 1);
-                return (_a = this.compressNumericUuid(numericUuid)) !== null && _a !== void 0 ? _a : Common_1.fail('ID is not known to this compressor.');
+                const numericUuid = (0, NumericUuid_1.incrementUuid)(session.sessionUuid, localCount - 1);
+                return (_a = this.compressNumericUuid(numericUuid)) !== null && _a !== void 0 ? _a : (0, Common_1.fail)('ID is not known to this compressor.');
             }
         }
         const closestResult = this.localIdToCluster.getPairOrNextLowerByValue(id);
@@ -914,7 +914,7 @@ class IdCompressor {
         }
         // 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 : Common_1.fail('Supplied final ID was not finalized by this compressor.');
+        const [_, cluster] = (_b = this.getClusterForFinalId(id)) !== null && _b !== void 0 ? _b : (0, Common_1.fail)('Supplied final ID was not finalized by this compressor.');
         const override = (_c = cluster.overrides) === null || _c === void 0 ? void 0 : _c.get(id);
         if (typeof override === 'object' && override.associatedLocalId !== undefined) {
             return override.associatedLocalId;
@@ -942,7 +942,7 @@ class IdCompressor {
      * session-space ID corresponding to A0000000-0000-0000-0000-000000000000 (with override X0000000-0000-0000-0000-000000000000).
      */
     compressNumericUuid(numericUuid) {
-        const stableId = NumericUuid_1.stableIdFromNumericUuid(numericUuid);
+        const stableId = (0, NumericUuid_1.stableIdFromNumericUuid)(numericUuid);
         const sessionSpaceId = this.recompressInternal(stableId, numericUuid);
         if (sessionSpaceId === undefined) {
             return undefined;
@@ -950,9 +950,8 @@ class IdCompressor {
         return sessionSpaceId;
     }
     getLocalIdForStableId(stableId) {
-        // TODO: This cast can be removed on typescript 4.6
-        const numericUuid = (typeof stableId === 'string' ? NumericUuid_1.numericUuidFromStableId(stableId) : stableId);
-        const offset = NumericUuid_1.getPositiveDelta(numericUuid, this.localSession.sessionUuid, this.localIdCount - 1);
+        const numericUuid = typeof stableId === 'string' ? (0, NumericUuid_1.numericUuidFromStableId)(stableId) : stableId;
+        const offset = (0, NumericUuid_1.getPositiveDelta)(numericUuid, this.localSession.sessionUuid, this.localIdCount - 1);
         if (offset === undefined) {
             return undefined;
         }
@@ -970,21 +969,21 @@ 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)) {
                 return false;
             }
-            if (!Common_1.compareMaps(this.sessions, other.sessions, (a, b) => IdCompressor.sessionDataEqual(a, b, true, compareLocalState))) {
+            if (!(0, Common_1.compareMaps)(this.sessions, other.sessions, (a, b) => IdCompressor.sessionDataEqual(a, b, true, compareLocalState))) {
                 return false;
             }
         }
@@ -1060,8 +1059,8 @@ class IdCompressor {
         return diff === undefined;
     }
     static sessionDataEqual(a, b, checkCluster = true, compareLocalState = true) {
-        if (a.attributionInfo !== b.attributionInfo ||
-            !NumericUuid_1.numericUuidEquals(a.sessionUuid, b.sessionUuid) ||
+        if (a.attributionId !== b.attributionId ||
+            !(0, NumericUuid_1.numericUuidEquals)(a.sessionUuid, b.sessionUuid) ||
             a.lastFinalizedLocalId !== b.lastFinalizedLocalId) {
             return false;
         }
@@ -1078,13 +1077,13 @@ class IdCompressor {
         return true;
     }
     static idClustersEqual(a, b, checkSessionData = true, compareLocalState = true) {
-        const areEqual = NumericUuid_1.numericUuidEquals(a.baseUuid, b.baseUuid) &&
+        const areEqual = (0, NumericUuid_1.numericUuidEquals)(a.baseUuid, b.baseUuid) &&
             a.capacity === b.capacity &&
             a.count === b.count &&
             (!checkSessionData || IdCompressor.sessionDataEqual(a.session, b.session, false, compareLocalState)) &&
             (a.overrides === undefined) === (b.overrides === undefined) &&
             (a.overrides === undefined ||
-                Common_1.compareMaps(Common_1.assertNotUndefined(a.overrides), Common_1.assertNotUndefined(b.overrides), (a, b) => {
+                (0, Common_1.compareMaps)((0, Common_1.assertNotUndefined)(a.overrides), (0, Common_1.assertNotUndefined)(b.overrides), (a, b) => {
                     if (compareLocalState) {
                         if (typeof a === 'string' || typeof b === 'string') {
                             return a === b;
@@ -1109,6 +1108,8 @@ 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
@@ -1116,8 +1117,10 @@ 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((0, Common_1.getOrCreate)(attributionIdToAttributionIndex, session.attributionId, (id) => (serializedAttributionIds !== null && serializedAttributionIds !== void 0 ? serializedAttributionIds : (serializedAttributionIds = [])).push(id) - 1));
                 }
                 sessionIdToSessionIndex.set(sessionId, serializedSessions.length);
                 serializedSessions.push(sessionData);
@@ -1125,9 +1128,9 @@ class IdCompressor {
         }
         const serializedClusters = [];
         for (const [baseFinalId, cluster] of this.finalIdToCluster.entries()) {
-            const sessionId = NumericUuid_1.stableIdFromNumericUuid(cluster.session.sessionUuid);
+            const sessionId = (0, NumericUuid_1.stableIdFromNumericUuid)(cluster.session.sessionUuid);
             if (sessionId !== reservedSessionId) {
-                const sessionIndex = (_a = sessionIdToSessionIndex.get(sessionId)) !== null && _a !== void 0 ? _a : Common_1.fail('Session object contains wrong session numeric UUID');
+                const sessionIndex = (_a = sessionIdToSessionIndex.get(sessionId)) !== null && _a !== void 0 ? _a : (0, Common_1.fail)('Session object contains wrong session numeric UUID');
                 const serializedCluster = [sessionIndex, cluster.capacity];
                 if (cluster.count !== cluster.capacity) {
                     serializedCluster.push(cluster.count);
@@ -1156,7 +1159,7 @@ class IdCompressor {
             }
         }
         // Reserved session not serialized, and local session is present but may not make IDs
-        Common_1.assert(serializedSessions.length - this.sessions.size <= 2, 'session not serialized');
+        (0, Common_1.assert)(serializedSessions.length - this.sessions.size <= 2, 'session not serialized');
         const serializedIdCompressor = {
             version: currentWrittenVersion,
             reservedIdCount: this.reservedIdCount,
@@ -1164,6 +1167,7 @@ class IdCompressor {
             sessions: serializedSessions,
             clusters: serializedClusters,
         };
+        (0, Common_1.setPropertyIfDefined)(serializedAttributionIds, serializedIdCompressor, 'attributionIds');
         if (withSession) {
             const serializedWithSession = serializedIdCompressor;
             serializedWithSession.localSessionIndex = serializedWithSession.sessions.findIndex(([sessionId]) => sessionId === this.localSessionId);
@@ -1172,40 +1176,41 @@ 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) {
-            Common_1.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) {
+                (0, Common_1.assert)(serializedAttributionIds !== undefined && serializedAttributionIds.length > attributionIndex);
+                attributionId = serializedAttributionIds[attributionIndex];
+            }
+            serializedLocalState = serializedWithSession.localState;
         }
         else {
-            Common_1.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);
@@ -1216,13 +1221,18 @@ class IdCompressor {
         }
         const sessionInfos = [];
         for (const serializedSession of serializedSessions) {
-            const [sessionId, attributionInfo] = serializedSession;
+            const [sessionId, attributionIndex] = serializedSession;
             if (sessionId === localSessionId) {
-                Common_1.assert(hasSession, 'Cannot resume existing session.');
+                (0, Common_1.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) {
+                    (0, Common_1.assert)(serializedAttributionIds !== undefined && serializedAttributionIds.length > attributionIndex, 'AttributionId index out of bounds');
+                    attributionId = serializedAttributionIds[attributionIndex];
+                }
+                const session = compressor.createSession(sessionId, attributionId);
                 sessionInfos.push({ session, sessionId });
             }
         }
@@ -1234,7 +1244,7 @@ class IdCompressor {
             const cluster = {
                 capacity,
                 count,
-                baseUuid: NumericUuid_1.incrementUuid(sessionUuid, currentIdCount),
+                baseUuid: (0, NumericUuid_1.incrementUuid)(sessionUuid, currentIdCount),
                 session,
             };
             const lastFinalizedNormalized = lastFinalizedLocalId !== null && lastFinalizedLocalId !== void 0 ? lastFinalizedLocalId : 0;
@@ -1249,7 +1259,7 @@ class IdCompressor {
             session.currentClusterDetails = { clusterBase, cluster };
             compressor.nextClusterBaseFinalId = (compressor.nextClusterBaseFinalId + capacity);
             compressor.finalIdToCluster.append(clusterBase, cluster);
-            compressor.clustersAndOverridesInversion.set(NumericUuid_1.stableIdFromNumericUuid(cluster.baseUuid), {
+            compressor.clustersAndOverridesInversion.set((0, NumericUuid_1.stableIdFromNumericUuid)(cluster.baseUuid), {
                 clusterBase,
                 cluster,
             });
@@ -1263,7 +1273,7 @@ class IdCompressor {
                             originalOverridingFinal,
                         };
                         if (serializedLocalState !== undefined) {
-                            Common_1.setPropertyIfDefined(localOverridesInverse.get(override), unifiedOverride, 'associatedLocalId');
+                            (0, Common_1.setPropertyIfDefined)(localOverridesInverse.get(override), unifiedOverride, 'associatedLocalId');
                         }
                         cluster.overrides.set(finalId, unifiedOverride);
                     }
@@ -1287,20 +1297,20 @@ class IdCompressor {
                             originalOverridingFinal: finalId,
                         };
                         if (serializedLocalState !== undefined) {
-                            Common_1.setPropertyIfDefined(associatedLocal, finalizedOverride, 'associatedLocalId');
+                            (0, Common_1.setPropertyIfDefined)(associatedLocal, finalizedOverride, 'associatedLocalId');
                         }
                         compressor.clustersAndOverridesInversion.set(IdCompressor.createInversionKey(override), finalizedOverride);
                     }
                 }
             }
         }
-        Common_1.assert(compressor.localSession.lastFinalizedLocalId === undefined ||
+        (0, Common_1.assert)(compressor.localSession.lastFinalizedLocalId === undefined ||
             compressor.localIdCount >= -compressor.localSession.lastFinalizedLocalId);
         return compressor;
     }
     static convertToCurrentVersion(serializedCompressor, hasSession) {
         if (serializedCompressor.version !== currentWrittenVersion) {
-            Common_1.fail('Unknown SerializedIdCompressor version number');
+            (0, Common_1.fail)('Unknown SerializedIdCompressor version number');
         }
         const serialized = serializedCompressor;
         if (hasSession !== hasOngoingSession(serialized)) {
@@ -1331,10 +1341,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,
     };
 }
 /**
@@ -1344,10 +1352,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