@fluidframework/merge-tree 2.20.0 → 2.22.0

package/lib/partialLengths.js

@@ -3,37 +3,36 @@
  * Licensed under the MIT License.
  */
 import { assert } from "@fluidframework/core-utils/internal";
-import { RedBlackTree } from "./collections/index.js";
 import { UnassignedSequenceNumber } from "./constants.js";
-import { compareNumbers, seqLTE, } from "./mergeTreeNodes.js";
-import { toRemovalInfo, toMoveInfo, assertInserted, isRemoved, } from "./segmentInfos.js";
+import { seqLTE, } from "./mergeTreeNodes.js";
+import { toRemovalInfo, toMoveInfo, assertInserted } from "./segmentInfos.js";
 import { SortedSet } from "./sortedSet.js";
 class PartialSequenceLengthsSet extends SortedSet {
-    getKey(item) {
-        return item.seq;
+    compare(a, b) {
+        return a.seq - b.seq;
     }
     addOrUpdate(newItem, update) {
+        if (newItem.seglen === 0) {
+            // Don't bother doing any updates for deltas of 0.
+            return;
+        }
         const prev = this.latestLeq(newItem.seq);
         if (prev?.seq !== newItem.seq) {
             // new element, update len
             newItem.len = (prev?.len ?? 0) + newItem.seglen;
         }
         // update the len of all following elements
-        for (let i = this.keySortedItems.length - 1; i >= 0; i--) {
-            const element = this.keySortedItems[i];
+        for (let i = this.sortedItems.length - 1; i >= 0; i--) {
+            const element = this.sortedItems[i];
             if (!element || element.seq <= newItem.seq) {
                 break;
             }
             element.len += newItem.seglen;
         }
         super.addOrUpdate(newItem, (currentPartial, partialLength) => {
+            assert(partialLength.clientId === currentPartial.clientId, 0xab6 /* clientId mismatch */);
             currentPartial.seglen += partialLength.seglen;
-            if (partialLength.remoteObliteratedLen) {
-                currentPartial.remoteObliteratedLen ?? (currentPartial.remoteObliteratedLen = 0);
-                currentPartial.remoteObliteratedLen += partialLength.remoteObliteratedLen;
-            }
             currentPartial.len += partialLength.seglen;
-            combineOverlapClients(currentPartial, partialLength);
         });
     }
     /**
@@ -42,7 +41,7 @@ class PartialSequenceLengthsSet extends SortedSet {
      * @param key - sequence number
      */
     latestLeq(key) {
-        return this.keySortedItems[this.latestLeqIndex(key)];
+        return this.sortedItems[this.latestLeqIndex(key)];
     }
     /**
      * Returns the partial length whose sequence number is the lowest sequence
@@ -51,7 +50,7 @@ class PartialSequenceLengthsSet extends SortedSet {
      */
     firstGte(key) {
         const { index } = this.findItemPosition({ seq: key, len: 0, seglen: 0 });
-        return this.keySortedItems[index];
+        return this.sortedItems[index];
     }
     latestLeqIndex(key) {
         const { exists, index } = this.findItemPosition({ seq: key, len: 0, seglen: 0 });
@@ -61,17 +60,17 @@ class PartialSequenceLengthsSet extends SortedSet {
         const mindex = this.latestLeqIndex(minSeq);
         let minLength = 0;
         if (mindex >= 0) {
-            minLength = this.keySortedItems[mindex].len;
+            minLength = this.sortedItems[mindex].len;
             const seqCount = this.size;
             if (mindex <= seqCount - 1) {
                 // Still some entries remaining
                 const remainingCount = seqCount - mindex - 1;
                 // Copy down
                 for (let i = 0; i < remainingCount; i++) {
-                    this.keySortedItems[i] = this.keySortedItems[i + mindex + 1];
-                    this.keySortedItems[i].len -= minLength;
+                    this.sortedItems[i] = this.sortedItems[i + mindex + 1];
+                    this.sortedItems[i].len -= minLength;
                 }
-                this.keySortedItems.length = remainingCount;
+                this.sortedItems.length = remainingCount;
             }
         }
         return minLength;
@@ -85,13 +84,13 @@ class PartialSequenceLengthsSet extends SortedSet {
  * "What is the length of `block` from the perspective of some particular seq and clientId?".
  *
  * It also supports incremental updating of state for newly-sequenced ops that don't affect the structure of the
- * MergeTree.
+ * MergeTree (in most cases--see AB#31003 or comments on {@link PartialSequenceLengths.update}).
  *
  * To answer these queries, it pre-builds several lists which track the length of the block at a per-sequence-number
  * level. These lists are:
  *
  * 1. (`partialLengths`): Stores the total length of the block.
- * 2. (`clientSeqNumbers[clientId]`): Stores only the total lengths of segments submitted by `clientId`. [see footnote]
+ * 2. (`perClientAdjustments[clientId]`): Stores adjustments to the base length which account for all changes submitted by `clientId`. [see footnote]
  *
  * The reason both lists are necessary is that resolving the length of the block from the perspective of
  * (clientId, refSeq) requires including both of the following types of segments:
@@ -114,15 +113,96 @@ class PartialSequenceLengthsSet extends SortedSet {
  * (length of the block at the minimum sequence number)
  * + (partialLengths total length at refSeq)
  * + (unsequenced edits' total length submitted before localSeq)
- * - (overlapping remove of the unsequenced edits' total length at refSeq)
+ * + (adjustments for changes double-counted by happening at or before both localSeq and refSeq)
  *
  * This algorithm scales roughly linearly with number of editing clients and the size of the collab window.
  * (certain unlikely sequences of operations may introduce log factors on those variables)
  *
- * Note: there is some slight complication with clientSeqNumbers resulting from the possibility of different clients
- * concurrently removing the same segment. See the field's documentation for more details.
+ * @privateRemarks
+ * If you are looking to understand this class in more detail, a suggested order of internalization is:
+ *
+ * 1. The above description and how it relates to the implementation of `getPartialLength` (which implements the above high-level description
+ * 2. `PartialSequenceLengthsSet`, which allows binary searching for overall length deltas at a given sequence number and handles updates.
+ * 3. The `fromLeaves` method, which is the base case for the [potential] recursion in `combine`
+ * 4. The logic in `combine` to aggregate smaller block entries into larger ones
+ * 5. The incremental code path of `update`
  */
 export class PartialSequenceLengths {
+    constructor(
+    /**
+     * The minimumSequenceNumber as defined by the collab window used in the last call to `update`,
+     * or if no such calls have been made, the one used on construction.
+     */
+    minSeq, computeLocalPartials) {
+        this.minSeq = minSeq;
+        /**
+         * Length of the block this PartialSequenceLength corresponds to when viewed at `minSeq`.
+         */
+        this.minLength = 0;
+        /**
+         * Total number of segments in the subtree rooted at the block this PartialSequenceLength corresponds to.
+         */
+        this.segmentCount = 0;
+        /**
+         * List of PartialSequenceLength objects--ordered by increasing seq--giving length information about
+         * the block associated with this PartialSequenceLengths object.
+         *
+         * `minLength + partialLengths[i].len` gives the length of this block when considering the perspective of an observer
+         * client who has received edits up to (and including) sequence number `i`.
+         */
+        this.partialLengths = new PartialSequenceLengthsSet();
+        /**
+         * perClientAdjustments[clientId] contains a PartialSequenceLengthsSet of adjustments to the observer client's
+         * perspective (see {@link PartialSequenceLengths.partialLengths}) necessary to account for changes made by
+         * that client.
+         *
+         * As per doc comment on {@link PartialSequenceLengths}, the overall adjustment performed for the perspective of
+         * (clientId, refSeq) is given by the sum of length deltas in `perClientAdjustments[clientId]`
+         * for all sequence numbers S such that S \>= refSeq.
+         *
+         * (since these are ordered by sequence number and we cache cumulative sums, this is implemented using two lookups and a subtraction).
+         *
+         * The specific adjustments are roughly categorized as follows:
+         *
+         * - Ops submitted by a given client generally receive a partial lengths entry corresponding to their sequence number.
+         * e.g. insert of "ABC" at seq 5 will have a per-client adjustment entry of \{ seq: 5, seglen: 3 \}.
+         *
+         * - When client A deletes a segment concurrently with client B and loses the race (B's delete is sequenced first),
+         * A's per-client adjustments will contain an entry with a negative `seglen` corresponding to the length of the segment
+         * and a sequence number corresponding to that of B's delete. It will *not* receive a per-client adjustment for its own delete.
+         * This ensures that for perspectives (A, refSeq), the deleted segment will show up as a negative delta for all values of refSeq, since:
+         * 1. For refSeq \< B's delete, the per-client adjustment will apply and be added to the total length
+         * 2. For refSeq \>= B's delete, B's partial length entry in the overall set will apply, and the per-client adjustment will not apply
+         *
+         * - When client A attempts to insert a segment into a location that is concurrently obliterated by client B immediately upon insertion,
+         * A's per-client adjustments will again not include an entry for its own insert.
+         * Instead, the entry which would normally contain `seq` equal to that of A's insert would instead have `seq` equal to that of B's obliterate.
+         * This gives the overall correct behavior: for any perspective which isn't client A, there is no adjustment necessary anywhere (it's as if
+         * the segment never existed). For client A's perspective, the segment should be considered visible until A has acked B's obliterate.
+         * This is accomplished as for the perspective (A, refSeq):
+         * 1. For refSeq \< B's obliterate, the segment length will be included as part of the per-client adjustment for A
+         * 2. For refSeq \>= B's obliterate, the segment will be omitted from the per-client adjustment for A
+         *
+         * Note that the special-casing for inserting segments that are immediately obliterated is only necessary for segments that never were visible
+         * in the tree. If an insert and obliterate are concurrent but the insert is sequenced first, the normal per-client adjustment is fine.
+         *
+         * The second case (overlapping removal) applies to any combination of remove / obliterate operations.
+         */
+        this.perClientAdjustments = [];
+        /**
+         * If incremental update of partial lengths fails, this gets set to the seq of the failed update.
+         * When higher up blocks attempt to incrementally update, they first check if the seq they are updating for
+         * matches this value. If it does, they propagate a full refresh instead.
+         */
+        this.lastIncrementalInvalidationSeq = Number.NEGATIVE_INFINITY;
+        if (computeLocalPartials) {
+            this.unsequencedRecords = {
+                partialLengths: new PartialSequenceLengthsSet(),
+                perRefSeqAdjustments: new Map(),
+                cachedAdjustmentByRefSeq: new Map(),
+            };
+        }
+    }
     /**
      * Combine the partial lengths of block's children
      * @param block - an interior node. If `recur` is false, it is assumed that each interior node child of this block
@@ -163,7 +243,7 @@ export class PartialSequenceLengths {
             const childPartialsLen = childPartials.length;
             const childPartialLengths = [];
             const childUnsequencedPartialLengths = [];
-            const childOverlapRemoves = [];
+            const childPerRefSeqAdjustments = [];
             for (let i = 0; i < childPartialsLen; i++) {
                 const { segmentCount, minLength, partialLengths, unsequencedRecords } = childPartials[i];
                 combinedPartialLengths.segmentCount += segmentCount;
@@ -171,19 +251,43 @@ export class PartialSequenceLengths {
                 childPartialLengths.push(partialLengths.items);
                 if (unsequencedRecords) {
                     childUnsequencedPartialLengths.push(unsequencedRecords.partialLengths.items);
-                    childOverlapRemoves.push(unsequencedRecords.overlappingRemoves);
+                    childPerRefSeqAdjustments.push(unsequencedRecords.perRefSeqAdjustments);
                 }
             }
             mergePartialLengths(childPartialLengths, combinedPartialLengths.partialLengths);
             if (computeLocalPartials) {
                 combinedPartialLengths.unsequencedRecords = {
                     partialLengths: mergePartialLengths(childUnsequencedPartialLengths),
-                    overlappingRemoves: [...mergeSortedListsBySeq(childOverlapRemoves)],
-                    cachedOverlappingByRefSeq: new Map(),
+                    cachedAdjustmentByRefSeq: new Map(),
+                    perRefSeqAdjustments: new Map(),
                 };
+                for (const perRefSeq of childPerRefSeqAdjustments) {
+                    for (const [refSeq, partials] of perRefSeq) {
+                        let combinedPartials = combinedPartialLengths.unsequencedRecords.perRefSeqAdjustments.get(refSeq);
+                        if (combinedPartials === undefined) {
+                            combinedPartials = new PartialSequenceLengthsSet();
+                            combinedPartialLengths.unsequencedRecords.perRefSeqAdjustments.set(refSeq, combinedPartials);
+                        }
+                        for (const item of partials.items) {
+                            combinedPartials.addOrUpdate({ ...item });
+                        }
+                    }
+                }
             }
-            for (const partial of combinedPartialLengths.partialLengths.items) {
-                combinedPartialLengths.addClientSeqNumberFromPartial(partial);
+            // could merge these like we do above rather than do out of order like this
+            for (let i = 0; i < childPartialsLen; i++) {
+                const { perClientAdjustments } = childPartials[i];
+                if (perClientAdjustments.length > 0) {
+                    for (let clientId = 0; clientId < perClientAdjustments.length; clientId++) {
+                        const clientAdjustment = perClientAdjustments[clientId];
+                        if (clientAdjustment === undefined) {
+                            continue;
+                        }
+                        for (const partial of perClientAdjustments[clientId].items) {
+                            combinedPartialLengths.addClientAdjustment(clientId, partial.seq, partial.seglen);
+                        }
+                    }
+                }
             }
         }
         // TODO: incremental zamboni during build
@@ -194,10 +298,9 @@ export class PartialSequenceLengths {
         return combinedPartialLengths;
     }
     /**
-     * Creates and returns a PartialSequenceLengths structure that tracks the lengths of only the
-     * leaf children of the provided MergeBlock.
+     * Create a `PartialSequenceLengths` which tracks only changes incurred by direct child leaves of `block`.
      */
-    static fromLeaves(block, collabWindow, computeLocalPartials) {
+    static fromLeaves(block, collabWindow, computeLocalPartials, retry = true) {
         const combinedPartialLengths = new PartialSequenceLengths(collabWindow.minSeq, computeLocalPartials);
         combinedPartialLengths.segmentCount = block.childCount;
         for (let i = 0; i < block.childCount; i++) {
@@ -205,193 +308,152 @@ export class PartialSequenceLengths {
             if (child.isLeaf()) {
                 // Leaf segment
                 const segment = child;
-                if (segment.seq !== undefined && seqLTE(segment.seq, collabWindow.minSeq)) {
-                    combinedPartialLengths.minLength += segment.cachedLength;
-                }
-                else {
-                    PartialSequenceLengths.insertSegment(combinedPartialLengths, segment);
-                }
-                const removalInfo = toRemovalInfo(segment);
                 const moveInfo = toMoveInfo(segment);
-                if ((removalInfo?.removedSeq !== undefined &&
-                    seqLTE(removalInfo.removedSeq, collabWindow.minSeq)) ||
-                    (moveInfo?.movedSeq !== undefined && seqLTE(moveInfo.movedSeq, collabWindow.minSeq))) {
-                    combinedPartialLengths.minLength -= segment.cachedLength;
+                if (moveInfo?.wasMovedOnInsert) {
+                    PartialSequenceLengths.accountForMoveOnInsert(combinedPartialLengths, segment, collabWindow);
                 }
-                else if (removalInfo !== undefined || moveInfo !== undefined) {
-                    PartialSequenceLengths.insertSegment(combinedPartialLengths, segment, removalInfo, moveInfo);
+                else {
+                    PartialSequenceLengths.accountForInsertion(combinedPartialLengths, segment, collabWindow);
+                    PartialSequenceLengths.accountForRemoval(combinedPartialLengths, segment, collabWindow);
                 }
             }
         }
-        // Post-process correctly-ordered partials computing sums and creating
-        // lists for each present client id
-        const seqPartials = combinedPartialLengths.partialLengths;
-        let prevLen = 0;
-        for (const partial of seqPartials.items) {
-            partial.len = prevLen + partial.seglen;
-            prevLen = partial.len;
-            combinedPartialLengths.addClientSeqNumberFromPartial(partial);
-        }
-        prevLen = 0;
-        if (combinedPartialLengths.unsequencedRecords !== undefined) {
-            const localPartials = combinedPartialLengths.unsequencedRecords.partialLengths;
-            for (const partial of localPartials.items) {
-                partial.len = prevLen + partial.seglen;
-                prevLen = partial.len;
-            }
-        }
         PartialSequenceLengths.options.verifier?.(combinedPartialLengths);
         return combinedPartialLengths;
     }
-    static getOverlapClients(overlapClientIds, seglen) {
-        const bst = new RedBlackTree(compareNumbers);
-        for (const clientId of overlapClientIds) {
-            bst.put(clientId, { clientId, seglen });
-        }
-        return bst;
-    }
-    static accumulateRemoveClientOverlap(partialLength, overlapRemoveClientIds, seglen) {
-        if (partialLength.overlapRemoveClients) {
-            for (const clientId of overlapRemoveClientIds) {
-                const overlapClientNode = partialLength.overlapRemoveClients.get(clientId);
-                if (overlapClientNode) {
-                    overlapClientNode.data.seglen += seglen;
-                }
-                else {
-                    partialLength.overlapRemoveClients.put(clientId, { clientId, seglen });
-                }
-            }
+    /**
+     * Assuming this segment was moved on insertion, inserts length information about that operation
+     * into the appropriate per-client adjustments (the overall view needs no such adjustment since
+     * from an observing client's perspective, the segment never exists).
+     */
+    static accountForMoveOnInsert(combinedPartialLengths, segment, collabWindow) {
+        assertInserted(segment);
+        const moveInfo = toMoveInfo(segment);
+        assert(moveInfo?.wasMovedOnInsert === true, 0xab7 /* Segment was not moved on insert */);
+        if (moveInfo.movedSeq <= collabWindow.minSeq) {
+            // This segment was obliterated as soon as it was inserted, and everyone was aware of the obliterate.
+            // Thus every single client treats this segment as length 0 from every perspective, and no adjustments
+            // are necessary.
+            return;
         }
-        else {
-            partialLength.overlapRemoveClients = PartialSequenceLengths.getOverlapClients(overlapRemoveClientIds, seglen);
+        const isLocal = segment.seq === UnassignedSequenceNumber;
+        const clientId = segment.clientId;
+        const partials = isLocal
+            ? combinedPartialLengths.unsequencedRecords?.partialLengths
+            : combinedPartialLengths.partialLengths;
+        if (partials === undefined) {
+            // Local partial but its computation isn't required
+            return;
         }
-    }
-    static accumulateMoveClientOverlap(partialLength, overlapMoveClientIds, seglen) {
-        if (partialLength.overlapObliterateClients) {
-            for (const clientId of overlapMoveClientIds) {
-                const overlapClientNode = partialLength.overlapObliterateClients.get(clientId);
-                if (overlapClientNode) {
-                    overlapClientNode.data.seglen += seglen;
-                }
-                else {
-                    partialLength.overlapObliterateClients.put(clientId, { clientId, seglen });
-                }
-            }
+        if (isLocal) {
+            // Implication -> this is a local segment which will be obliterated as soon as it is acked.
+            // For refSeqs preceding that movedSeq and localSeqs following the localSeq, it will be visible.
+            // For the rest, it will not be visible.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const localSeq = segment.localSeq;
+            partials.addOrUpdate({
+                seq: localSeq,
+                len: 0,
+                seglen: segment.cachedLength,
+                clientId,
+            });
+            combinedPartialLengths.addLocalAdjustment({
+                refSeq: moveInfo.movedSeq,
+                localSeq,
+                seglen: -segment.cachedLength,
+            });
         }
         else {
-            partialLength.overlapObliterateClients = PartialSequenceLengths.getOverlapClients(overlapMoveClientIds, seglen);
+            // Segment was obliterated on insert. Generally this means it should be visible only to the
+            // inserting client (in which case we add an adjustment to only that client's perspective),
+            // but if that client has also removed it, we don't need to add anything.
+            const removeInfo = toRemovalInfo(segment);
+            const wasRemovedByInsertingClient = removeInfo !== undefined && removeInfo.removedClientIds.includes(clientId);
+            const wasMovedByInsertingClient = moveInfo !== undefined && moveInfo.movedClientIds.includes(clientId);
+            if (!wasRemovedByInsertingClient && !wasMovedByInsertingClient) {
+                const moveSeq = moveInfo?.movedSeq;
+                assert(moveSeq !== undefined, 0xab8 /* ObliterateOnInsertion implies moveSeq is defined */);
+                combinedPartialLengths.addClientAdjustment(clientId, moveSeq, segment.cachedLength);
+            }
         }
     }
     /**
-     * Coalesce overlapping move lengths for a partial length entry that already
-     * exists
-     *
-     * @param segmentLen - Length of segment with overlapping moves
-     * @param segment - Segment with overlapping moves
-     * @param firstGte - Existing partial length entry
-     * @param clientIds - Ids of clients that concurrently obliterated this segment
+     * Inserts length information about the insertion of `segment` into
+     * `combinedPartialLengths.partialLengths` and the appropriate per-client adjustments.
      */
-    static accumulateMoveOverlapForExisting(segmentLen, segment, firstGte, clientIds) {
+    static accountForInsertion(combinedPartialLengths, segment, collabWindow) {
         assertInserted(segment);
-        const nonInsertingClientIds = clientIds.filter((id) => id !== segment.clientId);
-        PartialSequenceLengths.accumulateMoveClientOverlap(firstGte, nonInsertingClientIds, segmentLen);
-        // if this segment was obliterated by the client that inserted it,
-        // and if it overlaps with the obliterate of another client, we need to
-        // take into account whether it was obliterated on insert by the other
-        // client
-        if (clientIds.length !== nonInsertingClientIds.length) {
-            PartialSequenceLengths.accumulateMoveClientOverlap(firstGte, [segment.clientId], toMoveInfo(segment)?.wasMovedOnInsert ? -segment.cachedLength : segmentLen);
+        if (segment.seq !== undefined && seqLTE(segment.seq, collabWindow.minSeq)) {
+            combinedPartialLengths.minLength += segment.cachedLength;
+            return;
         }
-    }
-    /**
-     * Tracks which clients have made concurrent obliterates.
-     *
-     * @param obliterateOverlapLen - Length of segment with overlap
-     * @param clientIds - Ids of clients that have concurrently obliterated this
-     * segment
-     */
-    static getMoveOverlapForExisting(segment, obliterateOverlapLen, clientIds) {
-        assertInserted(segment);
-        const nonInsertingClientIds = clientIds.filter((id) => id !== segment.clientId);
-        const overlapObliterateClients = PartialSequenceLengths.getOverlapClients(nonInsertingClientIds, obliterateOverlapLen);
-        if (clientIds.length !== nonInsertingClientIds.length) {
-            overlapObliterateClients.put(segment.clientId, {
-                clientId: segment.clientId,
-                seglen: toMoveInfo(segment)?.wasMovedOnInsert
-                    ? -segment.cachedLength
-                    : obliterateOverlapLen,
-            });
+        const isLocal = segment.seq === UnassignedSequenceNumber;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const seqOrLocalSeq = isLocal ? segment.localSeq : segment.seq;
+        const segmentLen = segment.cachedLength;
+        const clientId = segment.clientId;
+        const partials = isLocal
+            ? combinedPartialLengths.unsequencedRecords?.partialLengths
+            : combinedPartialLengths.partialLengths;
+        if (!partials) {
+            // Local partial but its computation isn't required
+            return;
         }
-        return overlapObliterateClients;
-    }
-    static updatePartialsAfterInsertion(segment, segmentLen, remoteObliteratedLen, obliterateOverlapLen = segmentLen, partials, seq, clientId, removeClientOverlap, moveClientOverlap) {
-        const firstGte = partials.firstGte(seq);
-        let partialLengthEntry;
-        if (firstGte?.seq === seq) {
-            partialLengthEntry = firstGte;
-            // Existing entry at this seq--this occurs for ops that insert/delete
-            // more than one segment.
-            partialLengthEntry.seglen += segmentLen;
-            if (remoteObliteratedLen) {
-                partialLengthEntry.remoteObliteratedLen ?? (partialLengthEntry.remoteObliteratedLen = 0);
-                partialLengthEntry.remoteObliteratedLen += remoteObliteratedLen;
-            }
-            if (removeClientOverlap) {
-                PartialSequenceLengths.accumulateRemoveClientOverlap(firstGte, removeClientOverlap, obliterateOverlapLen);
-            }
-            if (moveClientOverlap) {
-                PartialSequenceLengths.accumulateMoveOverlapForExisting(obliterateOverlapLen, segment, firstGte, moveClientOverlap);
-            }
+        if (isLocal) {
+            partials.addOrUpdate({
+                seq: seqOrLocalSeq,
+                clientId,
+                len: 0,
+                seglen: segmentLen,
+            });
         }
         else {
-            const overlapObliterateClients = moveClientOverlap
-                ? PartialSequenceLengths.getMoveOverlapForExisting(segment, obliterateOverlapLen, moveClientOverlap)
-                : undefined;
-            partialLengthEntry = {
-                seq,
+            partials.addOrUpdate({
+                seq: seqOrLocalSeq,
                 clientId,
                 len: 0,
                 seglen: segmentLen,
-                remoteObliteratedLen,
-                overlapRemoveClients: removeClientOverlap
-                    ? PartialSequenceLengths.getOverlapClients(removeClientOverlap, obliterateOverlapLen)
-                    : undefined,
-                overlapObliterateClients,
-            };
-            partials.addOrUpdate(partialLengthEntry);
+            });
+            combinedPartialLengths.addClientAdjustment(clientId, seqOrLocalSeq, segmentLen);
         }
     }
     /**
-     * Inserts length information about the insertion of `segment` into
-     * `combinedPartialLengths.partialLengths`.
-     *
-     * Does not update the clientSeqNumbers field to account for this segment.
-     *
-     * If `removalInfo` or `moveInfo` are defined, this operation updates the
-     * bookkeeping to account for the (re)moval of this segment at the (re)movedSeq
-     * instead.
-     *
-     * When the insertion or (re)moval of the segment is un-acked and
-     * `combinedPartialLengths` is meant to compute such records, this does the
-     * analogous addition to the bookkeeping for the local segment in
-     * `combinedPartialLengths.unsequencedRecords`.
+     * Inserts length information about the removal or obliteration of `segment` into
+     * `combinedPartialLengths.partialLengths` and the appropriate per-client adjustments.
      */
-    static insertSegment(combinedPartialLengths, segment, removalInfo, moveInfo) {
+    static accountForRemoval(combinedPartialLengths, segment, collabWindow) {
         assertInserted(segment);
+        const removalInfo = toRemovalInfo(segment);
+        const moveInfo = toMoveInfo(segment);
+        if (!removalInfo && !moveInfo) {
+            return;
+        }
+        if ((removalInfo?.removedSeq !== undefined &&
+            seqLTE(removalInfo.removedSeq, collabWindow.minSeq)) ||
+            (moveInfo?.movedSeq !== undefined && seqLTE(moveInfo.movedSeq, collabWindow.minSeq))) {
+            combinedPartialLengths.minLength -= segment.cachedLength;
+            return;
+        }
         const removalIsLocal = !!removalInfo && removalInfo.removedSeq === UnassignedSequenceNumber;
         const moveIsLocal = !!moveInfo && moveInfo.movedSeq === UnassignedSequenceNumber;
-        const isLocal = segment.seq === UnassignedSequenceNumber ||
-            (!!removalInfo && removalIsLocal && (!moveInfo || moveIsLocal)) ||
-            (!!moveInfo && moveIsLocal && (!removalInfo || removalIsLocal));
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        let seqOrLocalSeq = isLocal ? segment.localSeq : segment.seq;
-        let segmentLen = segment.cachedLength;
-        let clientId = segment.clientId;
-        let removeClientOverlap;
-        let moveClientOverlap;
-        let remoteObliteratedLen;
+        const isLocalInsertion = segment.seq === UnassignedSequenceNumber;
+        const isOnlyLocalRemoval = removalIsLocal && (!moveInfo || moveIsLocal);
+        const isOnlyLocalMove = moveIsLocal && (!removalInfo || removalIsLocal);
+        const isLocal = isLocalInsertion || isOnlyLocalRemoval || isOnlyLocalMove;
+        if (segment.seq === UnassignedSequenceNumber &&
+            !(removalIsLocal && (!moveInfo || moveIsLocal)) &&
+            !(moveIsLocal && (!removalInfo || removalIsLocal))) {
+            throw new Error("Should have handled this codepath in wasMovedOnInsertion");
+        }
+        const lenDelta = -segment.cachedLength;
+        let clientId;
+        let seqOrLocalSeq;
         // it's not possible to have an overlapping obliterate and remove that are both local
         assert((!moveIsLocal && !removalIsLocal) || moveIsLocal !== removalIsLocal, 0x870 /* overlapping local obliterate and remove */);
+        const clientsWithRemoveOrObliterate = new Set([
+            ...(removalInfo?.removedClientIds ?? []),
+            ...(moveInfo?.movedClientIds ?? []),
+        ]);
         const removeHappenedFirst = removalInfo &&
             (!moveInfo ||
                 moveIsLocal ||
@@ -399,36 +461,17 @@ export class PartialSequenceLengths {
         if (removeHappenedFirst) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             seqOrLocalSeq = removalIsLocal ? removalInfo.localRemovedSeq : removalInfo.removedSeq;
-            segmentLen = -segmentLen;
             // The client who performed the remove is always stored
             // in the first position of removalInfo.
             clientId = removalInfo.removedClientIds[0];
-            const hasOverlap = removalInfo.removedClientIds.length > 1;
-            removeClientOverlap = hasOverlap ? removalInfo.removedClientIds : undefined;
         }
-        else if (moveInfo) {
+        else {
+            assert(moveInfo !== undefined, 0xab9 /* Expected move to exist if remove either did not exist or didn't happen first */);
             // The client who performed the move is always stored
             // in the first position of moveInfo.
             clientId = moveInfo.movedClientIds[0];
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             seqOrLocalSeq = moveIsLocal ? moveInfo.localMovedSeq : moveInfo.movedSeq;
-            if (moveInfo.wasMovedOnInsert) {
-                assert(moveInfo.movedSeq !== -1, 0x871 /* wasMovedOnInsert should only be set on acked obliterates */);
-                segmentLen = 0;
-            }
-            else {
-                segmentLen = -segmentLen;
-            }
-            const hasOverlap = moveInfo.movedClientIds.length > 1;
-            moveClientOverlap = hasOverlap ? moveInfo.movedClientIds : undefined;
-        } // BUG BUG: something fishy here around how/when move info is passed or not
-        // this condition only hits if it is not passed, so we can't rely on the passed move info
-        // and need to inspect the segment directly. maybe related to AB#15630.
-        else if (toMoveInfo(segment)?.wasMovedOnInsert) {
-            // if this segment was obliterated on insert, its length is only
-            // visible to the client that inserted it
-            segmentLen = 0;
-            remoteObliteratedLen = segment.cachedLength;
         }
         const partials = isLocal
             ? combinedPartialLengths.unsequencedRecords?.partialLengths
@@ -437,137 +480,105 @@ export class PartialSequenceLengths {
             // Local partial but its computation isn't required
             return;
         }
-        // overlapping move and remove, remove happened first
-        if (moveInfo && removalInfo && removeHappenedFirst && !moveIsLocal) {
-            // The client who performed the remove is always stored
-            // in the first position of removalInfo.
-            const moveClientId = moveInfo.movedClientIds[0];
-            const hasOverlap = moveInfo.movedClientIds.length > 1;
-            PartialSequenceLengths.updatePartialsAfterInsertion(segment, 0, -segment.cachedLength, segmentLen, partials, moveInfo.movedSeq, moveClientId, undefined, hasOverlap ? moveInfo.movedClientIds : undefined);
-        }
-        if (removalInfo && !removeHappenedFirst && !removalIsLocal) {
-            const removeSeqOrLocalSeq = removalIsLocal
-                ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    removalInfo.localRemovedSeq
-                : removalInfo.removedSeq;
-            // The client who performed the remove is always stored
-            // in the first position of removalInfo.
-            const removeClientId = removalInfo.removedClientIds[0];
-            const hasOverlap = removalInfo.removedClientIds.length > 1;
-            PartialSequenceLengths.updatePartialsAfterInsertion(segment, 0, -segment.cachedLength, segmentLen, partials, removeSeqOrLocalSeq, removeClientId, hasOverlap ? removalInfo.removedClientIds : undefined, undefined);
+        if (isLocal) {
+            // The segment is either inserted only locally or removed/moved only locally.
+            // We already accounted for the insertion in the accountForInsertion codepath.
+            // Only thing left to do is account for the removal.
+            partials.addOrUpdate({
+                seq: seqOrLocalSeq,
+                clientId,
+                len: 0,
+                seglen: lenDelta,
+            });
         }
-        PartialSequenceLengths.updatePartialsAfterInsertion(segment, segmentLen, remoteObliteratedLen, undefined, partials, seqOrLocalSeq, clientId, removeClientOverlap, moveClientOverlap);
-        // todo: the below block needs to be changed to handle obliterate, which
-        // doesn't have great support for reconnect at the moment. see ADO #3714
-        const { unsequencedRecords } = combinedPartialLengths;
-        if (unsequencedRecords &&
-            removeClientOverlap &&
-            isRemoved(segment) &&
-            segment.localRemovedSeq !== undefined) {
-            const localSeq = segment.localRemovedSeq;
-            const localPartialLengthEntry = {
+        else {
+            partials.addOrUpdate({
                 seq: seqOrLocalSeq,
-                localSeq,
                 clientId,
                 len: 0,
-                seglen: segmentLen,
-            };
-            let localIndexFirstGTE = 0;
-            for (; localIndexFirstGTE < unsequencedRecords.overlappingRemoves.length; localIndexFirstGTE++) {
-                if (unsequencedRecords.overlappingRemoves[localIndexFirstGTE].seq >= seqOrLocalSeq) {
-                    break;
+                seglen: lenDelta,
+            });
+            for (const id of clientsWithRemoveOrObliterate) {
+                if (id === collabWindow.clientId) {
+                    // The local client also removed or obliterated this segment.
+                    const localSeq = moveInfo?.localMovedSeq ?? removalInfo?.localRemovedSeq;
+                    if (localSeq === undefined) {
+                        // Sure, the local client did it--but that change was already acked.
+                        // No need to account for it in the unsequenced records.
+                        continue;
+                    }
+                    const { unsequencedRecords } = combinedPartialLengths;
+                    if (!unsequencedRecords) {
+                        // Local partial but its computation isn't required.
+                        continue;
+                    }
+                    assert(localSeq !== undefined, 0xaba /* Local client was in move/removed client ids but segment has no local seq for either */);
+                    unsequencedRecords.partialLengths.addOrUpdate({
+                        seq: localSeq,
+                        clientId: collabWindow.clientId,
+                        seglen: lenDelta,
+                        len: 0,
+                    });
+                    // Because we've included deltas which take effect when either of localSeq or refSeq are high enough,
+                    // we need to offset this with an adjustment that takes effect when both are high enough.
+                    combinedPartialLengths.addLocalAdjustment({
+                        refSeq: seqOrLocalSeq,
+                        localSeq,
+                        // combinedPartialLengths.partialLengths has an entry removing this segment from a perspective >= seqOrLocalSeq.
+                        // combinedPartialLengths.unsequencedRecords.partialLengths now has an entry removing this segment from a perspective
+                        // with local seq >= `localSeq`.
+                        // In order to only remove this segment once, we add back in the length (where this entry only takes effect when
+                        // both above are true due to logic in computeOverallRefSeqAdjustment).
+                        seglen: segment.cachedLength,
+                    });
                 }
-            }
-            insertIntoList(unsequencedRecords.overlappingRemoves, localIndexFirstGTE, localPartialLengthEntry);
-            const tweakedLocalPartialEntry = {
-                ...localPartialLengthEntry,
-                seq: localSeq,
-            };
-            unsequencedRecords.partialLengths.addOrUpdate(tweakedLocalPartialEntry);
-        }
-    }
-    static addSeq(partialLengths, seq, seqSeglen, remoteObliteratedLen, clientId) {
-        let seqPartialLen;
-        let penultPartialLen;
-        let pLen = partialLengths.latestLeq(seq);
-        if (pLen) {
-            if (pLen.seq === seq) {
-                seqPartialLen = pLen;
-                pLen = partialLengths.latestLeq(seq - 1);
-                if (pLen) {
-                    penultPartialLen = pLen;
+                else {
+                    // Note that all clients that have a remove or obliterate operation on this segment
+                    // use the seq of the winning move/obliterate in their per-client adjustments!
+                    combinedPartialLengths.addClientAdjustment(id, seqOrLocalSeq, lenDelta);
+                    // Also ensure that all these clients have seen the segment as inserted before being removed
+                    // This is technically not necessary for removes (we never ask for the length of this block with
+                    // respect to a refSeq which this entry would affect), but it's simpler to just add it here.
+                    // We already add this entry as part of the accountForInsertion codepath for the client that
+                    // actually did insert the segment, hence not doing so [again] here.
+                    if (segment.seq > collabWindow.minSeq && id !== segment.clientId) {
+                        combinedPartialLengths.addClientAdjustment(id, segment.seq, segment.cachedLength);
+                    }
                 }
             }
-            else {
-                penultPartialLen = pLen;
-            }
-        }
-        const len = penultPartialLen === undefined ? seqSeglen : penultPartialLen.len + seqSeglen;
-        if (seqPartialLen === undefined) {
-            seqPartialLen = {
-                clientId,
-                len,
-                seglen: seqSeglen,
-                seq,
-                remoteObliteratedLen,
-            };
-            partialLengths.addOrUpdate(seqPartialLen);
-        }
-        else {
-            seqPartialLen.remoteObliteratedLen = remoteObliteratedLen;
-            seqPartialLen.seglen = seqSeglen;
-            seqPartialLen.len = len;
-            // Assert client id matches
         }
     }
-    constructor(
-    /**
-     * The minimumSequenceNumber as defined by the collab window used in the last call to `update`,
-     * or if no such calls have been made, the one used on construction.
-     */
-    minSeq, computeLocalPartials) {
-        this.minSeq = minSeq;
-        /**
-         * Length of the block this PartialSequenceLength corresponds to when viewed at `minSeq`.
-         */
-        this.minLength = 0;
-        /**
-         * Total number of segments in the subtree rooted at the block this PartialSequenceLength corresponds to.
-         */
-        this.segmentCount = 0;
-        /**
-         * List of PartialSequenceLength objects--ordered by increasing seq--giving length information about
-         * the block associated with this PartialSequenceLengths object.
-         *
-         * `partialLengths[i].len` contains the length of this block considering only sequenced segments with
-         * `sequenceNumber <= partialLengths[i].seq`.
-         */
-        this.partialLengths = new PartialSequenceLengthsSet();
+    // Assume: seq is latest sequence number; no structural change to sub-tree, but this partial lengths
+    // entry needs to account for the change made by the client with `clientId` at sequence number `seq`.
+    // (and `update` has been called on all descendant PartialSequenceLengths).
+    // This implementation does not support overlapping removes: callers should recompute partial lengths
+    // using `combine` when the change that has just been applied involves such an operation.
+    // TODO: assert client id matches
+    update(node, seq, clientId, collabWindow) {
+        // In the current implementation, this method gets invoked multiple times for the same sequence number (i.e. mid-operation).
+        // We counter this by first zeroing out existing entries from previous updates, but it isn't ideal.
+        // Even if we fix this at the merge-tree level, the same type of issue can crop up with grouped batching enabled.
+        const latest = this.partialLengths.latestLeq(seq);
+        if (latest?.seq === seq) {
+            this.partialLengths.addOrUpdate({ seq, len: 0, seglen: -latest.seglen, clientId });
+        }
+        // .forEach natively ignores undefined entries.
+        // eslint-disable-next-line unicorn/no-array-for-each
+        this.perClientAdjustments.forEach((clientAdjustments) => {
+            const leqPartial = clientAdjustments.latestLeq(seq);
+            if (leqPartial && leqPartial.seq === seq) {
+                this.addClientAdjustment(clientId, seq, -leqPartial.seglen);
+            }
+        });
         /**
-         * clientSeqNumbers[clientId] is a list of partial lengths for sequenced ops which either:
-         * - were submitted by `clientId`.
-         * - deleted a range containing segments that were concurrently deleted by `clientId`
+         * If any of the changes made by the client at `seq` necessitate partial length entries at sequence numbers other than `seq`,
+         * this flag is set to true. This propagates upwards when aggregating parents as well.
          *
-         * The second case is referred to as the "overlapping delete" case. It is necessary to avoid double-counting
-         * the removal of those segments in queries including clientId.
+         * Note: it seems feasible to update parents more incrementally by tracking the changes made to child blocks for a given update.
+         * There isn't a great place for this information to flow today.
          */
-        this.clientSeqNumbers = [];
-        if (computeLocalPartials) {
-            this.unsequencedRecords = {
-                partialLengths: new PartialSequenceLengthsSet(),
-                overlappingRemoves: [],
-                cachedOverlappingByRefSeq: new Map(),
-            };
-        }
-    }
-    // Assume: seq is latest sequence number; no structural change to sub-tree, but a segment
-    // with sequence number seq has been added within the sub-tree (and `update` has been called
-    // on all descendant PartialSequenceLengths)
-    // TODO: assert client id matches
-    update(node, seq, clientId, collabWindow) {
-        var _a;
+        let failIncrementalPropagation = false;
         let seqSeglen = 0;
-        let remoteObliteratedLen = 0;
         let segCount = 0;
         // Compute length for seq across children
         for (let i = 0; i < node.childCount; i++) {
@@ -576,12 +587,6 @@ export class PartialSequenceLengths {
                 const segment = child;
                 const removalInfo = toRemovalInfo(segment);
                 const moveInfo = toMoveInfo(segment);
-                const removalIsLocal = !!removalInfo && removalInfo.removedSeq === UnassignedSequenceNumber;
-                const moveIsLocal = !!moveInfo && moveInfo.movedSeq === UnassignedSequenceNumber;
-                const removeHappenedFirst = removalInfo &&
-                    (!moveInfo ||
-                        moveIsLocal ||
-                        (!removalIsLocal && moveInfo.movedSeq > removalInfo.removedSeq));
                 if (seq === segment.seq) {
                     // if this segment was moved on insert, its length should
                     // only be visible to the inserting client
@@ -589,36 +594,23 @@ export class PartialSequenceLengths {
                         moveInfo &&
                         moveInfo.movedSeq < segment.seq &&
                         moveInfo.wasMovedOnInsert) {
-                        remoteObliteratedLen += segment.cachedLength;
+                        this.addClientAdjustment(clientId, moveInfo.movedSeq, segment.cachedLength);
+                        failIncrementalPropagation = true;
                     }
                     else {
                         seqSeglen += segment.cachedLength;
+                        this.addClientAdjustment(clientId, seq, segment.cachedLength);
                     }
                 }
-                if (seq === removalInfo?.removedSeq) {
-                    // if the remove op happened before an overlapping obliterate,
-                    // all clients can see the remove at this seq. otherwise, only
-                    // the removing client is aware of the remove
-                    if (removeHappenedFirst) {
-                        seqSeglen -= segment.cachedLength;
-                    }
-                    else {
-                        remoteObliteratedLen -= segment.cachedLength;
-                    }
-                }
-                if (seq === moveInfo?.movedSeq) {
-                    if (removeHappenedFirst) {
-                        remoteObliteratedLen -= segment.cachedLength;
-                    }
-                    else if (moveInfo.wasMovedOnInsert &&
-                        segment.seq !== UnassignedSequenceNumber &&
-                        segment.seq !== undefined &&
-                        moveInfo.movedSeq > segment.seq) {
-                        remoteObliteratedLen += segment.cachedLength;
-                        seqSeglen -= segment.cachedLength;
-                    }
-                    else if (segment.seq !== UnassignedSequenceNumber) {
-                        seqSeglen -= segment.cachedLength;
+                const earlierDeletion = Math.min(removalInfo?.removedSeq ?? Number.MAX_VALUE, moveInfo?.movedSeq ?? Number.MAX_VALUE);
+                if (segment.seq !== UnassignedSequenceNumber && seq === earlierDeletion) {
+                    seqSeglen -= segment.cachedLength;
+                    if (clientId !== collabWindow.clientId) {
+                        this.addClientAdjustment(clientId, seq, -segment.cachedLength);
+                        if (segment.seq > collabWindow.minSeq && segment.clientId !== clientId) {
+                            this.addClientAdjustment(clientId, segment.seq, segment.cachedLength);
+                            failIncrementalPropagation = true;
+                        }
                     }
                 }
                 segCount++;
@@ -627,20 +619,35 @@ export class PartialSequenceLengths {
                 const childBlock = child;
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const branchPartialLengths = childBlock.partialLengths;
+                if (branchPartialLengths.lastIncrementalInvalidationSeq === seq) {
+                    // Bail out.
+                    const newPartials = PartialSequenceLengths.combine(node, collabWindow, false);
+                    newPartials.lastIncrementalInvalidationSeq = seq;
+                    node.partialLengths = newPartials;
+                    return;
+                }
                 const partialLengths = branchPartialLengths.partialLengths;
                 const leqPartial = partialLengths.latestLeq(seq);
                 if (leqPartial && leqPartial.seq === seq) {
                     seqSeglen += leqPartial.seglen;
-                    remoteObliteratedLen += leqPartial.remoteObliteratedLen ?? 0;
                 }
                 segCount += branchPartialLengths.segmentCount;
+                // .forEach natively ignores undefined entries.
+                // eslint-disable-next-line unicorn/no-array-for-each
+                branchPartialLengths.perClientAdjustments.forEach((clientAdjustments) => {
+                    const leqBranchPartial = clientAdjustments.latestLeq(seq);
+                    if (leqBranchPartial && leqBranchPartial.seq === seq) {
+                        this.addClientAdjustment(clientId, seq, leqBranchPartial.seglen);
+                    }
+                });
             }
         }
+        if (failIncrementalPropagation) {
+            this.lastIncrementalInvalidationSeq = seq;
+        }
         this.segmentCount = segCount;
         this.unsequencedRecords = undefined;
-        PartialSequenceLengths.addSeq(this.partialLengths, seq, seqSeglen, remoteObliteratedLen, clientId);
-        (_a = this.clientSeqNumbers)[clientId] ?? (_a[clientId] = new PartialSequenceLengthsSet());
-        PartialSequenceLengths.addSeq(this.clientSeqNumbers[clientId], seq, seqSeglen + remoteObliteratedLen, undefined, clientId);
+        this.partialLengths.addOrUpdate({ seq, seglen: seqSeglen, len: 0, clientId });
         if (PartialSequenceLengths.options.zamboni) {
             this.zamboni(collabWindow);
         }
@@ -657,22 +664,18 @@ export class PartialSequenceLengths {
      * constructed with `computeLocalPartials` set to true and not subsequently updated with `update`.
      */
     getPartialLength(refSeq, clientId, localSeq) {
-        let pLen = this.minLength;
-        const cliLatestIndex = this.cliLatest(clientId);
-        const cliSeq = this.clientSeqNumbers[clientId];
-        pLen += this.partialLengths.latestLeq(refSeq)?.len ?? 0;
+        let length = this.minLength;
+        length += this.partialLengths.latestLeq(refSeq)?.len ?? 0;
         if (localSeq === undefined) {
-            if (cliLatestIndex >= 0) {
-                const cliLatest = cliSeq.items[cliLatestIndex];
-                if (cliLatest.seq > refSeq) {
-                    // The client has local edits after refSeq, add in the length adjustments
-                    pLen += cliLatest.len;
-                    const precedingCli = this.cliLatestLEQ(clientId, refSeq);
-                    if (precedingCli) {
-                        // Subtract out double-counted lengths: segments still in the collab window but before
-                        // the refSeq submitted by the client we're querying for were counted in each addition above.
-                        pLen -= precedingCli.len;
-                    }
+            const latestClientEntry = this.latestClientEntry(clientId);
+            if (latestClientEntry !== undefined && latestClientEntry.seq > refSeq) {
+                // The client has local edits after refSeq, add in the length adjustments
+                length += latestClientEntry.len;
+                const precedingCli = this.latestClientEntryLEQ(clientId, refSeq);
+                if (precedingCli) {
+                    // Subtract out double-counted lengths: segments still in the collab window but before
+                    // the refSeq submitted by the client we're querying for were counted in each addition above.
+                    length -= precedingCli.len;
                 }
             }
         }
@@ -682,32 +685,16 @@ export class PartialSequenceLengths {
             // Local segments at or before localSeq should also be included
             const local = unsequencedPartialLengths.latestLeq(localSeq);
             if (local) {
-                pLen += local.len;
-                // Lastly, we must subtract out any double-counted removes, which occur if a currently un-acked local
-                // remove overlaps with a remote client's remove that occurred at sequence number <=refSeq.
-                pLen -= this.computeOverlappingLocalRemoves(refSeq, localSeq);
+                length += local.len;
+                // Lastly, we must add in any additional adjustment due to double-counting removes and obliterations
+                // removing local-only segments.
+                length += this.computeOverallRefSeqAdjustment(refSeq, localSeq);
             }
         }
-        return pLen;
+        return length;
     }
     /**
-     * Computes the seglen for the double-counted removed overlap at (refSeq, localSeq). This logic is equivalent
-     * to the following:
-     *
-     * ```typescript
-     *   let total = 0;
-     *   for (const partialLength of this.unsequencedRecords!.overlappingRemoves) {
-     *       if (partialLength.seq > refSeq) {
-     *           break;
-     *       }
-     *
-     *      if (partialLength.localSeq <= localSeq) {
-     *          total += partialLength.seglen;
-     *      }
-     *   }
-     *
-     *   return total;
-     * ```
+     * Computes the seglen for the double-counted removed overlap at (refSeq, localSeq).
      *
      * Reconnect happens to only need to compute these lengths for two refSeq values: before and
      * after the rebase. Since these lists potentially scale with O(collab window * number of local edits)
@@ -715,24 +702,29 @@ export class PartialSequenceLengths {
      * we cache the results for a given refSeq in `this.unsequencedRecords.cachedOverlappingByRefSeq` so
      * that they can be binary-searched the same way the usual partialLengths lists are.
      */
-    computeOverlappingLocalRemoves(refSeq, localSeq) {
+    computeOverallRefSeqAdjustment(refSeq, localSeq) {
         if (this.unsequencedRecords === undefined) {
             return 0;
         }
-        let cachedOverlapPartials = this.unsequencedRecords.cachedOverlappingByRefSeq.get(refSeq);
-        if (!cachedOverlapPartials) {
+        let cachedAdjustment = this.unsequencedRecords.cachedAdjustmentByRefSeq.get(refSeq);
+        if (!cachedAdjustment) {
             const partials = new PartialSequenceLengthsSet();
-            for (const partial of this.unsequencedRecords.overlappingRemoves) {
-                if (partial.seq > refSeq) {
-                    break;
+            for (const [seq, adjustments,] of this.unsequencedRecords.perRefSeqAdjustments.entries()) {
+                if (seq > refSeq) {
+                    // TODO: Prior code path got away with an early exit here by sorting the entries by refSeq.
+                    // We could do the same here if we wanted.
+                    // Old codepath basically flattened the 2d array into a 1d array with both dimensions listed.
+                    continue;
+                }
+                for (const partial of adjustments.items) {
+                    // This coalesces entries with the same localSeq as well as computes overall lengths.
+                    partials.addOrUpdate({ ...partial });
                 }
-                partials.addOrUpdate({ ...partial, seq: partial.localSeq, len: 0 });
             }
-            // This coalesces entries with the same localSeq as well as computes overall lengths.
-            cachedOverlapPartials = partials;
-            this.unsequencedRecords.cachedOverlappingByRefSeq.set(refSeq, cachedOverlapPartials);
+            cachedAdjustment = partials;
+            this.unsequencedRecords.cachedAdjustmentByRefSeq.set(refSeq, cachedAdjustment);
         }
-        const overlap = cachedOverlapPartials.latestLeq(localSeq);
+        const overlap = cachedAdjustment.latestLeq(localSeq);
         return overlap?.len ?? 0;
     }
     toString(glc, indentCount = 0) {
@@ -741,12 +733,12 @@ export class PartialSequenceLengths {
             buf += `(${partial.seq},${partial.len}) `;
         }
         // eslint-disable-next-line @typescript-eslint/no-for-in-array, no-restricted-syntax
-        for (const clientId in this.clientSeqNumbers) {
-            if (this.clientSeqNumbers[clientId].size > 0) {
+        for (const clientId in this.perClientAdjustments) {
+            if (this.perClientAdjustments[clientId].size > 0) {
                 buf += `Client `;
                 buf += glc ? `${glc(+clientId)}` : `${clientId}`;
                 buf += "[";
-                for (const partial of this.clientSeqNumbers[clientId].items) {
+                for (const partial of this.perClientAdjustments[clientId].items) {
                     buf += `(${partial.seq},${partial.len})`;
                 }
                 buf += "]";
@@ -760,49 +752,39 @@ export class PartialSequenceLengths {
         this.minLength += this.partialLengths.copyDown(segmentWindow.minSeq);
         this.minSeq = segmentWindow.minSeq;
         // eslint-disable-next-line @typescript-eslint/no-for-in-array, guard-for-in, no-restricted-syntax
-        for (const clientId in this.clientSeqNumbers) {
-            const cliPartials = this.clientSeqNumbers[clientId];
+        for (const clientId in this.perClientAdjustments) {
+            const cliPartials = this.perClientAdjustments[clientId];
             if (cliPartials) {
                 cliPartials.copyDown(segmentWindow.minSeq);
             }
         }
     }
-    addClientSeqNumber(clientId, seq, seglen) {
-        var _a;
-        (_a = this.clientSeqNumbers)[clientId] ?? (_a[clientId] = new PartialSequenceLengthsSet());
-        const cli = this.clientSeqNumbers[clientId];
+    addClientAdjustment(clientId, seq, seglen) {
+        this.perClientAdjustments[clientId] ??= new PartialSequenceLengthsSet();
+        const cli = this.perClientAdjustments[clientId];
         cli.addOrUpdate({ seq, len: 0, seglen });
     }
-    // Assumes sequence number already coalesced and that this is called in increasing `seq` order.
-    addClientSeqNumberFromPartial(partialLength) {
-        const seglen = partialLength.seglen + (partialLength.remoteObliteratedLen ?? 0);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        this.addClientSeqNumber(partialLength.clientId, partialLength.seq, seglen);
-        if (partialLength.overlapRemoveClients) {
-            partialLength.overlapRemoveClients.map((oc) => {
-                // Original client entry was handled above
-                if (partialLength.clientId !== oc.data.clientId) {
-                    this.addClientSeqNumber(oc.data.clientId, partialLength.seq, oc.data.seglen);
-                }
-                return true;
-            });
-        }
-        if (partialLength.overlapObliterateClients) {
-            partialLength.overlapObliterateClients.map((oc) => {
-                // Original client entry was handled above
-                if (partialLength.clientId !== oc.data.clientId) {
-                    this.addClientSeqNumber(oc.data.clientId, partialLength.seq, oc.data.seglen);
-                }
-                return true;
-            });
-        }
+    addLocalAdjustment({ refSeq, localSeq, seglen, }) {
+        assert(this.unsequencedRecords !== undefined, 0xabb /* Local adjustment computed without partials */);
+        const adjustments = this.unsequencedRecords.perRefSeqAdjustments.get(refSeq) ??
+            new PartialSequenceLengthsSet();
+        this.unsequencedRecords.perRefSeqAdjustments.set(refSeq, adjustments);
+        adjustments.addOrUpdate({ seq: localSeq, len: 0, seglen });
     }
-    cliLatestLEQ(clientId, refSeq) {
-        return this.clientSeqNumbers[clientId]?.latestLeq(refSeq);
+    /**
+     * Returns the partial lengths associated with the latest change associated with `clientId` at or before `refSeq`.
+     * Returns undefined if no such change exists.
+     */
+    latestClientEntryLEQ(clientId, refSeq) {
+        return this.perClientAdjustments[clientId]?.latestLeq(refSeq);
     }
-    cliLatest(clientId) {
-        const cliSeqs = this.clientSeqNumbers[clientId];
-        return cliSeqs && cliSeqs.size > 0 ? cliSeqs.size - 1 : -1;
+    /**
+     * Get the partial lengths associated with the most recent change received by `clientId`, or undefined
+     * if this client has made no changes in this block within the collab window.
+     */
+    latestClientEntry(clientId) {
+        const cliSeqs = this.perClientAdjustments[clientId];
+        return cliSeqs && cliSeqs.size > 0 ? cliSeqs.items[cliSeqs.size - 1] : undefined;
     }
 }
 PartialSequenceLengths.options = {
@@ -847,20 +829,6 @@ function verifyPartialLengthsInner(partialSeqLengths, partialLengths, clientPart
                 assert(false, 0x057 /* "Negative length after length adjustment!" */);
             }
         }
-        if (partialLength.overlapRemoveClients) {
-            // Only the flat partialLengths can have overlapRemoveClients, the per client view shouldn't
-            assert(!clientPartials, 0x058 /* "Both overlapRemoveClients and clientPartials are set!" */);
-            // Each overlap client counts as one, but the first remove to sequence was already counted.
-            // (this aligns with the logic to omit the removing client in `addClientSeqNumberFromPartial`)
-            count += partialLength.overlapRemoveClients.size() - 1;
-        }
-        if (partialLength.overlapObliterateClients) {
-            // Only the flat partialLengths can have overlapObliterateClients, the per client view shouldn't
-            assert(!clientPartials, 0x872 /* Both overlapObliterateClients and clientPartials are set! */);
-            // Each overlap client counts as one, but the first move to sequence was already counted.
-            // (this aligns with the logic to omit the moving client in `addClientSeqNumberFromPartial`)
-            count += partialLength.overlapObliterateClients.size() - 1;
-        }
     }
     return count;
 }
@@ -885,13 +853,15 @@ export function verifyExpectedPartialLengths(mergeTree, node, refSeq, clientId,
         }
     }
     if (expected !== partialLen) {
+        const nonIncrementalPartials = PartialSequenceLengths.combine(node, mergeTree.collabWindow, false, true);
+        const nonIncrementalLength = nonIncrementalPartials.getPartialLength(refSeq, clientId, localSeq);
         node.partialLengths?.getPartialLength(refSeq, clientId, localSeq);
-        throw new Error(`expected partial length of ${expected} but found ${partialLen}. refSeq: ${refSeq}, clientId: ${clientId}`);
+        throw new Error(`expected partial length of ${expected} but found ${partialLen}. refSeq: ${refSeq}, clientId: ${clientId}. (non-incremental codepath returned ${nonIncrementalLength})`);
     }
 }
 export function verifyPartialLengths(partialSeqLengths) {
-    if (partialSeqLengths["clientSeqNumbers"]) {
-        for (const cliSeq of partialSeqLengths["clientSeqNumbers"]) {
+    if (partialSeqLengths["perClientAdjustments"]) {
+        for (const cliSeq of partialSeqLengths["perClientAdjustments"]) {
             if (cliSeq) {
                 verifyPartialLengthsInner(partialSeqLengths, cliSeq, true);
             }
@@ -906,56 +876,6 @@ export function verifyPartialLengths(partialSeqLengths) {
     }
 }
 /* eslint-enable @typescript-eslint/dot-notation */
-/**
- * Clones an `overlapRemoveClients` red-black tree.
- */
-function cloneOverlapRemoveClients(oldTree) {
-    if (!oldTree) {
-        return undefined;
-    }
-    const newTree = new RedBlackTree(compareNumbers);
-    oldTree.map((bProp) => {
-        newTree.put(bProp.data.clientId, { ...bProp.data });
-        return true;
-    });
-    return newTree;
-}
-function combineForOverlapClients(treeA, treeB) {
-    if (treeA) {
-        if (treeB) {
-            treeB.map((bProp) => {
-                const aProp = treeA.get(bProp.key);
-                if (aProp) {
-                    aProp.data.seglen += bProp.data.seglen;
-                }
-                else {
-                    treeA.put(bProp.data.clientId, { ...bProp.data });
-                }
-                return true;
-            });
-        }
-    }
-    else {
-        return cloneOverlapRemoveClients(treeB);
-    }
-}
-/**
- * Combines the `overlapRemoveClients` and `overlapObliterateClients` fields of
- * two `PartialSequenceLength` objects, modifying the first PartialSequenceLength's
- * bookkeeping in-place.
- *
- * Combination is performed additively on `seglen` on a per-client basis.
- */
-export function combineOverlapClients(a, b) {
-    const overlapRemoveClients = combineForOverlapClients(a.overlapRemoveClients, b.overlapRemoveClients);
-    if (overlapRemoveClients) {
-        a.overlapRemoveClients = overlapRemoveClients;
-    }
-    const overlapObliterateClients = combineForOverlapClients(a.overlapObliterateClients, b.overlapObliterateClients);
-    if (overlapObliterateClients) {
-        a.overlapObliterateClients = overlapObliterateClients;
-    }
-}
 /**
  * Given a number of seq-sorted `partialLength` lists, merges them into a combined seq-sorted `partialLength`
  * list. This merge includes coalescing `PartialSequenceLength` entries at the same seq.
@@ -974,8 +894,6 @@ function mergePartialLengths(childPartialLengths, mergedLengths = new PartialSeq
     for (const partialLength of mergeSortedListsBySeq(childPartialLengths)) {
         mergedLengths.addOrUpdate({
             ...partialLength,
-            overlapRemoveClients: cloneOverlapRemoveClients(partialLength.overlapRemoveClients),
-            overlapObliterateClients: cloneOverlapRemoveClients(partialLength.overlapObliterateClients),
         });
     }
     return mergedLengths;
@@ -1022,15 +940,4 @@ function mergeSortedListsBySeq(lists) {
     }
     return { [Symbol.iterator]: () => new PartialSequenceLengthIterator(lists) };
 }
-function insertIntoList(list, index, elem) {
-    if (index < list.length) {
-        for (let k = list.length; k > index; k--) {
-            list[k] = list[k - 1];
-        }
-        list[index] = elem;
-    }
-    else {
-        list.push(elem);
-    }
-}
 //# sourceMappingURL=partialLengths.js.map