From c6b3293ecc5ef3cefcbb2e7bcac8beb6171909ae Mon Sep 17 00:00:00 2001 From: Evie Gauthier Date: Tue, 24 Mar 2026 18:46:21 -0400 Subject: [PATCH] fix: two timeline pagination bugs affecting message ordering MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## 1. useTimelinePagination: finally-block resets fetchingRef prematurely When a paginated page returns 1–4 events and more history exists, the paginator fires a recursive continuation call (`paginate(backwards)`) before the outer `finally` block runs. The sequence was: 1. outer try: `fetchingRef.current[dir] = false; paginate(backwards);` → inner paginate runs synchronously: checks lock (false) → sets it to `true` → hits `await` → suspends 2. outer finally: `fetchingRef.current[dir] = false;` → overwrites the `true` that inner paginate just wrote This left `fetchingRef.current[dir] = false` while the inner paginate was mid-flight. The `backwardStatus === 'loading'` guard on the scroll handler masked the problem in most cases, but for a long chain of sparse pages each returning 1–4 events, multiple overlapping paginations could start. If the SDK's internal per-timeline lock was also released (or a forward-direction call raced), events could be requested from stale pagination tokens and be inserted out of order. Fix: add a `continuing` local boolean. When a recursive continuation is fired, `continuing = true` is set first. The `finally` block skips the reset when `continuing` is true, leaving the lock in the inner paginate's hands. The inner paginate's own `finally` releases it when it finishes. ## 2. getLinkedTimelines: O(N²) array copies in recursive accumulator The previous recursive `collectTimelines(tl, dir, [...acc, tl])` created N intermediate arrays for an N-timeline chain (sizes 1, 2, 3, … N), giving O(N²) total allocations. For a power user who paginates back through hundreds of pages of history, this becomes measurable GC pressure. Replace with a simple iterative loop (`while (current) { push; next }`) that builds exactly one output array in O(N) time. --- src/app/hooks/timeline/useTimelineSync.ts | 20 +++++++++++++++++++- src/app/utils/timeline.ts | 18 +++++++----------- 2 files changed, 26 insertions(+), 12 deletions(-) diff --git a/src/app/hooks/timeline/useTimelineSync.ts b/src/app/hooks/timeline/useTimelineSync.ts index 395d6fc4..9c758321 100644 --- a/src/app/hooks/timeline/useTimelineSync.ts +++ b/src/app/hooks/timeline/useTimelineSync.ts @@ -171,6 +171,13 @@ const useTimelinePagination = ( await to(decryptAllTimelineEvent(mx, fetchedTimeline)); } + // `continuing` tracks whether we hand the fetchingRef lock to a recursive + // continuation call below. The finally block must NOT reset the lock if + // the recursive call has already claimed it, otherwise there is a brief + // window where fetchingRef is false while the recursive paginate is in + // flight, allowing a third overlapping call to start on sparse pages. + let continuing = false; + if (alive()) { recalibratePagination(lTimelines); (backwards ? setBackwardStatus : setForwardStatus)('idle'); @@ -184,13 +191,24 @@ const useTimelinePagination = ( Direction.Backward ) === 'string'; if (stillHasToken) { + // Release lock so inner paginate can claim it, then mark continuing + // so the finally block below does NOT reset it after inner claims. fetchingRef.current[directionKey] = false; + continuing = true; paginate(backwards); + // At this point the inner paginate has synchronously set + // fetchingRef.current[directionKey] = true before hitting its own + // await. The finally below will skip the reset. } } } } finally { - fetchingRef.current[directionKey] = false; + // Only release the lock if we did NOT hand it to a recursive continuation. + // If `continuing` is true the recursive call owns the lock and will release + // it in its own finally block. + if (!continuing) { + fetchingRef.current[directionKey] = false; + } } }; }, [mx, alive, setTimeline, limit, setBackwardStatus, setForwardStatus]); diff --git a/src/app/utils/timeline.ts b/src/app/utils/timeline.ts index 4ed92ab1..0934e5b0 100644 --- a/src/app/utils/timeline.ts +++ b/src/app/utils/timeline.ts @@ -22,18 +22,14 @@ export const getFirstLinkedTimeline = ( return current; }; -const collectTimelines = ( - tl: EventTimeline | null, - dir: Direction, - acc: EventTimeline[] = [] -): EventTimeline[] => { - if (!tl) return acc; - return collectTimelines(tl.getNeighbouringTimeline(dir), dir, [...acc, tl]); -}; - export const getLinkedTimelines = (timeline: EventTimeline): EventTimeline[] => { - const firstTimeline = getFirstLinkedTimeline(timeline, Direction.Backward); - return collectTimelines(firstTimeline, Direction.Forward); + const result: EventTimeline[] = []; + let current: EventTimeline | null = getFirstLinkedTimeline(timeline, Direction.Backward); + while (current) { + result.push(current); + current = current.getNeighbouringTimeline(Direction.Forward); + } + return result; }; export const timelineToEventsCount = (t: EventTimeline) => {