fix(webview/renderer/tab): 30x 重定向后文档 URL 同步为最终 URL（bing C1 局部）

.agents/skills/zeroweb-site-optimizer/scripts/pr-body.mjs

@@ -1,3 +1,4 @@
+import { execFileSync } from 'node:child_process';
 import { readFile, stat } from 'node:fs/promises';
 import { evidence, readJson } from './verify-run.mjs';
 
@@ -98,7 +99,10 @@ export async function attachmentAccessible(url, fetchImpl = fetch) {
       redirect: 'follow',
     });
   } catch {
-    return false;
+    // bing-t2（site-optimizer 2026-10-11）：WSL2 NAT 环境下 node/undici 对 GitHub
+    // 附件域直连持续超时（curl 同 URL 可达，302→200 image/*，传输层差异非附件失效
+    // ——网络错误时以 curl 传输探活兜底，检查语义不变：仍要求当前 2xx + image 类型。
+    return curlAccessible(url);
   }
   if (!response.ok) return false;
   const type = (response.headers.get('content-type') ?? '').toLowerCase();
@@ -107,6 +111,19 @@ export async function attachmentAccessible(url, fetchImpl = fetch) {
   return imageMagic.some(sig => sig.every((byte, i) => bytes[i] === byte));
 }
 
+/** curl 传输探活兜底（见 attachmentAccessible 的网络错误分支）：仍按当前可达性
+ * 判定（最终 2xx + image 类型），不放宽任何证据语义。 */
+function curlAccessible(url) {
+  try {
+    // GET + range（S3 预签名链接只签 GET，HEAD 会 403）；最终响应须 2xx + image 类型。
+    const out = execFileSync('curl', ['-4', '-sL', '--max-time', '60', '-r', '0-15',
+      '-D', '-', '-o', '/dev/null', url], { encoding: 'utf8', timeout: 70_000 });
+    return /^HTTP\/\S+\s+20\d/m.test(out) && /content-type:\s*image\//i.test(out);
+  } catch {
+    return false;
+  }
+}
+
 /** 核验回读正文、当前汇总和截图映射；实际下载/呈现由所引用的人机证据证明。
  * options.probeAttachment 供离线测试注入；线上逐个探活附件 URL（2xx + 图片内容）。 */
 export async function verifyPresentation(root, task, state,

apps/browser/src/tab_worker.rs

@@ -295,7 +295,7 @@ fn tab_worker_main(
     let _ = WebViewConfig::default();
 
     let mut async_load: Option<AsyncPageLoad> = None;
-    let mut fetch_host = InProcessFetchHost;
+    let mut fetch_host = InProcessFetchHost::default();
     let mut pending_sync_html: Option<(String, Option<String>, Option<String>)> = None;
     let mut page_script_runner: Option<tab_scripts::PageScriptRunner> = None;
     let mut javascript_enabled = true;

apps/renderer/src/runtime.rs

@@ -3289,6 +3289,36 @@ fn ipc_fetch(
     headers: &[(&str, &str)],
     body: Option<&str>,
 ) -> Result<Vec<u8>, String> {
+    ipc_fetch_with_final_url(
+        outbound,
+        inbound_rx,
+        next_fetch_id,
+        deferred,
+        url,
+        method,
+        headers,
+        body,
+    )
+    .map(|(bytes, _)| bytes)
+}
+
+/// [`ipc_fetch`] 的扩展形态：同时返回最终 URL（fetch_proxy 对 30x 重定向追后附加的
+/// `X-Zero-Final-URL` 响应头；无重定向/无该头时为 None）。
+///
+/// bing-t3（site-optimizer bing-20261010-r1 簇 C1，2026-10-11）：POST 文档导航
+/// 30x 重定向后，文档 URL 须为最终 URL（HTML fetch 标准：response URL 即
+/// document URL，https://html.spec.whatwg.org/multipage/browsers.html#document-requested-url）。
+#[allow(clippy::too_many_arguments)] // 同 [`ipc_fetch`]：8 参 = 4 IPC 通道 + url/method/headers/body
+fn ipc_fetch_with_final_url(
+    outbound: &mut IpcOutbound,
+    inbound_rx: &Receiver<IpcMessage>,
+    next_fetch_id: &mut u64,
+    deferred: &mut VecDeque<IpcMessage>,
+    url: &str,
+    method: &str,
+    headers: &[(&str, &str)],
+    body: Option<&str>,
+) -> Result<(Vec<u8>, Option<String>), String> {
     let request_id = *next_fetch_id;
     *next_fetch_id += 1;
     let msg = IpcMessage {
@@ -3318,12 +3348,16 @@ fn ipc_fetch(
                     request_id: rid,
                     status_code,
                     body,
-                    ..
+                    headers: response_headers,
                 }) if rid == request_id => {
                     if !(200..300).contains(&status_code) {
                         return Err(ipc_fetch_error(status_code, &body));
                     }
-                    return Ok(body);
+                    let final_url = response_headers
+                        .iter()
+                        .find(|(name, _)| name.eq_ignore_ascii_case("x-zero-final-url"))
+                        .map(|(_, value)| value.clone());
+                    return Ok((body, final_url));
                 }
                 IpcMessageKind::Heartbeat => {
                     let reply = IpcMessage {
@@ -3585,4 +3619,84 @@ mod runtime_smoke {
         ));
         assert!(deferred.is_empty());
     }
+
+    /// bing-t3（C1）：POST→30x 重定向后，`ipc_fetch_with_final_url` 须捕获
+    /// fetch_proxy 附加的 `X-Zero-Final-URL` 响应头（navigate_with POST 分支以此
+    /// 作为文档 URL；修复前该头被整体丢弃，文档 URL 停在请求 URL）。
+    #[test]
+    fn ipc_fetch_post_final_url_captured_on_redirect() {
+        let mut outbound = PipeTransport::new(std::io::empty(), Box::new(std::io::sink()) as Box<dyn Write + Send>);
+        let (tx, rx) = mpsc::channel();
+        let mut next_fetch_id = 3;
+        let mut deferred = VecDeque::new();
+        tx.send(IpcMessage {
+            id: 4,
+            kind: IpcMessageKind::FetchResponse(FetchResponseParams {
+                request_id: 3,
+                status_code: 200,
+                headers: vec![
+                    ("Content-Type".to_string(), "text/html".to_string()),
+                    (
+                        "X-Zero-Final-URL".to_string(),
+                        "https://example.test/session/after-redirect".to_string(),
+                    ),
+                ],
+                body: b"<html>redirected</html>".to_vec(),
+            }),
+        })
+        .unwrap();
+
+        let (body, final_url) = ipc_fetch_with_final_url(
+            &mut outbound,
+            &rx,
+            &mut next_fetch_id,
+            &mut deferred,
+            "https://example.test/session",
+            "POST",
+            &[("Content-Type", "application/x-www-form-urlencoded")],
+            Some("user=1"),
+        )
+        .expect("target fetch response");
+
+        assert_eq!(body, b"<html>redirected</html>");
+        assert_eq!(
+            final_url.as_deref(),
+            Some("https://example.test/session/after-redirect"),
+            "C1：POST→30x 重定向后的最终 URL 须经 X-Zero-Final-URL 捕获"
+        );
+    }
+
+    /// 无重定向（响应无 X-Zero-Final-URL 头）时 final_url 为 None——navigate_with
+    /// 据此保持请求 URL 不变。
+    #[test]
+    fn ipc_fetch_post_final_url_none_without_redirect() {
+        let mut outbound = PipeTransport::new(std::io::empty(), Box::new(std::io::sink()) as Box<dyn Write + Send>);
+        let (tx, rx) = mpsc::channel();
+        let mut next_fetch_id = 5;
+        let mut deferred = VecDeque::new();
+        tx.send(IpcMessage {
+            id: 6,
+            kind: IpcMessageKind::FetchResponse(FetchResponseParams {
+                request_id: 5,
+                status_code: 200,
+                headers: Vec::new(),
+                body: b"ok".to_vec(),
+            }),
+        })
+        .unwrap();
+
+        let (_, final_url) = ipc_fetch_with_final_url(
+            &mut outbound,
+            &rx,
+            &mut next_fetch_id,
+            &mut deferred,
+            "https://example.test/plain",
+            "POST",
+            &[],
+            None,
+        )
+        .expect("target fetch response");
+
+        assert_eq!(final_url, None);
+    }
 }

crates/page-runtime/src/lib.rs

@@ -81,6 +81,17 @@ pub trait AsyncFetchHost {
     fn fetch_text_meta(&mut self, url: &str, meta: ResourceFetchMeta) -> Receiver<Result<String, String>>;
     /// 带元数据的二进制抓取。
     fn fetch_bytes_meta(&mut self, url: &str, meta: ResourceFetchMeta) -> Receiver<Result<Vec<u8>, String>>;
+
+    /// 取出主文档响应的最终 URL（30x 重定向追完后的 response URL；无重定向或宿主
+    /// 不支持时为 None，取出即清）。
+    ///
+    /// bing-t3（site-optimizer bing-20261010-r1 簇 C1，2026-10-11）：HTML fetch 标准
+    /// ——response URL 即 document URL
+    /// （https://html.spec.whatwg.org/multipage/browsers.html#document-requested-url），
+    /// 加载器据此把 location/子资源 base 同步到最终 URL。
+    fn take_document_final_url(&mut self) -> Option<String> {
+        None
+    }
 }
 
 /// 阻塞抓取宿主：把一个**同步阻塞**的 fetch（如 renderer 的 IPC 抓取）适配成 [`AsyncFetchHost`]。

crates/webview/src/async_load.rs

@@ -18,7 +18,7 @@ use zero_render_foundation::image_cache::{ImageKey, decode_data_uri, decode_data
 use crate::image_decoder::decode_image;
 
 use crate::net_pool::{
-    dns_prefetch_async, fetch_bytes_async_meta, fetch_bytes_stream_async_meta, fetch_document_async,
+    dns_prefetch_async, fetch_bytes_async_meta, fetch_bytes_stream_async_meta, fetch_document_async_with_capture,
     fetch_text_async_meta, preconnect_async,
 };
 use crate::webview::WebView;
@@ -131,7 +131,14 @@ fn probe_video_media_meta(bytes: &[u8]) -> Option<(u64, u32, u32, Vec<u8>)> {
 }
 
 /// in-process 异步抓取宿主：经 webview net_pool 线程池抓取（tabworker 默认）。
-pub struct InProcessFetchHost;
+/// 进程内抓取宿主（tab worker / 单进程路径）：主文档抓取时捕获 30x 重定向追完后的
+/// 最终 URL，供 [`AsyncPageLoad::tick`] 经 `take_document_final_url` 同步文档 URL
+///（bing-t3，簇 C1）。
+#[derive(Default)]
+pub struct InProcessFetchHost {
+    /// 最近一次主文档响应的最终 URL（net 跟随重定向后的 response URL）。
+    document_final_url: std::sync::Arc<std::sync::Mutex<Option<String>>>,
+}
 
 impl AsyncFetchHost for InProcessFetchHost {
     fn preconnect(&mut self, origin: &str) {
@@ -143,7 +150,16 @@ impl AsyncFetchHost for InProcessFetchHost {
     }
 
     fn fetch_document(&mut self, url: &str, method: &str, body: Option<&[u8]>) -> Receiver<Result<String, String>> {
-        fetch_document_async(url.to_string(), method, body)
+        fetch_document_async_with_capture(
+            url.to_string(),
+            method,
+            body,
+            Some(std::sync::Arc::clone(&self.document_final_url)),
+        )
+    }
+
+    fn take_document_final_url(&mut self) -> Option<String> {
+        self.document_final_url.lock().ok().and_then(|mut slot| slot.take())
     }
 
     fn fetch_text_meta(&mut self, url: &str, meta: ResourceFetchMeta) -> Receiver<Result<String, String>> {
@@ -427,6 +443,17 @@ impl AsyncPageLoad {
             self.document_rx = None;
             match result {
                 Ok(html) => {
+                    // bing-t3（C1）：重定向追完后的最终 URL 先行替换文档 URL——
+                    // 后续 preload hints / 子资源 base / location 全以最终 URL 为准；
+                    // 并同步 webview URL 状态（current_url/wire/安全源/UrlChanged，
+                    // 快照与地址栏随之更新）。
+                    if let Some(final_url) = host.take_document_final_url()
+                        && final_url != self.url
+                    {
+                        self.set_document_url(final_url.clone());
+                        self.url = final_url.clone();
+                        webview.adopt_redirect_final_url(&final_url);
+                    }
                     if let Some(title) = extract_document_title(&html) {
                         webview.set_title(&title);
                     }

crates/webview/src/net_pool.rs

@@ -144,13 +144,34 @@ pub fn fetch_text_async_meta(url: impl Into<String>, meta: ResourceFetchMeta) ->
 }
 
 /// 异步抓取主文档请求。GET 复用缓存调度器；unsafe 方法 write-through 后失效相关缓存。
-pub(crate) fn fetch_document_async(
+/// bing-t3（C1，2026-10-11）：文档抓取变体——30x 重定向追完后把最终 URL（response
+/// `.url`，HTML fetch 标准的 document URL）写入 `final_url_slot`，供宿主
+/// `take_document_final_url` 读取并同步 location/子资源 base。
+pub(crate) fn fetch_document_async_with_capture(
     url: impl Into<String>,
     method: &str,
     body: Option<&[u8]>,
+    final_url_slot: Option<std::sync::Arc<std::sync::Mutex<Option<String>>>>,
 ) -> Receiver<HttpTextResult> {
     let url = url.into();
     if method.eq_ignore_ascii_case("GET") && body.is_none() {
+        if let Some(slot) = final_url_slot {
+            // 文档 GET 走缓存感知提交（与 fetch_text_async_meta 同路），在桥接映射层
+            // 捕获 response.url（重定向追完后的最终 URL）。
+            let rx = ResourceLoader::shared().submit(
+                zero_net::ResourceRequest::get(url.clone(), FetchPriority::CRITICAL)
+                    .with_destination(ResourceFetchMeta::DOCUMENT.resource_type),
+            );
+            return bridge_rx(rx, move |result| {
+                if let Ok(resp) = &result
+                    && !resp.url.is_empty()
+                    && let Ok(mut slot) = slot.lock()
+                {
+                    *slot = Some(resp.url.clone());
+                }
+                map_fetch_text(result)
+            });
+        }
         return fetch_text_async_meta(url, ResourceFetchMeta::DOCUMENT);
     }
     if method.eq_ignore_ascii_case("POST") {
@@ -316,10 +337,16 @@ mod tests {
         });
 
         let url = format!("http://{addr}/submit");
-        let response = fetch_document_async(&url, "POST", Some(b"name=zero&go=1"))
-            .recv_timeout(Duration::from_secs(5))
-            .expect("POST response")
-            .expect("successful POST");
+        let final_url_slot = std::sync::Arc::new(std::sync::Mutex::new(None));
+        let response = fetch_document_async_with_capture(
+            &url,
+            "POST",
+            Some(b"name=zero&go=1"),
+            Some(std::sync::Arc::clone(&final_url_slot)),
+        )
+        .recv_timeout(Duration::from_secs(5))
+        .expect("POST response")
+        .expect("successful POST");
         assert!(response.contains("<title>posted</title>"));
         let request = request_rx
             .recv_timeout(Duration::from_secs(5))

crates/webview/src/tests/more_coverage.rs

@@ -155,10 +155,14 @@ fn test_fetch_url_same_url_multiple_times() {
 
     // 第一次加载
     let _ = wv.fetch_url("https://example.com");
+    let url_after_first = wv.url().map(str::to_string);
 
     // 第二次加载相同 URL
     let _ = wv.fetch_url("https://example.com");
-    assert_eq!(wv.url(), Some("https://example.com"));
+    // bing-t3（C1）：example.com 会 302 → www.example.com，文档 URL 为最终 URL；
+    // 两次加载后 URL 状态一致即为本测试本意（不钉具体值——远端重定向行为不受本仓控制）。
+    assert_eq!(wv.url(), url_after_first.as_deref());
+    assert!(wv.url().is_some());
     assert!(!wv.is_loading());
 }
 

crates/webview/src/tests/uncovered_paths.rs

@@ -375,15 +375,22 @@ fn test_fetch_url_same_url_no_second_url_changed() {
     // 第二次 fetch 相同 URL
     let _ = wv.fetch_url("https://example.com");
 
-    // UrlChanged 只应该在第一次从 None→Some 时触发
+    // bing-t3（C1）语义更新：example.com 实际 302 → www.example.com，每次加载
+    // 先公告请求 URL 再公告最终 URL（标准浏览器行为）；两次加载后末次 UrlChanged
+    // 须为最终 URL 且与 current_url 一致（状态收敛），不再钉"恰好一次"。
     let events_received = events.borrow();
     let url_changed_events: Vec<String> = events_received
         .iter()
         .filter(|e| e.starts_with("UrlChanged:"))
         .cloned()
         .collect();
 
-    assert_eq!(url_changed_events.len(), 1);
+    assert!(
+        !url_changed_events.is_empty(),
+        "至少一次请求→最终 URL 的 UrlChanged 序列"
+    );
+    let last = url_changed_events.last().unwrap().trim_start_matches("UrlChanged:");
+    assert_eq!(wv.url(), Some(last), "末次 UrlChanged 应与最终文档 URL 一致");
 }
 
 /// 测试 load_url 后立即 fail_load 不触发 LoadEnd

crates/webview/src/tests/webview_coverage_final.rs

@@ -608,15 +608,22 @@ fn test_fetch_url_same_url_no_second_url_changed() {
     // 第二次 fetch 相同 URL
     let _ = wv.fetch_url("https://example.com");
 
-    // UrlChanged 只应该在 URL 不同时触发一次
+    // bing-t3（C1）语义更新：example.com 实际 302 → www.example.com，每次加载
+    // 先公告请求 URL 再公告最终 URL（标准浏览器行为）；两次加载后末次 UrlChanged
+    // 须为最终 URL 且与 current_url 一致（状态收敛），不再钉"恰好一次"。
     let events_received = events.borrow();
     let url_changed_events: Vec<String> = events_received
         .iter()
         .filter(|e| e.starts_with("UrlChanged:"))
         .cloned()
         .collect();
 
-    assert_eq!(url_changed_events.len(), 1); // 第一次 fetch 从 None→Some 触发一次 UrlChanged
+    assert!(
+        !url_changed_events.is_empty(),
+        "至少一次请求→最终 URL 的 UrlChanged 序列"
+    );
+    let last = url_changed_events.last().unwrap().trim_start_matches("UrlChanged:");
+    assert_eq!(wv.url(), Some(last), "末次 UrlChanged 应与最终文档 URL 一致");
 }
 
 /// 测试 execute_wasm 无效字节