From b15fa23b8aed8ca05723614fab09c057d56f3af6 Mon Sep 17 00:00:00 2001
From: hl-valdemar <valdemar.lorenzen@icloud.com>
Date: Mon, 12 Oct 2026 01:22:42 +0200
Subject: [PATCH] fix: cap feed requests at 60 videos total

---
 README.md      |   8 +-
 src/main.rs    | 702 +++++++++++++++++++++++++------------
 src/youtube.rs | 931 +++++++++++++++++++++++++++++++++++++++++--------
 3 files changed, 1255 insertions(+), 386 deletions(-)

diff --git a/README.md b/README.md
index e07294f..31c15a1 100644
--- a/README.md
+++ b/README.md
@@ -286,13 +286,13 @@ Using the same binding for overview and description preserves the default cycle.
 
 ## Loading and previews
 
-Search loads 60 results per page; Feed and category views request 60 uploads per channel per page. Feed requests divide channels into disjoint batches across at most four concurrent yt-dlp processes. Individual channel views use one batch. Search uses one extractor to preserve relevance without repeating the same continuation traversal in parallel.
+Search loads up to 60 results per page. Feed and category views share a **60-upload total request budget per load**, distributed fairly across active channels—not 60 per channel. Each channel retains its own offset; exhausted channels stop receiving requests, and feeds with more than 60 channels rotate through them across loads. Matching ranges are batched across at most four concurrent yt-dlp processes, with further batches queued. Individual channel views can use the full 60-row budget.
 
-In normal mode, the next page starts fetching when 20 loaded rows remain, preserving selection and existing rows. Only one page request runs at a time; insert mode and open popups pause automatic prefetch. A feed page is accepted only after every batch succeeds. Switching views cancels all pending batches; returning resumes the same unfinished range. Deep channel archives can get slower because yt-dlp offsets traverse earlier pages again.
+In normal mode, forward video navigation authorizes prefetch when 20 loaded rows remain. Each successful page clears that intent, so short, duplicate-only, or unavailable batches do not immediately chain additional loads at startup. Only one page request runs at a time; insert mode and open popups pause automatic prefetch. A feed page is accepted only after every batch succeeds. Switching views cancels running and queued batches; returning resumes the same unaccepted per-channel ranges. Deep channel archives can get slower because yt-dlp offsets traverse earlier pages again.
 
-Malformed individual entries—including invalid video IDs, missing required fields, and wrong field types—are discarded without losing valid videos from the same page. Skipped entries still count toward pagination, so a full page of bad or unavailable entries does not hide later results. Invalid JSON, malformed playlist-level metadata, and extractor failures still fail the page.
+Malformed individual entries—including invalid video IDs, missing required fields, and wrong field types—are discarded without losing valid videos from the same page. Raw entries, including skipped and duplicate rows, consume the request budget and determine each channel's exhaustion; a full unavailable batch therefore does not hide later results. Invalid JSON, malformed playlist-level metadata, missing/extra playlists, oversized responses, and extractor failures still fail the page without advancing channel offsets.
 
-Feed views merge newest-first using available upload dates. Older uploads wait while newer channel pages catch up; undated uploads appear when the feed is exhausted. Publication labels use `YYYY-MM-DD`; `~` marks an estimated UTC date, and `Unknown` means unavailable metadata.
+Feed views sort all loaded videos newest-first using available upload dates, with undated videos last. The budget limits what has been inspected: later loads may discover newer videos and insert them above older rows, while selection and pending description requests stay attached to the same video ID. Publication labels use `YYYY-MM-DD`; `~` marks an estimated UTC date, and `Unknown` means unavailable metadata.
 
 Pane titles show animated spinners while content loads. Errors retain loaded rows and stop automatic retries; `r` refreshes the current view.
 
diff --git a/src/main.rs b/src/main.rs
index e121203..a213c6e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -79,16 +79,16 @@
 //! r reloads config and refreshes the current view.
 //! Feed includes saved `[channels]` entries, even untagged, plus direct tag entries, without duplicates.
 //! Untagging is not unsubscribing: remove mappings and tag references from the file to unsubscribe.
-//! Search pages contain 60 results; Feed/tag pages request 60 uploads per channel's /videos tab.
-//! Search uses one extractor; feeds batch disjoint channels across up to four concurrent extractors.
+//! Search pages contain 60 results; Feed/tag pages share a total request budget of 60 uploads.
+//! Search uses one extractor; feeds batch matching channel ranges across up to four concurrent extractors.
 //! Invalid individual video entries are discarded; raw entry counts still determine pagination.
 //! Invalid JSON, playlist-level metadata, and extractor failures remain page errors.
-//! In unobstructed normal mode, 20 rows before the loaded end fetches the next page without replacing rows/selection.
+//! Forward video navigation authorizes prefetch within 20 rows of the loaded end in unobstructed normal mode.
+//! Each accepted page clears that intent, so short or invalid batches never auto-chain on startup.
 //! Loading result/preview panes animate a spinner after their title, including additional pages.
 //! Info spinners cover image download/decode/resize and description fetching; errors stop them.
-//! Feed rows use approximate upload dates; older rows wait until newer channel pages catch up.
-//! Undated feed rows appear at exhaustion. Cached views retain their page position across switches.
-//! Switching views cancels in-flight extraction; returning resumes the same pending range.
+//! Feed rows, including undated rows, are globally newest-first among loaded uploads; selection follows video ID.
+//! Switching views cancels in-flight extraction; returning retains the unaccepted request and per-channel offsets.
 //! Errors keep loaded rows and stop automatic retries; r reloads config and restarts the current view.
 //! Deep pages may slow down because yt-dlp offsets re-traverse earlier continuation pages.
 //! Video tables show Published as YYYY-MM-DD; ~ marks estimated UTC dates, Unknown missing metadata.
@@ -309,7 +309,9 @@ struct View {
     loaded: bool,
     next_start: usize,
     has_more: bool,
-    pending: Vec<Video>,
+    feed_cursor: youtube::FeedCursor,
+    feed_requests: Vec<youtube::FeedRequest>,
+    prefetch_requested: bool,
     page_error: Option<String>,
     watch_filter: WatchFilter,
 }
@@ -326,7 +328,9 @@ impl View {
             loaded: false,
             next_start: 1,
             has_more: false,
-            pending: Vec::new(),
+            feed_cursor: youtube::FeedCursor::default(),
+            feed_requests: Vec::new(),
+            prefetch_requested: false,
             page_error: None,
             watch_filter: WatchFilter::All,
         }
@@ -338,7 +342,9 @@ impl View {
         self.loaded = false;
         self.next_start = 1;
         self.has_more = false;
-        self.pending.clear();
+        self.feed_cursor = youtube::FeedCursor::default();
+        self.feed_requests.clear();
+        self.prefetch_requested = false;
         self.page_error = None;
     }
 
@@ -347,45 +353,51 @@ impl View {
             .next_start
             .checked_add(PAGE_SIZE)
             .ok_or("Page offset exceeds the supported range")?;
-        let mut videos = if feed {
-            self.pending.append(&mut page.videos);
-            std::mem::take(&mut self.pending)
-        } else {
-            page.videos
-        };
         if feed {
-            videos.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+            self.feed_cursor.accept(&page.feed_progress)?;
         }
-        if !videos.is_empty() {
-            // Borrow IDs before moving rows, retaining the existing row data.
-            let keep: Vec<_> = {
-                let mut ids = HashSet::with_capacity(self.videos.len() + videos.len());
-                ids.extend(self.videos.iter().map(|video| video.id.as_str()));
-                videos
-                    .iter()
-                    .map(|video| ids.insert(video.id.as_str()))
-                    .collect()
+        if !page.videos.is_empty() {
+            let selected = if feed {
+                self.selection.selected().and_then(|index| {
+                    self.videos.get(index).map(|video| {
+                        <[u8; 11]>::try_from(video.id.as_bytes()).expect("validated video ID")
+                    })
+                })
+            } else {
+                None
             };
-            let mut keep = keep.into_iter();
-            videos.retain(|_| keep.next().expect("one deduplication flag per video"));
-        }
-        let ready = if feed && page.has_more {
-            page.cutoff.map_or(0, |cutoff| {
-                videos.partition_point(|video| video.timestamp.is_some_and(|date| date >= cutoff))
-            })
-        } else {
-            videos.len()
-        };
-        self.videos.extend(videos.drain(..ready));
-        if feed {
-            self.pending = videos;
+            let mut ids = HashSet::with_capacity(self.videos.len() + page.videos.len());
+            ids.extend(self.videos.iter().map(|video| {
+                <[u8; 11]>::try_from(video.id.as_bytes()).expect("validated video ID")
+            }));
+            page.videos.retain(|video| {
+                ids.insert(<[u8; 11]>::try_from(video.id.as_bytes()).expect("validated video ID"))
+            });
+            self.videos.append(&mut page.videos);
+            if feed {
+                // ponytail: sort loaded metadata only; a globally newest archive merge needs
+                // per-channel frontier lookahead rather than fair quotas.
+                self.videos.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+                if let Some(id) = selected {
+                    self.selection.select(
+                        self.videos
+                            .iter()
+                            .position(|video| video.id.as_bytes() == id.as_slice()),
+                    );
+                }
+            }
         }
         if self.selection.selected().is_none() && !self.videos.is_empty() {
             self.selection.select(Some(0));
         }
         self.loaded = true;
         self.next_start = next_start;
-        self.has_more = page.has_more;
+        self.has_more = if feed {
+            self.feed_cursor.has_more()
+        } else {
+            page.has_more
+        };
+        self.prefetch_requested = false;
         self.page_error = None;
         Ok(())
     }
@@ -393,6 +405,7 @@ impl View {
     fn needs_page(&self) -> bool {
         self.loaded
             && self.has_more
+            && self.prefetch_requested
             && self.page_error.is_none()
             && (self.videos.is_empty()
                 || self
@@ -890,7 +903,7 @@ struct App {
     preview: Option<PreviewMode>,
     help_popup: Option<HelpPopup>,
     thumbnail: thumbnail::Thumbnail,
-    description_job: Option<(usize, Job)>,
+    description_job: Option<(String, Job)>,
     description_error: Option<String>,
     // ponytail: 64-entry linear lookup; use a keyed LRU if the buffer grows.
     descriptions: std::collections::VecDeque<(String, String)>,
@@ -924,9 +937,13 @@ impl App {
     fn with_state(
         options: Options,
         config_path: PathBuf,
-        config: config::Config,
+        mut config: config::Config,
         video_state: video_state::State,
     ) -> Self {
+        // Cursor channel indices must remain stable when a config only reorders memberships.
+        for channels in config.categories.values_mut() {
+            channels.sort_unstable();
+        }
         let query = options.query.clone().unwrap_or_default();
         let feed_channels = config.subscriptions();
         let key_hints = KeyHints::new(&config.keys);
@@ -1419,7 +1436,10 @@ impl App {
                 view.name,
                 view.videos.len()
             );
-            Job::feed(channels, view.next_start)
+            view.feed_cursor.plan(channels.len()).and_then(|requests| {
+                view.feed_requests = requests;
+                Job::feed(channels, &view.feed_requests)
+            })
         };
         match result {
             Ok(job) => self.job = Some(job),
@@ -1467,11 +1487,7 @@ impl App {
             );
         }
         let continuation = if view.has_more {
-            if view.videos.is_empty() && !view.pending.is_empty() {
-                "newer pages pending"
-            } else {
-                "more available"
-            }
+            "more available"
         } else {
             "end"
         };
@@ -1489,7 +1505,7 @@ impl App {
             if self.views[self.view_index].source == ViewSource::Search {
                 youtube::search_results(&output)
             } else {
-                youtube::feed_results(&output)
+                youtube::feed_results(&output, &self.views[self.view_index].feed_requests)
             }
         });
         let feed = self.views[self.view_index].source != ViewSource::Search;
@@ -1716,7 +1732,10 @@ impl App {
         self.close_preview();
     }
 
-    fn apply_config(&mut self, config: config::Config) {
+    fn apply_config(&mut self, mut config: config::Config) {
+        for channels in config.categories.values_mut() {
+            channels.sort_unstable();
+        }
         if config.keys != self.config.keys {
             self.key_hints = KeyHints::new(&config.keys);
             if let Some(help) = &mut self.help_popup {
@@ -1987,7 +2006,9 @@ impl App {
             view.loaded = source.loaded;
             view.next_start = source.next_start;
             view.has_more = source.has_more;
-            view.pending = source.pending.clone();
+            view.feed_cursor = source.feed_cursor.clone();
+            view.feed_requests = source.feed_requests.clone();
+            view.prefetch_requested = source.prefetch_requested;
             view.page_error = source.page_error.clone();
             Some(view)
         } else {
@@ -2385,7 +2406,7 @@ impl App {
             return;
         }
         match Job::description(&video.id) {
-            Ok(job) => self.description_job = Some((index, job)),
+            Ok(job) => self.description_job = Some((video.id.clone(), job)),
             Err(error) => self.description_error = Some(error.to_string()),
         }
     }
@@ -2434,6 +2455,14 @@ impl App {
         }
     }
 
+    fn finish_description(&mut self, id: String, result: Result<String, String>) {
+        match result.and_then(|output| youtube::full_description(&output, &id)) {
+            Ok(description) => self.remember_description(id, description),
+            Err(error) => self.description_error = Some(error),
+        }
+        self.description_viewport = None;
+    }
+
     fn update(&mut self) {
         if let Some(result) = self.job.as_mut().and_then(Job::poll) {
             self.finish_page(result);
@@ -2461,17 +2490,11 @@ impl App {
             .as_mut()
             .and_then(|(_, job)| job.poll())
         {
-            let (index, _) = self
+            let (id, _) = self
                 .description_job
                 .take()
                 .expect("completed description job exists");
-            if let Some(video) = self.views[self.view_index].videos.get(index) {
-                match result.and_then(|output| youtube::full_description(&output, &video.id)) {
-                    Ok(description) => self.remember_description(video.id.clone(), description),
-                    Err(error) => self.description_error = Some(error),
-                }
-            }
-            self.description_viewport = None;
+            self.finish_description(id, result);
         }
         if let Some(result) = self.player_launch.as_mut().and_then(PlayerLaunch::poll) {
             self.player_launch = None;
@@ -2736,12 +2759,18 @@ impl App {
                     self.browse_category_collection(CollectionKind::Saved)
                 }
                 Some(Action::VideoPlay) => self.play(),
-                Some(Action::VideoNext) => self.views[self.view_index].selection.select_next(),
+                Some(Action::VideoNext) => {
+                    self.views[self.view_index].prefetch_requested = true;
+                    self.views[self.view_index].selection.select_next();
+                }
                 Some(Action::VideoPrevious) => {
                     self.views[self.view_index].selection.select_previous()
                 }
                 Some(Action::VideoFirst) => self.views[self.view_index].selection.select_first(),
-                Some(Action::VideoLast) => self.views[self.view_index].selection.select_last(),
+                Some(Action::VideoLast) => {
+                    self.views[self.view_index].prefetch_requested = true;
+                    self.views[self.view_index].selection.select_last();
+                }
                 _ => {}
             }
         }
@@ -3570,6 +3599,46 @@ mod tests {
         )
     }
 
+    // Unrelated UI fixtures still parse real feed envelopes with a shared-budget plan.
+    fn feed_fixture(output: &str) -> Result<Page, String> {
+        let channels = serde_json::Deserializer::from_str(output)
+            .into_iter::<serde_json::Value>()
+            .count();
+        let requests = youtube::FeedCursor::default().plan(channels).unwrap();
+        youtube::feed_results(output, &requests)
+    }
+
+    fn finish_feed_fixture(app: &mut App, output: &str, full: bool) {
+        let view = &mut app.views[app.view_index];
+        let channels = view
+            .source
+            .channels(&app.config, &app.feed_channels, &view.group_channels)
+            .len();
+        view.feed_requests = view.feed_cursor.plan(channels).unwrap();
+        let mut envelopes: Vec<_> = serde_json::Deserializer::from_str(output)
+            .into_iter::<serde_json::Value>()
+            .map(Result::unwrap)
+            .collect();
+        assert!(envelopes.len() <= view.feed_requests.len());
+        envelopes.resize_with(
+            view.feed_requests.len(),
+            || serde_json::json!({"entries":[]}),
+        );
+        if full {
+            for (envelope, request) in envelopes.iter_mut().zip(&view.feed_requests) {
+                let entries = envelope["entries"].as_array_mut().unwrap();
+                assert!(entries.len() <= request.count);
+                entries.resize(request.count, serde_json::Value::Null);
+            }
+        }
+        let output = envelopes
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join("\n");
+        app.finish_page(Ok(output));
+    }
+
     fn choose_combined(app: &mut App, key: KeyEvent) {
         app.key(key);
         while app
@@ -3723,10 +3792,12 @@ mod tests {
                 "https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA",
             ]
         );
-        app.finish_page(Ok(
+        finish_feed_fixture(
+            &mut app,
             r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Shared","timestamp":300},{"id":"l-GaaivVJCE","title":"Old","timestamp":100}]}
-{"entries":[{"id":"jNQXAC9IVRw","title":"Shared again","timestamp":300},{"id":"rQ_J9WH6CGk","title":"Middle","timestamp":200}]}"#.into()
-        ));
+{"entries":[{"id":"jNQXAC9IVRw","title":"Shared again","timestamp":300},{"id":"rQ_J9WH6CGk","title":"Middle","timestamp":200}]}"#,
+            true,
+        );
         assert_eq!(
             app.views[app.view_index]
                 .videos
@@ -3736,7 +3807,11 @@ mod tests {
             ["jNQXAC9IVRw", "rQ_J9WH6CGk", "l-GaaivVJCE"]
         );
         rename_press(&mut app, KeyCode::Down);
-        app.finish_page(Ok(r#"{"entries":[{"id":"l-GaaivVJCE","title":"Duplicate","timestamp":100},{"id":"SLV9AJxnb1U","title":"Last","timestamp":50}]}"#.into()));
+        finish_feed_fixture(
+            &mut app,
+            r#"{"entries":[{"id":"l-GaaivVJCE","title":"Duplicate","timestamp":100},{"id":"SLV9AJxnb1U","title":"Last","timestamp":50}]}"#,
+            false,
+        );
         let next_start = app.views[app.view_index].next_start;
         let names = vec!["Alpha".into(), "Gamma".into()];
         let mut replacement = View::new(group_name(&names), ViewSource::CategoryGroup(names));
@@ -3777,9 +3852,11 @@ mod tests {
     #[test]
     fn combined_cache_resets_only_for_changed_resolved_union_and_drops_deleted_members() {
         let mut app = group_app("config", "");
-        app.finish_page(Ok(
-            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#.into(),
-        ));
+        finish_feed_fixture(
+            &mut app,
+            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
+            false,
+        );
         let group = app.views[app.view_index].source.clone();
         let original = std::fs::read_to_string(&app.config_path).unwrap();
         std::fs::write(
@@ -3825,9 +3902,11 @@ mod tests {
     #[test]
     fn checked_category_rename_preserves_canonical_group_pin_selection_and_history() {
         let mut app = group_app("rename", "");
-        app.finish_page(Ok(
-            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#.into(),
-        ));
+        finish_feed_fixture(
+            &mut app,
+            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
+            false,
+        );
         let old = app.views[app.view_index].source.clone();
         app.view_history.push(old.clone());
         app.forward_history.push(old);
@@ -3869,16 +3948,20 @@ mod tests {
     #[test]
     fn saving_combined_view_copies_snapshot_and_preserves_cached_state_without_pinning() {
         let mut app = group_app("save", "");
-        app.finish_page(Ok(r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","timestamp":200},{"id":"l-GaaivVJCE","title":"Second","timestamp":100}]}"#.into()));
+        finish_feed_fixture(
+            &mut app,
+            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","timestamp":200},{"id":"l-GaaivVJCE","title":"Second","timestamp":100}]}"#,
+            true,
+        );
         rename_press(&mut app, KeyCode::Down);
         let source = app.views[app.view_index].source.clone();
         let channels = app.views[app.view_index].group_channels.clone();
-        let pending = youtube::search_results(
-            r#"{"entries":[{"id":"rQ_J9WH6CGk","title":"Pending","timestamp":50}]}"#,
-        )
-        .unwrap()
-        .videos;
-        app.views[app.view_index].pending = pending;
+        let next_requests = app.views[app.view_index]
+            .feed_cursor
+            .plan(channels.len())
+            .unwrap();
+        app.views[app.view_index].feed_requests = next_requests.clone();
+        app.views[app.view_index].prefetch_requested = true;
         app.views[app.view_index].has_more = true;
         app.views[app.view_index].page_error = Some("keep failure".into());
         let original = std::fs::read_to_string(&app.config_path).unwrap();
@@ -3921,7 +4004,12 @@ mod tests {
         assert_eq!(view.selection.selected(), Some(1));
         assert_eq!(view.videos.len(), 2);
         assert_eq!(view.next_start, PAGE_SIZE + 1);
-        assert_eq!(view.pending[0].id, "rQ_J9WH6CGk");
+        assert_eq!(view.feed_requests, next_requests);
+        assert_eq!(
+            view.feed_cursor.clone().plan(channels.len()).unwrap(),
+            next_requests
+        );
+        assert!(view.prefetch_requested);
         assert!(view.has_more);
         assert_eq!(view.page_error.as_deref(), Some("keep failure"));
         assert!(app.job.is_none());
@@ -4147,7 +4235,8 @@ mod tests {
         app.view_index = 2;
         let view = &mut app.views[2];
         view.videos = videos.clone();
-        view.pending = vec![videos[0].clone()];
+        view.feed_requests = view.feed_cursor.plan(1).unwrap();
+        view.prefetch_requested = true;
         view.selection.select(Some(1));
         view.loaded = true;
         view.next_start = 41;
@@ -4162,7 +4251,8 @@ mod tests {
         assert_eq!(view.name, "Zeta");
         assert_eq!(view.selection.selected(), Some(1));
         assert_eq!(view.videos.len(), 2);
-        assert_eq!(view.pending.len(), 1);
+        assert_eq!(view.feed_requests.len(), 1);
+        assert!(view.prefetch_requested);
         assert_eq!(view.next_start, 41);
         assert!(view.loaded && view.has_more);
         assert_eq!(view.page_error.as_deref(), Some("keep page failure"));
@@ -5851,7 +5941,7 @@ mod tests {
         let videos = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#;
         for (label, identity) in app.config.saved_channels() {
             let mut view = View::new(label, ViewSource::Channel(identity));
-            view.videos = youtube::feed_results(videos).unwrap().videos;
+            view.videos = feed_fixture(videos).unwrap().videos;
             view.loaded = true;
             view.next_start = 41;
             view.selection.select(Some(1));
@@ -6131,6 +6221,7 @@ tags.cancel = "z"
         let selected = app.views[app.view_index].selection.selected();
         let press = |app: &mut App, code| app.key(KeyEvent::new(code, KeyModifiers::NONE));
         app.views[app.view_index].has_more = true;
+        app.views[app.view_index].prefetch_requested = true;
         assert!(app.can_prefetch());
         press(&mut app, KeyCode::Char('?'));
         assert!(!app.can_prefetch());
@@ -6682,10 +6773,9 @@ tags.cancel = "z"
         loaded_channel_views(&mut app);
         browse_channel(&mut app, "Alpha");
         app.views[app.view_index].has_more = true;
-        app.views[app.view_index].pending =
-            youtube::feed_results(r#"{"entries":[{"id":"l-GaaivVJCE","title":"Pending"}]}"#)
-                .unwrap()
-                .videos;
+        app.views[app.view_index].feed_requests =
+            app.views[app.view_index].feed_cursor.plan(1).unwrap();
+        app.views[app.view_index].prefetch_requested = true;
         app.views[app.view_index].page_error = Some("kept".into());
         app.apply_config(config::Config {
             keys: Default::default(),
@@ -6708,7 +6798,8 @@ tags.cancel = "z"
         assert!(view.loaded && view.has_more);
         assert_eq!(view.next_start, 41);
         assert_eq!(view.selection.selected(), Some(1));
-        assert_eq!(view.pending.len(), 1);
+        assert_eq!(view.feed_requests.len(), 1);
+        assert!(view.prefetch_requested);
         assert_eq!(view.page_error.as_deref(), Some("kept"));
         let beta = app
             .views
@@ -7453,136 +7544,283 @@ tags.cancel = "z"
     }
 
     #[test]
-    fn feed_pages_hold_short_channel_tails_until_newer_long_histories_finish() {
-        let mut view = View::new("Feed".into(), ViewSource::Feed);
-        let second_base = 101 + PAGE_SIZE as i64;
-        let first_base = second_base + PAGE_SIZE as i64;
-        let long_page = |base: i64| {
-            serde_json::json!({
-                "entries": (0..PAGE_SIZE).map(|index| serde_json::json!({
-                    "id": format!("long{:07}", base + index as i64),
-                    "title": "Long channel",
-                    "timestamp": base + index as i64,
-                })).collect::<Vec<_>>()
-            })
-            .to_string()
-        };
-        let short = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Short old tail","timestamp":100},{"id":"rQ_J9WH6CGk","title":"Unknown date"}]}"#;
-        let first = youtube::feed_results(&format!("{}\n{short}", long_page(first_base))).unwrap();
-        view.accept_page(first, true).unwrap();
-        assert_eq!(view.videos.len(), PAGE_SIZE);
-        assert_eq!(view.videos.last().unwrap().timestamp, Some(first_base));
-        assert_eq!(view.pending.len(), 2);
-        view.selection.select(Some(PAGE_SIZE - 1));
-        let second =
-            youtube::feed_results(&format!("{}\n{short}", long_page(second_base))).unwrap();
-        view.accept_page(second, true).unwrap();
-        assert_eq!(view.videos.len(), PAGE_SIZE * 2);
-        assert_eq!(view.videos.last().unwrap().timestamp, Some(second_base));
-        assert_eq!(view.pending.len(), 2);
-        assert_eq!(view.selection.selected(), Some(PAGE_SIZE - 1));
-        view.accept_page(
-            youtube::feed_results(&format!(
-                r#"{{"entries":[{{"id":"l-GaaivVJCE","title":"Long last row","timestamp":{}}}]}} {{"entries":[]}}"#,
-                second_base - 1,
-            ))
-            .unwrap(),
-            true,
-        ).unwrap();
+    fn many_channel_feed_consumes_only_sixty_requested_rows() {
+        let mut app = app(&["tubular"]);
+        app.view_index = 1;
+        app.feed_channels = (0..75)
+            .map(|index| format!("https://www.youtube.com/@creator{index}"))
+            .collect();
+        let view = &mut app.views[1];
+        view.feed_requests = view.feed_cursor.plan(app.feed_channels.len()).unwrap();
         assert_eq!(
-            view.videos[PAGE_SIZE * 2..]
+            view.feed_requests
+                .iter()
+                .map(|request| request.count)
+                .sum::<usize>(),
+            PAGE_SIZE
+        );
+        assert_eq!(view.feed_requests.len(), PAGE_SIZE);
+        let output = view
+            .feed_requests
+            .iter()
+            .map(|request| {
+                serde_json::json!({"entries":[{
+                    "id":format!("channel{:04}", request.channel),
+                    "title":"Upload",
+                    "timestamp":request.channel,
+                }]})
+                .to_string()
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        app.finish_page(Ok(output));
+        assert_eq!(app.views[1].videos.len(), PAGE_SIZE);
+        assert!(app.views[1].has_more);
+        assert!(!app.can_prefetch());
+        let next = app.views[1]
+            .feed_cursor
+            .plan(app.feed_channels.len())
+            .unwrap();
+        assert!(
+            next.iter()
+                .any(|request| request.channel >= PAGE_SIZE && request.start == 1)
+        );
+        assert_eq!(
+            next.iter().map(|request| request.count).sum::<usize>(),
+            PAGE_SIZE
+        );
+        app.views[1].feed_requests = next.clone();
+        app.views[1].prefetch_requested = true;
+        app.finish_page(Ok(r#"{"entries":[]}"#.into()));
+        assert!(app.views[1].page_error.is_some());
+        assert_eq!(app.views[1].videos.len(), PAGE_SIZE);
+        assert_eq!(app.views[1].next_start, PAGE_SIZE + 1);
+        assert_eq!(
+            app.views[1]
+                .feed_cursor
+                .plan(app.feed_channels.len())
+                .unwrap(),
+            next
+        );
+        assert!(app.views[1].prefetch_requested);
+    }
+
+    #[test]
+    fn loaded_feed_rows_are_visible_sorted_and_keep_selection_and_description_identity() {
+        let mut app = app(&["tubular"]);
+        app.view_index = 1;
+        app.feed_channels = vec![
+            "https://www.youtube.com/@one".into(),
+            "https://www.youtube.com/@two".into(),
+        ];
+        // Keep both channels active despite a short visible page.
+        finish_feed_fixture(
+            &mut app,
+            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Old","timestamp":100},{"id":"rQ_J9WH6CGk","title":"Undated"}]}
+{"entries":[{"id":"l-GaaivVJCE","title":"Middle","timestamp":200}]}"#,
+            true,
+        );
+        assert_eq!(
+            app.views[1]
+                .videos
                 .iter()
                 .map(|video| video.id.as_str())
                 .collect::<Vec<_>>(),
             ["l-GaaivVJCE", "jNQXAC9IVRw", "rQ_J9WH6CGk"]
         );
-        assert!(view.pending.is_empty());
-        assert!(!view.has_more);
-        assert!(!view.needs_page());
-    }
-
-    #[test]
-    fn unavailable_full_channel_pages_do_not_release_other_channels_ahead_of_newer_uploads() {
-        let mut view = View::new("Feed".into(), ViewSource::Feed);
-        let dated = |base: i64| {
-            serde_json::json!({
-                "entries": (0..PAGE_SIZE).map(|index| serde_json::json!({
-                    "id": format!("dated{:06}", base + index as i64),
-                    "title": "Dated upload",
-                    "timestamp": base + index as i64,
-                })).collect::<Vec<_>>()
-            })
-        };
-        let unavailable = serde_json::json!({
-            "entries": vec![serde_json::Value::Null; PAGE_SIZE]
-        });
-        let page = youtube::feed_results(&format!("{}\n{unavailable}", dated(100))).unwrap();
-        view.accept_page(page, true).unwrap();
-        assert!(view.videos.is_empty());
-        assert_eq!(view.selection.selected(), None);
-        assert!(view.needs_page());
-        let page = youtube::feed_results(&format!("{{\"entries\":[]}}\n{}", dated(200))).unwrap();
-        view.accept_page(page, true).unwrap();
-        assert_eq!(
-            view.videos.first().unwrap().timestamp,
-            Some(200 + PAGE_SIZE as i64 - 1)
+        app.views[1].selection.select(Some(1));
+        let description_id = app.views[1].videos[1].id.clone();
+        app.preview = Some(PreviewMode::Info);
+        app.remember_description("l-GaaivVJCE".into(), "Keep cached preview".into());
+        finish_feed_fixture(
+            &mut app,
+            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Duplicate","timestamp":100},{"id":"SLV9AJxnb1U","title":"Newer","timestamp":300}]}
+{"entries":[]}"#,
+            false,
         );
-        assert_eq!(view.videos.last().unwrap().timestamp, Some(200));
-        view.accept_page(youtube::feed_results(r#"{"entries":[]}"#).unwrap(), true)
-            .unwrap();
         assert_eq!(
-            view.videos[PAGE_SIZE].timestamp,
-            Some(100 + PAGE_SIZE as i64 - 1)
+            app.views[1]
+                .videos
+                .iter()
+                .map(|video| video.id.as_str())
+                .collect::<Vec<_>>(),
+            ["SLV9AJxnb1U", "l-GaaivVJCE", "jNQXAC9IVRw", "rQ_J9WH6CGk"]
         );
-        assert_eq!(view.videos.last().unwrap().timestamp, Some(100));
-        assert!(!view.has_more);
-    }
-
-    #[test]
-    fn undated_full_feed_pages_stay_pending_and_do_not_look_exhausted() {
-        let mut app = app(&["tubular", "rust"]);
-        app.view_index = 1;
-        app.feed_channels
-            .push("https://www.youtube.com/@jawed".into());
-        app.config
-            .channels
-            .insert("@jawed".into(), app.feed_channels[0].clone());
-        let entries: Vec<_> = (0..PAGE_SIZE)
-            .map(|index| {
-                serde_json::json!({
-                    "id": format!("unknown{index:04}"),
-                    "title": "Undated",
-                })
-            })
-            .collect();
-        app.finish_page(Ok(serde_json::json!({"entries": entries}).to_string()));
-        assert!(app.views[1].videos.is_empty());
-        assert_eq!(app.views[1].pending.len(), PAGE_SIZE);
-        assert_eq!(app.views[1].next_start, PAGE_SIZE + 1);
-        assert!(app.views[1].loaded);
-        assert!(app.can_prefetch());
-        app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
-        assert_eq!(app.views[1].selection.selected(), None);
-        assert!(app.job.is_none());
-        app.finish_page(Err("Continuation failed".into()));
-        assert_eq!(app.views[1].pending.len(), PAGE_SIZE);
-        assert_eq!(app.views[1].next_start, PAGE_SIZE + 1);
-        assert!(!app.can_prefetch());
-        app.finish_page(Ok(r#"{"entries":[]}"#.into()));
-        assert_eq!(app.views[1].videos.len(), PAGE_SIZE);
-        assert!(app.views[1].pending.is_empty());
-        assert_eq!(app.views[1].selection.selected(), Some(0));
-        assert!(!app.can_prefetch());
-        app.views[1].next_start = 81;
-        app.views[1].has_more = true;
-        app.views[1].page_error = Some("Refresh resets this".into());
-        app.key(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE));
-        assert_eq!(app.views[1].next_start, 1);
-        assert!(app.views[1].videos.is_empty());
-        assert!(app.views[1].pending.is_empty());
+        assert_eq!(app.views[1].selection.selected(), Some(2));
+        assert_eq!(app.views[1].videos[2].title, "Old");
+        app.finish_description(
+            description_id,
+            Ok(r#"{"id":"jNQXAC9IVRw","description":"Selected upload description"}"#.into()),
+        );
+        assert_eq!(
+            cached_description(&app.descriptions, "jNQXAC9IVRw"),
+            Some("Selected upload description")
+        );
+        assert_eq!(
+            cached_description(&app.descriptions, "l-GaaivVJCE"),
+            Some("Keep cached preview")
+        );
+        assert_eq!(cached_description(&app.descriptions, "SLV9AJxnb1U"), None);
+        assert_eq!(app.preview, Some(PreviewMode::Info));
         assert!(!app.views[1].has_more);
-        assert!(app.views[1].page_error.is_none());
-        assert!(app.job.is_none());
+    }
+
+    #[test]
+    fn short_undated_or_invalid_feed_pages_require_new_forward_navigation() {
+        for visible in [0, 1, 19] {
+            let mut app = app(&["tubular"]);
+            app.view_index = 1;
+            app.feed_channels
+                .push("https://www.youtube.com/@jawed".into());
+            let mut entries: Vec<_> = (0..visible)
+                .map(|index| {
+                    serde_json::json!({
+                        "id":format!("unknown{index:04}"), "title":"Undated",
+                    })
+                })
+                .collect();
+            entries.resize(PAGE_SIZE - 1, serde_json::Value::Null);
+            entries.push(serde_json::json!({"id":"bad", "title":"Invalid ID"}));
+            finish_feed_fixture(
+                &mut app,
+                &serde_json::json!({"entries":entries}).to_string(),
+                false,
+            );
+            assert_eq!(app.views[1].videos.len(), visible);
+            assert!(app.views[1].has_more);
+            assert!(!app.can_prefetch());
+            app.update();
+            assert!(app.job.is_none());
+            app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
+            assert!(app.can_prefetch());
+            assert_eq!(
+                app.views[1].selection.selected(),
+                if visible == 0 {
+                    None
+                } else {
+                    Some((visible - 1).min(1))
+                }
+            );
+            finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
+            assert!(app.views[1].has_more);
+            assert!(!app.can_prefetch());
+            app.key(KeyEvent::new(KeyCode::Char('G'), KeyModifiers::SHIFT));
+            assert!(app.views[1].prefetch_requested);
+            let next = app.views[1].feed_cursor.plan(1).unwrap();
+            app.finish_page(Err("Continuation failed".into()));
+            assert_eq!(app.views[1].feed_cursor.plan(1).unwrap(), next);
+            assert!(!app.can_prefetch());
+            app.views[1].reset();
+            assert!(app.views[1].videos.is_empty());
+            assert!(app.views[1].feed_requests.is_empty());
+            assert!(!app.views[1].prefetch_requested);
+            assert_eq!(app.views[1].feed_cursor.plan(1).unwrap()[0].start, 1);
+        }
+    }
+
+    #[test]
+    fn feed_cursors_and_staged_requests_survive_cancellation_and_history_independently() {
+        let mut app = app(&["tubular"]);
+        app.feed_channels
+            .push("https://www.youtube.com/@one".into());
+        app.config
+            .categories
+            .insert("Two".into(), vec!["https://www.youtube.com/@two".into()]);
+        app.views
+            .push(View::new("Two".into(), ViewSource::Category("Two".into())));
+        app.views[0].loaded = true;
+        for index in [1, 2] {
+            app.view_index = index;
+            finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
+        }
+        app.view_index = 1;
+        app.views[1].prefetch_requested = true;
+        app.views[1].feed_requests = app.views[1].feed_cursor.plan(1).unwrap();
+        let cancelled = app.views[1].feed_requests.clone();
+        app.switch_view(2);
+        finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
+        assert_eq!(
+            app.views[2].feed_cursor.plan(1).unwrap()[0].start,
+            PAGE_SIZE * 2 + 1
+        );
+        app.back_view();
+        assert_eq!(app.view_index, 1);
+        assert_eq!(app.views[1].feed_requests, cancelled);
+        assert_eq!(app.views[1].feed_cursor.plan(1).unwrap(), cancelled);
+        assert!(app.views[1].prefetch_requested);
+        app.forward_view();
+        assert_eq!(app.view_index, 2);
+        assert!(!app.views[2].prefetch_requested);
+        assert_eq!(
+            app.views[2].feed_cursor.plan(1).unwrap()[0].start,
+            PAGE_SIZE * 2 + 1
+        );
+    }
+
+    #[test]
+    fn category_membership_reordering_keeps_cursor_request_intent_and_cache() {
+        let mut app = App::new(
+            Options::parse_from(["tubular"]),
+            PathBuf::new(),
+            config::Config {
+                categories: [(
+                    "Creators".into(),
+                    vec![
+                        "https://www.youtube.com/@two".into(),
+                        "https://www.youtube.com/@one".into(),
+                    ],
+                )]
+                .into(),
+                ..Default::default()
+            },
+        );
+        app.view_index = 2;
+        finish_feed_fixture(
+            &mut app,
+            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
+            true,
+        );
+        app.remember_description("jNQXAC9IVRw".into(), "Retained".into());
+        app.views[2].feed_requests = app.views[2].feed_cursor.plan(2).unwrap();
+        app.views[2].prefetch_requested = true;
+        let requests = app.views[2].feed_requests.clone();
+        let mut categories = app.config.categories.clone();
+        categories.get_mut("Creators").unwrap().reverse();
+        app.apply_config(config::Config {
+            categories,
+            ..Default::default()
+        });
+        assert_eq!(app.views[2].feed_requests, requests);
+        assert_eq!(app.views[2].feed_cursor.plan(2).unwrap(), requests);
+        assert!(app.views[2].prefetch_requested);
+        assert_eq!(app.views[2].videos[0].id, "jNQXAC9IVRw");
+        assert_eq!(app.views[2].selection.selected(), Some(0));
+        assert_eq!(
+            cached_description(&app.descriptions, "jNQXAC9IVRw"),
+            Some("Retained")
+        );
+        let mut categories = app.config.categories.clone();
+        categories
+            .get_mut("Creators")
+            .unwrap()
+            .push("https://www.youtube.com/@three".into());
+        app.apply_config(config::Config {
+            categories,
+            ..Default::default()
+        });
+        assert!(!app.views[2].loaded);
+        assert!(app.views[2].videos.is_empty());
+        assert!(app.views[2].feed_requests.is_empty());
+        assert!(!app.views[2].prefetch_requested);
+        assert_eq!(app.views[2].next_start, 1);
+        assert!(
+            app.views[2]
+                .feed_cursor
+                .plan(3)
+                .unwrap()
+                .iter()
+                .all(|request| request.start == 1)
+        );
     }
 
     #[test]
@@ -7624,13 +7862,13 @@ tags.cancel = "z"
         assert_eq!(app.views[0].next_start, PAGE_SIZE + 1);
         assert!(!app.views[0].needs_page());
         let view = &mut app.views[0];
-        view.pending =
-            youtube::search_results(r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Pending"}]}"#)
-                .unwrap()
-                .videos;
+        view.feed_requests = view.feed_cursor.plan(1).unwrap();
+        view.prefetch_requested = true;
         view.reset();
         assert!(view.videos.is_empty());
-        assert!(view.pending.is_empty());
+        assert!(view.feed_requests.is_empty());
+        assert!(!view.feed_cursor.has_more());
+        assert!(!view.prefetch_requested);
         assert_eq!(view.selection.selected(), None);
         assert_eq!(view.next_start, 1);
         assert!(!view.loaded);
@@ -7649,6 +7887,8 @@ tags.cancel = "z"
         app.views[0].accept_page(page, false).unwrap();
         assert!(!app.can_prefetch());
         app.mode = Mode::Normal;
+        assert!(!app.can_prefetch());
+        app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
         assert!(app.can_prefetch());
         app.preview = Some(PreviewMode::Description);
         assert!(!app.can_prefetch());
@@ -7945,10 +8185,10 @@ tags.cancel = "z"
             pinned_categories: vec!["Rust".into()],
         });
         app.views[0].selection.select(Some(1));
-        app.views[1].videos = youtube::feed_results(videos).unwrap().videos;
+        app.views[1].videos = feed_fixture(videos).unwrap().videos;
         app.views[1].loaded = true;
         app.views[1].selection.select(Some(0));
-        app.views[2].videos = youtube::feed_results(videos).unwrap().videos;
+        app.views[2].videos = feed_fixture(videos).unwrap().videos;
         app.views[2].loaded = true;
         app.views[2].selection.select(Some(0));
         app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
@@ -8018,31 +8258,25 @@ tags.cancel = "z"
         );
         let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"New","timestamp":200},{"id":"rQ_J9WH6CGk","title":"Old","timestamp":100}]}"#;
         assert_eq!(app.feed_channels, vec![direct, registered]);
-        app.views[1].videos = youtube::feed_results(videos).unwrap().videos;
+        app.views[1].videos = feed_fixture(videos).unwrap().videos;
         app.views[1].selection.select(Some(1));
         app.views[1].loaded = true;
         app.views[1].next_start = 41;
         app.views[1].has_more = true;
-        app.views[1].pending = youtube::feed_results(
-            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Buffered","timestamp":50}]}"#,
-        )
-        .unwrap()
-        .videos;
+        app.views[1].feed_requests = app.views[1].feed_cursor.plan(2).unwrap();
+        app.views[1].prefetch_requested = true;
         app.views[1].page_error = Some("Retained page error".into());
         app.remember_description(
             app.views[1].videos[1].id.clone(),
             "Retained description".into(),
         );
-        app.views[3].videos = youtube::feed_results(videos).unwrap().videos;
+        app.views[3].videos = feed_fixture(videos).unwrap().videos;
         app.views[3].selection.select(Some(0));
         app.views[3].loaded = true;
         app.views[3].next_start = 61;
         app.views[3].has_more = true;
-        app.views[3].pending = youtube::feed_results(
-            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Tag pending","timestamp":50}]}"#,
-        )
-        .unwrap()
-        .videos;
+        app.views[3].feed_requests = app.views[3].feed_cursor.plan(1).unwrap();
+        app.views[3].prefetch_requested = true;
         app.views[3].page_error = Some("Tag page failed".into());
         app.switch_view(1);
 
@@ -8063,7 +8297,8 @@ tags.cancel = "z"
         assert_eq!(app.views[1].selection.selected(), Some(1));
         assert_eq!(app.views[1].next_start, 41);
         assert!(app.views[1].has_more);
-        assert_eq!(app.views[1].pending[0].id, "jNQXAC9IVRw");
+        assert_eq!(app.views[1].feed_requests.len(), 2);
+        assert!(app.views[1].prefetch_requested);
         assert_eq!(
             app.views[1].page_error.as_deref(),
             Some("Retained page error")
@@ -8077,7 +8312,8 @@ tags.cancel = "z"
         assert_eq!(app.views[4].selection.selected(), None);
         assert_eq!(app.views[4].next_start, 1);
         assert!(!app.views[4].has_more);
-        assert!(app.views[4].pending.is_empty());
+        assert!(app.views[4].feed_requests.is_empty());
+        assert!(!app.views[4].prefetch_requested);
         assert!(app.views[4].page_error.is_none());
 
         app.apply_config(config::Config {
@@ -8097,7 +8333,8 @@ tags.cancel = "z"
         assert_eq!(app.views[1].selection.selected(), Some(1));
         assert_eq!(app.views[1].next_start, 41);
         assert!(app.views[1].has_more);
-        assert_eq!(app.views[1].pending.len(), 1);
+        assert_eq!(app.views[1].feed_requests.len(), 2);
+        assert!(app.views[1].prefetch_requested);
         assert!(app.views[1].page_error.is_some());
 
         let mut channels = app.config.channels.clone();
@@ -8114,12 +8351,13 @@ tags.cancel = "z"
         assert_eq!(app.views[1].selection.selected(), None);
         assert_eq!(app.views[1].next_start, 1);
         assert!(!app.views[1].has_more);
-        assert!(app.views[1].pending.is_empty());
+        assert!(app.views[1].feed_requests.is_empty());
+        assert!(!app.views[1].prefetch_requested);
         assert!(app.views[1].page_error.is_none());
         assert_eq!(app.view_index, 1);
         assert!(app.job.is_none());
 
-        app.views[1].videos = youtube::feed_results(videos).unwrap().videos;
+        app.views[1].videos = feed_fixture(videos).unwrap().videos;
         app.views[1].selection.select(Some(1));
         app.views[1].loaded = true;
         let mut channels = app.config.channels.clone();
@@ -8153,7 +8391,7 @@ tags.cancel = "z"
         });
         let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#;
         for (index, view) in app.views.iter_mut().enumerate() {
-            view.videos = youtube::feed_results(videos).unwrap().videos;
+            view.videos = feed_fixture(videos).unwrap().videos;
             view.loaded = true;
             view.selection.select(Some(usize::from(index % 2 == 0)));
         }
diff --git a/src/youtube.rs b/src/youtube.rs
index 4b9208f..ee60899 100644
--- a/src/youtube.rs
+++ b/src/youtube.rs
@@ -1,4 +1,5 @@
 use std::{
+    collections::VecDeque,
     ffi::OsStr,
     io::{self, Read},
     path::Path,
@@ -11,10 +12,121 @@ use serde::{Deserialize, Serialize};
 
 pub const PAGE_SIZE: usize = 60;
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FeedRequest {
+    pub channel: usize,
+    pub start: usize,
+    pub count: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FeedProgress {
+    pub request: FeedRequest,
+    /// Raw rows, including unavailable, invalid and duplicate entries.
+    pub count: usize,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct FeedCursor {
+    // None before planning; an exhausted channel has no next offset.
+    positions: Option<Vec<Option<usize>>>,
+    rotation: usize,
+}
+
+impl FeedCursor {
+    /// Planning is repeatable until a complete successful page is accepted.
+    pub fn plan(&mut self, channels: usize) -> io::Result<Vec<FeedRequest>> {
+        let positions = self
+            .positions
+            .get_or_insert_with(|| vec![Some(1); channels]);
+        if positions.len() != channels {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Feed channel membership changed without resetting its cursor",
+            ));
+        }
+        self.planned().map(|(requests, _)| requests)
+    }
+
+    fn planned(&self) -> io::Result<(Vec<FeedRequest>, usize)> {
+        let Some(positions) = &self.positions else {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Feed is not planned",
+            ));
+        };
+        let active = positions
+            .iter()
+            .filter(|position| position.is_some())
+            .count();
+        if active == 0 {
+            return Ok((Vec::new(), self.rotation));
+        }
+        let selected = active.min(PAGE_SIZE);
+        let mut requests = Vec::with_capacity(selected);
+        let mut next_rotation = self.rotation;
+        for step in 0..positions.len() {
+            let channel = (self.rotation + step) % positions.len();
+            let Some(start) = positions[channel] else {
+                continue;
+            };
+            let index = requests.len();
+            let count = PAGE_SIZE / selected + usize::from(index < PAGE_SIZE % selected);
+            range_end(start, count)?;
+            requests.push(FeedRequest {
+                channel,
+                start,
+                count,
+            });
+            if index == (PAGE_SIZE - 1) % selected {
+                next_rotation = (channel + 1) % positions.len();
+            }
+            if requests.len() == selected {
+                break;
+            }
+        }
+        requests.sort_unstable_by_key(|request| (request.start, request.count, request.channel));
+        Ok((requests, next_rotation))
+    }
+
+    pub fn accept(&mut self, progress: &[FeedProgress]) -> Result<(), String> {
+        let (requests, rotation) = self.planned().map_err(|error| error.to_string())?;
+        if progress.len() != requests.len() {
+            return Err("Feed progress did not match the planned channels".into());
+        }
+        // Preflight every request and offset before changing any channel or the rotation.
+        for (entry, request) in progress.iter().zip(&requests) {
+            if entry.request != *request || entry.count > request.count {
+                return Err("Feed progress did not match the planned request".into());
+            }
+            if entry.count == request.count && request.start.checked_add(request.count).is_none() {
+                return Err("Feed channel offset overflow".into());
+            }
+        }
+        let positions = self.positions.as_mut().unwrap();
+        for entry in progress {
+            positions[entry.request.channel] = if entry.count < entry.request.count {
+                None
+            } else {
+                Some(entry.request.start + entry.request.count)
+            };
+        }
+        self.rotation = rotation;
+        Ok(())
+    }
+
+    /// Unrequested channels remain active until their own response proves exhaustion.
+    pub fn has_more(&self) -> bool {
+        self.positions
+            .as_ref()
+            .is_some_and(|positions| positions.iter().any(Option::is_some))
+    }
+}
+
 pub struct Page {
     pub videos: Vec<Video>,
     pub has_more: bool,
-    pub cutoff: Option<i64>,
+    pub feed_progress: Vec<FeedProgress>,
 }
 
 #[derive(Clone, Deserialize, Serialize)]
@@ -56,7 +168,7 @@ pub fn search_results(output: &str) -> Result<Page, String> {
     Ok(Page {
         videos,
         has_more,
-        cutoff: None,
+        feed_progress: Vec::new(),
     })
 }
 
@@ -118,16 +230,17 @@ pub(crate) fn validate_video(video: &mut Video) -> Result<(), String> {
     Ok(())
 }
 
-pub fn feed_results(output: &str) -> Result<Page, String> {
+pub fn feed_results(output: &str, requests: &[FeedRequest]) -> Result<Page, String> {
+    validate_feed_requests(requests).map_err(|error| error.to_string())?;
     let mut videos = Vec::new();
-    let mut playlists = 0;
-    let mut has_more = false;
-    let mut cutoff = None;
-    let mut unknown_frontier = false;
-    // Multiple yt-dlp URLs produce one playlist object per line, not one combined object.
-    for result in serde_json::Deserializer::from_str(output).into_iter::<SearchResults>() {
-        let playlist = result.map_err(|error| format!("Invalid feed response: {error}"))?;
-        playlists += 1;
+    let mut feed_progress = Vec::with_capacity(requests.len());
+    let mut playlists = serde_json::Deserializer::from_str(output).into_iter::<SearchResults>();
+    // Each URL produces one playlist envelope; grouped command output follows request order.
+    for &request in requests {
+        let playlist = playlists
+            .next()
+            .ok_or_else(|| "Feed returned fewer playlists than requested".to_owned())?
+            .map_err(|error| format!("Invalid feed response: {error}"))?;
         if playlist
             .channel_id
             .as_deref()
@@ -135,9 +248,11 @@ pub fn feed_results(output: &str) -> Result<Page, String> {
         {
             return Err("Feed returned an invalid YouTube channel ID".into());
         }
-        // Raw rows include unavailable videos; filtering them must not end pagination early.
-        let full_page = playlist.entries.len() >= PAGE_SIZE;
-        let first_video = videos.len();
+        let count = playlist.entries.len();
+        if count > request.count {
+            return Err("Feed returned more rows than requested".into());
+        }
+        feed_progress.push(FeedProgress { request, count });
         for entry in playlist.entries {
             let Ok(mut video) = serde_json::from_str::<Video>(entry.get()) else {
                 continue;
@@ -155,19 +270,10 @@ pub fn feed_results(output: &str) -> Result<Page, String> {
                 videos.push(video);
             }
         }
-        if full_page {
-            has_more = true;
-            let oldest = videos[first_video..]
-                .iter()
-                .filter_map(|video| video.timestamp)
-                .min();
-            // A full undated/unavailable page may hide newer uploads on its next page.
-            unknown_frontier |= oldest.is_none();
-            cutoff = cutoff.max(oldest);
-        }
     }
-    if playlists == 0 {
-        return Err("Feed returned no playlist data".into());
+    if let Some(extra) = playlists.next() {
+        extra.map_err(|error| format!("Invalid feed response: {error}"))?;
+        return Err("Feed returned more playlists than requested".into());
     }
     // Keep the newest occurrence of each ID without copying IDs into a second collection.
     videos.sort_unstable_by(|a, b| a.id.cmp(&b.id).then_with(|| b.timestamp.cmp(&a.timestamp)));
@@ -175,8 +281,10 @@ pub fn feed_results(output: &str) -> Result<Page, String> {
     videos.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
     Ok(Page {
         videos,
-        has_more,
-        cutoff: if unknown_frontier { None } else { cutoff },
+        has_more: feed_progress
+            .iter()
+            .any(|entry| entry.count == entry.request.count),
+        feed_progress,
     })
 }
 
@@ -216,15 +324,52 @@ pub fn channel_handle(output: &str, expected_id: &str) -> Result<String, String>
 }
 
 fn page_end(start: usize) -> io::Result<usize> {
-    start
-        .checked_add(PAGE_SIZE - 1)
-        .filter(|_| start != 0)
-        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Invalid playlist page offset"))
+    range_end(start, PAGE_SIZE)
 }
 
-// Own every extractor so replacing a request or quitting cancels the whole page.
+fn range_end(start: usize, count: usize) -> io::Result<usize> {
+    count
+        .checked_sub(1)
+        .and_then(|offset| start.checked_add(offset))
+        .filter(|_| start != 0)
+        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Invalid playlist page range"))
+}
+
+fn validate_feed_requests(requests: &[FeedRequest]) -> io::Result<()> {
+    let mut remaining = PAGE_SIZE;
+    if requests.is_empty() {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "No channels to request",
+        ));
+    }
+    for (index, request) in requests.iter().enumerate() {
+        range_end(request.start, request.count)?;
+        remaining = remaining.checked_sub(request.count).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Feed request exceeds 60 total rows",
+            )
+        })?;
+        if requests[..index]
+            .iter()
+            .any(|prior| prior.channel == request.channel)
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Duplicate feed channel",
+            ));
+        }
+    }
+    Ok(())
+}
+
+const MAX_EXTRACTORS: usize = 4;
+
+// Own running and queued extractors so replacing a request cancels the whole page.
 pub struct Job {
     children: Vec<Extraction>,
+    queued: VecDeque<Command>,
 }
 
 struct Extraction {
@@ -234,11 +379,51 @@ struct Extraction {
     completed: Option<String>,
 }
 
-fn channel_batches(channels: &[String]) -> impl Iterator<Item = &[String]> {
-    let count = channels.len().min(4);
-    (0..count).map(move |index| {
-        &channels[index * channels.len() / count..(index + 1) * channels.len() / count]
-    })
+fn feed_commands(channels: &[String], requests: &[FeedRequest]) -> io::Result<Vec<Command>> {
+    validate_feed_requests(requests)?;
+    let mut commands = Vec::new();
+    let mut bounds = None;
+    let batch_size = requests.len().div_ceil(MAX_EXTRACTORS);
+    let mut batch_len = 0;
+    for (index, request) in requests.iter().enumerate() {
+        let channel = channels.get(request.channel).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Feed channel index is out of range",
+            )
+        })?;
+        if requests[..index]
+            .iter()
+            .any(|prior| &channels[prior.channel] == channel)
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Duplicate feed channel URL",
+            ));
+        }
+        if bounds != Some((request.start, request.count)) || batch_len == batch_size {
+            let mut command = extractor();
+            command.args([
+                "--flat-playlist",
+                "--playlist-start",
+                &request.start.to_string(),
+                "--playlist-end",
+                &range_end(request.start, request.count)?.to_string(),
+                "--extractor-args",
+                "youtubetab:approximate_date",
+                "--dump-single-json",
+            ]);
+            commands.push(command);
+            bounds = Some((request.start, request.count));
+            batch_len = 0;
+        }
+        commands
+            .last_mut()
+            .unwrap()
+            .arg(format!("{channel}/videos"));
+        batch_len += 1;
+    }
+    Ok(commands)
 }
 
 impl Job {
@@ -257,34 +442,8 @@ impl Job {
         ]))
     }
 
-    pub fn feed(channels: &[String], start: usize) -> io::Result<Self> {
-        if channels.is_empty() {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "No channels in this category",
-            ));
-        }
-        let end = page_end(start)?;
-        let start = start.to_string();
-        let end = end.to_string();
-        // ponytail: offsets traverse prior continuations; use direct tokens/per-channel exhaustion
-        // tracking if deep archives become slow.
-        Self::spawn_all(channel_batches(channels).map(|batch| {
-            let mut command = extractor();
-            command
-                .args([
-                    "--flat-playlist",
-                    "--playlist-start",
-                    &start,
-                    "--playlist-end",
-                    &end,
-                    "--extractor-args",
-                    "youtubetab:approximate_date",
-                    "--dump-single-json",
-                ])
-                .args(batch.iter().map(|channel| format!("{channel}/videos")));
-            command
-        }))
+    pub fn feed(channels: &[String], requests: &[FeedRequest]) -> io::Result<Self> {
+        Self::spawn_all(feed_commands(channels, requests)?)
     }
 
     pub fn channel(id: &str) -> io::Result<Self> {
@@ -315,41 +474,66 @@ impl Job {
     fn spawn(command: &mut Command) -> io::Result<Self> {
         Ok(Self {
             children: vec![Extraction::spawn(command)?],
+            queued: VecDeque::new(),
         })
     }
 
     fn spawn_all(commands: impl IntoIterator<Item = Command>) -> io::Result<Self> {
-        // Collect drops already-started children if a later spawn fails.
-        let children = commands
-            .into_iter()
-            .map(|mut command| Extraction::spawn(&mut command))
-            .collect::<io::Result<Vec<_>>>()?;
-        Ok(Self { children })
+        let mut job = Self {
+            children: Vec::new(),
+            queued: VecDeque::new(),
+        };
+        // Dropping job also cancels started children if any initial spawn fails.
+        for mut command in commands {
+            if job.children.len() < MAX_EXTRACTORS {
+                job.children.push(Extraction::spawn(&mut command)?);
+            } else {
+                job.queued.push_back(command);
+            }
+        }
+        Ok(job)
     }
 
     pub fn poll(&mut self) -> Option<Result<String, String>> {
         if self.children.is_empty() {
             return None;
         }
-        let mut pending = false;
+        let mut active = 0;
         for child in &mut self.children {
             if child.completed.is_some() {
                 continue;
             }
             match child.poll() {
-                None => pending = true,
+                None => active += 1,
                 Some(Ok(output)) => child.completed = Some(output),
                 Some(Err(error)) => {
+                    self.queued.clear();
                     self.children.clear();
                     return Some(Err(error));
                 }
             }
         }
-        if pending {
+        while active < MAX_EXTRACTORS {
+            let Some(mut command) = self.queued.pop_front() else {
+                break;
+            };
+            match Extraction::spawn(&mut command) {
+                Ok(child) => {
+                    self.children.push(child);
+                    active += 1;
+                }
+                Err(error) => {
+                    self.queued.clear();
+                    self.children.clear();
+                    return Some(Err(error.to_string()));
+                }
+            }
+        }
+        if active != 0 {
             return None;
         }
         let mut children = self.children.drain(..);
-        // Keep the first buffer; only subsequent batches need to be appended.
+        // Retain command order even when a queued group completes ahead of an earlier one.
         let mut output = children.next()?.completed.take().unwrap();
         output.reserve(
             children
@@ -656,20 +840,207 @@ impl Drop for PlayerLaunch {
 mod tests {
     use super::*;
 
+    const ONE_CHANNEL: [FeedRequest; 1] = [FeedRequest {
+        channel: 0,
+        start: 1,
+        count: PAGE_SIZE,
+    }];
+
+    fn full_progress(requests: &[FeedRequest]) -> Vec<FeedProgress> {
+        requests
+            .iter()
+            .map(|&request| FeedProgress {
+                request,
+                count: request.count,
+            })
+            .collect()
+    }
+
     #[test]
-    fn channel_batches_are_bounded_balanced_and_preserve_every_requested_url() {
-        for count in 0..=17 {
-            let channels: Vec<_> = (0..count).map(|index| format!("channel-{index}")).collect();
-            let batches: Vec<_> = channel_batches(&channels).collect();
-            assert_eq!(batches.len(), count.min(4));
-            assert!(batches.iter().all(|batch| !batch.is_empty()));
-            assert_eq!(batches.concat(), channels);
-            if !batches.is_empty() {
-                let smallest = batches.iter().map(|batch| batch.len()).min().unwrap();
-                let largest = batches.iter().map(|batch| batch.len()).max().unwrap();
-                assert!(largest - smallest <= 1);
+    fn feed_cursor_shares_60_rows_across_17_channels_with_continuous_uneven_offsets() {
+        let mut cursor = FeedCursor::default();
+        assert!(!cursor.has_more());
+        let mut offsets = [1; 17];
+        for _ in 0..3 {
+            let requests = cursor.plan(17).unwrap();
+            let planned = cursor.clone();
+            assert_eq!(
+                cursor.plan(17).unwrap(),
+                requests,
+                "retrying must preserve the plan"
+            );
+            assert_eq!(
+                cursor, planned,
+                "planning must not advance offsets or rotation"
+            );
+            assert_eq!(requests.len(), 17);
+            assert_eq!(
+                requests.iter().map(|request| request.count).sum::<usize>(),
+                PAGE_SIZE
+            );
+            assert_eq!(
+                requests.iter().filter(|request| request.count == 4).count(),
+                9
+            );
+            assert_eq!(
+                requests.iter().filter(|request| request.count == 3).count(),
+                8
+            );
+            assert!(requests.windows(2).all(|pair| {
+                (pair[0].start, pair[0].count, pair[0].channel)
+                    < (pair[1].start, pair[1].count, pair[1].channel)
+            }));
+            for request in &requests {
+                assert_eq!(request.start, offsets[request.channel]);
+                offsets[request.channel] += request.count;
             }
+            cursor.accept(&full_progress(&requests)).unwrap();
         }
+        // Rotating the nine remainder rows avoids permanently favoring the first channels.
+        assert!(offsets.iter().max().unwrap() - offsets.iter().min().unwrap() <= 1);
+        let saved = cursor.clone();
+        assert!(cursor.plan(16).is_err());
+        assert_eq!(cursor, saved);
+    }
+
+    #[test]
+    fn exhausted_channel_quota_moves_to_survivors_without_restarting_offsets() {
+        let mut cursor = FeedCursor::default();
+        let first = cursor.plan(3).unwrap();
+        let mut progress = full_progress(&first);
+        progress
+            .iter_mut()
+            .find(|entry| entry.request.channel == 1)
+            .unwrap()
+            .count = 0;
+        cursor.accept(&progress).unwrap();
+        let second = cursor.plan(3).unwrap();
+        assert_eq!(
+            second,
+            [
+                FeedRequest {
+                    channel: 0,
+                    start: 21,
+                    count: 30
+                },
+                FeedRequest {
+                    channel: 2,
+                    start: 21,
+                    count: 30
+                },
+            ]
+        );
+        let mut progress = full_progress(&second);
+        progress[0].count = 29;
+        cursor.accept(&progress).unwrap();
+        let last = cursor.plan(3).unwrap();
+        assert_eq!(
+            last,
+            [FeedRequest {
+                channel: 2,
+                start: 51,
+                count: PAGE_SIZE
+            }]
+        );
+        cursor
+            .accept(&[FeedProgress {
+                request: last[0],
+                count: 0,
+            }])
+            .unwrap();
+        assert!(!cursor.has_more());
+        assert!(cursor.plan(3).unwrap().is_empty());
+        let mut empty = FeedCursor::default();
+        assert!(empty.plan(0).unwrap().is_empty());
+        assert!(!empty.has_more());
+    }
+
+    #[test]
+    fn more_than_60_channels_rotate_fairly_and_unvisited_channels_do_not_exhaust() {
+        let mut cursor = FeedCursor::default();
+        let mut seen = [false; 137];
+        let mut offsets = vec![1; 137];
+        for _ in 0..3 {
+            let requests = cursor.plan(137).unwrap();
+            assert_eq!(requests.len(), PAGE_SIZE);
+            for request in &requests {
+                assert_eq!(request.count, 1);
+                assert_eq!(request.start, offsets[request.channel]);
+                seen[request.channel] = true;
+                offsets[request.channel] += 1;
+            }
+            cursor.accept(&full_progress(&requests)).unwrap();
+        }
+        assert!(seen.iter().all(|seen| *seen));
+        let mut cursor = FeedCursor::default();
+        for expected_remaining in [77, 17, 0] {
+            let requests = cursor.plan(137).unwrap();
+            assert_eq!(
+                requests.iter().map(|request| request.count).sum::<usize>(),
+                PAGE_SIZE
+            );
+            let progress: Vec<_> = requests
+                .iter()
+                .map(|&request| FeedProgress { request, count: 0 })
+                .collect();
+            cursor.accept(&progress).unwrap();
+            assert_eq!(
+                cursor
+                    .positions
+                    .as_ref()
+                    .unwrap()
+                    .iter()
+                    .filter(|offset| offset.is_some())
+                    .count(),
+                expected_remaining,
+            );
+            assert_eq!(cursor.has_more(), expected_remaining != 0);
+        }
+        assert!(cursor.plan(137).unwrap().is_empty());
+    }
+
+    #[test]
+    fn cursor_rejects_invalid_or_stale_progress_and_overflow_atomically() {
+        let mut cursor = FeedCursor::default();
+        assert!(cursor.accept(&[]).is_err());
+        let requests = cursor.plan(3).unwrap();
+        let valid = full_progress(&requests);
+        let saved = cursor.clone();
+        let mut bad = valid.clone();
+        bad[2].count += 1;
+        assert!(cursor.accept(&bad).is_err());
+        assert_eq!(cursor, saved);
+        bad = valid.clone();
+        bad[2].request.channel = 99;
+        assert!(cursor.accept(&bad).is_err());
+        assert_eq!(cursor, saved);
+        bad = valid.clone();
+        bad[2].request = bad[0].request;
+        assert!(cursor.accept(&bad).is_err());
+        assert_eq!(cursor, saved);
+        bad = valid.clone();
+        bad[2].request.start += 1;
+        assert!(cursor.accept(&bad).is_err());
+        assert_eq!(cursor, saved);
+        bad = valid.clone();
+        bad.reverse();
+        assert!(cursor.accept(&bad).is_err());
+        assert_eq!(cursor, saved);
+        assert!(cursor.accept(&valid[..2]).is_err());
+        assert_eq!(cursor, saved);
+        cursor.accept(&valid).unwrap();
+        let accepted = cursor.clone();
+        assert!(cursor.accept(&valid).is_err());
+        assert_eq!(cursor, accepted);
+
+        let mut overflow = FeedCursor {
+            positions: Some(vec![Some(1), Some(usize::MAX - 19), Some(1)]),
+            rotation: 0,
+        };
+        let requests = overflow.plan(3).unwrap();
+        let saved = overflow.clone();
+        assert!(overflow.accept(&full_progress(&requests)).is_err());
+        assert_eq!(overflow, saved);
     }
 
     #[cfg(unix)]
@@ -767,6 +1138,98 @@ mod tests {
             std::fs::remove_dir_all(directory).unwrap();
         }
 
+        #[test]
+        fn queued_range_groups_keep_four_workers_and_preserve_parser_request_order() {
+            let requests: Vec<_> = (0..6)
+                .map(|channel| FeedRequest {
+                    channel,
+                    start: channel + 1,
+                    count: channel + 1,
+                })
+                .collect();
+            let commands = requests.iter().map(|request| {
+                let output =
+                    serde_json::json!({"entries": vec![serde_json::Value::Null; request.count]});
+                controlled(&format!("printf '%s' '{output}'"))
+            });
+            let mut job = Job::spawn_all(commands).unwrap();
+            assert_eq!(job.children.len(), MAX_EXTRACTORS);
+            assert_eq!(job.queued.len(), 2);
+            for child in &job.children {
+                wait_stopped(child);
+            }
+            release(&mut job.children[3]);
+            assert!(job.poll().is_none());
+            assert_eq!(job.queued.len(), 1);
+            assert_eq!(
+                job.children
+                    .iter()
+                    .filter(|child| child.completed.is_none())
+                    .count(),
+                MAX_EXTRACTORS
+            );
+            wait_stopped(&job.children[4]);
+            release(&mut job.children[4]);
+            release(&mut job.children[1]);
+            assert!(job.poll().is_none());
+            assert!(job.queued.is_empty());
+            assert!(
+                job.children
+                    .iter()
+                    .filter(|child| child.completed.is_none())
+                    .count()
+                    <= MAX_EXTRACTORS
+            );
+            wait_stopped(&job.children[5]);
+            release(&mut job.children[5]);
+            assert!(job.poll().is_none());
+            release(&mut job.children[2]);
+            assert!(job.poll().is_none());
+            release(&mut job.children[0]);
+            let output = job.poll().unwrap().unwrap();
+            let page = feed_results(&output, &requests).unwrap();
+            assert_eq!(page.feed_progress, full_progress(&requests));
+            assert!(page.videos.is_empty());
+            assert!(job.poll().is_none());
+        }
+
+        #[test]
+        fn queued_spawn_failure_discards_outputs_and_cancels_running_and_queued_groups() {
+            let mut job = Job::spawn_all([
+                controlled("printf '%s' 'completed output'"),
+                controlled("printf '%s' 'pending one'"),
+                controlled("printf '%s' 'pending two'"),
+                controlled("printf '%s' 'pending three'"),
+                isolated_command(OsStr::new("/dev/null/tubular-missing-extractor")),
+                controlled("printf '%s' 'must never start'"),
+            ])
+            .unwrap();
+            for child in &job.children {
+                wait_stopped(child);
+            }
+            let pids: Vec<_> = job.children[1..]
+                .iter()
+                .map(|child| child.child.as_ref().unwrap().id())
+                .collect();
+            let outputs: Vec<_> = job.children[1..].iter_mut().map(take_output).collect();
+            release(&mut job.children[0]);
+            assert!(
+                job.poll()
+                    .unwrap()
+                    .unwrap_err()
+                    .starts_with("Cannot start yt-dlp:")
+            );
+            assert!(job.children.is_empty());
+            assert!(job.queued.is_empty());
+            for output in outputs {
+                assert!(output.recv().unwrap().is_ok());
+            }
+            for pid in pids {
+                assert_reaped(pid);
+            }
+            assert!(job.poll().is_none());
+        }
+
         #[test]
         fn aggregate_waits_for_all_batches_and_merges_in_request_not_completion_order() {
             let mut job = Job::spawn_all([
@@ -804,26 +1267,40 @@ mod tests {
         }
 
         #[test]
-        fn a_failed_batch_discards_completed_output_and_cancels_pending_siblings() {
+        fn a_failed_group_discards_completed_output_and_cancels_running_and_queued_siblings() {
             let mut job = Job::spawn_all([
                 controlled("printf '%s' '{\"complete\":true}'"),
                 controlled(
                     "printf '%s' '{\"partial\":true}'; printf '%s' 'batch failed' >&2; exit 7",
                 ),
                 controlled("/bin/sh -c 'kill -STOP $$' & wait"),
+                controlled("printf '%s' 'pending sibling'"),
+                controlled("printf '%s' 'queued sibling'"),
+                controlled("printf '%s' 'must never start'"),
             ])
             .unwrap();
             for child in &job.children {
                 wait_stopped(child);
             }
-            let pending_pid = job.children[2].child.as_ref().unwrap().id();
-            let pending_output = take_output(&mut job.children[2]);
             release(&mut job.children[0]);
             assert!(job.poll().is_none());
+            wait_stopped(&job.children[4]);
+            assert_eq!(job.queued.len(), 1);
+            let pids: Vec<_> = job.children[2..]
+                .iter()
+                .map(|child| child.child.as_ref().unwrap().id())
+                .collect();
+            let outputs: Vec<_> = job.children[2..].iter_mut().map(take_output).collect();
             release(&mut job.children[1]);
             assert_eq!(job.poll().unwrap().unwrap_err(), "batch failed");
-            assert!(pending_output.recv().unwrap().is_ok());
-            assert_reaped(pending_pid);
+            assert!(job.children.is_empty());
+            assert!(job.queued.is_empty());
+            for output in outputs {
+                assert!(output.recv().unwrap().is_ok());
+            }
+            for pid in pids {
+                assert_reaped(pid);
+            }
             assert!(job.poll().is_none());
         }
 
@@ -851,12 +1328,18 @@ mod tests {
         }
 
         #[test]
-        fn dropping_a_page_cancels_and_reaps_every_batch() {
+        fn dropping_a_page_cancels_and_reaps_running_groups_and_drops_queued_commands() {
             let mut job = Job::spawn_all([
                 controlled("/bin/sh -c 'kill -STOP $$' & wait"),
                 controlled("printf '%s' 'must not finish'"),
+                controlled("printf '%s' 'pending two'"),
+                controlled("printf '%s' 'pending three'"),
+                controlled("printf '%s' 'queued one must never start'"),
+                controlled("printf '%s' 'queued two must never start'"),
             ])
             .unwrap();
+            assert_eq!(job.children.len(), MAX_EXTRACTORS);
+            assert_eq!(job.queued.len(), 2);
             for child in &job.children {
                 wait_stopped(child);
             }
@@ -905,7 +1388,7 @@ mod tests {
 
     #[test]
     fn publication_dates_prefer_exact_metadata_and_handle_utc_boundaries_and_invalid_dates() {
-        for parse in [search_results, feed_results] {
+        for feed in [false, true] {
             for (upload_date, timestamp, expected) in [
                 (Some("20240229"), Some(0), Some("2024-02-29")),
                 (Some("20000229"), None, Some("2000-02-29")),
@@ -924,7 +1407,12 @@ mod tests {
                     "upload_date": upload_date, "timestamp": timestamp,
                 }]})
                 .to_string();
-                let page = parse(&output).unwrap();
+                let page = if feed {
+                    feed_results(&output, &ONE_CHANNEL)
+                } else {
+                    search_results(&output)
+                }
+                .unwrap();
                 assert_eq!(page.videos[0].publication_date.as_deref(), expected);
             }
         }
@@ -951,7 +1439,7 @@ mod tests {
 
     #[test]
     fn bad_video_entries_do_not_discard_valid_results() {
-        for parse in [search_results, feed_results] {
+        for feed in [false, true] {
             for bad in [
                 r#"{"id":"UC4QobU6STFB0P71PMvOGN5A","title":"Channel result"}"#,
                 r#"{"id":"--bad","title":"Unsafe ID"}"#,
@@ -970,7 +1458,12 @@ mod tests {
                 let output = format!(
                     r#"{{"entries":[{{"id":"jNQXAC9IVRw","title":"Before"}},{bad},{{"id":"rQ_J9WH6CGk","title":"After"}}]}}"#,
                 );
-                let page = parse(&output).unwrap_or_else(|error| {
+                let page = if feed {
+                    feed_results(&output, &ONE_CHANNEL)
+                } else {
+                    search_results(&output)
+                }
+                .unwrap_or_else(|error| {
                     panic!("bad entry {bad} discarded the entire page: {error}")
                 });
                 assert_eq!(
@@ -985,26 +1478,33 @@ mod tests {
     }
 
     #[test]
-    fn discarded_entries_still_count_for_pagination_but_not_feed_frontiers() {
+    fn discarded_raw_entries_advance_the_cursor_only_after_acceptance() {
         let bad = serde_json::json!({"id":"invalid", "title":"Bad", "timestamp":-500});
         let mut entries = vec![bad; PAGE_SIZE];
-        for parse in [search_results, feed_results] {
-            let page = parse(&serde_json::json!({"entries":entries}).to_string()).unwrap();
-            assert!(page.videos.is_empty());
-            assert!(
-                page.has_more,
-                "an all-invalid full page must not stop pagination"
-            );
-            assert_eq!(page.cutoff, None);
-        }
-        entries[0] = serde_json::json!({"id":"jNQXAC9IVRw","title":"Valid","timestamp":100});
-        let page = feed_results(&serde_json::json!({"entries":entries}).to_string()).unwrap();
+        let output = serde_json::json!({"entries": entries}).to_string();
+        let search = search_results(&output).unwrap();
+        assert!(search.videos.is_empty());
+        assert!(search.has_more);
+        assert!(search.feed_progress.is_empty());
+        let mut cursor = FeedCursor::default();
+        let requests = cursor.plan(1).unwrap();
+        let saved = cursor.clone();
+        let page = feed_results(&output, &requests).unwrap();
+        assert!(page.videos.is_empty());
         assert!(page.has_more);
-        assert_eq!(
-            page.cutoff,
-            Some(100),
-            "invalid dates must not release old feed rows"
-        );
+        assert_eq!(page.feed_progress, full_progress(&requests));
+        assert_eq!(cursor, saved, "parsing alone must not advance the cursor");
+        cursor.accept(&page.feed_progress).unwrap();
+        assert_eq!(cursor.plan(1).unwrap()[0].start, PAGE_SIZE + 1);
+
+        entries[0] = serde_json::json!({"id":"jNQXAC9IVRw","title":"Valid","timestamp":100});
+        let page = feed_results(
+            &serde_json::json!({"entries": entries}).to_string(),
+            &cursor.plan(1).unwrap(),
+        )
+        .unwrap();
+        assert!(page.has_more);
+        assert_eq!(page.feed_progress[0].count, PAGE_SIZE);
         assert_eq!(page.videos[0].id, "jNQXAC9IVRw");
     }
 
@@ -1034,9 +1534,16 @@ mod tests {
     fn feeds_merge_newest_first_deduplicate_and_inherit_channel_identity() {
         let output = r#"{"channel_id":"UCaYhcUwRBNscFNUKTjgPFiA","uploader_id":"@RustVideos","channel":"Rust\u001b","entries":[null,{"id":"l-GaaivVJCE","title":"Older","timestamp":100},{"id":"jNQXAC9IVRw","title":"Unknown","timestamp":null}]}
 {"channel_id":"UCaYhcUwRBNscFNUKTjgPFiA","uploader_id":"@RustVideos","channel":"Rust","entries":[{"id":"SLV9AJxnb1U","title":"Newest","timestamp":300},{"id":"l-GaaivVJCE","title":"Newer","timestamp":200},{"id":"rQ_J9WH6CGk","title":"No metadata","channel_id":null}]}"#;
-        let page = feed_results(output).unwrap();
+        let requests = FeedCursor::default().plan(2).unwrap();
+        let page = feed_results(output, &requests).unwrap();
         assert!(!page.has_more);
-        assert_eq!(page.cutoff, None);
+        assert_eq!(
+            page.feed_progress
+                .iter()
+                .map(|entry| entry.count)
+                .collect::<Vec<_>>(),
+            [3, 3]
+        );
         let videos = page.videos;
         assert_eq!(
             videos
@@ -1061,18 +1568,19 @@ mod tests {
         );
         let unavailable = feed_results(
             r#"{"entries":[null,{"id":"jNQXAC9IVRw","title":"Unknown","channel_id":null}]}"#,
+            &ONE_CHANNEL,
         )
         .unwrap()
         .videos;
         assert_eq!(unavailable[0].channel_id, None);
-        assert!(feed_results(r#"{"channel_id":"malformed","entries":[]}"#).is_err());
-        assert!(feed_results("").is_err());
-        assert!(feed_results("{}").is_err());
-        assert!(feed_results("{not JSON}").is_err());
-        let exhausted = feed_results(r#"{"entries":[]}"#).unwrap();
+        assert!(feed_results(r#"{"channel_id":"malformed","entries":[]}"#, &ONE_CHANNEL).is_err());
+        assert!(feed_results("", &ONE_CHANNEL).is_err());
+        assert!(feed_results("{}", &ONE_CHANNEL).is_err());
+        assert!(feed_results("{not JSON}", &ONE_CHANNEL).is_err());
+        let exhausted = feed_results(r#"{"entries":[]}"#, &ONE_CHANNEL).unwrap();
         assert!(exhausted.videos.is_empty());
         assert!(!exhausted.has_more);
-        assert_eq!(exhausted.cutoff, None);
+        assert_eq!(exhausted.feed_progress[0].count, 0);
     }
 
     #[test]
@@ -1087,16 +1595,116 @@ mod tests {
                 Err(error) if error.kind() == io::ErrorKind::InvalidInput
             ));
             assert!(matches!(
-                Job::feed(&channels, start),
+                Job::feed(&channels, &[FeedRequest { start, ..ONE_CHANNEL[0] }]),
                 Err(error) if error.kind() == io::ErrorKind::InvalidInput
             ));
         }
         assert!(matches!(
-            Job::feed(&[], 1),
+            Job::feed(&[], &ONE_CHANNEL),
             Err(error) if error.kind() == io::ErrorKind::InvalidInput
         ));
     }
 
+    #[test]
+    fn feeds_reject_invalid_request_budgets_and_envelope_or_row_count_mismatches() {
+        let channels = vec!["https://www.youtube.com/@RustVideos".to_owned(); 2];
+        for requests in [
+            Vec::new(),
+            vec![FeedRequest {
+                count: 0,
+                ..ONE_CHANNEL[0]
+            }],
+            vec![FeedRequest {
+                count: PAGE_SIZE + 1,
+                ..ONE_CHANNEL[0]
+            }],
+            vec![FeedRequest {
+                channel: 2,
+                ..ONE_CHANNEL[0]
+            }],
+            vec![
+                FeedRequest {
+                    channel: 0,
+                    start: 1,
+                    count: 30,
+                },
+                FeedRequest {
+                    channel: 0,
+                    start: 2,
+                    count: 30,
+                },
+            ],
+            vec![
+                FeedRequest {
+                    channel: 0,
+                    start: 1,
+                    count: 30,
+                },
+                FeedRequest {
+                    channel: 1,
+                    start: 1,
+                    count: 30,
+                },
+            ],
+            vec![
+                FeedRequest {
+                    channel: 0,
+                    start: 1,
+                    count: 31,
+                },
+                FeedRequest {
+                    channel: 1,
+                    start: 1,
+                    count: 30,
+                },
+            ],
+        ] {
+            assert!(matches!(
+                Job::feed(&channels, &requests),
+                Err(error) if error.kind() == io::ErrorKind::InvalidInput
+            ));
+        }
+        let requests = FeedCursor::default().plan(2).unwrap();
+        assert!(feed_results(r#"{"entries":[]}"#, &requests).is_err());
+        for output in [
+            r#"{"entries":[]} {"entries":[]}"#,
+            r#"{"entries":[]} garbage"#,
+            r#"{"entries":[null]} {"entries":null}"#,
+            r#"{"entries":null}"#,
+            r#"{"entries":{}}"#,
+            r#"{"entries":[{"id":}]}"#,
+        ] {
+            assert!(feed_results(output, &ONE_CHANNEL).is_err());
+        }
+        let request = [FeedRequest {
+            channel: 0,
+            start: 1,
+            count: 2,
+        }];
+        assert!(feed_results(r#"{"entries":[null,null,null]}"#, &request).is_err());
+        assert!(feed_results(r#"{"entries":[]}"#, &[]).is_err());
+        assert!(
+            feed_results(
+                r#"{"entries":[]}"#,
+                &[FeedRequest {
+                    count: 0,
+                    ..ONE_CHANNEL[0]
+                }]
+            )
+            .is_err()
+        );
+        assert!(
+            feed_results(
+                r#"{"entries":[]}"#,
+                &[FeedRequest {
+                    count: PAGE_SIZE + 1,
+                    ..ONE_CHANNEL[0]
+                }]
+            )
+            .is_err()
+        );
+    }
+
     #[test]
     fn search_pagination_counts_raw_rows_and_preserves_relevance_order() {
         for count in [0, PAGE_SIZE - 1, PAGE_SIZE, PAGE_SIZE + 1] {
@@ -1107,7 +1715,7 @@ mod tests {
             let page = search_results(&output).unwrap();
             assert_eq!(page.has_more, count >= PAGE_SIZE);
             assert!(page.videos.is_empty());
-            assert_eq!(page.cutoff, None);
+            assert!(page.feed_progress.is_empty());
         }
         let mut entries = vec![serde_json::Value::Null; PAGE_SIZE];
         entries[0] = serde_json::json!({
@@ -1118,7 +1726,7 @@ mod tests {
         });
         let page = search_results(&serde_json::json!({"entries": entries}).to_string()).unwrap();
         assert!(page.has_more);
-        assert_eq!(page.cutoff, None);
+        assert!(page.feed_progress.is_empty());
         assert_eq!(page.videos.len(), 2);
         assert_eq!(page.videos[0].id, "aaaaaaaaaaa");
         assert_eq!(page.videos[1].id, "bbbbbbbbbbb");
@@ -1126,47 +1734,61 @@ mod tests {
 
     #[test]
     fn feed_pagination_counts_nulls_and_duplicates_before_filtering() {
-        for count in [0, PAGE_SIZE - 1, PAGE_SIZE, PAGE_SIZE + 1] {
+        for count in [0, PAGE_SIZE - 1, PAGE_SIZE] {
             let output = serde_json::json!({
                 "entries": vec![serde_json::Value::Null; count]
             })
             .to_string();
-            let page = feed_results(&output).unwrap();
-            assert_eq!(page.has_more, count >= PAGE_SIZE);
+            let page = feed_results(&output, &ONE_CHANNEL).unwrap();
+            assert_eq!(page.has_more, count == PAGE_SIZE);
             assert!(page.videos.is_empty());
-            assert_eq!(page.cutoff, None);
+            assert_eq!(
+                page.feed_progress,
+                [FeedProgress {
+                    request: ONE_CHANNEL[0],
+                    count
+                }]
+            );
         }
         let entry = serde_json::json!({
             "id": "aaaaaaaaaaa", "title": "Repeated", "timestamp": 123
         });
-        let page =
-            feed_results(&serde_json::json!({"entries": vec![entry; PAGE_SIZE]}).to_string())
-                .unwrap();
+        let page = feed_results(
+            &serde_json::json!({"entries": vec![entry; PAGE_SIZE]}).to_string(),
+            &ONE_CHANNEL,
+        )
+        .unwrap();
         assert!(page.has_more);
-        assert_eq!(page.cutoff, Some(123));
+        assert_eq!(page.feed_progress[0].count, PAGE_SIZE);
         assert_eq!(page.videos.len(), 1);
 
         let mut entries = vec![serde_json::Value::Null; PAGE_SIZE];
         entries[0] = serde_json::json!({"id": "bbbbbbbbbbb", "title": "Unknown"});
-        let page = feed_results(&serde_json::json!({"entries": entries}).to_string()).unwrap();
+        let page = feed_results(
+            &serde_json::json!({"entries": entries}).to_string(),
+            &ONE_CHANNEL,
+        )
+        .unwrap();
         assert!(page.has_more);
-        assert_eq!(page.cutoff, None);
+        assert_eq!(page.feed_progress[0].count, PAGE_SIZE);
         assert_eq!(page.videos.len(), 1);
         assert_eq!(page.videos[0].timestamp, None);
     }
 
     #[test]
-    fn feed_frontier_uses_only_full_channel_minima_and_retains_all_rows() {
-        let mut first = vec![serde_json::Value::Null; PAGE_SIZE];
+    fn feeds_retain_short_and_undated_rows_without_a_global_frontier() {
+        let requests = FeedCursor::default().plan(5).unwrap();
+        let mut first = vec![serde_json::Value::Null; requests[0].count];
         first[0] =
             serde_json::json!({"id":"aaaaaaaaaaa","title":"Older duplicate","timestamp":500});
-        first[1] = serde_json::json!({"id":"bbbbbbbbbbb","title":"First frontier","timestamp":300});
+        first[1] =
+            serde_json::json!({"id":"bbbbbbbbbbb","title":"First dated row","timestamp":300});
         first[2] = serde_json::json!({"id":"ccccccccccc","title":"Unknown"});
-        let mut second = vec![serde_json::Value::Null; PAGE_SIZE];
+        let mut second = vec![serde_json::Value::Null; requests[1].count];
         second[0] =
             serde_json::json!({"id":"aaaaaaaaaaa","title":"Newest duplicate","timestamp":600});
         second[1] =
-            serde_json::json!({"id":"ddddddddddd","title":"Second frontier","timestamp":400});
+            serde_json::json!({"id":"ddddddddddd","title":"Second dated row","timestamp":400});
         let short = serde_json::json!({"entries":[
             {"id":"eeeeeeeeeee","title":"Short newer","timestamp":999}
         ]});
@@ -1181,9 +1803,15 @@ mod tests {
             older_short,
             serde_json::json!({"entries":[]})
         );
-        let page = feed_results(&output).unwrap();
+        let page = feed_results(&output, &requests).unwrap();
         assert!(page.has_more);
-        assert_eq!(page.cutoff, Some(400));
+        assert_eq!(
+            page.feed_progress
+                .iter()
+                .map(|entry| entry.count)
+                .collect::<Vec<_>>(),
+            [12, 12, 1, 1, 0]
+        );
         assert_eq!(
             page.videos
                 .iter()
@@ -1201,15 +1829,18 @@ mod tests {
         assert_eq!(page.videos[1].title, "Newest duplicate");
         assert_eq!(page.videos.last().unwrap().timestamp, None);
 
-        let exhausted = feed_results(&format!(
-            "{}\n{}\n{}",
-            short,
-            older_short,
-            serde_json::json!({"entries":[]})
-        ))
+        let requests = FeedCursor::default().plan(3).unwrap();
+        let exhausted = feed_results(
+            &format!(
+                "{}\n{}\n{}",
+                short,
+                older_short,
+                serde_json::json!({"entries":[]})
+            ),
+            &requests,
+        )
         .unwrap();
         assert!(!exhausted.has_more);
-        assert_eq!(exhausted.cutoff, None);
         assert_eq!(exhausted.videos.len(), 2);
     }