macltok

public

Star0

Fork 0

Watch0

82 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `002c79e4c6ec`

tarball

atagen <boss@atagen.co>2026-10-25 13:25 UTC

7 files changed+80-222

history: fence every committed completion and drop the joined gap filter

A fill or recent load that committed pages and then failed or was cancelled answered before those pages reached the timeline. The joined gap filter guarded a case the sdk never produces. RetryRecent's fallback pagination reached further back on every retry, so it now only runs on an empty room timeline.

Modified file: docs/segmented-history.md+11 additions−13 deletions@@ -19,9 +19,10 @@ the fresh window and what was retained.
 - `Loaded`, `Cancelled` or `Failed(message)` as it settles
 - `Idle` when the room closes, whatever was happening
 
-`Failed` stays until `HistoryRepairCommand::RetryRecent` or a reopen. a failed
-load falls back to paginating `EngineConfig::initial_history_limit` events, so
-the room isn't left empty.
+`Failed` stays until `HistoryRepairCommand::RetryRecent`, and closing the room
+turns it to `Idle` like anything else. a failed load on a room timeline with no
+events yet falls back to paginating `EngineConfig::initial_history_limit`
+events, so the room isn't left empty.
 
 ## filling a gap
 
@@ -55,20 +56,17 @@ gaps appear in `TimelineState.items` as `TimelineItem::HistoryGap`, between the
 sections they separate. a row keeps its id while its lifecycle changes, and is
 removed once the gap joins. joined gaps never appear.
 
-history lands as incremental `TimelineChanged` diffs, never a `TimelineReset`.
-before answering, the room fences on `Timeline::flush_history`, which applies
-what the cache already queued without replacing the timeline, so receipts, the
-read marker and row ids survive.
+history lands as `TimelineChanged` diffs, never a `TimelineReset`. they are
+incremental unless the cache's loaded window changed under the operation, after
+a restart or a shrink, when the sdk sends the room as one `Reset` diff. before
+answering, the room fences on `Timeline::flush_history`, which applies what the
+cache already queued without replacing the timeline, so receipts, the read
+marker and row ids survive. a failed or cancelled operation that committed
+pages is fenced the same way.
 
 a command's answer comes after its outcome is published, and after the mirror
 has applied it when one is attached.
 
-## known holes
-
-a limited sync for a room with no events in memory records a plain gap instead
-of a history gap (review 2026-10-25 S1), so an interval can still render as
-continuous. both `prev_batch` drops in the sdk's `handle_sync` remain.
-
 ## wire shapes
 
 serde enums are externally tagged.

Modified file: src/engine/repair.rs+6 additions−2 deletions@@ -293,8 +293,12 @@ async fn fill_gap(
             let next = tokio::select! {
                 biased;
                 _ = cancel.changed() => return Ok(Stopped::Cancelled),
-                result = cache.fill_history_gap_once(report.gap_id.clone()) => {
-                    result.map_err(cache_error)?
+                result = cache.fill_history_gap_once(report.gap_id.clone()) => match result {
+                    Ok(next) => next,
+                    Err(error) => {
+                        committed |= matches!(error, EventCacheError::PaginationError(_));
+                        return Err(cache_error(error));
+                    }
                 }
             };
             let (gap, events) = match next {

Modified file: src/engine/room.rs+6 additions−2 deletions@@ -157,12 +157,15 @@ impl RoomActor {
 
     async fn finish_repair(&self, mut completion: Completion, timelines: &mut Timelines) {
         let mut cancellation = Ok(());
+        // pages a failed or cancelled operation already committed still have to be on
+        // screen before anyone hears it stopped
         if completion.committed
             && !completion.closing
-            && completion.result.is_ok()
             && let Err(error) = timelines.room.publish_history().await
         {
-            completion.unpublished(error.clone());
+            if completion.result.is_ok() {
+                completion.unpublished(error.clone());
+            }
             cancellation = Err(error);
         }
         let event = match &completion.outcome {
@@ -183,6 +186,7 @@ impl RoomActor {
             completion.outcome,
             Outcome::Recent(RecentHistoryState::Failed(_))
         ) && limit > 0
+            && !timelines.room.has_events().await
         {
             timelines.room.paginate(limit, None);
         }

Modified file: src/engine/timeline.rs+11 additions−8 deletions@@ -144,6 +144,14 @@ impl TimelineSession {
         drained.await.map_err(|_| Error::interrupted())
     }
 
+    pub(super) async fn has_events(&self) -> bool {
+        self.timeline
+            .items()
+            .await
+            .iter()
+            .any(|item| item.as_event().is_some())
+    }
+
     pub(super) fn paginate(&self, limit: u16, reply: Option<Responder>) {
         if let Err(error) = self.pagination.try_send(PaginationRequest { limit, reply }) {
             let (request, error) = match error {
@@ -415,8 +423,7 @@ async fn start_watcher(
 ) -> Result<(JoinHandle<()>, mpsc::UnboundedSender<Fence>), SendEventError> {
     let (items, mut stream) = timeline.subscribe().await;
     let current_user_id = context.current_user_id.clone();
-    let (normalised, mut hidden) =
-        normalise_timeline(items.iter(), current_user_id.as_deref(), scope);
+    let normalised = normalise_timeline(items.iter(), current_user_id.as_deref(), scope);
     context.media.register(scope, normalised.media).await;
     context
         .events
@@ -456,12 +463,8 @@ async fn start_watcher(
                 Some(_) = replies.fetches.join_next(), if !replies.fetches.is_empty() => continue,
             };
             for diffs in diffs {
-                let normalised = normalise_timeline_diffs(
-                    diffs,
-                    current_user_id.as_deref(),
-                    &scope,
-                    &mut hidden,
-                );
+                let normalised =
+                    normalise_timeline_diffs(diffs, current_user_id.as_deref(), &scope);
                 media.register(&scope, normalised.media).await;
                 replies.fetch(normalised.missing_replies);
                 if normalised.diffs.is_empty() {

Modified file: src/model.rs+1−1

@@ -2131,7 +2131,7 @@ pub enum RecentHistoryState {

21312131 Loading,

21322132 Loaded,

21332133 Cancelled,

2134- /// stays until a retry or the room is reopened

2134+ /// stays until a retry, or until closing the room makes it `Idle`

21352135 Failed(String),

21362136 }

21372137

Modified file: src/normalise/timeline.rs+26 additions−195 deletions@@ -52,16 +52,10 @@ struct Normaliser<'a> {
 }
 
 impl Normaliser<'_> {
-    /// `None` for rows macltok leaves out
-    fn item(&mut self, item: &SdkTimelineItem) -> Option<TimelineItem> {
-        if let TimelineItemKind::Virtual(VirtualTimelineItem::HistoryGap(gap)) = item.kind()
-            && gap.status == matrix_sdk::event_cache::HistoryGapStatus::Joined
-        {
-            return None;
-        }
+    fn item(&mut self, item: &SdkTimelineItem) -> TimelineItem {
         self.media
             .extend(media_registrations_for_item(item, self.scope));
-        Some(match item.kind() {
+        match item.kind() {
             TimelineItemKind::Event(event) => {
                 TimelineItem::Event(Box::new(self.event(item, event)))
             }
@@ -77,6 +71,7 @@ impl Normaliser<'_> {
             TimelineItemKind::Virtual(VirtualTimelineItem::HistoryGap(gap)) => {
                 use matrix_sdk::event_cache::HistoryGapStatus;
                 let (lifecycle, failure) = match &gap.status {
+                    // the sdk drops joined gaps before they reach a timeline
                     HistoryGapStatus::Idle | HistoryGapStatus::Joined => {
                         (HistoryGapLifecycle::Idle, None)
                     }
@@ -94,7 +89,7 @@ impl Normaliser<'_> {
                     failure,
                 })
             }
-        })
+        }
     }
 
     fn event(&mut self, item: &SdkTimelineItem, event: &EventTimelineItem) -> TimelineEvent {
@@ -154,28 +149,25 @@ pub(crate) fn normalise_timeline<'a>(
     items: impl Iterator<Item = &'a Arc<SdkTimelineItem>>,
     current_user_id: Option<&UserId>,
     scope: &MediaScope,
-) -> (NormalisedTimeline, HiddenRows) {
+) -> NormalisedTimeline {
     let mut normaliser = Normaliser {
         current_user_id,
         scope,
         media: Vec::new(),
         missing_replies: Vec::new(),
     };
-    let mut hidden = HiddenRows::default();
-    let items = hidden.reset(items.map(|item| normaliser.item(item)));
-    let normalised = NormalisedTimeline {
-        items: items.into_iter().collect(),
+    let items = items.map(|item| normaliser.item(item)).collect();
+    NormalisedTimeline {
+        items,
         media: normaliser.media,
         missing_replies: normaliser.missing_replies,
-    };
-    (normalised, hidden)
+    }
 }
 
 pub(crate) fn normalise_timeline_diffs(
     diffs: Vec<VectorDiff<Arc<SdkTimelineItem>>>,
     current_user_id: Option<&UserId>,
     scope: &MediaScope,
-    hidden: &mut HiddenRows,
 ) -> NormalisedTimelineDiffs {
     let mut normaliser = Normaliser {
         current_user_id,
@@ -185,7 +177,23 @@ pub(crate) fn normalise_timeline_diffs(
     };
     let diffs = diffs
         .into_iter()
-        .filter_map(|diff| hidden.translate(diff.map(|item| normaliser.item(&item))))
+        .map(|diff| match diff.map(|item| normaliser.item(&item)) {
+            VectorDiff::Append { values } => TimelineDiff::Append {
+                values: values.into_iter().collect(),
+            },
+            VectorDiff::Clear => TimelineDiff::Clear,
+            VectorDiff::PushFront { value } => TimelineDiff::PushFront { value },
+            VectorDiff::PushBack { value } => TimelineDiff::PushBack { value },
+            VectorDiff::PopFront => TimelineDiff::PopFront,
+            VectorDiff::PopBack => TimelineDiff::PopBack,
+            VectorDiff::Insert { index, value } => TimelineDiff::Insert { index, value },
+            VectorDiff::Set { index, value } => TimelineDiff::Set { index, value },
+            VectorDiff::Remove { index } => TimelineDiff::Remove { index },
+            VectorDiff::Truncate { length } => TimelineDiff::Truncate { length },
+            VectorDiff::Reset { values } => TimelineDiff::Reset {
+                values: values.into_iter().collect(),
+            },
+        })
         .collect();
     NormalisedTimelineDiffs {
         diffs,
@@ -194,135 +202,6 @@ pub(crate) fn normalise_timeline_diffs(
     }
 }
 
-/// which sdk rows were left out, so diff indices can step over them
-#[derive(Default)]
-pub(crate) struct HiddenRows {
-    rows: imbl::Vector<bool>,
-    hidden: usize,
-}
-
-impl HiddenRows {
-    fn visible_index(&self, index: usize) -> usize {
-        if self.hidden == 0 {
-            return index;
-        }
-        self.rows
-            .iter()
-            .take(index)
-            .filter(|hidden| !**hidden)
-            .count()
-    }
-
-    fn push(&mut self, front: bool, item: &Option<TimelineItem>) {
-        self.hidden += usize::from(item.is_none());
-        if front {
-            self.rows.push_front(item.is_none());
-        } else {
-            self.rows.push_back(item.is_none());
-        }
-    }
-
-    fn forget(&mut self, hidden: bool) -> bool {
-        self.hidden -= usize::from(hidden);
-        !hidden
-    }
-
-    fn reset(&mut self, items: impl Iterator<Item = Option<TimelineItem>>) -> Vec<TimelineItem> {
-        *self = Self::default();
-        items
-            .filter_map(|item| {
-                self.push(false, &item);
-                item
-            })
-            .collect()
-    }
-
-    fn translate(&mut self, diff: VectorDiff<Option<TimelineItem>>) -> Option<TimelineDiff> {
-        Some(match diff {
-            VectorDiff::Append { values } => {
-                let values: Vec<_> = values
-                    .into_iter()
-                    .filter_map(|item| {
-                        self.push(false, &item);
-                        item
-                    })
-                    .collect();
-                if values.is_empty() {
-                    return None;
-                }
-                TimelineDiff::Append { values }
-            }
-            VectorDiff::Clear => {
-                *self = Self::default();
-                TimelineDiff::Clear
-            }
-            VectorDiff::PushFront { value } => {
-                self.push(true, &value);
-                TimelineDiff::PushFront { value: value? }
-            }
-            VectorDiff::PushBack { value } => {
-                self.push(false, &value);
-                TimelineDiff::PushBack { value: value? }
-            }
-            VectorDiff::PopFront => {
-                let hidden = self.rows.pop_front()?;
-                self.forget(hidden).then_some(TimelineDiff::PopFront)?
-            }
-            VectorDiff::PopBack => {
-                let hidden = self.rows.pop_back()?;
-                self.forget(hidden).then_some(TimelineDiff::PopBack)?
-            }
-            VectorDiff::Insert { index, value } => {
-                let visible = self.visible_index(index);
-                self.hidden += usize::from(value.is_none());
-                self.rows.insert(index, value.is_none());
-                TimelineDiff::Insert {
-                    index: visible,
-                    value: value?,
-                }
-            }
-            VectorDiff::Set { index, value } => {
-                let visible = self.visible_index(index);
-                let was_hidden = self.rows.set(index, value.is_none());
-                self.hidden = self.hidden + usize::from(value.is_none()) - usize::from(was_hidden);
-                match (was_hidden, value) {
-                    (false, Some(value)) => TimelineDiff::Set {
-                        index: visible,
-                        value,
-                    },
-                    (false, None) => TimelineDiff::Remove { index: visible },
-                    (true, Some(value)) => TimelineDiff::Insert {
-                        index: visible,
-                        value,
-                    },
-                    (true, None) => return None,
-                }
-            }
-            VectorDiff::Remove { index } => {
-                let visible = self.visible_index(index);
-                let hidden = self.rows.remove(index);
-                self.forget(hidden)
-                    .then_some(TimelineDiff::Remove { index: visible })?
-            }
-            VectorDiff::Truncate { length } => {
-                let visible = self.visible_index(length);
-                let dropped = self
-                    .rows
-                    .iter()
-                    .skip(length)
-                    .filter(|hidden| **hidden)
-                    .count();
-                self.hidden -= dropped;
-                self.rows.truncate(length);
-                TimelineDiff::Truncate { length: visible }
-            }
-            VectorDiff::Reset { values } => TimelineDiff::Reset {
-                values: self.reset(values.into_iter()),
-            },
-        })
-    }
-}
-
 /// `media_identity` is `None` for embedded reply content, which never gets fetchable media of its own
 fn content(content: &TimelineItemContent, media_identity: Option<&str>) -> TimelineContent {
     match content {
@@ -593,51 +472,3 @@ pub(super) fn formatted_body(message: &MessageType) -> Option<String> {
     (formatted.format == MessageFormat::Html).then(|| formatted.body.clone())
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn row(n: u64) -> Option<TimelineItem> {
-        Some(TimelineItem::DayDivider { timestamp_ms: n })
-    }
-
-    #[test]
-    fn hidden_rows_keep_diff_indices_on_the_visible_timeline() {
-        let mut sdk: imbl::Vector<Option<TimelineItem>> = imbl::Vector::new();
-        let mut hidden = HiddenRows::default();
-        let mut visible: imbl::Vector<TimelineItem> = imbl::Vector::new();
-        let diffs = [
-            VectorDiff::Reset {
-                values: [row(0), None, row(1)].into_iter().collect(),
-            },
-            VectorDiff::Insert {
-                index: 1,
-                value: row(2),
-            },
-            VectorDiff::Set {
-                index: 2,
-                value: row(3),
-            },
-            VectorDiff::Set {
-                index: 0,
-                value: None,
-            },
-            VectorDiff::PushFront { value: None },
-            VectorDiff::Remove { index: 3 },
-            VectorDiff::Append {
-                values: [None, row(4)].into_iter().collect(),
-            },
-            VectorDiff::PopFront,
-            VectorDiff::Truncate { length: 2 },
-            VectorDiff::PopBack,
-        ];
-        for diff in diffs {
-            diff.clone().apply(&mut sdk);
-            if let Some(diff) = hidden.translate(diff) {
-                diff.try_apply(&mut visible).unwrap();
-            }
-            let expected: imbl::Vector<_> = sdk.iter().flatten().cloned().collect();
-            assert_eq!(visible, expected);
-        }
-    }
-}

Modified file: tests/history_repair.rs+19 additions−1 deletions@@ -7,7 +7,7 @@ use macltok::Mirror;
 use macltok::{
     ClientHandle, Engine, EngineConfig, EngineError, Event, EventStream, HistoryGap,
     HistoryRepairPhase, HistoryRepairReport, HistoryRepairStop, RecentHistoryState, Termination,
-    TimelineId, TimelineItem,
+    TimelineDiff, TimelineId, TimelineItem,
 };
 use matrix_sdk::{
     Client,
@@ -74,6 +74,10 @@ async fn next_until(room: &mut TestRoom, mut predicate: impl FnMut(&Event) -> bo
                     diffs,
                 } => {
                     for diff in diffs.clone() {
+                        assert!(
+                            !matches!(diff, TimelineDiff::Reset { .. }),
+                            "history replaced the room timeline"
+                        );
                         diff.try_apply(&mut room.items)
                             .expect("diff did not fit the timeline");
                     }
@@ -577,6 +581,20 @@ async fn closing_during_a_recent_load_settles_idle_not_failed() {
         .mount()
         .await;
     open_room(&mut room, room_id).await;
+    tokio::time::timeout(Duration::from_secs(5), async {
+        while !room
+            .server
+            .received_requests()
+            .await
+            .unwrap()
+            .iter()
+            .any(|request| request.url.path().ends_with("/messages"))
+        {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .expect("the recent load never asked for messages");
     room.handle.close_room(room_id.to_owned()).await.unwrap();
     let mut states = Vec::new();
     next_until(&mut room, |event| {

macltok

Commit 002c79e4c6ec

Commit `002c79e4c6ec`