@@ -3883,6 +3883,125 @@ mod tests {
         .expect("the page's own stylesheet was refused");
     }
 
+    /// A navigation answered 204 or 205 ends without a download offer, an error or a new
+    /// document: the tab gets Cancelled and keeps its page. A traversal answered 204 leaves
+    /// the history cursor on the page that stays.
+    #[tokio::test]
+    async fn navigation_to_no_content_keeps_the_page() {
+        use crate::events::NavigationEvent;
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+        // `/flip` is a page the first time and 204 after that.
+        let flips = Arc::new(AtomicUsize::new(0));
+        tokio::spawn(async move {
+            while let Ok((mut stream, _)) = listener.accept().await {
+                let flips = flips.clone();
+                tokio::spawn(async move {
+                    let mut buf = vec![0u8; 4096];
+                    let n = stream.read(&mut buf).await.unwrap_or(0);
+                    let flip = buf[..n].starts_with(b"GET /flip ");
+                    let gone = flip && flips.fetch_add(1, Ordering::SeqCst) > 0;
+                    let head = if buf[..n].starts_with(b"GET /204 ") || gone {
+                        "HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n".to_string()
+                    } else if buf[..n].starts_with(b"GET /205 ") {
+                        "HTTP/1.1 205 Reset Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_string()
+                    } else {
+                        let page = "<html><head><title>kept</title></head><body>page</body></html>";
+                        format!(
+                            "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\
+                             Content-Length: {}\r\nConnection: close\r\n\r\n{page}",
+                            page.len()
+                        )
+                    };
+                    let _ = stream.write_all(head.as_bytes()).await;
+                });
+            }
+        });
+
+        let mut engine = engine_with_max_zones(1);
+        let mut events = engine.subscribe_events();
+        let _join = tokio::spawn(engine.start().expect("start"));
+        let mut zone = engine.zone_builder().services(services()).create().expect("zone");
+        let tab = zone.tab_builder().create().await.expect("tab");
+
+        // Every event up to the end of the next navigation; panics on an offer or a failure.
+        async fn next_end(events: &mut broadcast::Receiver<EngineEvent>) -> NavigationEvent {
+            tokio::time::timeout(Duration::from_secs(10), async {
+                loop {
+                    match events.recv().await {
+                        Ok(EngineEvent::DownloadRequested { url, .. }) => panic!("download offered for {url}"),
+                        Ok(EngineEvent::Navigation {
+                            event: event @ (NavigationEvent::Finished { .. } | NavigationEvent::Cancelled { .. }),
+                            ..
+                        }) => return event,
+                        Ok(EngineEvent::Navigation {
+                            event: NavigationEvent::Failed { error, .. },
+                            ..
+                        }) => panic!("navigation failed: {error}"),
+                        Ok(_) => continue,
+                        Err(e) => panic!("event stream closed: {e}"),
+                    }
+                }
+            })
+            .await
+            .expect("timed out waiting for the navigation to end")
+        }
+
+        tab.navigate(format!("http://127.0.0.1:{port}/page"))
+            .await
+            .expect("navigate");
+        assert!(matches!(next_end(&mut events).await, NavigationEvent::Finished { .. }));
+
+        for status in ["204", "205"] {
+            tab.navigate(format!("http://127.0.0.1:{port}/{status}"))
+                .await
+                .expect("navigate");
+            match next_end(&mut events).await {
+                NavigationEvent::Cancelled { url, .. } => assert_eq!(url.path(), format!("/{status}")),
+                other => panic!("{status}: expected Cancelled, got {other:?}"),
+            }
+            assert_eq!(tab.url().map(|u| u.path().to_string()).as_deref(), Some("/page"));
+            assert_eq!(tab.title(), "kept");
+        }
+
+        // Nothing was left pending behind the cancel: the next navigation is a plain one.
+        tab.navigate(format!("http://127.0.0.1:{port}/page"))
+            .await
+            .expect("navigate");
+        assert!(matches!(next_end(&mut events).await, NavigationEvent::Finished { .. }));
+        assert!(tab.pending_downloads().is_empty());
+
+        // Forward to an entry that now answers 204: the cursor stays on the page shown.
+        tab.navigate(format!("http://127.0.0.1:{port}/flip"))
+            .await
+            .expect("navigate");
+        assert!(matches!(next_end(&mut events).await, NavigationEvent::Finished { .. }));
+        tab.go_back().await.expect("go back");
+        assert!(matches!(next_end(&mut events).await, NavigationEvent::Finished { .. }));
+        tab.go_forward().await.expect("go forward");
+        assert!(matches!(next_end(&mut events).await, NavigationEvent::Cancelled { .. }));
+        assert_eq!(tab.url().map(|u| u.path().to_string()).as_deref(), Some("/page"));
+        assert!(tab.can_go_forward(), "the cursor stayed on /flip");
+
+        // After a fragment navigation the page shown is on the fragment's entry.
+        tab.navigate(format!("http://127.0.0.1:{port}/page#s"))
+            .await
+            .expect("navigate");
+        assert!(matches!(next_end(&mut events).await, NavigationEvent::Finished { .. }));
+        tab.navigate(format!("http://127.0.0.1:{port}/204"))
+            .await
+            .expect("navigate");
+        assert!(matches!(next_end(&mut events).await, NavigationEvent::Cancelled { .. }));
+        assert_eq!(
+            tab.url().and_then(|u| u.fragment().map(str::to_string)).as_deref(),
+            Some("s")
+        );
+        assert!(tab.can_go_back(), "the cursor went back to /page's entry");
+    }
+
     /// A reload ignoring the cache asks for a fresh copy all the way to the server
     /// (`Cache-Control` and `Pragma: no-cache`, no validators); a plain reload does not.
     #[tokio::test]
 
@@ -226,6 +226,8 @@ pub enum NavigationResult<C: RenderConfiguration> {
         meta: FetchResultMeta,
         spool: crate::net::Spool,
     },
+    /// The response was 204 or 205: the navigation ends and the page stays.
+    NoContent { nav_id: NavigationId, url: Url },
 }
 
 // Current active navigation
@@ -375,9 +377,10 @@ pub struct TabWorker<C: RenderConfiguration> {
     /// the renders that follow do not fetch it again. Cleared when a navigation
     /// commits a new document.
     remote_favicon: Option<Url>,
-    /// The history entry the shown document was committed to. A traversal
-    /// moves the cursor before its load commits, and a title the renderer
-    /// reports meanwhile is still this document's, not the cursor's.
+    /// The history entry the shown page is on: the one its document was
+    /// committed to, or a fragment navigation's since. A traversal moves the
+    /// cursor before its load commits, and a title the renderer reports
+    /// meanwhile is still this document's, not the cursor's.
     document_entry: Option<HistoryEntryId>,
 }
 
@@ -781,6 +784,45 @@ impl<C: RenderConfiguration> TabWorker<C> {
         self.context.has_remote_renderer()
     }
 
+    /// End a navigation that leaves the current document showing. Not an error: the
+    /// Cancelled event stops the shell's spinner and puts its address bar back.
+    fn end_navigation_in_place(&mut self, nav_id: NavigationId, url: Url, reason: &str) {
+        self.sink.security.abandon(nav_id);
+        // A superseded navigation's result: the tab's state is the newer one's.
+        if self.active_nav.as_ref().is_some_and(|a| a.nav_id == nav_id) {
+            self.active_nav = None;
+            self.load = None;
+            self.is_loading = false;
+            self.is_error = false;
+            self.state = TabState::Idle;
+            self.pending_url = None;
+            self.return_to_document_entry();
+        }
+        self.send_event(EngineEvent::Navigation {
+            tab_id: self.tab_id,
+            event: NavigationEvent::Cancelled {
+                nav_id,
+                url,
+                reason: crate::engine::events::CancelReason::Custom(reason.into()),
+            },
+        });
+    }
+
+    /// Undo what the start of a navigation did to the page that stays: a traversal moved the
+    /// history cursor, and every navigation scrolled to the top. The offset is the one saved
+    /// on the document's entry when the navigation began.
+    fn return_to_document_entry(&mut self) {
+        let Some(entry) = self.document_entry else {
+            return;
+        };
+        if self.history.current() != Some(entry) && self.history.go_to(entry).is_some() {
+            self.emit_history_changed();
+        }
+        if let Some((x, y)) = self.history.entry(entry).map(|e| e.scroll) {
+            self.apply_scroll(x, y);
+        }
+    }
+
     fn on_nav_result(&mut self, res: NavigationResult<C>) {
         match res {
             NavigationResult::Ok {
@@ -925,29 +967,16 @@ impl<C: RenderConfiguration> TabWorker<C> {
                 self.remote_capture = false;
                 self.remote_focus = None;
             }
+            NavigationResult::NoContent { nav_id, url } => {
+                self.end_navigation_in_place(nav_id, url, "no content");
+            }
             NavigationResult::Download { nav_id, meta, spool } => {
-                self.sink.security.abandon(nav_id);
                 // Not an error and not a page change: the tab stays on its current document
-                // and the shell gets a download offer. The Cancelled event stops spinners.
+                // and the shell gets a download offer.
                 // The navigation ends here, without cancelling it: its token is the fetch's
                 // parent, so the next navigation or a CancelNavigation would stop the body
                 // under an accepted download. The spool owns the fetch from now on.
-                if self.active_nav.as_ref().is_some_and(|a| a.nav_id == nav_id) {
-                    self.active_nav = None;
-                    self.load = None;
-                }
-                self.is_loading = false;
-                self.is_error = false;
-                self.state = TabState::Idle;
-                self.pending_url = None;
-                self.send_event(EngineEvent::Navigation {
-                    tab_id: self.tab_id,
-                    event: NavigationEvent::Cancelled {
-                        nav_id,
-                        url: meta.final_url.clone(),
-                        reason: crate::engine::events::CancelReason::Custom("download".into()),
-                    },
-                });
+                self.end_navigation_in_place(nav_id, meta.final_url.clone(), "download");
                 let info = crate::net::types::ResponseInfo::from(&meta);
                 self.next_offer += 1;
                 let pending = PendingDownload {
@@ -2070,6 +2099,7 @@ impl<C: RenderConfiguration> TabWorker<C> {
             }
             HistoryIntent::Reload | HistoryIntent::Replace | HistoryIntent::Traverse(_) => {}
         }
+        self.document_entry = self.history.current();
         self.current_url = Some(url.clone());
 
         // Layout already exists, so the target can be scrolled to right away. A traversal to
@@ -2451,6 +2481,12 @@ impl<C: RenderConfiguration> TabWorker<C> {
                         spool,
                     });
                 }
+                Ok(RoutedOutcome::NoContent) => {
+                    let _ = tx_done.send(NavigationResult::NoContent {
+                        nav_id,
+                        url: document_final_url,
+                    });
+                }
                 Ok(RoutedOutcome::ViewerRendered(_doc)) => {
                     log::warn!("Tab[{:?}] viewer rendering not supported yet", tab_id);
                     let _ = tx_done.send(NavigationResult::Err {
 
@@ -55,6 +55,10 @@ pub enum RoutedOutcome<C: RenderConfiguration> {
         meta: Box<crate::net::types::FetchResultMeta>,
         spool: Spool,
     },
+
+    /// A top-level navigation answered 204 or 205: the navigation ends and the current
+    /// document stays (HTML, "process a navigate response").
+    NoContent,
 }
 
 /// The disk held by download spools across every tab of an engine.
@@ -479,6 +483,11 @@ pub async fn route_response_for<C: RenderConfiguration>(
         }
     };
 
+    if dest == RequestDestination::Document && matches!(meta.status, 204 | 205) {
+        handle.cancel.cancel();
+        return Ok(RoutedOutcome::NoContent);
+    }
+
     let outcome = decide_handling(&meta, dest, peek_buf.clone(), policy);
 
     match (dest, outcome.decision, body_content) {