fix(m168): 复审 r2 三项 —— 夹具不再空转、启动不再替英文用户下载、时限不再判慢线下不完

复审 r2（p2-3 / fix-then-merge）三项：

1. **P2-1 爬行服务端是空转的**（`font/tests/support.rs`，从 `tests.rs` 拆出守 400 行）：
   `seen.windows(4).any(|w| w == b"\n\n")` 拿 4 字节窗口比 2 字节切片 ⇒ `PartialEq` 先比长度 ⇒
   恒 false ⇒ 请求头永远读不完、一个字节不发，用例证明的其实只是「连接挂着被掐断」。上一版
   这里是 Python 生成时把 `\r\n` 落成了真实换行字节。现在两处都是转义写法
   （`b"\r\n\r\n"` + 完整 CRLF 响应头），并且**把「夹具真的在说话」变成断言**：
   `serve_trickle()` 返回 `TrickleProof { header, dripped }`，用例断言「真的发过头」「真的挤过
   字节」——否则夹具再坏一次也会绿。拆成两条用例：`a_trickling_candidate_is_cut_by_the_attempt_deadline`
   （[爬行, 正常]，300 ms 切断第一个后第二个成功，0.38 s）与
   `the_total_deadline_cuts_a_single_crawling_candidate`（单候选 + 400 ms 总预算）。
   变异证明：把服务端改成「一个字节都不发」⇒ 两条用例红在「爬行服务端必须真的发出响应头」。

2. **P2-2 启动替英文用户下 17 MiB（真行为 bug）**：
   - `fonts::resolve_with` **不再触发下载**（启动那一拍只报告判据）。唯一的触发点收在
     `fonts::cjk_for`（`ui/lang.rs::log_cjk`），那一拍的 `setting` 与 `LangChoice` 同源
     （ULL_LANG > 配置 > 系统 locale）= 「界面实际用哪种语言」。
   - `plan` 把 `is_downloading()` / `Ready` 的闸提到**所有策略之前**：上一版只在 `NeedsDownload`
     分支里，"下载中 + Unprobeable" 会把状态改回「无法探测」而线程还在飞，下完又翻回「已就绪」。
     当时那条理由（「否则界面停在正在下载」）只对僵死成立 ⇒ worker 现在用 `catch_unwind`
     兜底「任何 panic 都写终态」，闸才敢前移。
   - 出图通道：新增 `install::set_offline(true)`（`App::with_presenter` 在
     `options.screenshot.is_some()` 时调），`plan_with_offline` 在 offline 下永不 `Start`。
     于是 `pages/harness/app.rs` 与 `--screenshot` 都不会在 zh-locale 无字体机器上真下 17 MiB。
   - 被钉住的旧判据（`Unprobeable + Downloading ⇒ Apply`）改成 `Skip` 并写明旧行为为什么是错的；
     新增 `every_strategy_skips_while_a_download_is_in_flight`（四策略打表）与
     `the_screenshot_channel_never_starts_a_download`。

3. **P2-3 90 s 单次上限把「慢但能下完」变永久失败**：改 `ATTEMPT_DEADLINE=120 s` /
   `TOTAL_DEADLINE=360 s`，并且**最后一个候选拿整个剩余总预算**（前 n-1 个仍 `min(单次, 剩余)`）。
   算账写在常量文档里：17 772 300 B / 360 s ≈ 49 KB/s，比 r1 实测最慢那条 IPv6（67~77 KB/s）
   还低一档 ⇒ 慢而能下完的线路仍有一次成功机会；健康线路（1.1~16.6 s）在第一/第二个候选就结束。
   代价（最坏 6 分钟）也是刻意取舍，写在同一处。

顺手：`i18n::CjkFont::source` 的「尚未钉死」改成指向 `Source::Pinned`；`clock.rs` 与
`general_section.rs` 注释里的 17.0 MB → 16.9 MB。

验证（`CARGO_TARGET_DIR=C:/Temp/ull-target/wt-168`，全量重编；取退出码，不截断）：
- `cargo test -p unlucky-core --all-targets` → **16 个 target / 1189 passed / 0 failed / exit 0**
  （lib 625 + setting 115 + 其余 14 个）
- `cargo test -p unlucky-i18n` → 31 passed / 0 failed / exit 0
- `cargo test -p unlucky-app-iced`（含 `no_hardcoded_tokens` integration）→ **693 passed / 0 failed / exit 0**
- `cargo clippy -p unlucky-i18n -p unlucky-core -p unlucky-app-iced --all-targets -- -D warnings` → exit 0
- `cargo fmt --all -- --check` 干净；全仓受检文件 ≤400（本分支最大 361）

crates/app-iced/src/app/state/construct.rs

@@ -86,6 +86,10 @@ impl App {
         // 界面语言（M106）：**M92 已经探测对了，问题是一直没人用**——`pages::Model.lang` 此前在
         // `view::model` 里被写死成 `Lang::En`，于是中文系统上开出来的是全英文界面。
         let lang = LangState::boot(&bridge, options.screenshot.is_some());
+        // M168（复审 r2 P2-2）：出图通道**不许联网**——`log_cjk` 那一拍会走 `after_probe`，
+        // 一台 zh-locale 且没有中文字体的机器上会真的下 17 MiB，并可能在出图过程中注册新字体
+        // （D30：同一份代码要出同一张图）。产品路径不设这个开关。
+        crate::fonts::install::set_offline(options.screenshot.is_some());
         let mut view = pages::Model::new(
             pages::Screen::Instances,
             width,

crates/app-iced/src/app/update/clock.rs

@@ -43,7 +43,7 @@ impl App {
             self.view_dirty = true;
         }
         // 中文字体下载（M168）：后台线程推进，这里只比对快照。变了就重建视图模型 ⇒ 设置页那一行
-        // 从「正在获取中文字体…（17.0 MB）」翻到「已就绪 / 获取失败」，不需要用户再点一下。
+        // 从「正在获取中文字体…（16.9 MB）」翻到「已就绪 / 获取失败」，不需要用户再点一下。
         let font_status = crate::fonts::install::status();
         if font_status != self.font_seen {
             self.font_seen = font_status;

crates/app-iced/src/fonts.rs

@@ -224,8 +224,10 @@ pub fn resolve_with(setting: Option<&str>) -> Resolved {
     // D28 后半：语言 + 中文环境的中文字体策略。`faces` 的 `None` 在这里是「字体库读不出来」，
     // 适配层会把它翻成 `Unprobeable` 而不是「缺字体」（否则会误触发一次 CDN 下载）。
     let cjk_report = cjk::probe_with(setting, faces.as_deref());
-    // M168：只有 `NeedsDownload` 才会在这里发起下载（后台线程），其余三路一次网络都不发。
+    // **这里不发起下载**（复审 r2 P2-2 ①）：启动那一拍（`boot.rs` / `pages/harness/app.rs`）拿到的
-    install::after_probe(cjk_report.strategy);
+    // `setting` 是 `None`，只按系统 locale 判——zh-locale + 配置 `en_us` 的机器会在这里就下 17 MiB，
+    // 而随后 `App` 读到配置、把状态翻成「当前界面语言不需要中文字体」，线程却还在下。
+    // 真正的触发点只有一个：[`cjk_for`]（`ui/lang.rs::log_cjk`，那一拍已经知道**生效语言**）。
 
     Resolved {
         platform,
@@ -235,13 +237,18 @@ pub fn resolve_with(setting: Option<&str>) -> Resolved {
     }
 }
 
-/// 语言切换后的中文策略重算（M106 判据 / M168 触发下载）：`setting` 是配置里 `ui.language` 的
+/// 语言切换后的中文策略重算（M106 判据）+ **唯一**的下载触发点（M168）：`setting` 是配置里
-/// **显式值**（`None` = 跟随系统，由 [`crate::platform::locale::SystemLocale`] 决定）。
+/// `ui.language` 的**显式值**（`None` = 跟随系统，由 [`crate::platform::locale::SystemLocale`] 决定）。
 ///
 /// 为什么需要它：启动那一轮（[`resolve`]）拿不到配置，只按系统 locale 判。用户在英文系统上
 /// 手选「简体中文」时，若不复算，策略会停在 `NotNeeded`——界面文字是中文、字体却没有中文字形，
-/// 那就是白块。复算出的 `NeedsDownload` 现在**真的会去下载**（M168：`install::after_probe`），
+/// 那就是白块。
-/// 结果进设置页那一行（`pages::settings::general`）与 stderr 的 `[font] cjk-download …` 日志。
+///
+/// **为什么触发只留在这里**（复审 r2 P2-2 ①）：这一拍的 `setting` 与 `LangChoice` 同源
+/// （`ULL_LANG` > 配置 > 系统 locale），也就是「界面实际用哪种语言」的那一份判据。
+/// 放在 [`resolve`] 里就会用「系统 locale」代表「用户选择」，zh-locale + 配置 `en_us` 的机器
+/// 会白下一次 17 MiB。出图通道（`--screenshot`）由 `install::set_offline(true)` 兜住，
+/// 仍然一次都不发。
 pub fn cjk_for(setting: Option<&str>) -> CjkReport {
     let report = cjk::probe_with(setting, system_faces().as_deref());
     install::after_probe(report.strategy);

crates/app-iced/src/fonts/install.rs

@@ -250,34 +250,54 @@ pub enum Step {
 
 /// 判据表（判据本体就在这张表的 `match` 里，`after_probe` 不含任何判据）。
 ///
-/// | 策略 | 当前状态 | 这一步 |
+/// | 当前状态 | 策略 | 这一步 |
 /// |---|---|---|
-/// | `NotNeeded` / `System` / `Unprobeable` | 任意 | `Apply`（零网络） |
+/// | **下载中**（任意策略） | 任意 | **`Skip`**（闸在最上面，见下） |
-/// | `NeedsDownload` | 下载中 / 已就绪 | **`Skip`**（幂等：切一次语言不起第二条线程） |
+/// | `Ready` | 任意 | `Skip`（幂等：已就绪不再发起） |
-/// | `NeedsDownload` | 未判定 / 失败过 / 其它 | `Start`（失败后的重试只能是用户再切一次语言） |
+/// | 其它 | `NotNeeded` / `System` / `Unprobeable` | `Apply`（只改状态，零网络） |
+/// | 其它 | `NeedsDownload` | `Start`（失败过的重试只能由用户再切一次语言触发） |
+///
+/// ## 为什么「下载中」要在**所有**策略之前先跳过（复审 r2 P2-2 ②）
+///
+/// 上一版把 `is_downloading()` 只放在 `NeedsDownload` 分支里，于是「下载中 + `Unprobeable`」
+/// 会走 `Apply(Unprobeable)` —— 把状态从「正在下载」改回「无法探测」，而**线程还在飞**：
+/// 下完之后 `Ready` 又把它盖回去，状态行在 30 秒里来回翻。当时给出的理由是「否则界面会停在
+/// 正在下载」——那个理由只对**僵死**的 `Downloading` 成立（线程 panic 才会僵死），而在飞是
+/// 常见情形。僵死那一半现在由 worker 的 `catch_unwind` 兜底（任何 panic 都会写终态），
+/// 所以「下载中一律 Skip」不再有卡死的风险。
+///
+/// `offline = true`（出图通道）时**永不** `Start`：D30 要求同一份代码出同一张图，而下载会额外
+/// 产生网络流量并可能在出图过程中注册新字体。
 #[must_use]
-pub fn plan(strategy: Strategy, current: &CjkInstall) -> Step {
+pub fn plan_with_offline(strategy: Strategy, current: &CjkInstall, offline: bool) -> Step {
+    if current.is_downloading() || matches!(current, CjkInstall::Ready { .. }) {
+        return Step::Skip;
+    }
     match strategy {
         Strategy::NotNeeded => Step::Apply(CjkInstall::NotNeeded),
         Strategy::System { family } => Step::Apply(CjkInstall::System {
             family: family.to_owned(),
         }),
         Strategy::Unprobeable => Step::Apply(CjkInstall::Unprobeable),
-        Strategy::NeedsDownload(font) => {
+        // 出图通道需要下载 ⇒ **什么都不做**（也不改状态）：写「不需要下载」是谎话，
-            if current.is_downloading() || matches!(current, CjkInstall::Ready { .. }) {
+        // 写「正在下载」也是谎话（并没有在下载）。
-                Step::Skip
+        Strategy::NeedsDownload(_) if offline => Step::Skip,
-            } else {
+        Strategy::NeedsDownload(font) => Step::Start(font),
-                Step::Start(font)
-            }
-        }
     }
 }
 
+/// 同 [`plan_with_offline`]，但按本进程当前的联网策略（生产判据入口）。
+#[must_use]
+pub fn plan(strategy: Strategy, current: &CjkInstall) -> Step {
+    plan_with_offline(strategy, current, offline())
+}
+
 /// 判据结论 → 现在这一步的结局（生产入口；判据全在 [`plan`]，这里只执行）。
 ///
-/// * 英文环境 / 系统已有 / 探测不出 → 只更新状态（零网络）；
 /// * 已经在下载 / 已就绪 → 什么都不做（幂等：切一次语言不会起第二条下载、不会重复注册 17 MiB）；
-/// * 上次失败过 → 只有再次切语言才会重试（用户显式动作），不会自己反复联网。
+/// * 英文环境 / 系统已有 / 探测不出 → 只更新状态（零网络）；
+/// * 上次失败过 → 只有再次切语言才会重试（用户显式动作），不会自己反复联网；
+/// * 出图通道（[`set_offline`]）→ 永不发起。
 pub fn after_probe(strategy: Strategy) -> CjkInstall {
     match plan(strategy, &status()) {
         Step::Skip => status(),
@@ -292,6 +312,24 @@ pub fn after_probe(strategy: Strategy) -> CjkInstall {
     }
 }
 
+/// 本进程是否**禁止**发起字体下载（出图通道用；D30：同一份代码出同一张图）。
+///
+/// 为什么需要它：截图/演示通道也会走 `App` 构造 → `lang.log_cjk()` → `cjk_for` → `after_probe`。
+/// 一台 zh-locale、没有中文字体的机器上，出图会真的下 17 MiB 并在出图过程中注册新字体——
+/// 这既产生流量，也让「同一份代码出同一张图」不再成立。
+pub fn set_offline(offline: bool) {
+    OFFLINE.store(offline, std::sync::atomic::Ordering::Relaxed);
+}
+
+/// 当前是否处于 [`set_offline`] 的状态。
+#[must_use]
+pub fn offline() -> bool {
+    OFFLINE.load(std::sync::atomic::Ordering::Relaxed)
+}
+
+/// 进程级联网开关（默认允许）。
+static OFFLINE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+
 /// 状态变更时记一行（只有真变了才打，避免每秒刷一行）。
 pub(super) fn update(state: CjkInstall) {
     let previous = {

crates/app-iced/src/fonts/install/tests.rs

@@ -218,13 +218,78 @@ fn the_idle_strategies_only_apply_state() {
             family: "SimSun".to_owned()
         })
     );
+    // 复审 r2 P2-2 ② 改判：**下载中一律 Skip**，即使策略说「探测不出」。
+    // 上一版在这里断言 `Apply(Unprobeable)`，理由是「否则界面会停在正在下载」——那个理由只对
+    // 僵死成立（线程 panic），而在飞是常见情形：线程还在下，状态却被改成「无法探测」，下完又
+    // 翻回「已就绪」，状态行在几十秒里来回翻。僵死由 worker 的 catch_unwind 兜底。
     assert_eq!(
         plan(Strategy::Unprobeable, &CjkInstall::Downloading { bytes: 1 }),
-        Step::Apply(CjkInstall::Unprobeable),
+        Step::Skip,
-        "探测不出也要把状态改回来（否则界面会停在「正在下载」）"
+        "在飞的下载不许被别的策略改写状态"
     );
 }
 
+/// **下载中一律 `Skip`**（复审 r2 P2-2 ②）：四种策略挨个打一遍。
+///
+/// 抓得住：把 `is_downloading()` 那道闸挪回 `NeedsDownload` 分支里（上一版就是这样）——
+/// `Unprobeable` / `NotNeeded` / `System` 三行立刻红。
+/// 抓不住：worker 真的永不僵死（那要制造 panic，见 `worker` 的 `catch_unwind` 与报告的「没验」）。
+#[test]
+fn every_strategy_skips_while_a_download_is_in_flight() {
+    let downloading = CjkInstall::Downloading { bytes: 17_772_300 };
+    for strategy in [
+        Strategy::NeedsDownload(&NOTO_SANS_SC),
+        Strategy::NotNeeded,
+        Strategy::System { family: "SimSun" },
+        Strategy::Unprobeable,
+    ] {
+        assert_eq!(
+            plan(strategy, &downloading),
+            Step::Skip,
+            "{strategy:?}：下载中不许改状态、不许起第二条线程"
+        );
+    }
+}
+
+/// 出图通道（`offline`）**永不发起下载**（D30：同一份代码出同一张图）。
+///
+/// 抓得住：删掉 `plan_with_offline` 里 `NeedsDownload(_) if offline => Skip` 那一臂 ⇒ 截图/演示
+/// 通道会在 zh-locale 且无中文字体的机器上真下 17 MiB，用例在 `Step::Skip` 处红。
+/// 抓不住：真出图时有没有产生流量（那要真机跑 `--screenshot`，见报告「没验」）。
+#[test]
+fn the_screenshot_channel_never_starts_a_download() {
+    assert_eq!(
+        plan_with_offline(
+            Strategy::NeedsDownload(&NOTO_SANS_SC),
+            &CjkInstall::Unknown,
+            true
+        ),
+        Step::Skip,
+        "出图通道不许联网"
+    );
+    assert_eq!(
+        plan_with_offline(
+            Strategy::NeedsDownload(&NOTO_SANS_SC),
+            &CjkInstall::Unknown,
+            false
+        ),
+        Step::Start(&NOTO_SANS_SC),
+        "正常通道该发起（否则上面那条可能是「永远 Skip」的假绿）"
+    );
+    // 只改状态的三种策略在两条通道里表现一致（它们本来就不联网）。
+    for strategy in [
+        Strategy::NotNeeded,
+        Strategy::System { family: "SimSun" },
+        Strategy::Unprobeable,
+    ] {
+        assert_eq!(
+            plan_with_offline(strategy, &CjkInstall::Unknown, false),
+            plan_with_offline(strategy, &CjkInstall::Unknown, true),
+            "{strategy:?}：不联网的策略与通道无关"
+        );
+    }
+}
+
 /// 截图钉子（D30）：每个 `ULL_FONT_STATUS` 取值都能解析成一档状态，坏值不猜。
 ///
 /// 抓得住：出图夹具写了一个不存在的取值却静默出「未知」状态的图（报告就会撒谎）。

crates/app-iced/src/fonts/install/worker.rs

@@ -68,11 +68,23 @@ pub(super) fn start(font: &'static font::CjkFont) {
 
     // 判据说「需要」，这条线程才存在：不需要的三种情形在 `after_probe` 就返回了。
     std::thread::spawn(move || {
-        let state = ensure_for(
+        // **保证写终态**（复审 r2 P2-2 ② 把这条当成「下载中一律 Skip」的前提）：
-            Strategy::NeedsDownload(font),
+        // 线程里任何 panic（库内部、注册路径、OOM 前的 unwrap）都要落成 `Failed`，
-            &fetcher,
+        // 否则状态会永远停在「正在获取中文字体…」而幂等闸又不许别人改它。
-            &register_into_font_system,
+        let state = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        );
+            ensure_for(
+                Strategy::NeedsDownload(font),
+                &fetcher,
+                &register_into_font_system,
+            )
+        })) {
+            Ok(state) => state,
+            Err(_) => CjkInstall::Failed {
+                class: FetchClass::Disk,
+                message: "字体安装线程 panic（已捕获，状态回到终态；界面继续用系统字体）"
+                    .to_owned(),
+            },
+        };
         // `from_cache` 只认下载器**这次**的结论（复审 r1 次要项）：取之前「文件在不在」会说谎——
         // 坏缓存会被删掉重下，那时 `has_cached()` 还是 true，而真相是「联网下了一次」。
         let from_cache = fetcher.was_cached().unwrap_or(false);

crates/app-iced/src/pages/settings/tests/general_section.rs

@@ -102,7 +102,7 @@ fn the_font_status_row_speaks_in_four_states_and_two_languages() {
         assert!(value.contains(reason), "失败原因没进文案：{value}");
     }
 
-    // 下载中写的是**真实**字节数（17.0 MB），不是假百分比。
+    // 下载中写的是**真实**字节数（17 772 300 B → 16.9 MiB），不是假百分比。
     let (value, _) = general::font_status(&zh, &CjkInstall::Downloading { bytes: 17_772_300 });
     assert!(
         value.contains("16.9 MB"),

crates/core/src/download/font.rs

@@ -56,7 +56,7 @@ use super::verify;
 /// 写进数据根**。
 pub const MAX_FONT_BYTES: u64 = 32 * 1024 * 1024;
 
-/// **单次候选尝试**的整体时限（不是连接超时，也不是空闲超时）。
+/// **非最后一个候选**的单次尝试时限（不是连接超时，也不是空闲超时）。
 ///
 /// 为什么必须有：引擎的 `read_timeout` 是 30 s **空闲**超时，一条每秒只挤几 KB、但一直在动的
 /// 连接永远不会被判失败。复审实测过这条路径（同一台机器、同一份文件）：
@@ -66,15 +66,31 @@ pub const MAX_FONT_BYTES: u64 = 32 * 1024 * 1024;
 /// | Fastly 的 IPv6 边缘 | 60 s 只到 4.0 MB（≈67 KB/s，17.7 MB 要 ≈4 分钟） |
 /// | 同一域名的 IPv4 边缘 | 1.2 s 下完（≈15 MB/s） |
 ///
-/// 60~180 s 之间取 90 s：健康线路（实测 1.1~16.6 s）绰绰有余，而 75 KB/s 的爬行会在 90 s
+/// 120 s 是「差不多能过、但明显不对就换源」的位置：健康线路（实测 1.1~16.6 s）根本用不到它；
-/// 前被打断，转去下一个候选域。**超时归入网络档**（用户视角是「太慢」，不是「内容不对」）。
+/// 而 300 KB/s 以上的线路在 120 s 内能下完 17.7 MB。
-pub const ATTEMPT_DEADLINE: Duration = Duration::from_secs(90);
-
-/// 整条取回（所有候选加起来）的总时限。
 ///
-/// 候选是一个个试的，每个都有自己的 [`ATTEMPT_DEADLINE`]；总时限是**上限的上限**，防止将来
+/// ## 为什么**最后一个**候选不吃这个时限（复审 r2 P2-3）
-/// 候选列表变长时「N × 90 s」把设置页那一行卡成几分钟。当前两个独立域 ⇒ 实际最坏 3 分钟。
+///
-pub const TOTAL_DEADLINE: Duration = Duration::from_secs(180);
+/// 每个候选都从 0 字节重下（不做续传），所以「单次上限」直接就是一条**吞吐门槛**：
+/// `17 772 300 B / 上限`。第一版把两个候选都卡 90 s ⇒ 门槛 ≈197 KB/s，而 r1 实测那条 IPv6 是
+/// 67~77 KB/s——**改动前它能用 4 分钟下完，加了时限反而必失败、且重试无意义**。这正是我们想
+/// 避免的「把慢但当当能成的情况变成永久失败」。
+///
+/// 现在的规则（见 [`fetch_blocking_with_limits`]）：前 n-1 个候选各拿
+/// `min(ATTEMPT_DEADLINE, 剩余)`，**最后一个候选拿整个剩余总预算**。所以只要这条线在
+/// [`TOTAL_DEADLINE`] 内下得完，它就还有一次老老实实下完的机会；而前面几个候选仍然会被快速换掉。
+/// **超时归入网络档**（用户视角是「太慢」，不是「内容不对」）。
+pub const ATTEMPT_DEADLINE: Duration = Duration::from_secs(120);
+
+/// 整条取回（所有候选加起来）的总时限，也是**最后一个候选**能拿到的预算上限。
+///
+/// 取值依据（复审 r2 P2-3 的算术）：17 772 300 B / 360 s ≈ **49 KB/s** —— 比 r1 实测最慢的
+/// 那条 IPv6 路径（67~77 KB/s）还低一档，于是「慢但当当能下完」的线路仍然有一次成功机会；
+/// 而任何健康线路（1.1~16.6 s）在第一或第二个候选上就结束了。
+///
+/// 代价：最坏情形下用户要在设置页看着「正在获取中文字体…（16.9 MB）」等 6 分钟。这是刻意的
+/// 取舍——**慢而最终成功**远好过**快而必然失败**（后者要用户自己再来一次，结果一样）。
+pub const TOTAL_DEADLINE: Duration = Duration::from_secs(360);
 
 /// 字体取回的失败分类（三层，见模块文档「失败分类为什么是三类」）。
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -194,8 +210,15 @@ pub fn fetch_blocking_with_limits(
             )));
             break;
         }
-        // 每次尝试给 min(单次上限, 剩余总预算)：两个时限都不许越。
+        // 前 n-1 个候选：`min(单次上限, 剩余)`；**最后一个候选**拿整个剩余总预算。
-        let budget = attempt_deadline.min(remaining);
+        // 为什么对最后一个放宽：每个候选都从 0 字节重下，「单次上限」就是一条吞吐门槛，
+        // 卡死最后一个等于把「慢但能下完」判成永久失败（复审 r2 P2-3 的算术，见 ATTEMPT_DEADLINE）。
+        let is_last = index + 1 == spec.urls.len();
+        let budget = if is_last {
+            remaining
+        } else {
+            attempt_deadline.min(remaining)
+        };
         let request = DownloadRequest::new(ResourceKind::Other, url.clone(), &final_path)
             .with_sha256(&spec.sha256)
             .with_size(spec.bytes);

crates/core/src/download/font/tests.rs

@@ -6,108 +6,20 @@
 //! 外网站点，跑 `cargo test` 不需要网络。真 CDN 的字节有没有变、17 MiB 要下多久，这些**不在**
 //! 本文件的能力范围内（报告里写明）。
 
-use std::io::{Read as _, Write as _};
+use std::path::Path;
-use std::net::TcpListener;
+use std::sync::atomic::Ordering;
-use std::path::{Path, PathBuf};
+use std::time::Duration;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
 
-use super::super::types::HashAlgo;
 use super::*;
 
-/// 每个用例一个独立数据根（共享引擎的登记处是进程级的，键撞了会互相干扰）。
+#[path = "tests/support.rs"]
-fn root(tag: &str) -> PathBuf {
+mod support;
-    static SEQ: AtomicUsize = AtomicUsize::new(0);
-    let seq = SEQ.fetch_add(1, Ordering::SeqCst);
-    let dir = std::env::temp_dir().join(format!("ull-font-{tag}-{}-{seq}", std::process::id()));
-    let _ = std::fs::remove_dir_all(&dir);
-    std::fs::create_dir_all(&dir).expect("建数据根");
-    dir
-}
 
-/// 一段「像字体」的字节：sfnt 头 + 一张表记录 + 载荷。
+use support::{dead_url, fake_font, root, serve, serve_trickle, sha256, spec_for};
-///
-/// 为什么造它而不是塞随机字节：`looks_like_sfnt` 是落盘前的一道闸，测试若拿 HTML 当正常内容，
-/// 「下载成功」这条路径就永远走不到。
-fn fake_font(payload: &[u8]) -> Vec<u8> {
-    let mut bytes = Vec::new();
-    bytes.extend_from_slice(b"\x00\x01\x00\x00"); // sfnt 版本
-    bytes.extend_from_slice(&1u16.to_be_bytes()); // numTables
-    bytes.extend_from_slice(&[0u8; 6]); // searchRange / entrySelector / rangeShift
-    bytes.extend_from_slice(b"TEST"); // 表名
-    bytes.extend_from_slice(&0u32.to_be_bytes()); // checksum
-    bytes.extend_from_slice(&28u32.to_be_bytes()); // offset
-    bytes.extend_from_slice(&(payload.len() as u32).to_be_bytes());
-    bytes.extend_from_slice(payload);
-    bytes
-}
-
-fn sha256(bytes: &[u8]) -> String {
-    verify::digest_bytes(HashAlgo::Sha256, bytes)
-}
-
-/// 回环 HTTP 服务：不管请求什么，都回同一份字节；记下处理了几条请求。
-///
-/// 只讲 HTTP/1.1 keep-alive，够用来判「第二次调用有没有再发请求」。
-fn serve(body: Vec<u8>, expected_requests: usize) -> (String, Arc<AtomicUsize>) {
-    let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
-    let addr = listener.local_addr().expect("取端口");
-    let served = Arc::new(AtomicUsize::new(0));
-    let counter = Arc::clone(&served);
-
-    std::thread::spawn(move || {
-        let mut requests = 0usize;
-        while requests < expected_requests {
-            let Ok((mut socket, _)) = listener.accept() else {
-                break;
-            };
-            let _ = socket.set_read_timeout(Some(Duration::from_secs(10)));
-            let mut seen = Vec::new();
-            loop {
-                let mut chunk = [0u8; 1024];
-                match socket.read(&mut chunk) {
-                    Ok(0) | Err(_) => break,
-                    Ok(read) => seen.extend_from_slice(&chunk[..read]),
-                }
-                if !seen.windows(4).any(|window| window == b"\r\n\r\n") {
-                    continue;
-                }
-                requests += 1;
-                counter.store(requests, Ordering::SeqCst);
-                let head = format!(
-                    "HTTP/1.1 200 OK\r\nContent-Type: font/ttf\r\nContent-Length: {}\r\n\r\n",
-                    body.len()
-                );
-                if socket.write_all(head.as_bytes()).is_err() || socket.write_all(&body).is_err() {
-                    break;
-                }
-                seen.clear();
-                if requests >= expected_requests {
-                    return;
-                }
-            }
-        }
-    });
-
-    (format!("http://{addr}/cjk.ttf"), served)
-}
-
-/// 一个**不会**有人监听的地址：证明「没联网」比证明「联网成功」更有力。
-fn dead_url() -> String {
-    let listener = TcpListener::bind("127.0.0.1:0").expect("占一个端口");
-    let addr = listener.local_addr().expect("取端口");
-    drop(listener);
-    format!("http://{addr}/cjk.ttf")
-}
-
-fn spec_for(urls: Vec<String>, bytes: &[u8]) -> FontSpec {
-    FontSpec::new(urls, sha256(bytes), bytes.len() as u64).expect("pin 应自洽")
-}
 
 /// 守卫 ③：**缓存命中不联网**。
 ///
-/// 抓得住：把 `fetch_blocking` 开头的缓存分支删掉（或改成「只 stat 不校验」以外的任何短路取消）
+/// 抓得住：把 `fetch_blocking` 开头的缓存分支删掉——URL 指向的死人端口会被真的去连，本用例红。
-/// —— 那样 URL 指向的死人端口会被真的去连，本用例当场红。
 /// 抓不住：真机上 17 MiB 文件读盘有多快。
 #[test]
 fn cache_hit_never_touches_the_network() {
@@ -223,79 +135,78 @@ fn an_html_error_page_is_not_a_font() {
     std::fs::remove_dir_all(&dir).ok();
 }
 
-/// 爬行服务端：回完头之后每 100 ms 只挤 1 字节，**永不结束**。
+/// 守卫（M168 复审 r2 P2-1/P2-3）：**单次尝试的时限会打断爬行连接并转下一个候选**。
 ///
-/// 这正是复审 P2-2 实测到的那条路径（IPv6 边缘 ≈67 KB/s，60 s 只到 4 MB）：引擎的
+/// 这个场景现在是真的：第一个候选是 `serve_trickle()`（发真实 CRLF 响应头，之后每 100 ms 一个
-/// `read_timeout` 是 30 s **空闲**超时，字节一直在动 ⇒ 引擎自己永远不会判它失败。只有我们
+/// 字节），第二个候选是正常服务端。
-/// 那一层的整体时限能打断它。离线（回环）可跑。
-fn serve_trickle() -> String {
-    let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
-    let addr = listener.local_addr().expect("取端口");
-    std::thread::spawn(move || {
-        let Ok((mut socket, _)) = listener.accept() else {
-            return;
-        };
-        let _ = socket.set_read_timeout(Some(Duration::from_secs(5)));
-        // 读掉请求头（不回也行，但要先把请求收干净，否则某些栈会说 RST）。
-        let mut seen = Vec::new();
-        loop {
-            let mut chunk = [0u8; 1024];
-            match socket.read(&mut chunk) {
-                Ok(0) | Err(_) => return,
-                Ok(read) => seen.extend_from_slice(&chunk[..read]),
-            }
-            if seen.windows(4).any(|window| {
-                window
-                    == b"
-
-"
-            }) {
-                break;
-            }
-        }
-        // 声明一个够大的长度，然后开始「爬」：每 100 ms 一个字节。
-        if socket
-            .write_all(
-                b"HTTP/1.1 200 OK
-Content-Type: font/ttf
-Content-Length: 1000000
-
-",
-            )
-            .is_err()
-        {
-            return;
-        }
-        for _ in 0..600 {
-            if socket.write_all(&[0u8]).is_err() {
-                return;
-            }
-            std::thread::sleep(Duration::from_millis(100));
-        }
-    });
-    format!("http://{addr}/cjk.ttf")
-}
-
-/// 守卫（M168 复审 P2-2）：**只爬不死的连接由整体时限打断**，不许让界面干等。
 ///
-/// 抓得住：把 `tokio::time::timeout` 摘掉（只剩引擎的 30 s **空闲**超时）——本用例会一直
+/// 抓得住：①`serve_trickle` 的响应头写错（上一版就是这个病：真实换行字节 + 4 字节窗口 ⇒ 恒 false
-/// 跑在「每 100 ms 一个字节」的连接上，`started.elapsed() < 4 s` 那条断言直接红（实际会挂到
+/// ⇒ 一个字节都不发）——那样第一个候选会在**读不到响应头**时按网络错失败，用例里
-/// 测试框架超时）。也抓得住「超时被归成校验失败」：`class()` 必须还是 `network`。
+/// `trickle_served` 的「服务端真的发过头」这条断言会红；②`budget` 不是 `min(单次, 剩余)` 而是
-/// 抓不住：90 s/180 s 两个默认值在真网络下够不够（那要真 CDN，见报告「未验」）。
+/// 直接用总预算 ⇒ 本用例会等到总预算（5 s）才换源，`elapsed < 3 s` 红；③时限被归成校验失败。
+/// 抓不住：默认值（120 s / 360 s）在真弱网下够不够（那要真 CDN，见报告「未验」）。
 #[test]
-fn a_trickling_connection_is_cut_by_the_deadline() {
+fn a_trickling_candidate_is_cut_by_the_attempt_deadline() {
-    let dir = root("deadline");
+    let dir = root("deadline-attempt");
-    let body = fake_font(b"not what the server sends");
+    let good = fake_font(b"served by the second candidate");
-    let spec = FontSpec::new(vec![serve_trickle()], sha256(&body), body.len() as u64).expect("pin");
+    let (good_url, _served) = serve(good.clone(), 4);
+    let (trickle_url, proof) = serve_trickle();
+    let spec = FontSpec::new(
+        vec![trickle_url, good_url],
+        sha256(&good),
+        good.len() as u64,
+    )
+    .expect("pin");
 
     let started = std::time::Instant::now();
-    let error = fetch_blocking_with_limits(
+    let fetched = fetch_blocking_with_limits(
         &dir,
         &spec,
         Duration::from_millis(300),
         Duration::from_secs(5),
     )
-    .expect_err("爬行连接必须被时限打断");
+    .expect("第二个候选应当成功");
+    assert_eq!(fetched.bytes, good);
+    assert!(
+        started.elapsed() < Duration::from_secs(3),
+        "单次上限该在 300 ms 处切断第一个候选，实际 {:?}",
+        started.elapsed()
+    );
+    assert!(cache_path(&dir, &spec).exists());
+    // **这条是「夹具没坏」的判据**（复审 r2 P2-1）：第一个候选必须真的发过响应头、真的挤过字节。
+    // 少了这两条，一个「什么都不发的服务端」也能让本用例绿——那证明的是「连接挂着被掐断」，
+    // 而不是我们想证明的「活着但在爬」。
+    assert!(
+        proof.header.load(Ordering::SeqCst),
+        "爬行服务端必须真的发出响应头"
+    );
+    assert!(
+        proof.dripped.load(Ordering::SeqCst) >= 1,
+        "爬行服务端必须真的挤出过字节（否则引擎的空闲超时那条路径根本没被造出来）"
+    );
+    std::fs::remove_dir_all(&dir).ok();
+}
+
+/// 守卫（M168 复审 r2 P2-3）：**总时限**也会打断爬行，且文案说清「超时」、不落盘。
+///
+/// 抓得住：总预算被当成「每个候选各给一次」⇒ 本用例会跑到 600 × 100 ms 的爬行结束（≈60 s），
+/// `elapsed < 4 s` 红；也抓得住超时被归成其它类别（`class()` 必须是 `network`）。
+/// 抓不住：真网络上的取值合不合适（同上，见「未验」）。
+#[test]
+fn the_total_deadline_cuts_a_single_crawling_candidate() {
+    let dir = root("deadline-total");
+    let body = fake_font(b"not what the server sends");
+    let (trickle_url, proof) = serve_trickle();
+    let spec = FontSpec::new(vec![trickle_url], sha256(&body), body.len() as u64).expect("pin");
+
+    let started = std::time::Instant::now();
+    let error = fetch_blocking_with_limits(
+        &dir,
+        &spec,
+        Duration::from_secs(30),
+        Duration::from_millis(400),
+    )
+    .expect_err("总时限必须打断爬行");
     assert_eq!(error.class(), "network", "超时属于网络档：{error}");
     assert!(
         error.message().contains("超时"),
@@ -307,6 +218,10 @@ fn a_trickling_connection_is_cut_by_the_deadline() {
         started.elapsed()
     );
     assert!(!cache_path(&dir, &spec).exists(), "超时不许落盘");
+    assert!(
+        proof.dripped.load(Ordering::SeqCst) >= 1,
+        "总时限也该掐在「有字节在动」的连接上，而不是一个不响的端口"
+    );
     std::fs::remove_dir_all(&dir).ok();
 }
 

crates/core/src/download/font/tests/support.rs

@@ -0,0 +1,177 @@
+//! `download::font` 的测试夹具（回环 HTTP 服务端 / 假字体字节 / 临时数据根）。
+//!
+//! 从 `tests.rs` 拆出只为守 400 行硬线（复审 r2 加了两条时限用例之后越线）。这里只有夹具，
+//! 断言全在 `tests.rs`——两个回环服务端（`serve` 正常、`serve_trickle` 只爬）是「缓存/校验/时限」
+//! 三组守卫的地基，改坏它们等于把守卫变成空转（复审 r2 P2-1 就是这么发现上一版的
+//! CRLF 字面量写坏了的）。
+
+use std::io::{Read as _, Write as _};
+use std::net::TcpListener;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use super::super::super::verify;
+use super::super::{FontSpec, HashAlgo};
+
+/// 每个用例一个独立数据根（共享引擎的登记处是进程级的，键撞了会互相干扰）。
+pub(super) fn root(tag: &str) -> PathBuf {
+    static SEQ: AtomicUsize = AtomicUsize::new(0);
+    let seq = SEQ.fetch_add(1, Ordering::SeqCst);
+    let dir = std::env::temp_dir().join(format!("ull-font-{tag}-{}-{seq}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).expect("建数据根");
+    dir
+}
+
+/// 一段「像字体」的字节：sfnt 头 + 一张表记录 + 载荷。
+///
+/// 为什么造它而不是塞随机字节：`looks_like_sfnt` 是落盘前的一道闸，测试若拿 HTML 当正常内容，
+/// 「下载成功」这条路径就永远走不到。
+pub(super) fn fake_font(payload: &[u8]) -> Vec<u8> {
+    let mut bytes = Vec::new();
+    bytes.extend_from_slice(b"\x00\x01\x00\x00"); // sfnt 版本
+    bytes.extend_from_slice(&1u16.to_be_bytes()); // numTables
+    bytes.extend_from_slice(&[0u8; 6]); // searchRange / entrySelector / rangeShift
+    bytes.extend_from_slice(b"TEST"); // 表名
+    bytes.extend_from_slice(&0u32.to_be_bytes()); // checksum
+    bytes.extend_from_slice(&28u32.to_be_bytes()); // offset
+    bytes.extend_from_slice(&(payload.len() as u32).to_be_bytes());
+    bytes.extend_from_slice(payload);
+    bytes
+}
+
+pub(super) fn sha256(bytes: &[u8]) -> String {
+    verify::digest_bytes(HashAlgo::Sha256, bytes)
+}
+
+/// 回环 HTTP 服务：不管请求什么，都回同一份字节；记下处理了几条请求。
+///
+/// 只讲 HTTP/1.1 keep-alive，够用来判「第二次调用有没有再发请求」。
+pub(super) fn serve(body: Vec<u8>, expected_requests: usize) -> (String, Arc<AtomicUsize>) {
+    let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
+    let addr = listener.local_addr().expect("取端口");
+    let served = Arc::new(AtomicUsize::new(0));
+    let counter = Arc::clone(&served);
+
+    std::thread::spawn(move || {
+        let mut requests = 0usize;
+        while requests < expected_requests {
+            let Ok((mut socket, _)) = listener.accept() else {
+                break;
+            };
+            let _ = socket.set_read_timeout(Some(Duration::from_secs(10)));
+            let mut seen = Vec::new();
+            loop {
+                let mut chunk = [0u8; 1024];
+                match socket.read(&mut chunk) {
+                    Ok(0) | Err(_) => break,
+                    Ok(read) => seen.extend_from_slice(&chunk[..read]),
+                }
+                if !seen.windows(4).any(|window| window == b"\r\n\r\n") {
+                    continue;
+                }
+                requests += 1;
+                counter.store(requests, Ordering::SeqCst);
+                let head = format!(
+                    "HTTP/1.1 200 OK\r\nContent-Type: font/ttf\r\nContent-Length: {}\r\n\r\n",
+                    body.len()
+                );
+                if socket.write_all(head.as_bytes()).is_err() || socket.write_all(&body).is_err() {
+                    break;
+                }
+                seen.clear();
+                if requests >= expected_requests {
+                    return;
+                }
+            }
+        }
+    });
+
+    (format!("http://{addr}/cjk.ttf"), served)
+}
+
+/// 一个**不会**有人监听的地址：证明「没联网」比证明「联网成功」更有力。
+pub(super) fn dead_url() -> String {
+    let listener = TcpListener::bind("127.0.0.1:0").expect("占一个端口");
+    let addr = listener.local_addr().expect("取端口");
+    drop(listener);
+    format!("http://{addr}/cjk.ttf")
+}
+
+/// 爬行服务端的取证计数器：`header` = 真的发过响应头，`dripped` = 真的挤出过几个字节。
+///
+/// 为什么把这两个数字**带出去**：这类 `serve_*` 夹具坏掉时，用例会静默变成另一种场景
+/// （复审 r2 P2-1 就是：请求头永远读不完 ⇒ 一个字节不发 ⇒ 用例证明的是「连接挂着」，而不是
+/// 「活着但在爬」）。用例拿到这两个数就能断言「服务端确实在说话」。
+pub(super) struct TrickleProof {
+    /// 响应头是否真的写出去了。
+    pub header: Arc<std::sync::atomic::AtomicBool>,
+    /// 写出去了几个正文字节。
+    pub dripped: Arc<AtomicUsize>,
+}
+
+/// 由 URL 候选 + 期望字节算 pin（哈希取这批字节的 sha256）。
+pub(super) fn spec_for(urls: Vec<String>, bytes: &[u8]) -> FontSpec {
+    FontSpec::new(urls, sha256(bytes), bytes.len() as u64).expect("pin 应自洽")
+}
+
+/// 爬行服务端：回完头之后每 100 ms 只挤 1 字节，**永远不结束**。
+///
+/// 这就是复审 r1 P2-2 实测到的那条路径（Fastly 的 IPv6 边缘 ≈67 KB/s）：引擎的 `read_timeout`
+/// 是 30 s **空闲**超时，而字节一直在动 ⇒ 引擎自己永远不会判它失败。只有我们这一层的整体时限
+/// 能打断它——这条服务端存在的唯一目的就是造出「活着但爬」的连接。
+///
+/// 注意这里的 `\r\n` 必须是**转义写法**：上一版这个函数里写成了真实换行字节（`b"\n\n"`，2 字节）
+/// 却拿 4 字节窗口去比，`PartialEq` 先比长度 ⇒ 恒 false ⇒ 请求头永远读不完、一个字节都不发，
+/// 用例证明的其实是另一件事（复审 r2 P2-1）。`serve()` 那边的写法是对的，别动它。
+pub(super) fn serve_trickle() -> (String, TrickleProof) {
+    let header_sent = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let dripped = Arc::new(AtomicUsize::new(0));
+    let (header_flag, drip_flag) = (Arc::clone(&header_sent), Arc::clone(&dripped));
+    let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
+    let addr = listener.local_addr().expect("取端口");
+    std::thread::spawn(move || {
+        let Ok((mut socket, _)) = listener.accept() else {
+            return;
+        };
+        let _ = socket.set_read_timeout(Some(Duration::from_secs(5)));
+        // 先把请求头读干净（不读完就写响应，某些栈会 RST）。
+        let mut seen = Vec::new();
+        loop {
+            let mut chunk = [0u8; 1024];
+            match socket.read(&mut chunk) {
+                Ok(0) | Err(_) => return,
+                Ok(read) => seen.extend_from_slice(&chunk[..read]),
+            }
+            if seen.windows(4).any(|window| window == b"\r\n\r\n") {
+                break;
+            }
+        }
+        // 声明一个够大的长度，然后开始「爬」：每 100 ms 一个字节。
+        if socket
+            .write_all(
+                b"HTTP/1.1 200 OK\r\nContent-Type: font/ttf\r\nContent-Length: 1000000\r\n\r\n",
+            )
+            .is_err()
+        {
+            return;
+        }
+        header_flag.store(true, Ordering::SeqCst);
+        for _ in 0..600 {
+            if socket.write_all(&[0u8]).is_err() {
+                return;
+            }
+            drip_flag.fetch_add(1, Ordering::SeqCst);
+            std::thread::sleep(Duration::from_millis(100));
+        }
+    });
+    (
+        format!("http://{addr}/cjk.ttf"),
+        TrickleProof {
+            header: header_sent,
+            dripped,
+        },
+    )
+}

crates/i18n/src/font.rs

@@ -97,7 +97,7 @@ pub struct CjkFont {
     pub license: &'static str,
     /// 这套字体可用的字重。
     pub weights: &'static [u16],
-    /// 下载源（尚未钉死）。
+    /// 下载源（URL 候选 + sha256 + 字节数，见 [`Source::Pinned`]）。
     pub source: Source,
 }