atmos/os_lib/web_engine/

font_queue.rs

//! フォント取得の非同期キュー（レンダリングをブロックしない）。
//!
//! 仕様は `spec/resource_loading.md`。
//!
//! ## なぜ必要か
//! CSS/JS/フォントは `parse_and_layout` の中から**同期的に**取得されており、
//! 取得が終わるまでレイアウトが進まなかった。
//! 実測で 5.3MB の Noto Sans JP のダウンロードが描画を止めていた
//! （画像だけは既に `image_loader_thread` + `IMAGE_QUEUE` で非同期化済み）。
//!
//! ## 方針（不変条件 R-1〜R-5）
//! - **R-1**: 未取得でもレンダリングは先へ進む（内蔵フォントで描く）
//! - **R-2**: サイズを理由に打ち切らない。**最後まで取得する**
//! - **R-3**: 取得完了は次のレイアウトでキャッシュ経由で反映される
//! - **R-4**: 同一 URL の重複取得はキュー段階で排除する
//! - **R-5**: 結果は `/cache/browser/` へ保存し、次回はネットワークを叩かない

extern crate alloc;

use alloc::collections::BTreeSet;
use alloc::string::String;
use alloc::vec::Vec;
use spin::Mutex;

/// 取得待ちのフォント URL。
pub(super) struct FontQueue {
    /// (host, path, is_https, 優先度, まとめ取得を諦めた印)。
    ///
    /// 5 番目は「一度まとめ取得で失敗したので次は個別に取る」印。
    /// これが無いと、失敗 → 積み直し → また同じ便にまとめられる →
    /// また失敗、の堂々巡りになる（実測でページが読めなくなった）。
    pub pending: Vec<(String, String, bool, u8, bool)>,
    /// 取得済み・取得中の URL（重複投入を防ぐ）。R-4。
    pub seen: BTreeSet<String>,
    /// 【2026-08-04】稼働中のワーカースレッド数。
    ///
    /// 以前は `thread_active: bool` で**ワーカーが 1 本だけ**だった。
    /// 5.3MB の Noto Sans JP を 1 本取っている間、同じキューの後続は
    /// 一切進まない。実測でギャラリー画像がフォント 21MB の後ろに
    /// 並んで実行時間内に届かなかった。
    ///
    /// 通信待ちの間はスケジューラへ譲るので、複数本走らせれば
    /// **重いリソースが他をブロックしなくなる**。
    pub active_workers: usize,
}

/// 【2026-07-31】取得完了を描画側へ知らせるフラグ（不変条件 R-3）。
///
/// 非同期化とキャッシュは動いていたが、**完了を通知する経路が無かった**ため
/// 同一ブート内で永久に反映されなかった（実測: cache hit 0 件 / 投入 14 件）。
/// レイアウトは取得完了より先に走るので、完了時に再レイアウトを促す必要がある。
///
/// 画像は `IMAGE_QUEUE.results` を毎フレーム見て反映しているので、
/// フォントも同じ考え方でフラグを立てる。
static FONTS_UPDATED: core::sync::atomic::AtomicBool =
    core::sync::atomic::AtomicBool::new(false);

/// 前回の確認以降にフォント取得が完了したか。**確認したらフラグを下ろす**
/// （何度も再レイアウトを繰り返さないため）。
pub(super) fn take_fonts_updated() -> bool {
    FONTS_UPDATED.swap(false, core::sync::atomic::Ordering::Relaxed)
}

/// 同時に走らせるフォント取得ワーカーの上限。
///
/// 多すぎると TCP ソケット表（32 件）を圧迫し、
/// 少なすぎると重い 1 本が他を止める。実サイトの `@font-face` は
/// Noto Sans JP 4 本 + Font Awesome 4 本なので、4 本並列で
/// おおむね一巡できる。
const MAX_FONT_WORKERS: usize = 4;

/// 1 本の接続でまとめて取る最大件数。
///
/// 多すぎると 1 本の接続に依存しすぎ、途中で壊れたときの
/// 積み直しが大きくなる。まずは控えめに。
const MAX_KEEPALIVE_BATCH: usize = 4;

pub(super) static FONT_QUEUE: Mutex<FontQueue> = Mutex::new(FontQueue {
    pending: Vec::new(),
    seen: BTreeSet::new(),
    active_workers: 0,
});

/// フォント取得を予約する。**即座に戻る**（R-1）。
///
/// 既に投入済みの URL は無視する（R-4）。
/// 待ち行列にある「指定優先度より高い」件数。
///
/// 画像側がこれを見て、CSS が待っている間は起こさないようにする。
/// 【2026-08-05 計測】最初にスタイルシートを積んだ時刻（tick, 0 なら未投入）。
///
/// 非同期化した CSS が「投入から到着まで」「到着から反映まで」で
/// それぞれ何 tick 失っているかを測る。
/// 目的: 非同期化が遅い原因の切り分け。破棄条件: 特定でき次第削除。
pub(super) static STYLE_ENQUEUE_TICK: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);
/// スタイルシートが届いた時刻（tick, 0 なら未到着）。
pub(super) static STYLE_ARRIVE_TICK: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

// 【2026-08-05 観測】まとめ取得を 6 回配線して 6 回とも
// `[NET][STATS] total=3` で止まった。毎回「取得のしかた」を変えていたが、
// **そもそもワーカーのループが回っているか**を一度も確かめていない。
// 中身ではなくループそのものを数える。
// 破棄条件: 停止の原因が特定でき次第削除。
/// ループを回った回数。
pub(super) static FQ_ITERS: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);
/// ワーカーを起こした回数。
pub(super) static FQ_SPAWNS: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);
/// ワーカーが終了した回数。
pub(super) static FQ_EXITS: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);
/// キャッシュ命中で早期 continue した回数。
pub(super) static FQ_CACHED: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);
/// 実際に取得へ進んだ回数。
pub(super) static FQ_FETCH: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);
/// 直近に観測した `pending` の長さ。
pub(super) static FQ_PENDING: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);

/// 観測値を 1 行で出す。`draw()` の節目から呼ぶ。
pub(super) fn diag_line() {
    use core::sync::atomic::Ordering as O;
    crate::warn!(
        "[FQDIAG] iters={} spawn={} exit={} cached={} fetch={} pending={}",
        FQ_ITERS.load(O::Relaxed),
        FQ_SPAWNS.load(O::Relaxed),
        FQ_EXITS.load(O::Relaxed),
        FQ_CACHED.load(O::Relaxed),
        FQ_FETCH.load(O::Relaxed),
        FQ_PENDING.load(O::Relaxed),
    );
    crate::warn!(
        "[FQDIAG2] pump不可={} 同時稼働={}",
        FQ_PUMP_BLOCKED.load(O::Relaxed),
        super::fetch_limit::active(),
    );
}

/// 取得待ちのフォント／CSS／JS 件数。待機判定（`[IDLE]` 行）から使う。
///
/// 【2026-08-25 バグ修正】ここは `FONT_QUEUE.lock()` していた。
///
/// 待機判定はウィンドウマネージャの提示ループから呼ばれる。
/// あちらは高優先度で、`spin::Mutex` は譲らずに回り続けるので、
/// 低優先度のワーカーがこのロックを握っている間に提示ループが
/// スピンへ入ると、**ワーカーが走れず解放もされない**。
/// 典型的な優先度逆転で、実測では取得が 7 件やり残しのまま
/// 900 秒経っても動かなくなった（`active=5` のまま静止）。
///
/// **待機判定はロックを取ってはいけない。**
/// 正確さは、キューを変更する側（既にロックを持っている側）が
/// 毎回 `FQ_PENDING` へ書き写すことで保つ。
pub(super) fn pending_len() -> usize {
    FQ_PENDING.load(core::sync::atomic::Ordering::Acquire) as usize
}

/// 稼働中のフォントワーカー本数の写し。
///
/// 全体の枠（`fetch_limit::active`）に余裕があっても、種別ごとの
/// 上限に達していれば起こせない。止まったときにどちらが原因かを
/// 分けるため、件数だけでなく**内訳**を出せるようにする。
/// `pending_len` と同じ理由で、読み出しはロックを取らない。
static FQ_WORKERS: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

pub(super) fn worker_count() -> usize {
    FQ_WORKERS.load(core::sync::atomic::Ordering::Acquire)
}

/// 取得（`https_get_binary_keepalive`）の中に居るワーカー数。
///
/// 停滞時に `worker_count` と同数なら、止まっているのは取得そのもの。
/// 少なければ、取得は返っているのに後段（復号・登録）で詰まっている。
static FQ_IN_FETCH: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

pub(super) fn in_fetch_count() -> usize {
    FQ_IN_FETCH.load(core::sync::atomic::Ordering::Acquire)
}

/// 稼働本数を写す。ロックを持っている側から呼ぶ。
pub(super) fn store_worker_count(n: usize) {
    FQ_WORKERS.store(n, core::sync::atomic::Ordering::Release);
}

pub(super) fn pending_higher_than(prio: u8) -> usize {
    FONT_QUEUE
        .lock()
        .pending
        .iter()
        .filter(|(_, _, _, p, _)| *p < prio)
        .count()
}

pub(super) fn enqueue_font(host: String, path: String, is_https: bool) {
    enqueue_kind(host, path, is_https, super::fetch_limit::Kind::Font)
}

/// 積むだけで**ワーカーを起こさない**版。
///
/// 【2026-08-05】`@font-face` は 1 回のレイアウトで 8 本まとめて見つかるのに、
/// 1 本目を積んだ時点でワーカーが走り出すため、
/// **残りが待ち行列へ並ぶ前に取得が始まって**しまい、
/// まとめ取得（`https_get_binary_keepalive`）に載る数が増えなかった
/// （実測でハンドシェイクは 14 → 12 までしか減らなかった）。
///
/// 全部積んでから `spawn_workers()` で起こせば、同じホストのものが
/// 同時に並ぶので 1 本の接続へまとめられる。
pub(super) fn enqueue_kind_deferred(
    host: String,
    path: String,
    is_https: bool,
    kind: super::fetch_limit::Kind,
) {
    let key = alloc::format!("{}{}", host, path);
    let mut q = FONT_QUEUE.lock();
    if q.seen.contains(&key) {
        return;
    }
    q.seen.insert(key);
    if kind == super::fetch_limit::Kind::Style {
        let _ = STYLE_ENQUEUE_TICK.compare_exchange(
            0,
            crate::kernel::timer::get_ticks(),
            core::sync::atomic::Ordering::AcqRel,
            core::sync::atomic::Ordering::Acquire,
        );
    }
    q.pending.push((host, path, is_https, kind.priority(), false));
    // 【2026-08-25】待機判定はロックを取らずに読むので、
    // ここで**正確な長さ**を写しておく（`fetch_limit::idle_line`）。
    FQ_PENDING.store(q.pending.len() as u32, core::sync::atomic::Ordering::Release);
}

/// 溜まっているぶんに対してワーカーを起こす。`enqueue_kind_deferred` と対で使う。
pub(super) fn spawn_workers() {
    let mut q = FONT_QUEUE.lock();
    while q.active_workers < MAX_FONT_WORKERS
        && super::fetch_limit::try_acquire(q.pending.len())
    {
        q.active_workers += 1;
        store_worker_count(q.active_workers);
        FQ_SPAWNS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        // 【2026-08-05 バグ修正】`spawn` はヒープ不足で **0 を返す**。
        // 戻り値を見ずに枠だけ確保していたため、失敗すると
        // 「ワーカーは居ないのに枠は埋まったまま」になり、
        // 以後**永久にワーカーを起こせなくなる**。失敗したら必ず返す。
        let pid = crate::kernel::scheduler::spawn(
            font_loader_thread,
            crate::kernel::scheduler::Priority::Low,
            "font_load",
        );
        if pid == 0 {
            q.active_workers = q.active_workers.saturating_sub(1);
            store_worker_count(q.active_workers);
            super::fetch_limit::release();
        }
    }
}

/// 種別を指定して積む。取り出しは**優先度の高い順**（`fetch_limit::Kind`）。
pub(super) fn enqueue_kind(
    host: String,
    path: String,
    is_https: bool,
    kind: super::fetch_limit::Kind,
) {
    let key = alloc::format!("{}{}", host, path);
    let mut q = FONT_QUEUE.lock();
    if q.seen.contains(&key) {
        return;
    }
    q.seen.insert(key);
    if kind == super::fetch_limit::Kind::Style {
        let _ = STYLE_ENQUEUE_TICK.compare_exchange(
            0,
            crate::kernel::timer::get_ticks(),
            core::sync::atomic::Ordering::AcqRel,
            core::sync::atomic::Ordering::Acquire,
        );
    }
    q.pending.push((host, path, is_https, kind.priority(), false));
    // 【2026-08-25】待機判定はロックを取らずに読むので、
    // ここで**正確な長さ**を写しておく（`fetch_limit::idle_line`）。
    FQ_PENDING.store(q.pending.len() as u32, core::sync::atomic::Ordering::Release);
    // 待ち行列があるうちはワーカーを増やす（上限まで）。
    // 1 本あたり 1 リソースを担当するので、重いフォントが
    // 他のフォントの取得を止めない。
    // 【2026-08-05】上限は種別ごとではなく**全体で**持つ
    // （`fetch_limit` 参照。フォント 4 + 画像 4 で 8 本張れていた）。
    // メイン HTML の取得中は新たに起こさない。
    if q.active_workers < MAX_FONT_WORKERS
        && super::fetch_limit::try_acquire(q.pending.len())
    {
        q.active_workers += 1;
        store_worker_count(q.active_workers);
        FQ_SPAWNS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        // 【2026-08-05 バグ修正】`spawn` はヒープ不足で **0 を返す**。
        // 戻り値を見ずに枠だけ確保していたため、失敗すると
        // 「ワーカーは居ないのに枠は埋まったまま」になり、
        // 以後**永久にワーカーを起こせなくなる**。失敗したら必ず返す。
        let pid = crate::kernel::scheduler::spawn(
            font_loader_thread,
            crate::kernel::scheduler::Priority::Low,
            "font_load",
        );
        if pid == 0 {
            q.active_workers = q.active_workers.saturating_sub(1);
            store_worker_count(q.active_workers);
            super::fetch_limit::release();
        }
    }
}

/// 溜まっている取得要求に対してワーカーを起こし直す。
///
/// 【2026-08-05】`enqueue_font` は**投入時にしか**ワーカーを起こさない。
/// `fetch_limit` の門（メイン HTML 取得中は起こさない）を入れたことで、
/// 門が閉じている間に投入された分が**永久に `pending` に残る**
/// ようになった（実測: `[NET][STATS] total=3`、正常時は 13）。
///
/// 門が開いたら拾い直す必要がある。`draw()` から毎フレーム呼ぶ。
/// 起こす条件は `enqueue_font` と同じなので、余分には起きない。
/// `pump()` が「積んであるのに起こせなかった」回数。
///
/// 【2026-08-05】遅延投入（`enqueue_kind_deferred` + `spawn_workers`）を
/// 試したとき `[FQDIAG] iters=0 spawn=0` でワーカーが一度も起動しなかった。
/// `pump()` は毎フレーム呼ばれているのに起こせていない。
/// **何が拒んでいるか**を数える。破棄条件: 特定でき次第削除。
pub(super) static FQ_PUMP_BLOCKED: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);

pub(super) fn pump() {
    // 【2026-09-06 バグ修正】ここは `lock()` だった。
    //
    // `pump()` は `draw()` から**毎フレーム**呼ばれる。描画側は高優先度で、
    // `spin::Mutex` は譲らずに回り続けるため、低優先度のワーカーが
    // この錠を握っている間に入ると**ワーカーが走れなくなる**。
    // 同じ優先度逆転は `pending_len`／`pending_count`／`image_results_ready`
    // で既に 3 回踏んでおり、「**待機・再描画の判定はロックを取ってはいけない**」
    // という規則になっていた。`pump()` はその規則から漏れていた。
    //
    // 実測（停滞時）: `fw=4 ff=0 font_pending=0 exit=0` ——
    // 取得中でもパニックでもなく、終了経路も通っていない。
    // ワーカーが錠待ちで止まり、稼働本数が上限に張り付いていた。
    //
    // 毎フレーム呼ばれるので、取れなければ諦めて次フレームに任せればよい。
    let Some(mut q) = FONT_QUEUE.try_lock() else {
        return;
    };
    // 【2026-08-25】パニックで死んだワーカーぶんの枠を戻す。
    // 死んだ本人は `active_workers` を減らせないので、
    // 毎フレーム走るここで遅れて回収する（詳細は `fetch_limit`）。
    let dead = super::fetch_limit::take_font_deaths();
    if dead > 0 {
        crate::warn!("[FONT] パニックで死んだワーカー {} 本を回収", dead);
        q.active_workers = q.active_workers.saturating_sub(dead);
        store_worker_count(q.active_workers);
    }
    if q.pending.is_empty() {
        return;
    }
    if q.active_workers >= MAX_FONT_WORKERS {
        FQ_PUMP_BLOCKED.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
    }
    if q.active_workers < MAX_FONT_WORKERS && super::fetch_limit::try_acquire(q.pending.len()) {
        q.active_workers += 1;
        store_worker_count(q.active_workers);
        // 【2026-08-05 バグ修正】`spawn` はヒープ不足で **0 を返す**。
        // 戻り値を見ずに枠だけ確保していたため、失敗すると
        // 「ワーカーは居ないのに枠は埋まったまま」になり、
        // 以後**永久にワーカーを起こせなくなる**。失敗したら必ず返す。
        let pid = crate::kernel::scheduler::spawn(
            font_loader_thread,
            crate::kernel::scheduler::Priority::Low,
            "font_load",
        );
        if pid == 0 {
            q.active_workers = q.active_workers.saturating_sub(1);
            store_worker_count(q.active_workers);
            super::fetch_limit::release();
        }
    }
}

/// 背景でフォントを取得してキャッシュへ書く。
///
/// **サイズによる打ち切りはしない**（R-2）。時間がかかっても最後まで取る。
/// レンダリングは待たないので、遅くても描画は進む。
fn font_loader_thread() {
    // 枠の所有を自分の PID で宣言する。パニックで死んだとき、
    // パニックハンドラがこの記録を頼りに枠を返す。
    let my_pid = crate::kernel::scheduler::get_current_process_id().unwrap_or(0);
    super::fetch_limit::claim(my_pid, super::fetch_limit::KIND_FONT);
    // このスレッドの稼働中に 1 本でも取得できたか。
    // 取得のたびに通知すると再レイアウトが本数分走ってしまうので、
    // キューを処理し終えてからまとめて 1 回だけ通知する。
    let mut got_any = false;
    loop {
        FQ_ITERS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        let next = {
            let mut q = FONT_QUEUE.lock();
            FQ_PENDING.store(q.pending.len() as u32, core::sync::atomic::Ordering::Relaxed);
            // 【2026-08-05】以前は `pop()`（後ろから）だった。
            // CSS はレイアウトに必須なので、種別の優先度で選ぶ。
            let prios: alloc::vec::Vec<u8> =
                q.pending.iter().map(|(_, _, _, p, _)| *p).collect();
            let picked = super::fetch_limit::pick_highest_priority(&prios)
                .map(|i| q.pending.remove(i));
            FQ_PENDING.store(q.pending.len() as u32, core::sync::atomic::Ordering::Release);
            // 【2026-08-05】同じホスト・同じ優先度の兄弟を、
            // **取り出す前に判定してから**一緒に引き取る。
            //
            // 判定は純粋関数（`queue_batch`、単体試験 11 件）。
            // ここで対象外なら待ち行列に一切触らないので、
            // 「取り出したのに使わない」経路ができない。
            let batch: alloc::vec::Vec<String> = match &picked {
                Some((h, _, https, pr, nb))
                    if super::queue_batch::may_start_batch(false, *https, *nb) =>
                {
                    let (h, pr) = (h.clone(), *pr);
                    let cands: alloc::vec::Vec<super::queue_batch::Candidate> = q
                        .pending
                        .iter()
                        .map(|e| super::queue_batch::Candidate {
                            same_host: e.0 == h,
                            same_priority: e.3 == pr,
                            is_https: e.2,
                            no_batch: e.4,
                        })
                        .collect();
                    let idxs = super::queue_batch::select_batch(&cands, MAX_KEEPALIVE_BATCH);
                    // 添字は昇順なので**後ろから**取り除く（ずれない）。
                    let mut v = alloc::vec::Vec::with_capacity(idxs.len());
                    for &i in idxs.iter().rev() {
                        let (_, pp, _, _, _) = q.pending.remove(i);
                        FQ_PENDING
                            .store(q.pending.len() as u32, core::sync::atomic::Ordering::Release);
                        v.push(pp);
                    }
                    v
                }
                _ => alloc::vec::Vec::new(),
            };
            match picked {
                Some(v) => (v, batch),
                None => {
                    // 取り残しが無いことを確認してから終了する
                    // （終了レースで永久に処理されないアイテムを作らない）。
                    q.active_workers = q.active_workers.saturating_sub(1);
                    store_worker_count(q.active_workers);
                    drop(q);
                    // 正常終了なので所有の記録を外してから枠を返す。
                    // 外し忘れると、その PID が使い回されたときに
                    // 無関係なスレッドの死で枠が二重に返る。
                    super::fetch_limit::unclaim(my_pid);
                    super::fetch_limit::release();
                    FQ_EXITS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
                    if got_any {
                        // ここで初めて描画側へ知らせる（R-3）。
                        FONTS_UPDATED.store(true, core::sync::atomic::Ordering::Relaxed);
                    }
                    // 【2026-08-05 重大】ここは `return` だった。
                    //
                    // カーネルスレッドの入口関数から `return` してもスレッドは
                    // 終わらず、**入口から再実行され続ける**。
                    // 実測: ワーカーを 4 本しか起こしていないのに
                    // この経路を **3 億回以上**通っていた
                    // （`[FQDIAG] iters=341562104 spawn=4 exit=341562100`）。
                    //
                    // 空回りが CPU を食い潰し、通信も描画も遅くなる。
                    // 他のスレッド（`async_load_thread_entry`、`main.rs` の各所）は
                    // いずれも `scheduler::exit()` を明示的に呼んでいる。
                    // ここだけ作法が違っていた。
                    crate::kernel::scheduler::exit();
                }
            }
        };
        let ((host, path, is_https, _prio, _no_batch), batch) = next;
        let is_style = _prio == super::fetch_limit::Kind::Style.priority();

        if super::cache::read_cache(&host, &path).is_some() {
            FQ_CACHED.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
            continue;
        }

        // 【2026-08-05】同一ホストをまとめて 1 接続で取る。
        //
        // 動機（実測）: `TLS握手=3512/14`（約 35 秒、1 回 約 250 tick）。
        // DNS も TCP 接続も軽く、重いのは TLS 交渉そのもの。
        // ホストは 4 種類程度なので、まとめれば大半を消せる。
        //
        // 6 回配線して 6 回とも `total=3` で止まったが、
        // その原因は**まとめ取得ではなくワーカーの空回り**だった
        // （`return` でスレッドが終わらず 3 億回転。R-17）。
        // 空回りを直したうえで改めて入れる。
        //
        // `batch` は**取り出す前に判定して**集めてある（`queue_batch`）。
        // ここは無条件に使い切る。取り出したまま使わない経路は作らない。
        if !batch.is_empty() {
            let mut paths = alloc::vec::Vec::with_capacity(1 + batch.len());
            paths.push(path.clone());
            paths.extend(batch.iter().cloned());
            // 通信中のワーカー数を数える。停滞したとき
            // 「種別の上限に張り付いている（fw=4）」までは分かっても、
            // **どこで止まっているか**が分からなかった。
            // ここが fw と同数なら、停止点は取得そのもの。
            FQ_IN_FETCH.fetch_add(1, core::sync::atomic::Ordering::AcqRel);
            let fetched = crate::kernel::tls::https_get_binary_keepalive(&host, &paths);
            FQ_IN_FETCH.fetch_sub(1, core::sync::atomic::Ordering::AcqRel);
            let results = match fetched {
                Ok(r) => r,
                Err(e) => {
                    crate::warn!("[KADIAG] まとめ取得に失敗 host={} err={}", host, e);
                    alloc::vec![None; paths.len()]
                }
            };
            let mut any = false;
            let mut retry: alloc::vec::Vec<String> = alloc::vec::Vec::new();
            for (pp, r) in paths.iter().zip(results.into_iter()) {
                match r {
                    Some(b) if !b.is_empty() => {
                        super::cache::write_cache(&host, pp, &b);
                        any = true;
                    }
                    // 取れなかったぶんは印を付けて**必ず戻す**。
                    // 印が無いと同じ便に乗り直して堂々巡りになる。
                    _ => retry.push(pp.clone()),
                }
            }
            if !retry.is_empty() {
                let mut q = FONT_QUEUE.lock();
                for pp in retry {
                    // 【2026-08-05 バグ修正】ここは `is_https` を `true` に
                    // 決め打ちしていた。HTTP で取ったものを HTTPS として
                    // 積み直すことになり、再試行は必ず失敗する。
                    // 元の値をそのまま使う。
                    q.pending.push((host.clone(), pp, is_https, _prio, true));
                    FQ_PENDING
                        .store(q.pending.len() as u32, core::sync::atomic::Ordering::Release);
                }
            }
            if any {
                FONTS_UPDATED.store(true, core::sync::atomic::Ordering::Relaxed);
                got_any = true;
            }
            crate::kernel::scheduler::yield_now();
            continue;
        }

        FQ_FETCH.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        let result = if is_https {
            crate::kernel::tls::https_get_binary(&host, &path)
        } else {
            crate::kernel::net::http_get_binary(&host, &path)
        };
        match result {
            Ok(bytes) if !bytes.is_empty() => {
                crate::warn!(
                    "[FONT] 背景取得完了 host={} path={} bytes={}",
                    host,
                    path,
                    bytes.len()
                );
                super::cache::write_cache(&host, &path, &bytes);
                if is_style {
                    let now = crate::kernel::timer::get_ticks();
                    let _ = STYLE_ARRIVE_TICK.compare_exchange(
                        0,
                        now,
                        core::sync::atomic::Ordering::AcqRel,
                        core::sync::atomic::Ordering::Acquire,
                    );
                    crate::warn!(
                        "[CSSTRACE] 到着 path={} 投入から={}tick",
                        path,
                        now.wrapping_sub(
                            STYLE_ENQUEUE_TICK.load(core::sync::atomic::Ordering::Acquire)
                        )
                    );
                }
                // 【2026-07-31】1 本ごとに通知する。
                //
                // 一度「キューが空になってからまとめて通知」に変えたが、
                // **通知が 0 回になった**。14 件投入して 8 件しか取れていない間は
                // キューが空になる瞬間が来ないため、取得が遅いほど
                // 永久に反映されないという逆の壊れ方をした（実測）。
                // 届いたものから順に反映する方が R-3 の趣旨にも合う。
                FONTS_UPDATED.store(true, core::sync::atomic::Ordering::Relaxed);
                got_any = true;
            }
            Ok(_) => {
                // 空応答はキャッシュしない（一度書くと恒久的に空が返り続ける）。
                crate::warn!("[FONT] 背景取得が空 host={} path={}", host, path);
            }
            Err(e) => {
                crate::warn!("[FONT] 背景取得失敗 host={} path={} err={}", host, path, e);
            }
        }
        crate::kernel::scheduler::yield_now();
    }
}