@@ -0,0 +68,4 @@
+		.update_device_last_seen(syncing_user, Some(syncing_device), client_ip)
+		.await;
+
+	// MSC3575's way of dropping subscriptions, which ruma does not model

@@ -184,2 +220,4 @@
 		.await
 }
+
+/// `None` if nothing happened in the room since `count`.

@@ -185,1 +221,4 @@
 }
+
+/// `None` if nothing happened in the room since `count`.
+async fn shortstatehash_after(

@@ -186,0 +252,4 @@
+		.map_err(|err| err!("PDU after count has no shortstatehash: {err}"))
+}
+
+/// `state_events` are the room's state changes in the range.

@@ -0,0 +11,5 @@
+use super::{SyncContext, scope, scope_update};
+use crate::client::sync::v5::lists::RoomSelection;
+
+/// MSC4548: a room entering the scope for the first time gets all of its
+/// account data.

@@ -0,0 +19,4 @@
+	v5::room::added_state,
+};
+
+/// MSC4543: device lists are only sent once the client has a position.

@@ -0,0 +139,4 @@
+		.await
+}
+
+async fn room_device_list_changes(

@@ -0,0 +65,4 @@
+}
+
+/// MSC4508: rooms in range of the named lists and the named subscriptions,
+/// all of either by default.

@@ -0,0 +66,4 @@
+
+/// MSC4508: rooms in range of the named lists and the named subscriptions,
+/// all of either by default.
+fn scope(

@@ -0,0 +104,16 @@
+	scope
+}
+
+/// A disabled extension forgets its scope, so enabling it again starts over.
+fn scope_update(
+	context: SyncContext<'_>,
+	previous: &ExtensionScope,
+	enabled: bool,
+	scope: HashSet<OwnedRoomId>,
+) -> Option<ExtensionScope> {
+	if !enabled {
+		return previous.enabled.then(ExtensionScope::default);
+	}
+
+	previous.advance(scope, context.since())
+}

@@ -0,0 +17,5 @@
+	room::{BuiltRooms, SentTimeline},
+};
+
+/// A room entering the scope only gets the receipts for its returned timeline
+/// and the user's own, rather than one for every member.

@@ -0,0 +92,7 @@
+		read_receipt
+			.readreceipts_since(room_id, Some(scan_from))
+			.ready_filter(|(read_user, count, receipt)| {
+				(!entering && *count > since)
+					|| (read_user != syncing_user
+						&& sent_timeline
+							.is_some_and(|timeline| receipts_any(receipt, &timeline.event_ids)))

@@ -0,0 +22,5 @@
+
+const DEFAULT_LIMIT: usize = 100;
+
+/// MSC4480 covers every joined room a list or subscription matches, including
+/// rooms outside the lists' ranges.

@@ -0,0 +71,4 @@
+	let found: Vec<_> = joined_rooms
+		.into_iter()
+		.stream()
+		.wide_then(async |room_id| {

@@ -0,0 +164,4 @@
+		push_sticky_event(services, &mut response, syncing_user, room_id, pdu).await;
+	}
+
+	// MSC4480 requires it, and it keeps the next request from scanning again

@@ -0,0 +211,4 @@
+	services: &Services,
+	context: SyncContext<'_>,
+) -> (
+	Vec<(OwnedRoomId, MembershipState, Option<u64>)>,

@@ -0,0 +300,4 @@
+		.map_or(MembershipState::Leave, |content| content.membership)
+}
+
+async fn candidate(

@@ -0,0 +346,4 @@
+	}
+}
+
+/// Invalid `m.direct` data counts as no DMs rather than failing every sync.

@@ -0,0 +385,5 @@
+		.is_some()
+}
+
+/// Stripped state is only recommended to carry `m.room.create`, so a room
+/// without one is treated as untyped rather than hidden from every list.

@@ -0,0 +417,6 @@
+	}
+}
+
+fn is_stripped(membership: &MembershipState) -> bool {
+	matches!(membership, MembershipState::Invite | MembershipState::Knock)
+}

@@ -0,0 +429,7 @@
+	event_type: &StateEventType,
+) -> Option<Raw<AnyStrippedStateEvent>> {
+	let state_cache = &services.rooms.state_cache;
+	let state = match membership {
+		| MembershipState::Knock => state_cache.knock_state(user_id, room_id).await,
+		| _ => state_cache.invite_state(user_id, room_id).await,
+	};

@@ -0,0 +444,5 @@
+	})
+}
+
+/// Rooms the user left are visible even if they never joined, e.g. after
+/// rejecting an invite.

@@ -0,0 +498,10 @@
+	let is_invite = candidate.membership == MembershipState::Invite;
+	let type_filtered = !filters.room_types.is_empty() || !filters.not_room_types.is_empty();
+
+	matches_bool_filter(candidate.is_dm, filters.is_dm)
+		&& matches_bool_filter(candidate.is_encrypted, filters.is_encrypted)
+		&& matches_bool_filter(is_invite, filters.is_invite)
+		&& (!type_filtered
+			|| candidate.room_type.as_ref().is_some_and(|room_type| {
+				matches_room_type(room_type, &filters.room_types, &filters.not_room_types)
+			}))

@@ -0,0 +507,6 @@
+			}))
+}
+
+fn matches_bool_filter(value: bool, filter: Option<bool>) -> bool {
+	filter.is_none_or(|expected| value == expected)
+}

@@ -0,0 +511,11 @@
+	filter.is_none_or(|expected| value == expected)
+}
+
+fn matches_room_type(
+	room_type: &RoomTypeFilter,
+	room_types: &[RoomTypeFilter],
+	not_room_types: &[RoomTypeFilter],
+) -> bool {
+	!not_room_types.contains(room_type)
+		&& (room_types.is_empty() || room_types.contains(room_type))
+}

@@ -0,0 +520,11 @@
+		&& (room_types.is_empty() || room_types.contains(room_type))
+}
+
+fn sort_by_activity(candidates: &mut [Candidate]) {
+	candidates.sort_unstable_by(|left, right| {
+		right
+			.activity
+			.cmp(&left.activity)
+			.then_with(|| left.room_id.cmp(&right.room_id))
+	});
+}

@@ -0,0 +529,4 @@
+	});
+}
+
+#[allow(clippy::single_range_in_vec_init, reason = "these are lists of index ranges")]

@@ -0,0 +531,4 @@
+
+#[allow(clippy::single_range_in_vec_init, reason = "these are lists of index ranges")]
+/// The disjoint index ranges a list's inclusive `[start, end]` ranges cover.
+/// MSC4186: without ranges the list holds every matching room.

@@ -0,0 +22,4 @@
+};
+use crate::{Ruma, client_ip::ClientIp};
+
+const MAX_TIMEOUT: Duration = Duration::from_secs(30);

@@ -0,0 +27,4 @@
+/// A response that takes this long to build is reported at `info`.
+const SLOW_BUILD: Duration = Duration::from_millis(100);
+
+/// MSC4186 allows at most this many lists and room subscriptions; the same

@@ -0,0 +25,4 @@
+const MAX_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// A response that takes this long to build is reported at `info`.
+const SLOW_BUILD: Duration = Duration::from_millis(100);

@@ -0,0 +121,15 @@
+
+		let (mut response, update) = build_response(services, context).await?;
+
+		// a changed list count is news even without room data, and clients
+		// replenish their one-time keys as soon as the counts move, and send
+		// encryption requests between syncs of a connection without rooms
+		let respond = !is_empty(&response)
+			|| update.list_counts.is_some()
+			|| match timeout_at(deadline, wake.woken()).await {
+				| Ok(Some(woken)) => {
+					debug!(conn_id = ?request.conn_id, ?woken, "sliding sync woken");
+					!has_rooms(&request) || woken.contains(&WakeKind::Keys)
+				},
+				| Ok(None) | Err(_) => true,
+			};

@@ -0,0 +172,6 @@
+	.collect()
+}
+
+fn has_rooms(request: &v5::Request) -> bool {
+	!request.lists.is_empty() || !request.room_subscriptions.is_empty()
+}

@@ -0,0 +260,4 @@
+
+/// `phases` are the elapsed times after selecting rooms, building them and
+/// building the extensions.
+fn log_build(context: SyncContext<'_>, rooms: usize, phases: [Duration; 3]) {

@@ -0,0 +170,4 @@
+		.await
+}
+
+/// `None` if the room must be sent in full.

@@ -0,0 +172,4 @@
+
+/// `None` if the room must be sent in full.
+fn since(previous: Option<&RoomState>, selected: &SelectedRoom) -> Option<u64> {
+	let previous = previous?;

@@ -0,0 +182,4 @@
+	(comparable && !selected.config.expands(&previous.config)).then_some(previous.sent_at)
+}
+
+fn room_update(

@@ -0,0 +375,4 @@
+
+	if join_pdu
+		.get_content::<RoomMemberEventContent>()
+		.is_ok_and(|content| content.membership != MembershipState::Join)

@@ -0,0 +396,9 @@
+	build_timeline_room(services, context, room_id, config, since, view).await
+}
+
+fn leave_only(since: Option<u64>, leave_pdu: PduEvent) -> v5::response::Room {
+	assign!(v5::response::Room::new(), {
+		initial: Some(since.is_none()),
+		required_state: vec![leave_pdu.into_format()],
+	})
+}

@@ -0,0 +531,4 @@
+		required_state.push(leave);
+	}
+
+	// clients drop their pagination token without one

@@ -163,3 +163,4 @@
 	type Err = Error;
 
-	fn from_str(token: &str) -> Result<Self, Self::Err> { Ok(Self::from_signed(token.parse()?)) }
+	/// Also accepts a sliding sync `pos`, which MSC4186 lets clients paginate
+	/// from; its count comes before the `_`.

@@ -0,0 +10,4 @@
+use super::RoomConfig;
+
+/// Responses a client may still acknowledge after it was sent a newer one.
+const MAX_PENDING: usize = 8;

@@ -0,0 +73,5 @@
+	pub typing: Option<ExtensionScope>,
+}
+
+/// The sequence number keeps a retried request from committing a response the
+/// client never received, even when the stream count has not moved.

@@ -0,0 +154,4 @@
+		}
+	}
+
+	/// Returns false unless `pos` is current or still pending.

@@ -0,0 +6,5 @@
+const MAX_TIMELINE_LIMIT: usize = 100;
+
+const WILDCARD: &str = "*";
+const LAZY: &str = "$LAZY";
+const ME: &str = "$ME";

@@ -0,0 +65,8 @@
+			let event_type = (event_type.to_string() != WILDCARD).then(|| event_type.clone());
+			let state_key = match state_key.as_str() {
+				| WILDCARD => StateKeyPattern::Any,
+				| ME => StateKeyPattern::Me,
+				| LAZY if event_type == Some(StateEventType::RoomMember) => {
+					this.lazy_members = true;
+					continue;
+				},