@fluidframework/container-runtime 2.0.0-internal.6.1.0 → 2.0.0-internal.6.2.0

package/dist/id-compressor/persistanceUtilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistanceUtilities.js","sourceRoot":"","sources":["../../src/id-compressor/persistanceUtilities.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAKH,MAAM,WAAW,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC;AACjD,MAAM,SAAS,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;AAE7B,SAAgB,WAAW,CAAC,MAAoB,EAAE,KAAa,EAAE,KAAa;IAC7E,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;IACtB,OAAO,KAAK,GAAG,CAAC,CAAC;AAClB,CAAC;AAHD,kCAGC;AAED,SAAgB,gBAAgB,CAC/B,MAAsB,EACtB,KAAa,EACb,KAAkB;IAElB,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,WAAW,CAAC;IACpC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,KAAK,IAAI,SAAS,CAAC;IACvC,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,4BAA4B;AAC/C,CAAC;AARD,4CAQC;AAED,SAAgB,YAAY,CAAC,MAAoB,EAAE,KAAa,EAAE,KAAc;IAC/E,OAAO,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClD,CAAC;AAFD,oCAEC;AAaD,SAAgB,UAAU,CAAC,KAAY;IACtC,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;IACjB,OAAO,KAAK,CAAC;AACd,CAAC;AAJD,gCAIC;AAED,SAAgB,eAAe,CAAC,KAAY;IAC3C,MAAM,SAAS,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IACpD,MAAM,KAAK,GAAG,CAAC,SAAS,IAAI,SAAS,CAAC,GAAG,SAAS,CAAC;IACnD,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;IACjB,OAAO,KAAoB,CAAC;AAC7B,CAAC;AAND,0CAMC;AAED,SAAgB,WAAW,CAAC,KAAY;IACvC,OAAO,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC;AAFD,kCAEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/* eslint-disable no-bitwise */\nimport { NumericUuid } from \"./identifiers\";\n\nconst halfNumeric = BigInt(\"0xFFFFFFFFFFFFFFFF\");\nconst sixtyFour = BigInt(64);\n\nexport function writeNumber(buffer: Float64Array, index: number, value: number): number {\n\tbuffer[index] = value;\n\treturn index + 1;\n}\n\nexport function writeNumericUuid(\n\tbuffer: BigUint64Array,\n\tindex: number,\n\tvalue: NumericUuid,\n): number {\n\tbuffer[index] = value & halfNumeric;\n\tbuffer[index + 1] = value >> sixtyFour;\n\treturn index + 2; // UUID values are 16 bytes.\n}\n\nexport function writeBoolean(buffer: Float64Array, index: number, value: boolean): number {\n\treturn writeNumber(buffer, index, value ? 1 : 0);\n}\n\n/**\n * Helper type to allow returning a value when reading as well as incrementing an index to make\n * deserialization easier.\n * Should be constructed with two views of the same buffer and index set to 0.\n */\nexport interface Index {\n\tbufferFloat: Float64Array;\n\tbufferUint: BigUint64Array;\n\tindex: number;\n}\n\nexport function readNumber(index: Index): number {\n\tconst value = index.bufferFloat[index.index];\n\tindex.index += 1;\n\treturn value;\n}\n\nexport function readNumericUuid(index: Index): NumericUuid {\n\tconst lowerHalf = index.bufferUint[index.index];\n\tconst upperHalf = index.bufferUint[index.index + 1];\n\tconst value = (upperHalf << sixtyFour) | lowerHalf;\n\tindex.index += 2;\n\treturn value as NumericUuid;\n}\n\nexport function readBoolean(index: Index): boolean {\n\treturn readNumber(index) === 1;\n}\n"]}

package/dist/id-compressor/sessionSpaceNormalizer.d.ts

@@ -0,0 +1,46 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { AppendOnlySortedMap } from "./appendOnlySortedMap";
+import { LocalCompressedId } from "./identifiers";
+/**
+ * The `SessionSpaceNormalizer` tracks the form of the IDs created by the local session.
+ * More precisely, it acts as a set of all `LocalCompressedId`s created by the local session and allows querying whether a specific
+ * ID was produced by the local session. This information can be used to determine whether the nth ID created by the local session
+ * was produced as a local ID (negative) or a final ID (positive).
+ *
+ * The local and final forms of IDs made by a session can be thought of as two equal-length sparse arrays, aligned such
+ * that normalizeLocalToFinal(locals[i]) === finals[i] and vice versa.
+ * Below is an example to illustrate how various mappings can arise:
+ *
+ * ```
+ *     +- Creation Index
+ *    /     +- Locals
+ *   /     /    +- Finals
+ *  /     /    /
+ * ---+-----+----
+ * 0  | -1  | 0   -|___ Two IDs are allocated as locals since no cluster exists. A new cluster is created when acked.
+ * 1  | -2  | 1   -|
+ * 2  |     | 2   -|
+ * 3  |     | 3   --|-- Three more IDs are allocated as finals eagerly since a cluster exists with available capacity.
+ * 4  |     | 4   -|
+ * 5  | -6  | 10  ----- One ID is allocated as a local (it overflows the existing cluster) and a new cluster is created after ack.
+ * 6  |     | 11  ----- This ID (and the subsequent few) is allocated eagerly as a final ID into the existing cluster.
+ * 7  |     | 12
+ * 8  |     | 13
+ * 9  |     | 14
+ * 10 | -11 |     ----- The cluster is out of room, so a local ID is allocated. It has no corresponding final ID since it has not been acked.
+ * ```
+ *
+ * This class stores the set of local IDs and thus their indices, as local IDs are essentially negative offsets from the first ID.
+ * The form (local or final) of a given ID index (for example, the 5th ID made by the local session) can be deduced from this information.
+ */
+export declare class SessionSpaceNormalizer {
+    private readonly localIdRanges;
+    get idRanges(): Pick<AppendOnlySortedMap<number, number>, "size" | "entries">;
+    addLocalRange(baseGenCount: number, count: number): void;
+    contains(query: LocalCompressedId): boolean;
+    equals(other: SessionSpaceNormalizer): boolean;
+}
+//# sourceMappingURL=sessionSpaceNormalizer.d.ts.map

package/dist/id-compressor/sessionSpaceNormalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionSpaceNormalizer.d.ts","sourceRoot":"","sources":["../../src/id-compressor/sessionSpaceNormalizer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,sBAAsB;IAGlC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiE;IAE/F,IAAW,QAAQ,IAAI,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,CAEnF;IAEM,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAcxD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO;IAY3C,MAAM,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO;CAMrD"}

package/dist/id-compressor/sessionSpaceNormalizer.js

@@ -0,0 +1,80 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionSpaceNormalizer = void 0;
+const appendOnlySortedMap_1 = require("./appendOnlySortedMap");
+const utilities_1 = require("./utilities");
+/**
+ * The `SessionSpaceNormalizer` tracks the form of the IDs created by the local session.
+ * More precisely, it acts as a set of all `LocalCompressedId`s created by the local session and allows querying whether a specific
+ * ID was produced by the local session. This information can be used to determine whether the nth ID created by the local session
+ * was produced as a local ID (negative) or a final ID (positive).
+ *
+ * The local and final forms of IDs made by a session can be thought of as two equal-length sparse arrays, aligned such
+ * that normalizeLocalToFinal(locals[i]) === finals[i] and vice versa.
+ * Below is an example to illustrate how various mappings can arise:
+ *
+ * ```
+ *     +- Creation Index
+ *    /     +- Locals
+ *   /     /    +- Finals
+ *  /     /    /
+ * ---+-----+----
+ * 0  | -1  | 0   -|___ Two IDs are allocated as locals since no cluster exists. A new cluster is created when acked.
+ * 1  | -2  | 1   -|
+ * 2  |     | 2   -|
+ * 3  |     | 3   --|-- Three more IDs are allocated as finals eagerly since a cluster exists with available capacity.
+ * 4  |     | 4   -|
+ * 5  | -6  | 10  ----- One ID is allocated as a local (it overflows the existing cluster) and a new cluster is created after ack.
+ * 6  |     | 11  ----- This ID (and the subsequent few) is allocated eagerly as a final ID into the existing cluster.
+ * 7  |     | 12
+ * 8  |     | 13
+ * 9  |     | 14
+ * 10 | -11 |     ----- The cluster is out of room, so a local ID is allocated. It has no corresponding final ID since it has not been acked.
+ * ```
+ *
+ * This class stores the set of local IDs and thus their indices, as local IDs are essentially negative offsets from the first ID.
+ * The form (local or final) of a given ID index (for example, the 5th ID made by the local session) can be deduced from this information.
+ */
+class SessionSpaceNormalizer {
+    constructor() {
+        // Run-length encoding of IDs that were generated as local IDs. They are stored as a list of tuples (genCount, count)
+        // that are sorted on the genCount so that contains checks can use a binary search.
+        this.localIdRanges = new appendOnlySortedMap_1.AppendOnlySortedMap(utilities_1.compareFiniteNumbers);
+    }
+    get idRanges() {
+        return this.localIdRanges;
+    }
+    addLocalRange(baseGenCount, count) {
+        const last = this.localIdRanges.last();
+        if (last !== undefined) {
+            const [lastGenCount, lastCount] = last;
+            // Check to see if the added run of local IDs is contiguous with the last range added.
+            // If it is, simply merge them (this is the common case).
+            if (lastGenCount + lastCount === baseGenCount) {
+                this.localIdRanges.replaceLast(lastGenCount, lastCount + count);
+                return;
+            }
+        }
+        this.localIdRanges.append(baseGenCount, count);
+    }
+    contains(query) {
+        const genCount = (0, utilities_1.genCountFromLocalId)(query);
+        const containingBlock = this.localIdRanges.getPairOrNextLower(genCount);
+        if (containingBlock !== undefined) {
+            const [baseGenCount, count] = containingBlock;
+            if (genCount <= baseGenCount + (count - 1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    equals(other) {
+        return this.localIdRanges.equals(other.localIdRanges, (countA, countB) => countA === countB);
+    }
+}
+exports.SessionSpaceNormalizer = SessionSpaceNormalizer;
+//# sourceMappingURL=sessionSpaceNormalizer.js.map

package/dist/id-compressor/sessionSpaceNormalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionSpaceNormalizer.js","sourceRoot":"","sources":["../../src/id-compressor/sessionSpaceNormalizer.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+DAA4D;AAE5D,2CAAwE;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAa,sBAAsB;IAAnC;QACC,qHAAqH;QACrH,mFAAmF;QAClE,kBAAa,GAAG,IAAI,yCAAmB,CAAiB,gCAAoB,CAAC,CAAC;IAsChG,CAAC;IApCA,IAAW,QAAQ;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;IAEM,aAAa,CAAC,YAAoB,EAAE,KAAa;QACvD,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QACvC,IAAI,IAAI,KAAK,SAAS,EAAE;YACvB,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;YACvC,sFAAsF;YACtF,yDAAyD;YACzD,IAAI,YAAY,GAAG,SAAS,KAAK,YAAY,EAAE;gBAC9C,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,CAAC,CAAC;gBAChE,OAAO;aACP;SACD;QACD,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;IAEM,QAAQ,CAAC,KAAwB;QACvC,MAAM,QAAQ,GAAG,IAAA,+BAAmB,EAAC,KAAK,CAAC,CAAC;QAC5C,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;QACxE,IAAI,eAAe,KAAK,SAAS,EAAE;YAClC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,GAAG,eAAe,CAAC;YAC9C,IAAI,QAAQ,IAAI,YAAY,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE;gBAC3C,OAAO,IAAI,CAAC;aACZ;SACD;QACD,OAAO,KAAK,CAAC;IACd,CAAC;IAEM,MAAM,CAAC,KAA6B;QAC1C,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAC/B,KAAK,CAAC,aAAa,EACnB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,MAAM,CACrC,CAAC;IACH,CAAC;CACD;AAzCD,wDAyCC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { AppendOnlySortedMap } from \"./appendOnlySortedMap\";\nimport { LocalCompressedId } from \"./identifiers\";\nimport { compareFiniteNumbers, genCountFromLocalId } from \"./utilities\";\n\n/**\n * The `SessionSpaceNormalizer` tracks the form of the IDs created by the local session.\n * More precisely, it acts as a set of all `LocalCompressedId`s created by the local session and allows querying whether a specific\n * ID was produced by the local session. This information can be used to determine whether the nth ID created by the local session\n * was produced as a local ID (negative) or a final ID (positive).\n *\n * The local and final forms of IDs made by a session can be thought of as two equal-length sparse arrays, aligned such\n * that normalizeLocalToFinal(locals[i]) === finals[i] and vice versa.\n * Below is an example to illustrate how various mappings can arise:\n *\n * ```\n *     +- Creation Index\n *    /     +- Locals\n *   /     /    +- Finals\n *  /     /    /\n * ---+-----+----\n * 0  | -1  | 0   -|___ Two IDs are allocated as locals since no cluster exists. A new cluster is created when acked.\n * 1  | -2  | 1   -|\n * 2  |     | 2   -|\n * 3  |     | 3   --|-- Three more IDs are allocated as finals eagerly since a cluster exists with available capacity.\n * 4  |     | 4   -|\n * 5  | -6  | 10  ----- One ID is allocated as a local (it overflows the existing cluster) and a new cluster is created after ack.\n * 6  |     | 11  ----- This ID (and the subsequent few) is allocated eagerly as a final ID into the existing cluster.\n * 7  |     | 12\n * 8  |     | 13\n * 9  |     | 14\n * 10 | -11 |     ----- The cluster is out of room, so a local ID is allocated. It has no corresponding final ID since it has not been acked.\n * ```\n *\n * This class stores the set of local IDs and thus their indices, as local IDs are essentially negative offsets from the first ID.\n * The form (local or final) of a given ID index (for example, the 5th ID made by the local session) can be deduced from this information.\n */\nexport class SessionSpaceNormalizer {\n\t// Run-length encoding of IDs that were generated as local IDs. They are stored as a list of tuples (genCount, count)\n\t// that are sorted on the genCount so that contains checks can use a binary search.\n\tprivate readonly localIdRanges = new AppendOnlySortedMap<number, number>(compareFiniteNumbers);\n\n\tpublic get idRanges(): Pick<AppendOnlySortedMap<number, number>, \"size\" | \"entries\"> {\n\t\treturn this.localIdRanges;\n\t}\n\n\tpublic addLocalRange(baseGenCount: number, count: number): void {\n\t\tconst last = this.localIdRanges.last();\n\t\tif (last !== undefined) {\n\t\t\tconst [lastGenCount, lastCount] = last;\n\t\t\t// Check to see if the added run of local IDs is contiguous with the last range added.\n\t\t\t// If it is, simply merge them (this is the common case).\n\t\t\tif (lastGenCount + lastCount === baseGenCount) {\n\t\t\t\tthis.localIdRanges.replaceLast(lastGenCount, lastCount + count);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tthis.localIdRanges.append(baseGenCount, count);\n\t}\n\n\tpublic contains(query: LocalCompressedId): boolean {\n\t\tconst genCount = genCountFromLocalId(query);\n\t\tconst containingBlock = this.localIdRanges.getPairOrNextLower(genCount);\n\t\tif (containingBlock !== undefined) {\n\t\t\tconst [baseGenCount, count] = containingBlock;\n\t\t\tif (genCount <= baseGenCount + (count - 1)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\tpublic equals(other: SessionSpaceNormalizer): boolean {\n\t\treturn this.localIdRanges.equals(\n\t\t\tother.localIdRanges,\n\t\t\t(countA, countB) => countA === countB,\n\t\t);\n\t}\n}\n"]}

package/dist/id-compressor/sessions.d.ts

@@ -0,0 +1,115 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { SessionId, StableId } from "@fluidframework/runtime-definitions";
+import { FinalCompressedId, LocalCompressedId, NumericUuid } from "./identifiers";
+/**
+ * A collection of all sessions known to the compressor (i.e. all finalized/acked allocated UUIDs and their corresponding local and final forms).
+ * This collection of all sessions comprises a distributed document's IDs.
+ */
+export declare class Sessions {
+    private readonly uuidSpace;
+    private readonly sessionCache;
+    constructor(sessions?: [sessionBase: NumericUuid, session: Session][]);
+    sessions(): IterableIterator<Session>;
+    getOrCreate(sessionId: SessionId): Session;
+    get(sessionId: SessionId): Session | undefined;
+    getContainingCluster(query: StableId): [cluster: IdCluster, alignedLocal: LocalCompressedId] | undefined;
+    clusterCollides(cluster: IdCluster): boolean;
+    equals(other: Sessions, includeLocalState: boolean): boolean;
+}
+/**
+ * The IDs created by a specific session, stored as a cluster chain to allow for fast conversions.
+ */
+export declare class Session {
+    private readonly clusterChain;
+    readonly sessionUuid: NumericUuid;
+    constructor(sessionId: SessionId | NumericUuid);
+    /**
+     * Adds a new empty cluster to the cluster chain of this session.
+     */
+    addNewCluster(baseFinalId: FinalCompressedId, capacity: number, count: number): IdCluster;
+    isEmpty(): boolean;
+    /**
+     * Returns the last cluster in this session's cluster chain, if any.
+     */
+    getLastCluster(): IdCluster | undefined;
+    /**
+     * Converts the local ID from this session to a final ID, if possible.
+     * @param includeAllocated - true if the conversion should succeed even if the local ID aligns with a part of the cluster that is allocated but not finalized.
+     */
+    tryConvertToFinal(searchLocal: LocalCompressedId, includeAllocated: boolean): FinalCompressedId | undefined;
+    /**
+     * Returns the cluster containing the supplied local ID, if possible.
+     * @param includeAllocated - true if the conversion should succeed even if the local ID aligns with a part of the cluster that is allocated but not finalized.
+     */
+    getClusterByLocal(localId: LocalCompressedId, includeAllocated: boolean): IdCluster | undefined;
+    /**
+     * Returns the cluster containing the supplied final ID, if possible.
+     */
+    getClusterByAllocatedFinal(final: FinalCompressedId): IdCluster | undefined;
+    /**
+     * Returns the cluster from the supplied cluster chain containing the supplied final ID, if possible.
+     * `clusterChain` must be sorted by final/local base ID.
+     */
+    static getContainingCluster(finalId: FinalCompressedId, clusterChain: readonly IdCluster[]): IdCluster | undefined;
+    static binarySearch<S, T>(search: S, arr: readonly T[], comparator: (a: S, b: T) => number): T | undefined;
+    equals(other: Session): boolean;
+}
+/**
+ * A cluster of final (sequenced via consensus), sequentially allocated compressed IDs.
+ * A final ID in a cluster decompresses to a sequentially allocated UUID that is the result of adding its offset within
+ * the cluster to base UUID for the session that created it.
+ */
+export interface IdCluster {
+    /**
+     * The session that created this cluster.
+     */
+    readonly session: Session;
+    /**
+     * The first final ID in the cluster.
+     */
+    readonly baseFinalId: FinalCompressedId;
+    /**
+     * The local ID aligned with `baseFinalId`.
+     */
+    readonly baseLocalId: LocalCompressedId;
+    /**
+     * The total number of final IDs reserved for allocation in the cluster.
+     * Clusters are reserved in blocks as a performance optimization.
+     */
+    capacity: number;
+    /**
+     * The number of final IDs currently allocated in the cluster.
+     */
+    count: number;
+}
+export declare function clustersEqual(a: IdCluster, b: IdCluster): boolean;
+/**
+ * Returns the final ID that is aligned with the supplied local ID within a cluster.
+ * Includes allocated IDs.
+ */
+export declare function getAlignedFinal(cluster: IdCluster, localWithin: LocalCompressedId): FinalCompressedId | undefined;
+/**
+ * Returns the local ID that is aligned with the supplied final ID within a cluster.
+ * Fails if the supplied ID does not fall within the cluster bounds.
+ */
+export declare function getAlignedLocal(cluster: IdCluster, finalWithin: FinalCompressedId): LocalCompressedId;
+/**
+ * Returns the last allocated final ID (i.e. any ID between base final and base final + capacity) within a cluster
+ */
+export declare function lastAllocatedFinal(cluster: IdCluster): FinalCompressedId;
+/**
+ * Returns the last allocated final ID (i.e. any ID between base final and base final + count) within a cluster
+ */
+export declare function lastFinalizedFinal(cluster: IdCluster): FinalCompressedId;
+/**
+ * Returns the last allocated local ID (i.e. any ID between base local and base local + capacity) within a cluster
+ */
+export declare function lastAllocatedLocal(cluster: IdCluster): LocalCompressedId;
+/**
+ * Returns the last allocated local ID (i.e. any ID between base local and base local + count) within a cluster
+ */
+export declare function lastFinalizedLocal(cluster: IdCluster): LocalCompressedId;
+//# sourceMappingURL=sessions.d.ts.map

package/dist/id-compressor/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../src/id-compressor/sessions.ts"],"names":[],"mappings":"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"}

package/dist/id-compressor/sessions.js

@@ -0,0 +1,305 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lastFinalizedLocal = exports.lastAllocatedLocal = exports.lastFinalizedFinal = exports.lastAllocatedFinal = exports.getAlignedLocal = exports.getAlignedFinal = exports.clustersEqual = exports.Session = exports.Sessions = void 0;
+const sorted_btree_1 = __importDefault(require("sorted-btree"));
+const common_utils_1 = require("@fluidframework/common-utils");
+const utilities_1 = require("./utilities");
+/**
+ * A collection of all sessions known to the compressor (i.e. all finalized/acked allocated UUIDs and their corresponding local and final forms).
+ * This collection of all sessions comprises a distributed document's IDs.
+ */
+class Sessions {
+    constructor(sessions) {
+        // A range-queryable store of all sessions. A btree is used as it solves the predecessor problem for any given UUID, allowing
+        // us to quickly find the session that may have produced it.
+        this.uuidSpace = new sorted_btree_1.default(undefined, utilities_1.compareBigints);
+        // A fast lookup table from session ID to the session object, used to avoid accessing the slower btree
+        this.sessionCache = new Map();
+        if (sessions !== undefined) {
+            // bulk load path
+            for (const [numeric, session] of sessions) {
+                this.sessionCache.set((0, utilities_1.stableIdFromNumericUuid)(numeric), session);
+            }
+            this.uuidSpace = new sorted_btree_1.default(sessions, utilities_1.compareBigints);
+            if (this.sessionCache.size !== sessions.length ||
+                sessions.length !== this.uuidSpace.size) {
+                throw new Error("Cannot resume existing session.");
+            }
+        }
+    }
+    sessions() {
+        return this.sessionCache.values();
+    }
+    getOrCreate(sessionId) {
+        const existing = this.sessionCache.get(sessionId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const session = new Session(sessionId);
+        (0, common_utils_1.assert)(this.uuidSpace.set(session.sessionUuid, session), 0x760 /* Duplicate session in map. */);
+        this.sessionCache.set(sessionId, session);
+        return session;
+    }
+    get(sessionId) {
+        return this.sessionCache.get(sessionId);
+    }
+    getContainingCluster(query) {
+        const numericStable = (0, utilities_1.numericUuidFromStableId)(query);
+        const possibleMatch = this.uuidSpace.getPairOrNextLower(numericStable);
+        if (possibleMatch === undefined) {
+            return undefined;
+        }
+        const [_, session] = possibleMatch;
+        const numericDelta = (0, utilities_1.subtractNumericUuids)(numericStable, session.sessionUuid);
+        if (numericDelta > Number.MAX_SAFE_INTEGER) {
+            return undefined;
+        }
+        const alignedLocal = (0, utilities_1.localIdFromGenCount)(Number(numericDelta) + 1);
+        const containingCluster = session.getClusterByLocal(alignedLocal, true);
+        if (containingCluster === undefined) {
+            return undefined;
+        }
+        return [containingCluster, alignedLocal];
+    }
+    clusterCollides(cluster) {
+        const { session: owningSession, baseLocalId, capacity } = cluster;
+        const clusterBaseNumeric = (0, utilities_1.offsetNumericUuid)(owningSession.sessionUuid, (0, utilities_1.genCountFromLocalId)(baseLocalId) - 1);
+        const clusterMaxNumeric = (0, utilities_1.offsetNumericUuid)(clusterBaseNumeric, capacity - 1);
+        let closestMatch = this.uuidSpace.getPairOrNextLower(clusterMaxNumeric);
+        // Find the first session that is not the owner of this new cluster.
+        // Once we have that, check to see if its cluster chain overlaps with the new cluster.
+        // Consider the following diagram of UUID space:
+        // Cluster chain A:  |----------------------|
+        // Cluster chain B:       |----------|
+        // Cluster chain C:                       |-------|
+        // While it is true that when adding a cluster to chain C, we would find
+        // the next lower session (which is B) and erroneously determine we do not collide
+        // with any other session, but this situation is impossible to get into as B would
+        // have detected that it collided with A (or the other way around, depending on ordering).
+        while (closestMatch !== undefined && closestMatch[1] === owningSession) {
+            closestMatch = this.uuidSpace.nextLowerPair(closestMatch[0]);
+        }
+        if (closestMatch === undefined) {
+            return false;
+        }
+        const [_, session] = closestMatch;
+        (0, common_utils_1.assert)(session !== owningSession, 0x761 /* Failed to attempt to detect collisions. */);
+        const lastCluster = session.getLastCluster();
+        if (lastCluster === undefined) {
+            // If the closest session is empty (the local session), then it is guaranteed (probabilistically) that there are no
+            // non-empty sessions that have a cluster chain that starts prior to the empty session and collides with the cluster
+            // we are checking, so we can return false.
+            return false;
+        }
+        const lastAllocatedNumeric = (0, utilities_1.offsetNumericUuid)(session.sessionUuid, (0, utilities_1.genCountFromLocalId)(lastAllocatedLocal(lastCluster)) - 1);
+        return lastAllocatedNumeric >= clusterBaseNumeric;
+    }
+    equals(other, includeLocalState) {
+        const checkIsSubset = (sessionsA, sessionsB) => {
+            const first = sessionsA.sessions().next();
+            const firstSessionThis = first.done ? undefined : first.value;
+            for (const [stableId, session] of sessionsA.sessionCache.entries()) {
+                const otherSession = sessionsB.sessionCache.get(stableId);
+                if (otherSession === undefined) {
+                    if (!session.isEmpty() || includeLocalState) {
+                        return false;
+                    }
+                    (0, common_utils_1.assert)(session === firstSessionThis, 0x762 /* The only non-empty session must be the local session. */);
+                }
+                else if (!session.equals(otherSession)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        return checkIsSubset(this, other) && checkIsSubset(other, this);
+    }
+}
+exports.Sessions = Sessions;
+/**
+ * The IDs created by a specific session, stored as a cluster chain to allow for fast conversions.
+ */
+class Session {
+    constructor(sessionId) {
+        // All clusters created by this session, in creation order (thus sorted by base final and local ID).
+        this.clusterChain = [];
+        this.sessionUuid =
+            typeof sessionId === "string" ? (0, utilities_1.numericUuidFromStableId)(sessionId) : sessionId;
+    }
+    /**
+     * Adds a new empty cluster to the cluster chain of this session.
+     */
+    addNewCluster(baseFinalId, capacity, count) {
+        const lastCluster = this.getLastCluster();
+        const newCluster = {
+            session: this,
+            baseFinalId,
+            baseLocalId: (lastCluster === undefined
+                ? -1
+                : lastAllocatedLocal(lastCluster) - 1),
+            capacity,
+            count,
+        };
+        this.clusterChain.push(newCluster);
+        return newCluster;
+    }
+    isEmpty() {
+        return this.clusterChain.length === 0;
+    }
+    /**
+     * Returns the last cluster in this session's cluster chain, if any.
+     */
+    getLastCluster() {
+        return this.clusterChain[this.clusterChain.length - 1];
+    }
+    /**
+     * Converts the local ID from this session to a final ID, if possible.
+     * @param includeAllocated - true if the conversion should succeed even if the local ID aligns with a part of the cluster that is allocated but not finalized.
+     */
+    tryConvertToFinal(searchLocal, includeAllocated) {
+        const containingCluster = this.getClusterByLocal(searchLocal, includeAllocated);
+        if (containingCluster === undefined) {
+            return undefined;
+        }
+        return getAlignedFinal(containingCluster, searchLocal);
+    }
+    /**
+     * Returns the cluster containing the supplied local ID, if possible.
+     * @param includeAllocated - true if the conversion should succeed even if the local ID aligns with a part of the cluster that is allocated but not finalized.
+     */
+    getClusterByLocal(localId, includeAllocated) {
+        const lastValidLocal = includeAllocated
+            ? lastAllocatedLocal
+            : lastFinalizedLocal;
+        const matchedCluster = Session.binarySearch(localId, this.clusterChain, (local, cluster) => {
+            const lastLocal = lastValidLocal(cluster);
+            if (local < lastLocal) {
+                return 1;
+            }
+            else if (local > cluster.baseLocalId) {
+                return -1;
+            }
+            else {
+                return 0;
+            }
+        });
+        return matchedCluster;
+    }
+    /**
+     * Returns the cluster containing the supplied final ID, if possible.
+     */
+    getClusterByAllocatedFinal(final) {
+        return Session.getContainingCluster(final, this.clusterChain);
+    }
+    /**
+     * Returns the cluster from the supplied cluster chain containing the supplied final ID, if possible.
+     * `clusterChain` must be sorted by final/local base ID.
+     */
+    static getContainingCluster(finalId, clusterChain) {
+        return Session.binarySearch(finalId, clusterChain, (final, cluster) => {
+            const lastFinal = lastAllocatedFinal(cluster);
+            if (final < cluster.baseFinalId) {
+                return -1;
+            }
+            else if (final > lastFinal) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+    }
+    static binarySearch(search, arr, comparator) {
+        let left = 0;
+        let right = arr.length - 1;
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            const c = comparator(search, arr[mid]);
+            if (c === 0) {
+                return arr[mid]; // Found the target, return its index.
+            }
+            else if (c > 0) {
+                left = mid + 1; // Continue search on right half.
+            }
+            else {
+                right = mid - 1; // Continue search on left half.
+            }
+        }
+        return undefined; // If we reach here, target is not in array.
+    }
+    equals(other) {
+        for (let i = 0; i < this.clusterChain.length; i++) {
+            if (!clustersEqual(this.clusterChain[i], other.clusterChain[i])) {
+                return false;
+            }
+        }
+        return this.sessionUuid === other.sessionUuid;
+    }
+}
+exports.Session = Session;
+function clustersEqual(a, b) {
+    return (a.session.sessionUuid === b.session.sessionUuid &&
+        a.baseFinalId === b.baseFinalId &&
+        a.baseLocalId === b.baseLocalId &&
+        a.capacity === b.capacity &&
+        a.count === b.count);
+}
+exports.clustersEqual = clustersEqual;
+/**
+ * Returns the final ID that is aligned with the supplied local ID within a cluster.
+ * Includes allocated IDs.
+ */
+function getAlignedFinal(cluster, localWithin) {
+    const clusterOffset = (0, utilities_1.genCountFromLocalId)(localWithin) - (0, utilities_1.genCountFromLocalId)(cluster.baseLocalId);
+    if (clusterOffset < cluster.capacity) {
+        return (cluster.baseFinalId + clusterOffset);
+    }
+    return undefined;
+}
+exports.getAlignedFinal = getAlignedFinal;
+/**
+ * Returns the local ID that is aligned with the supplied final ID within a cluster.
+ * Fails if the supplied ID does not fall within the cluster bounds.
+ */
+function getAlignedLocal(cluster, finalWithin) {
+    (0, common_utils_1.assert)(finalWithin >= cluster.baseFinalId && finalWithin <= lastAllocatedFinal(cluster), 0x763 /* Supplied ID is not within the cluster. */);
+    const finalDelta = finalWithin - cluster.baseFinalId;
+    return (cluster.baseLocalId - finalDelta);
+}
+exports.getAlignedLocal = getAlignedLocal;
+/**
+ * Returns the last allocated final ID (i.e. any ID between base final and base final + capacity) within a cluster
+ */
+function lastAllocatedFinal(cluster) {
+    return (cluster.baseFinalId + (cluster.capacity - 1));
+}
+exports.lastAllocatedFinal = lastAllocatedFinal;
+/**
+ * Returns the last allocated final ID (i.e. any ID between base final and base final + count) within a cluster
+ */
+function lastFinalizedFinal(cluster) {
+    return (cluster.baseFinalId + (cluster.count - 1));
+}
+exports.lastFinalizedFinal = lastFinalizedFinal;
+/**
+ * Returns the last allocated local ID (i.e. any ID between base local and base local + capacity) within a cluster
+ */
+function lastAllocatedLocal(cluster) {
+    return (cluster.baseLocalId - (cluster.capacity - 1));
+}
+exports.lastAllocatedLocal = lastAllocatedLocal;
+/**
+ * Returns the last allocated local ID (i.e. any ID between base local and base local + count) within a cluster
+ */
+function lastFinalizedLocal(cluster) {
+    return (cluster.baseLocalId - (cluster.count - 1));
+}
+exports.lastFinalizedLocal = lastFinalizedLocal;
+//# sourceMappingURL=sessions.js.map

package/dist/id-compressor/sessions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.js","sourceRoot":"","sources":["../../src/id-compressor/sessions.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport BTree from \"sorted-btree\";\nimport { SessionId, StableId } from \"@fluidframework/runtime-definitions\";\nimport { assert } from \"@fluidframework/common-utils\";\nimport {\n\tcompareBigints,\n\tlocalIdFromGenCount,\n\tgenCountFromLocalId,\n\tnumericUuidFromStableId,\n\tstableIdFromNumericUuid,\n\tsubtractNumericUuids,\n\toffsetNumericUuid,\n} from \"./utilities\";\nimport { FinalCompressedId, LocalCompressedId, NumericUuid } from \"./identifiers\";\n\n/**\n * A collection of all sessions known to the compressor (i.e. all finalized/acked allocated UUIDs and their corresponding local and final forms).\n * This collection of all sessions comprises a distributed document's IDs.\n */\nexport class Sessions {\n\t// A range-queryable store of all sessions. A btree is used as it solves the predecessor problem for any given UUID, allowing\n\t// us to quickly find the session that may have produced it.\n\tprivate readonly uuidSpace = new BTree<NumericUuid, Session>(undefined, compareBigints);\n\t// A fast lookup table from session ID to the session object, used to avoid accessing the slower btree\n\tprivate readonly sessionCache = new Map<SessionId, Session>();\n\n\tpublic constructor(sessions?: [sessionBase: NumericUuid, session: Session][]) {\n\t\tif (sessions !== undefined) {\n\t\t\t// bulk load path\n\t\t\tfor (const [numeric, session] of sessions) {\n\t\t\t\tthis.sessionCache.set(stableIdFromNumericUuid(numeric) as SessionId, session);\n\t\t\t}\n\t\t\tthis.uuidSpace = new BTree(sessions, compareBigints);\n\t\t\tif (\n\t\t\t\tthis.sessionCache.size !== sessions.length ||\n\t\t\t\tsessions.length !== this.uuidSpace.size\n\t\t\t) {\n\t\t\t\tthrow new Error(\"Cannot resume existing session.\");\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic sessions(): IterableIterator<Session> {\n\t\treturn this.sessionCache.values();\n\t}\n\n\tpublic getOrCreate(sessionId: SessionId): Session {\n\t\tconst existing = this.sessionCache.get(sessionId);\n\t\tif (existing !== undefined) {\n\t\t\treturn existing;\n\t\t}\n\t\tconst session = new Session(sessionId);\n\t\tassert(\n\t\t\tthis.uuidSpace.set(session.sessionUuid, session),\n\t\t\t0x760 /* Duplicate session in map. */,\n\t\t);\n\t\tthis.sessionCache.set(sessionId, session);\n\t\treturn session;\n\t}\n\n\tpublic get(sessionId: SessionId): Session | undefined {\n\t\treturn this.sessionCache.get(sessionId);\n\t}\n\n\tpublic getContainingCluster(\n\t\tquery: StableId,\n\t): [cluster: IdCluster, alignedLocal: LocalCompressedId] | undefined {\n\t\tconst numericStable = numericUuidFromStableId(query);\n\t\tconst possibleMatch = this.uuidSpace.getPairOrNextLower(numericStable);\n\t\tif (possibleMatch === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst [_, session] = possibleMatch;\n\t\tconst numericDelta = subtractNumericUuids(numericStable, session.sessionUuid);\n\t\tif (numericDelta > Number.MAX_SAFE_INTEGER) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst alignedLocal = localIdFromGenCount(Number(numericDelta) + 1);\n\t\tconst containingCluster = session.getClusterByLocal(alignedLocal, true);\n\t\tif (containingCluster === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn [containingCluster, alignedLocal];\n\t}\n\n\tpublic clusterCollides(cluster: IdCluster): boolean {\n\t\tconst { session: owningSession, baseLocalId, capacity } = cluster;\n\t\tconst clusterBaseNumeric = offsetNumericUuid(\n\t\t\towningSession.sessionUuid,\n\t\t\tgenCountFromLocalId(baseLocalId) - 1,\n\t\t);\n\t\tconst clusterMaxNumeric = offsetNumericUuid(clusterBaseNumeric, capacity - 1);\n\t\tlet closestMatch: [NumericUuid, Session] | undefined =\n\t\t\tthis.uuidSpace.getPairOrNextLower(clusterMaxNumeric);\n\t\t// Find the first session that is not the owner of this new cluster.\n\t\t// Once we have that, check to see if its cluster chain overlaps with the new cluster.\n\t\t// Consider the following diagram of UUID space:\n\t\t// Cluster chain A:  |----------------------|\n\t\t// Cluster chain B:       |----------|\n\t\t// Cluster chain C:                       |-------|\n\t\t// While it is true that when adding a cluster to chain C, we would find\n\t\t// the next lower session (which is B) and erroneously determine we do not collide\n\t\t// with any other session, but this situation is impossible to get into as B would\n\t\t// have detected that it collided with A (or the other way around, depending on ordering).\n\t\twhile (closestMatch !== undefined && closestMatch[1] === owningSession) {\n\t\t\tclosestMatch = this.uuidSpace.nextLowerPair(closestMatch[0]);\n\t\t}\n\t\tif (closestMatch === undefined) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst [_, session] = closestMatch;\n\t\tassert(session !== owningSession, 0x761 /* Failed to attempt to detect collisions. */);\n\t\tconst lastCluster = session.getLastCluster();\n\t\tif (lastCluster === undefined) {\n\t\t\t// If the closest session is empty (the local session), then it is guaranteed (probabilistically) that there are no\n\t\t\t// non-empty sessions that have a cluster chain that starts prior to the empty session and collides with the cluster\n\t\t\t// we are checking, so we can return false.\n\t\t\treturn false;\n\t\t}\n\t\tconst lastAllocatedNumeric = offsetNumericUuid(\n\t\t\tsession.sessionUuid,\n\t\t\tgenCountFromLocalId(lastAllocatedLocal(lastCluster)) - 1,\n\t\t);\n\t\treturn lastAllocatedNumeric >= clusterBaseNumeric;\n\t}\n\n\tpublic equals(other: Sessions, includeLocalState: boolean): boolean {\n\t\tconst checkIsSubset = (sessionsA: Sessions, sessionsB: Sessions) => {\n\t\t\tconst first = sessionsA.sessions().next();\n\t\t\tconst firstSessionThis = first.done ? undefined : first.value;\n\t\t\tfor (const [stableId, session] of sessionsA.sessionCache.entries()) {\n\t\t\t\tconst otherSession = sessionsB.sessionCache.get(stableId);\n\t\t\t\tif (otherSession === undefined) {\n\t\t\t\t\tif (!session.isEmpty() || includeLocalState) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t\tassert(\n\t\t\t\t\t\tsession === firstSessionThis,\n\t\t\t\t\t\t0x762 /* The only non-empty session must be the local session. */,\n\t\t\t\t\t);\n\t\t\t\t} else if (!session.equals(otherSession)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t};\n\t\treturn checkIsSubset(this, other) && checkIsSubset(other, this);\n\t}\n}\n\n/**\n * The IDs created by a specific session, stored as a cluster chain to allow for fast conversions.\n */\nexport class Session {\n\t// All clusters created by this session, in creation order (thus sorted by base final and local ID).\n\tprivate readonly clusterChain: IdCluster[] = [];\n\t// The numeric form of the SessionId\n\tpublic readonly sessionUuid: NumericUuid;\n\n\tpublic constructor(sessionId: SessionId | NumericUuid) {\n\t\tthis.sessionUuid =\n\t\t\ttypeof sessionId === \"string\" ? numericUuidFromStableId(sessionId) : sessionId;\n\t}\n\n\t/**\n\t * Adds a new empty cluster to the cluster chain of this session.\n\t */\n\tpublic addNewCluster(\n\t\tbaseFinalId: FinalCompressedId,\n\t\tcapacity: number,\n\t\tcount: number,\n\t): IdCluster {\n\t\tconst lastCluster = this.getLastCluster();\n\t\tconst newCluster: IdCluster = {\n\t\t\tsession: this,\n\t\t\tbaseFinalId,\n\t\t\tbaseLocalId: (lastCluster === undefined\n\t\t\t\t? -1\n\t\t\t\t: lastAllocatedLocal(lastCluster) - 1) as LocalCompressedId,\n\t\t\tcapacity,\n\t\t\tcount,\n\t\t};\n\t\tthis.clusterChain.push(newCluster);\n\t\treturn newCluster;\n\t}\n\n\tpublic isEmpty(): boolean {\n\t\treturn this.clusterChain.length === 0;\n\t}\n\n\t/**\n\t * Returns the last cluster in this session's cluster chain, if any.\n\t */\n\tpublic getLastCluster(): IdCluster | undefined {\n\t\treturn this.clusterChain[this.clusterChain.length - 1];\n\t}\n\n\t/**\n\t * Converts the local ID from this session to a final ID, if possible.\n\t * @param includeAllocated - true if the conversion should succeed even if the local ID aligns with a part of the cluster that is allocated but not finalized.\n\t */\n\tpublic tryConvertToFinal(\n\t\tsearchLocal: LocalCompressedId,\n\t\tincludeAllocated: boolean,\n\t): FinalCompressedId | undefined {\n\t\tconst containingCluster = this.getClusterByLocal(searchLocal, includeAllocated);\n\t\tif (containingCluster === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn getAlignedFinal(containingCluster, searchLocal);\n\t}\n\n\t/**\n\t * Returns the cluster containing the supplied local ID, if possible.\n\t * @param includeAllocated - true if the conversion should succeed even if the local ID aligns with a part of the cluster that is allocated but not finalized.\n\t */\n\tpublic getClusterByLocal(\n\t\tlocalId: LocalCompressedId,\n\t\tincludeAllocated: boolean,\n\t): IdCluster | undefined {\n\t\tconst lastValidLocal: (cluster: IdCluster) => LocalCompressedId = includeAllocated\n\t\t\t? lastAllocatedLocal\n\t\t\t: lastFinalizedLocal;\n\t\tconst matchedCluster = Session.binarySearch(\n\t\t\tlocalId,\n\t\t\tthis.clusterChain,\n\t\t\t(local, cluster): number => {\n\t\t\t\tconst lastLocal = lastValidLocal(cluster);\n\t\t\t\tif (local < lastLocal) {\n\t\t\t\t\treturn 1;\n\t\t\t\t} else if (local > cluster.baseLocalId) {\n\t\t\t\t\treturn -1;\n\t\t\t\t} else {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\t\t\t},\n\t\t);\n\t\treturn matchedCluster;\n\t}\n\n\t/**\n\t * Returns the cluster containing the supplied final ID, if possible.\n\t */\n\tpublic getClusterByAllocatedFinal(final: FinalCompressedId): IdCluster | undefined {\n\t\treturn Session.getContainingCluster(final, this.clusterChain);\n\t}\n\n\t/**\n\t * Returns the cluster from the supplied cluster chain containing the supplied final ID, if possible.\n\t * `clusterChain` must be sorted by final/local base ID.\n\t */\n\tpublic static getContainingCluster(\n\t\tfinalId: FinalCompressedId,\n\t\tclusterChain: readonly IdCluster[],\n\t): IdCluster | undefined {\n\t\treturn Session.binarySearch(finalId, clusterChain, (final, cluster) => {\n\t\t\tconst lastFinal = lastAllocatedFinal(cluster);\n\t\t\tif (final < cluster.baseFinalId) {\n\t\t\t\treturn -1;\n\t\t\t} else if (final > lastFinal) {\n\t\t\t\treturn 1;\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t});\n\t}\n\n\tstatic binarySearch<S, T>(\n\t\tsearch: S,\n\t\tarr: readonly T[],\n\t\tcomparator: (a: S, b: T) => number,\n\t): T | undefined {\n\t\tlet left = 0;\n\t\tlet right = arr.length - 1;\n\t\twhile (left <= right) {\n\t\t\tconst mid = Math.floor((left + right) / 2);\n\t\t\tconst c = comparator(search, arr[mid]);\n\t\t\tif (c === 0) {\n\t\t\t\treturn arr[mid]; // Found the target, return its index.\n\t\t\t} else if (c > 0) {\n\t\t\t\tleft = mid + 1; // Continue search on right half.\n\t\t\t} else {\n\t\t\t\tright = mid - 1; // Continue search on left half.\n\t\t\t}\n\t\t}\n\t\treturn undefined; // If we reach here, target is not in array.\n\t}\n\n\tpublic equals(other: Session): boolean {\n\t\tfor (let i = 0; i < this.clusterChain.length; i++) {\n\t\t\tif (!clustersEqual(this.clusterChain[i], other.clusterChain[i])) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn this.sessionUuid === other.sessionUuid;\n\t}\n}\n\n/**\n * A cluster of final (sequenced via consensus), sequentially allocated compressed IDs.\n * A final ID in a cluster decompresses to a sequentially allocated UUID that is the result of adding its offset within\n * the cluster to base UUID for the session that created it.\n */\nexport interface IdCluster {\n\t/**\n\t * The session that created this cluster.\n\t */\n\treadonly session: Session;\n\n\t/**\n\t * The first final ID in the cluster.\n\t */\n\treadonly baseFinalId: FinalCompressedId;\n\n\t/**\n\t * The local ID aligned with `baseFinalId`.\n\t */\n\treadonly baseLocalId: LocalCompressedId;\n\n\t/**\n\t * The total number of final IDs reserved for allocation in the cluster.\n\t * Clusters are reserved in blocks as a performance optimization.\n\t */\n\tcapacity: number;\n\n\t/**\n\t * The number of final IDs currently allocated in the cluster.\n\t */\n\tcount: number;\n}\n\nexport function clustersEqual(a: IdCluster, b: IdCluster): boolean {\n\treturn (\n\t\ta.session.sessionUuid === b.session.sessionUuid &&\n\t\ta.baseFinalId === b.baseFinalId &&\n\t\ta.baseLocalId === b.baseLocalId &&\n\t\ta.capacity === b.capacity &&\n\t\ta.count === b.count\n\t);\n}\n\n/**\n * Returns the final ID that is aligned with the supplied local ID within a cluster.\n * Includes allocated IDs.\n */\nexport function getAlignedFinal(\n\tcluster: IdCluster,\n\tlocalWithin: LocalCompressedId,\n): FinalCompressedId | undefined {\n\tconst clusterOffset =\n\t\tgenCountFromLocalId(localWithin) - genCountFromLocalId(cluster.baseLocalId);\n\tif (clusterOffset < cluster.capacity) {\n\t\treturn ((cluster.baseFinalId as number) + clusterOffset) as FinalCompressedId;\n\t}\n\treturn undefined;\n}\n\n/**\n * Returns the local ID that is aligned with the supplied final ID within a cluster.\n * Fails if the supplied ID does not fall within the cluster bounds.\n */\nexport function getAlignedLocal(\n\tcluster: IdCluster,\n\tfinalWithin: FinalCompressedId,\n): LocalCompressedId {\n\tassert(\n\t\tfinalWithin >= cluster.baseFinalId && finalWithin <= lastAllocatedFinal(cluster),\n\t\t0x763 /* Supplied ID is not within the cluster. */,\n\t);\n\tconst finalDelta = finalWithin - cluster.baseFinalId;\n\treturn (cluster.baseLocalId - finalDelta) as LocalCompressedId;\n}\n\n/**\n * Returns the last allocated final ID (i.e. any ID between base final and base final + capacity) within a cluster\n */\nexport function lastAllocatedFinal(cluster: IdCluster): FinalCompressedId {\n\treturn ((cluster.baseFinalId as number) + (cluster.capacity - 1)) as FinalCompressedId;\n}\n\n/**\n * Returns the last allocated final ID (i.e. any ID between base final and base final + count) within a cluster\n */\nexport function lastFinalizedFinal(cluster: IdCluster): FinalCompressedId {\n\treturn ((cluster.baseFinalId as number) + (cluster.count - 1)) as FinalCompressedId;\n}\n\n/**\n * Returns the last allocated local ID (i.e. any ID between base local and base local + capacity) within a cluster\n */\nexport function lastAllocatedLocal(cluster: IdCluster): LocalCompressedId {\n\treturn ((cluster.baseLocalId as number) - (cluster.capacity - 1)) as LocalCompressedId;\n}\n\n/**\n * Returns the last allocated local ID (i.e. any ID between base local and base local + count) within a cluster\n */\nexport function lastFinalizedLocal(cluster: IdCluster): LocalCompressedId {\n\treturn ((cluster.baseLocalId as number) - (cluster.count - 1)) as LocalCompressedId;\n}\n"]}