atmos/kernel/

draw.rs

use crate::kernel::font::FONT_DATA;
use core::cell::Cell;

static ICON_CURSOR_64: &[u8] = include_bytes!("../../icons/ic_fluent_cursor_64_regular.svg");

#[derive(Copy, Clone)]
pub struct Color(pub u32);

impl Color {
    pub fn to_hardware_format(self) -> u32 {
        let val = self.0;
        let a = val & 0xFF000000;
        let r = (val >> 16) & 0xFF;
        let g = (val >> 8) & 0xFF;
        let b = val & 0xFF;
        a | (b << 16) | (g << 8) | r
    }

    pub fn from_hardware_format(val: u32) -> Color {
        let a = val & 0xFF000000;
        let r = (val >> 16) & 0xFF;
        let g = (val >> 8) & 0xFF;
        let b = val & 0xFF;
        Color(a | (b << 16) | (g << 8) | r)
    }
}

impl Color {
    pub const BLACK: Color = Color(0xFF000000);
    pub const WHITE: Color = Color(0xFFFFFFFF);
    pub const LIGHT_GRAY: Color = Color(0xFFC6C6C6);
    pub const DARK_GRAY: Color = Color(0xFF848484);
    pub const BLUE: Color = Color(0xFF000084);
    pub const DARK_RED: Color = Color(0xFF840000);
    pub const INACTIVE_TITLE: Color = Color(0xFF5A5A5A);
}

const DMA_THRESHOLD_PIXELS: u32 = 2048; // 32bpp で 8KB 相当

/// 【2026-07-27診断】コンポジタが画面へ出したフレームの通し番号。
/// ヒーロー見出しの描画は成功しているのに画面に出ない件で、
/// 「文字を描いたフレーム」と「実際に表示されているフレーム」が
/// 同一かを突き合わせるために使う。
pub static FRAME_NO: core::sync::atomic::AtomicU32 = core::sync::atomic::AtomicU32::new(0);
/// ヒーロー見出し（size>=40 のテキスト）を最後に描画したフレーム番号。
pub static HERO_TEXT_FRAME: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(u32::MAX);


pub struct Screen {
    pub vram: *mut u32,
    pub back_buffer: *mut u32,
    pub use_back_buffer: core::cell::Cell<bool>,
    pub width: u32,
    pub height: u32,
    pub pitch: u32,                               // bytes per line
    pub clip: Cell<Option<(u32, u32, u32, u32)>>, // (x0, y0, x1, y1)
    /// 角丸の切り取り（x0, y0, x1, y1, 半径）。`clip` と併用し、角の外側の画素を捨てる。
    /// 【2026-10-03】`overflow:hidden; border-radius` の箱の中身用（`draw_clip::round_clip_inset`）。
    pub round_clip: Cell<Option<(i32, i32, i32, i32, i32)>>,
    clip_stack: Cell<[Option<(u32, u32, u32, u32)>; 8]>,
    clip_depth: Cell<usize>,

    // 動的描画ターゲットバッファの追加
    render_target: Cell<*mut u32>,
    target_width: Cell<u32>,
    target_height: Cell<u32>,
    saved_target_clip: Cell<Option<Option<(u32, u32, u32, u32)>>>,

    // VSync ページフリップ用
    vsync: Cell<bool>, // 2ページ確保済み（virtual_height=2H）で flip が使えるか
    page: Cell<u32>,   // 次に描画する VRAM ページ (0/1)
    fb_virtual_height: Cell<u32>, // GPU が確保した仮想高さ（2*height で 2 ページ）
    fb_size: Cell<u32>, // GPU が確保したバッファ総バイト数
    // VSync 部分フラッシュ用: 前回フレームのコンテンツのダーティ領域（今回と合わせ 2 フレーム分を裏ページへ）
    prev_content_region: Cell<Option<(u32, u32, u32, u32)>>,
    // 各ページ(0/1)に焼き込まれているカーソル位置。裏ページのカーソル消去に使う
    // （ページは交互なので裏ページのカーソルは 2 フレーム前の位置）。
    page_cursor: Cell<[(u32, u32); 2]>,
    // VSync 有効化直後は両ページを全面初期化する必要があるため、最初の数フレームは全面転送する
    vsync_init_count: Cell<u8>,
}

/// 【2026-07-31計測】テキスト描画に費やした tick の累積（フレーム毎にリセット）。
pub static TEXT_DRAW_TICKS: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

/// 【2026-08-01計測】矩形塗り（boxfill）の累積 tick。
pub static BOXFILL_TICKS: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);
/// 【2026-08-01計測】box-shadow 描画の累積 tick。
pub static SHADOW_TICKS: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

/// 【2026-08-01計測】角丸/クリップ付き背景の毎ピクセル塗りの累積 tick。
pub static RRECT_TICKS: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

/// 【2026-08-01計測】clip-path / opacity / mix-blend-mode による
/// 背景の毎ピクセル塗りの累積 tick。
pub static PIXBG_TICKS: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

/// 描画側から使う計測ガード（`PIXBG_TICKS` 用）。
pub struct PixBgTimer(usize);
impl PixBgTimer {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        Self(crate::kernel::timer::get_ticks())
    }
}
impl Drop for PixBgTimer {
    fn drop(&mut self) {
        PIXBG_TICKS.fetch_add(
            crate::kernel::timer::get_ticks().wrapping_sub(self.0),
            core::sync::atomic::Ordering::Relaxed,
        );
    }
}

/// 描画側から使う計測ガード。
pub struct RRectTimer(usize);
impl RRectTimer {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        Self(crate::kernel::timer::get_ticks())
    }
}
impl Drop for RRectTimer {
    fn drop(&mut self) {
        RRECT_TICKS.fetch_add(
            crate::kernel::timer::get_ticks().wrapping_sub(self.0),
            core::sync::atomic::Ordering::Relaxed,
        );
    }
}

struct AccTimer(usize, &'static core::sync::atomic::AtomicUsize);
impl Drop for AccTimer {
    fn drop(&mut self) {
        self.1.fetch_add(
            crate::kernel::timer::get_ticks().wrapping_sub(self.0),
            core::sync::atomic::Ordering::Relaxed,
        );
    }
}

/// 早期 return があるため Drop で確実に積む。
struct TextDrawTimer(usize);
impl Drop for TextDrawTimer {
    fn drop(&mut self) {
        TEXT_DRAW_TICKS.fetch_add(
            crate::kernel::timer::get_ticks().wrapping_sub(self.0),
            core::sync::atomic::Ordering::Relaxed,
        );
    }
}

impl Screen {
    pub fn new(vram: *mut u32, width: u32, height: u32, pitch: u32) -> Self {
        Self {
            vram,
            back_buffer: core::ptr::null_mut(),
            use_back_buffer: core::cell::Cell::new(false),
            width,
            height,
            pitch,
            clip: Cell::new(None),
            round_clip: Cell::new(None),
            clip_stack: Cell::new([None; 8]),
            clip_depth: Cell::new(0),
            render_target: Cell::new(core::ptr::null_mut()),
            target_width: Cell::new(width),
            target_height: Cell::new(height),
            saved_target_clip: Cell::new(None),
            vsync: Cell::new(false),
            page: Cell::new(0),
            fb_virtual_height: Cell::new(0),
            fb_size: Cell::new(0),
            prev_content_region: Cell::new(None),
            page_cursor: Cell::new([(0, 0), (0, 0)]),
            vsync_init_count: Cell::new(0),
        }
    }

    pub fn vsync_enabled(&self) -> bool {
        self.vsync.get()
    }

    pub fn has_pending_vsync_sync(&self) -> bool {
        self.prev_content_region.get().is_some()
    }

    /// フレームバッファの実ジオメトリをシリアルへ出力する（実機デバッグ用）。
    /// ブート最序盤のログがスクロールアウトしても確認できるよう、任意の地点で呼べる。
    pub fn debug_geometry(&self) {
        let addr = self.vram as usize;
        let region = if addr >= crate::kernel::mmu::DEVICE_REGION_START {
            "uncached/Device OK"
        } else {
            "CACHED RAM (<0x38000000) !!"
        };
        crate::println!(
            "[FB] vram=0x{:08X} ({}) | {}x{} | pitch={} (width*4={}) | virt_h={} | size={}",
            addr,
            region,
            self.width,
            self.height,
            self.pitch,
            self.width * 4,
            self.fb_virtual_height.get(),
            self.fb_size.get()
        );
    }

    /// GPU が実際に確保したフレームバッファのジオメトリ（仮想高さ・総サイズ）を記録する。
    /// enable_vsync() がこれを見て 2 ページ確保済みか判定する。
    pub fn set_fb_geometry(&self, virtual_height: u32, size: u32) {
        self.fb_virtual_height.set(virtual_height);
        self.fb_size.set(size);
    }

    /// VSync ページフリップを有効化する。ただし 2 ページ（virtual_height >= 2*height かつ
    /// バッファサイズ十分）が実際に確保できている場合のみ。確保できていなければ単一バッファの
    /// ままにする（page1 がフレームバッファ外を指して横線ノイズになるのを防ぐ）。
    /// 有効化できたら true を返す。
    pub fn enable_vsync(&self) -> bool {
        let virt_h = self.fb_virtual_height.get();
        let size = self.fb_size.get();
        let two_pages = virt_h >= self.height * 2
            && (size == 0 || size as u64 >= (self.pitch as u64) * (self.height as u64) * 2);
        if !two_pages {
            self.vsync.set(false);
            return false;
        }
        // 初期表示をページ0に固定
        let _ = crate::kernel::mailbox::set_virtual_offset(0, 0);
        self.page.set(0);
        self.vsync.set(true);
        // 最初の 2 フラッシュは両ページを全面初期化する（部分フラッシュ前提のため）
        self.vsync_init_count.set(2);
        self.prev_content_region.set(None);
        self.page_cursor.set([(0, 0), (0, 0)]);
        true
    }

    pub fn set_render_target(&self, buf: *mut u32, w: u32, h: u32) {
        // メイン画面のクリップを退避し、オフスクリーンターゲット内ではクリップを初期化
        let old_clip = self.clip.get();
        self.saved_target_clip.set(Some(old_clip));
        self.clip.set(None);
        self.render_target.set(buf);
        self.target_width.set(w);
        self.target_height.set(h);
    }

    pub fn reset_render_target(&self) {
        self.render_target.set(core::ptr::null_mut());
        self.target_width.set(self.width);
        self.target_height.set(self.height);
        // 退避されていたメイン画面のクリップを復元
        if let Some(saved) = self.saved_target_clip.take() {
            self.clip.set(saved);
        }
    }

    pub fn resolve_target(&self) -> (*mut u32, u32, u32) {
        let custom_target = self.render_target.get();
        if !custom_target.is_null() {
            (
                custom_target,
                self.target_width.get(),
                self.target_height.get(),
            )
        } else {
            let base_ptr = if self.use_back_buffer.get() && !self.back_buffer.is_null() {
                self.back_buffer
            } else {
                self.vram
            };
            (base_ptr, self.width, self.height)
        }
    }

    /// ターゲットバッファの1行あたりの実際のピクセル数（Stride）を返します。
    pub fn resolve_stride(&self) -> u32 {
        let custom_target = self.render_target.get();
        if !custom_target.is_null() {
            self.target_width.get()
        } else if self.use_back_buffer.get() && !self.back_buffer.is_null() {
            self.width
        } else {
            self.pitch / 4
        }
    }

    pub fn enable_double_buffering(&mut self) {
        if self.back_buffer.is_null() {
            // Allocate a back buffer matching the screen size
            let Ok(layout) = core::alloc::Layout::array::<u32>((self.width * self.height) as usize)
            else {
                return; // サイズ計算がオーバーフローした場合は有効化しない
            };
            unsafe {
                self.back_buffer = alloc::alloc::alloc_zeroed(layout) as *mut u32;
            }
            if self.back_buffer.is_null() {
                return; // 確保失敗時はバックバッファ無効のまま継続
            }
        }
        self.use_back_buffer.set(true);
    }

    pub fn flush(&self) {
        if self.use_back_buffer.get() && !self.back_buffer.is_null() {
            let stride = self.pitch / 4;
            let w = self.width;
            let h = self.height;

            if self.vsync.get() {
                // ページフリップ: 裏ページ(現在 page)へ全画面コピーしてから VBlank で flip。
                // 表示中ページは書き換えないためティアリングが起きない。
                let page = self.page.get();
                let page_off_px = page * h * stride; // ページ先頭のピクセルオフセット
                let dst = self.vram as u32 + page_off_px * 4;
                if stride == w {
                    crate::kernel::dma::dma_memcpy(5, self.back_buffer as u32, dst, w * h * 4);
                } else {
                    crate::kernel::dma::dma_memcpy_2d(
                        5,
                        self.back_buffer as u32,
                        dst,
                        w * 4,
                        h,
                        w * 4,
                        stride * 4,
                    );
                }
                // VBlank 同期フリップ（表示元をこのページへ）
                let _ = crate::kernel::mailbox::set_virtual_offset(0, page * h);
                // VSync（VBlank）完了を待機
                let _ = crate::kernel::mailbox::wait_vsync();
                // 次回は反対のページへ描く
                self.page.set(1 - page);
            } else if stride == w {
                crate::kernel::dma::dma_memcpy(
                    5,
                    self.back_buffer as u32,
                    self.vram as u32,
                    w * h * 4,
                );
            } else {
                crate::kernel::dma::dma_memcpy_2d(
                    5,
                    self.back_buffer as u32,
                    self.vram as u32,
                    w * 4,
                    h,
                    w * 4,
                    stride * 4,
                );
            }
        }
    }

    pub fn flush_rect(&self, x0: u32, y0: u32, x1: u32, y1: u32) {
        // VSync ページフリップ時は部分転送だと裏ページに古い領域が残るため、
        // 全画面コピー+flip に切り替える（ティアリング無し優先）。
        if self.vsync.get() {
            self.flush();
            return;
        }
        if self.use_back_buffer.get() && !self.back_buffer.is_null() {
            let stride = self.pitch / 4;
            let w = self.width;
            let h = self.height;

            let cx0 = x0.min(w - 1);
            let cx1 = x1.min(w - 1).max(cx0);
            let cy0 = y0.min(h - 1);
            let cy1 = y1.min(h - 1).max(cy0);

            let rect_w = cx1 - cx0 + 1;
            let rect_h = cy1 - cy0 + 1;

            if rect_w * rect_h >= DMA_THRESHOLD_PIXELS {
                let src_offset = (cy0 * w + cx0) * 4;
                let dst_offset = (cy0 * stride + cx0) * 4;
                crate::kernel::dma::dma_memcpy_2d(
                    5,
                    self.back_buffer as u32 + src_offset,
                    self.vram as u32 + dst_offset,
                    rect_w * 4,
                    rect_h,
                    w * 4,
                    stride * 4,
                );
            } else {
                for y in cy0..=cy1 {
                    unsafe {
                        let src = self.back_buffer.add((y * w + cx0) as usize);
                        let dst = self.vram.add((y * stride + cx0) as usize);
                        core::ptr::copy_nonoverlapping(src, dst, rect_w as usize);
                    }
                }
            }
        }
    }

    /// 画面バッファ内の指定矩形 (x, y, w, h) を垂直方向に `dy` ピクセル移動（Blitスクロール）する。
    ///
    /// - `dy > 0`: 下へスクロール（コンテンツは上へ移動）
    /// - `dy < 0`: 上へスクロール（コンテンツは下へ移動）
    ///
    /// 重複領域の移動には安全なメモリコピー（`core::ptr::copy`、memmove 相当）を使用するため、
    /// 前方/後方コピーによるデータ破壊が起きない。
    pub fn scroll_rect(&self, x: u32, y: u32, w: u32, h: u32, dy: i32) {
        if dy == 0 || w == 0 || h == 0 {
            return;
        }
        let abs_dy = dy.unsigned_abs();
        if abs_dy >= h {
            return;
        }
        let (target_ptr, buf_w, buf_h) = self.resolve_target();
        if x >= buf_w || y >= buf_h {
            return;
        }
        let actual_w = w.min(buf_w - x);
        let actual_h = h.min(buf_h - y);
        if abs_dy >= actual_h {
            return;
        }

        let stride = self.resolve_stride() as usize;
        let move_h = (actual_h - abs_dy) as usize;
        let copy_w = actual_w as usize;

        unsafe {
            if dy > 0 {
                // コンテンツを上へシフト（下方の行を上方へコピー）
                let src_y = (y + abs_dy) as usize;
                let dst_y = y as usize;
                for row in 0..move_h {
                    let src = target_ptr.add((src_y + row) * stride + x as usize);
                    let dst = target_ptr.add((dst_y + row) * stride + x as usize);
                    core::ptr::copy(src, dst, copy_w);
                }
            } else {
                // コンテンツを下へシフト（上方の行を下方へコピー）
                let src_y = y as usize;
                let dst_y = (y + abs_dy) as usize;
                for row in (0..move_h).rev() {
                    let src = target_ptr.add((src_y + row) * stride + x as usize);
                    let dst = target_ptr.add((dst_y + row) * stride + x as usize);
                    core::ptr::copy(src, dst, copy_w);
                }
            }
        }
    }

    /// 一時的に裏画面を無効化し、直接VRAM（表画面）にマウスを描画します
    pub fn draw_mouse_direct(&self, mouse: &Mouse) {
        let prev = self.use_back_buffer.get();
        self.use_back_buffer.set(false);
        mouse.draw(self);
        self.use_back_buffer.set(prev);
    }

    /// バックバッファにカーソルを一時合成してからflushする。
    /// flush中にカーソルが消えてちらつく現象を防ぐ。
    pub fn flush_with_cursor(&self, mouse: &Mouse) {
        if !self.use_back_buffer.get() || self.back_buffer.is_null() {
            self.flush();
            return;
        }
        let cursor_size = Mouse::SIZE as usize;
        let w = self.width as usize;
        let h = self.height as usize;
        let cx = mouse.x as usize;
        let cy = mouse.y as usize;

        // カーソル領域のバックバッファを一時保存
        let rows = cursor_size.min(h.saturating_sub(cy));
        let cols = cursor_size.min(w.saturating_sub(cx));
        let mut saved = alloc::vec![0u32; cursor_size * cursor_size];
        unsafe {
            for row in 0..rows {
                let src = self.back_buffer.add((cy + row) * w + cx);
                core::ptr::copy_nonoverlapping(
                    src,
                    saved.as_mut_ptr().add(row * cursor_size),
                    cols,
                );
            }
        }

        // バックバッファにカーソルを描画してから flush
        mouse.draw(self);
        self.flush();

        // バックバッファを復元（カーソルを消す）
        unsafe {
            for row in 0..rows {
                let dst = self.back_buffer.add((cy + row) * w + cx);
                core::ptr::copy_nonoverlapping(saved.as_ptr().add(row * cursor_size), dst, cols);
            }
        }
    }

    /// VSync ページフリップ時に、ダーティ領域だけを裏ページへ転送してフリップする部分フラッシュ。
    /// `content` は今回のコンテンツのダーティ矩形 (x0,y0,x1,y1)。カーソルは内部で合成する。
    /// 裏ページは 2 フレーム前の内容なので「今回 ∪ 前回」のダーティ領域を転送して整合を保つ。
    /// 全画面コピーを避けるため、小さな更新ではコストが大幅に下がる。
    pub fn flush_dirty_pageflip(&self, content: Option<(u32, u32, u32, u32)>, mouse: &Mouse) {
        if !self.vsync.get() || !self.use_back_buffer.get() || self.back_buffer.is_null() {
            // VSync 無効時は呼ばれない想定だが、安全のため全面フラッシュにフォールバック
            self.flush_with_cursor(mouse);
            return;
        }
        let w = self.width;
        let h = self.height;
        let stride = self.pitch / 4;
        let cs = Mouse::SIZE;

        #[inline]
        fn union(a: (u32, u32, u32, u32), b: (u32, u32, u32, u32)) -> (u32, u32, u32, u32) {
            (a.0.min(b.0), a.1.min(b.1), a.2.max(b.2), a.3.max(b.3))
        }

        #[inline]
        fn cursor_rect(x: u32, y: u32, cs: u32, w: u32, h: u32) -> (u32, u32, u32, u32) {
            (x.min(w), y.min(h), (x + cs).min(w), (y + cs).min(h))
        }

        let page = self.page.get(); // これから描く裏ページ
                                    // 今回のカーソル矩形（新位置）
        let c_new = cursor_rect(mouse.x, mouse.y, cs, w, h);
        // 裏ページに焼き込まれている古いカーソル（2 フレーム前の位置）を消すための矩形
        let old_c = self.page_cursor.get()[page as usize];
        let c_old = cursor_rect(old_c.0, old_c.1, cs, w, h);

        // 今回のコンテンツのダーティ（クランプ）
        let content_now = content.map(|c| (c.0.min(w), c.1.min(h), c.2.min(w), c.3.min(h)));

        // 転送領域: 最初の数フレームは全面、それ以降は
        //   コンテンツ(今回 ∪ 前回) ∪ カーソル(新) ∪ 裏ページの旧カーソル
        // 【2026-07-26 検証済み・仮説は否定】ヒーロー見出しがバックバッファへは
        // 書き込まれている（[GLYPH][PX] で 1 文字 200〜500px を確認）のに画面へ
        // 出ない件について、「ダーティ矩形が描画範囲を覆えていない」疑いを
        // 検証するため一時的に常時全面転送にして実機確認したが、**それでも
        // 文字は表示されなかった**。したがって転送領域は原因ではない
        // （＝文字は「表示に使われるバッファとは別の場所」へ書かれている）。
        // 常時全面転送は性能を損なうだけなので元の差分転送へ戻す。
        let region = if self.vsync_init_count.get() > 0 {
            self.vsync_init_count.set(self.vsync_init_count.get() - 1);
            (0, 0, w, h)
        } else {
            // コンテンツの 2 フレーム分
            let content_region = match (content_now, self.prev_content_region.get()) {
                (Some(a), Some(b)) => Some(union(a, b)),
                (Some(a), None) => Some(a),
                (None, Some(b)) => Some(b),
                (None, None) => None,
            };
            let mut r = union(c_new, c_old);
            if let Some(cr) = content_region {
                r = union(r, cr);
            }
            r
        };

        let x0 = region.0.min(w);
        let y0 = region.1.min(h);
        let x1 = region.2.min(w).max(x0);
        let y1 = region.3.min(h).max(y0);

        // カーソルを back_buffer に一時合成（SIZE×SIZE を退避）
        let cx = mouse.x as usize;
        let cy = mouse.y as usize;
        let wsz = w as usize;
        let hsz = h as usize;
        let rows = (cs as usize).min(hsz.saturating_sub(cy));
        let cols = (cs as usize).min(wsz.saturating_sub(cx));
        let mut saved = alloc::vec![0u32; (cs * cs) as usize];
        unsafe {
            for row in 0..rows {
                let src = self.back_buffer.add((cy + row) * wsz + cx);
                core::ptr::copy_nonoverlapping(
                    src,
                    saved.as_mut_ptr().add(row * cs as usize),
                    cols,
                );
            }
        }
        mouse.draw(self); // back_buffer にカーソルを描画（use_back_buffer=true 前提）

        // 裏ページへ region を部分転送 → フリップ
        if x1 > x0 && y1 > y0 {
            let rect_w = x1 - x0;
            let rect_h = y1 - y0;
            let src_off = y0 * w + x0;
            let dst_off = page * h * stride + y0 * stride + x0;
            crate::kernel::dma::dma_memcpy_2d(
                5,
                self.back_buffer as u32 + src_off * 4,
                self.vram as u32 + dst_off * 4,
                rect_w * 4,
                rect_h,
                w * 4,
                stride * 4,
            );
            let _ = crate::kernel::mailbox::set_virtual_offset(0, page * h);
            let _ = crate::kernel::mailbox::wait_vsync();
            self.page.set(1 - page);
        }

        // back_buffer のカーソルを復元
        unsafe {
            for row in 0..rows {
                let dst = self.back_buffer.add((cy + row) * wsz + cx);
                core::ptr::copy_nonoverlapping(saved.as_ptr().add(row * cs as usize), dst, cols);
            }
        }

        // この裏ページにはカーソルを新位置で焼き込んだので記録（次にこのページを描く時に消す）
        let mut pc = self.page_cursor.get();
        pc[page as usize] = (mouse.x, mouse.y);
        self.page_cursor.set(pc);
        self.prev_content_region.set(content_now);
    }

    pub fn set_clip(&self, x0: u32, y0: u32, x1: u32, y1: u32) {
        self.clip.set(Some((x0, y0, x1, y1)));
    }

    /// 現在のクリップ矩形（診断用）。`None` はクリップ無し。
    pub fn clip_rect(&self) -> Option<(u32, u32, u32, u32)> {
        self.clip.get()
    }

    pub fn clear_clip(&self) {
        self.clip.set(None);
    }

    /// 現在のクリップをスタックに積んで、新しいクリップを現在と交差させて設定する。
    /// pop_clip() で元のクリップに戻る（最大 8 段ネスト可。iframe の入れ子の描画も積む）。
    pub fn push_clip(&self, x0: u32, y0: u32, x1: u32, y1: u32) {
        let depth = self.clip_depth.get();
        if depth < 8 {
            let mut stack = self.clip_stack.get();
            stack[depth] = self.clip.get();
            self.clip_stack.set(stack);
            self.clip_depth.set(depth + 1);
        }
        let new_clip = if let Some((cx0, cy0, cx1, cy1)) = self.clip.get() {
            (cx0.max(x0), cy0.max(y0), cx1.min(x1), cy1.min(y1))
        } else {
            (x0, y0, x1, y1)
        };
        self.clip.set(Some(new_clip));
    }

    /// push_clip() で積んだクリップを復元する。
    pub fn pop_clip(&self) {
        let depth = self.clip_depth.get();
        if depth > 0 {
            let stack = self.clip_stack.get();
            self.clip.set(stack[depth - 1]);
            self.clip_depth.set(depth - 1);
        } else {
            self.clip.set(None);
        }
    }

    pub fn clear(&self, color: Color) {
        // クリップ領域が設定されている場合、その範囲のみクリアする（部分再描画対応）。
        // boxfill はクリップ対応済みなので、クリップ領域だけが塗りつぶされる。
        if let Some((cx0, cy0, cx1, cy1)) = self.clip.get() {
            self.boxfill(cx0, cy0, cx1, cy1, color);
            return;
        }

        let (target_ptr, _w, h) = self.resolve_target();

        // V3D タイルクリア (64x64 タイル) は実機で 64px グリッド状のアーティファクト
        // (色付きの点線) を生じることがあり、また pitch パディングを考慮しないため使用しない。
        // stride を正しく扱う DMA fill に一本化する。
        let stride = self.resolve_stride();
        let color_val = color.to_hardware_format();
        crate::kernel::dma::dma_fill_rect(
            5, // DMA Channel 5
            &color_val as *const _ as u32,
            target_ptr as u32,
            stride,
            h,
            stride * 4,
        );
    }

    /// 計算量: **O(1)** — クリップ判定 1 回と 32bit 書き込み 1 回。
    ///
    /// 描画の最下層プリミティブ。上層はこれの呼び出し回数で見積もれる
    /// （規約は `spec/complexity_annotation.md`）。
    /// 角丸の切り取りの外側か（`round_clip` が無ければ常に false）。
    #[inline]
    fn outside_round_clip(&self, x: u32, y: u32) -> bool {
        match self.round_clip.get() {
            None => false,
            Some((x0, y0, x1, y1, r)) => {
                let (x, y) = (x as i32, y as i32);
                let inset = crate::kernel::draw_clip::round_clip_inset(y, y0, y1, r);
                inset > 0 && (x < x0 + inset || x >= x1 - inset)
            }
        }
    }

    pub fn draw_pixel(&self, x: u32, y: u32, color: Color) {
        if let Some((cx0, cy0, cx1, cy1)) = self.clip.get() {
            if x < cx0 || x >= cx1 || y < cy0 || y >= cy1 {
                return;
            }
        }
        if self.outside_round_clip(x, y) {
            return;
        }

        // 半透明色は背景と source-over 合成する（`spec/alpha_compositing.md`）。
        // 実サイトの `.hero-overlay { background: rgba(0,0,0,.2) }`（0x33000000）が
        // 不透明な黒帯として描かれていた回帰への対処。
        //
        // 【互換上の妥協】アルファ 0x00 は「完全透明」ではなく**不透明**として扱う。
        // 既存コードの大半はアルファを設定せず 0x00 のまま色を渡しており、
        // 仕様どおり完全透明にすると画面全体が消える。合成するのは 0x01〜0xFE のみ。
        // この妥協は `spec/alpha_compositing.md` にも明記してある。
        let a = (color.0 >> 24) & 0xFF;
        let color = if a == 0 || a == 0xFF {
            color
        } else {
            Color(crate::os_lib::web_engine::alpha_blend::blend_argb_over(
                color.0,
                self.read_pixel(x, y).0 | 0xFF00_0000,
            ))
        };

        let (target_ptr, w, h) = self.resolve_target();
        // 画面外の座標は捨てる。要素がビューポートをはみ出すのは正常なので
        // これは異常ではなく、ログも出さない（`spec/logging_policy.md` L-3）。
        if x < w && y < h {
            let stride = self.resolve_stride();
            unsafe {
                let ptr = target_ptr.add((y * stride + x) as usize);
                core::ptr::write_volatile(ptr, color.to_hardware_format());
            }
        }
    }

    pub fn read_pixel(&self, x: u32, y: u32) -> Color {
        let (target_ptr, w, h) = self.resolve_target();
        if x < w && y < h {
            let stride = self.resolve_stride();
            unsafe {
                let ptr = target_ptr.add((y * stride + x) as usize);
                Color::from_hardware_format(core::ptr::read_volatile(ptr))
            }
        } else {
            Color::BLACK
        }
    }

    /// 計算量: **O(1)**。ただし定数倍は `draw_pixel` より重い。
    ///
    /// - `alpha == 0`: 何もしない（最速）
    /// - `alpha == 255`: `draw_pixel` へ委譲（O(1)、軽い）
    /// - それ以外: **既存ピクセルの読み出し**＋3 チャンネルの合成が要る。
    ///   読み出しがフレームバッファへのアクセスになるため、
    ///   不透明の場合の数倍のコストになる
    pub fn draw_pixel_alpha(&self, x: u32, y: u32, color: Color, alpha: u8) {
        if alpha == 0 {
            return;
        }
        if let Some((cx0, cy0, cx1, cy1)) = self.clip.get() {
            if x < cx0 || x >= cx1 || y < cy0 || y >= cy1 {
                return;
            }
        }
        if self.outside_round_clip(x, y) {
            return;
        }

        let (target_ptr, w, h) = self.resolve_target();
        if x >= w || y >= h {
            return;
        }
        let stride = self.resolve_stride();
        unsafe {
            let ptr = target_ptr.add((y * stride + x) as usize);
            if alpha == 255 {
                core::ptr::write_volatile(ptr, color.to_hardware_format());
                return;
            }

            let bg_val = core::ptr::read_volatile(ptr);
            // ハードウェアフォーマットは 0xAABBGGRR
            let a = alpha as u32;
            let inv_a = 255 - a;

            let fg_r = (color.0 >> 16) & 0xFF;
            let fg_g = (color.0 >> 8) & 0xFF;
            let fg_b = color.0 & 0xFF;

            let fg_rb_term = ((fg_b * a + 127) << 16) | (fg_r * a + 127);
            let bg_rb = bg_val & 0x00FF_00FF;
            let rb_prod = fg_rb_term + bg_rb * inv_a;
            let r = (rb_prod & 0xFFFF) / 255;
            let b = (rb_prod >> 16) / 255;
            let g = (fg_g * a + 127 + ((bg_val >> 8) & 0xFF) * inv_a) / 255;

            let blended = 0xFF00_0000 | (b << 16) | (g << 8) | r;
            core::ptr::write_volatile(ptr, blended);
        }
    }

    /// ベクトルフォントを用いて、指定したサイズと色で文字列を描画します (アンチエイリアス対応)
    pub fn draw_string_vector(&self, x: u32, y: u32, s: &str, color: Color, size_px: u32) {
        let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
        if let Some(ref mut font) = *font_lock {
            let (_, w, h) = self.resolve_target();
            let mut cur_x = x as i32;
            for c in s.chars() {
                if let Some(glyph) = font.get_glyph(c, size_px) {
                    let gx = cur_x + glyph.x_offset;
                    // ベクトルフォントのベースラインから上端(Top)基準にアセンダ補正(0.85 * size_px)を追加して、位置ズレを解消
                    let gy = y as i32 + glyph.y_offset + (size_px as i32 * 85 / 100);

                    for row in 0..glyph.height {
                        let py = gy + row as i32;
                        if py < 0 || py >= h as i32 {
                            continue;
                        }
                        for col in 0..glyph.width {
                            let px = gx + col as i32;
                            if px < 0 || px >= w as i32 {
                                continue;
                            }

                            let alpha = glyph.data[(row * glyph.width + col) as usize];
                            if alpha > 0 {
                                self.draw_pixel_alpha(px as u32, py as u32, color, alpha);
                            }
                        }
                    }

                    cur_x += glyph.advance as i32;
                }
            }
        }
    }

    /// ベクトルフォントを用いて、指定した背景色で文字列を描画します（カラーキャッシュによる高速化版）
    pub fn draw_string_vector_bg(
        &self,
        x: u32,
        y: u32,
        s: &str,
        color: Color,
        size_px: u32,
        bg: Color,
    ) {
        let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
        if let Some(ref mut font) = *font_lock {
            let (_, w, h) = self.resolve_target();
            let mut cur_x = x as i32;
            for c in s.chars() {
                if let Some(glyph) = font.get_color_glyph(c, size_px, color.0, bg.0) {
                    let gx = cur_x + glyph.x_offset;
                    let gy = y as i32 + glyph.y_offset + (size_px as i32 * 85 / 100);

                    for row in 0..glyph.height {
                        let py = gy + row as i32;
                        if py < 0 || py >= h as i32 {
                            continue;
                        }
                        for col in 0..glyph.width {
                            let px = gx + col as i32;
                            if px < 0 || px >= w as i32 {
                                continue;
                            }
                            let pixel_color = glyph.data[(row * glyph.width + col) as usize];
                            if (pixel_color >> 24) > 0 {
                                // 完全透明ピクセルはスキップ
                                self.draw_pixel(px as u32, py as u32, Color(pixel_color));
                            }
                        }
                    }
                    cur_x += glyph.advance as i32;
                } else {
                    cur_x += (size_px / 2) as i32;
                }
            }
        }
    }

    /// 縦スクロールバーの共通描画ヘルパー（幅 6px のサム）。
    ///
    /// - `track_x`: バー帯の左端 X
    /// - `track_y` / `track_h`: トラック（可動域）の上端 Y と高さ
    /// - `content_h`: コンテンツ全体の高さ
    /// - `viewport_h`: 表示領域の高さ
    /// - `scroll_pos`: 現在のスクロール量 (0..=content_h-viewport_h)
    ///
    /// コンテンツが表示領域に収まっている場合は何も描かない。
    /// Web ページ・textarea・将来的にターミナル等、スクロールする UI は
    /// すべてこのヘルパーを使い、見た目と計算を統一する。
    /// 計算量: **O(6×Th)** — Th はサムの高さ（ピクセル）。`boxfill` 1 回ぶん。
    /// 幅は 6px 固定なので実質 O(Th)。
    /// スタイリング（幅、サム色、トラック色）に対応した垂直スクロールバー描画
    pub fn draw_vscrollbar_styled(
        &self,
        track_x: u32,
        track_y: i32,
        track_h: i32,
        content_h: i32,
        viewport_h: i32,
        scroll_pos: i32,
        thumb_width: u32,
        thumb_color: Color,
        track_color: Option<Color>,
    ) {
        if content_h <= viewport_h || track_h <= 0 || viewport_h <= 0 || thumb_width == 0 {
            return;
        }
        if let Some(track_col) = track_color {
            self.boxfill(
                track_x,
                track_y.max(0) as u32,
                track_x + thumb_width,
                (track_y + track_h).max(0) as u32,
                track_col,
            );
        }
        let max_scroll = (content_h - viewport_h).max(1);
        let thumb_h = ((track_h * viewport_h) / content_h).clamp(24.min(track_h), track_h);
        let ratio = scroll_pos.clamp(0, max_scroll) as f32 / max_scroll as f32;
        let thumb_y = track_y + (ratio * (track_h - thumb_h) as f32) as i32;
        self.boxfill(
            track_x,
            thumb_y.max(0) as u32,
            track_x + thumb_width,
            (thumb_y + thumb_h).max(0) as u32,
            thumb_color,
        );
    }

    pub fn draw_vscrollbar(
        &self,
        track_x: u32,
        track_y: i32,
        track_h: i32,
        content_h: i32,
        viewport_h: i32,
        scroll_pos: i32,
    ) {
        let thumb_color = Color(crate::kernel::config::get_config().theme.scrollbar_thumb);
        self.draw_vscrollbar_styled(
            track_x,
            track_y,
            track_h,
            content_h,
            viewport_h,
            scroll_pos,
            6,
            thumb_color,
            None,
        );
    }

    /// 計算量: **O(W×H)** — W = `x1-x0`, H = `y1-y0`（ピクセル）。
    ///
    /// 定数倍がアルファで大きく変わる:
    /// - 不透明（`alpha == 0xFF`）/ 完全透明: 行単位の一括書き込み。軽い
    /// - **半透明（1〜254）**: 1 ピクセルずつ `draw_pixel_alpha` へ委譲するため
    ///   **数倍重い**（`spec/alpha_compositing.md`）
    ///
    /// 呼び出し頻度: 要素ごとに毎フレーム。画面を覆う大きな要素が支配的になる。
    pub fn boxfill(&self, x0: u32, y0: u32, x1: u32, y1: u32, color: Color) {
        // 半透明色（0x01〜0xFE）は 1 ピクセルずつ背景と合成する必要があるため、
        // 一括書き込み経路ではなく draw_pixel へ委譲する。
        // これを怠ると `.hero-overlay { background: rgba(0,0,0,.2) }` が
        // 不透明な黒帯として塗られる（`spec/alpha_compositing.md`）。
        let a = (color.0 >> 24) & 0xFF;
        // 【2026-08-05 発見・修正】アルファ 0（完全透明）は**何も描かない**。
        //
        // 以前は `a == 0` が下の一括書き込み経路へ落ち、
        // `0x00000000` をそのまま書き込んでいた。フレームバッファには
        // アルファが無いので、これは**不透明な黒**になる。
        //
        // 実測: `border-color: transparent`（= `bd=Some(0)`）を持つ
        // 20×20 の `<i>` 要素が黒い枠（☐）として描かれ、
        // Font Awesome のアイコン位置に box が並んでいた。
        //
        // `extract_color` で直したのと同じバグ種別
        // （`spec/alpha_compositing.md`: アルファ 0 は「透明」であって
        //  「不透明な黒」ではない）。
        if a == 0 {
            return;
        }
        // 角丸の切り取りがあれば、角の行だけ左右を削って 1 行ずつ塗る（両端を含む座標）。
        if let Some((rx0, ry0, rx1, ry1, r)) = self.round_clip.get() {
            let (bx0, by0, bx1, by1) = (x0 as i32, y0 as i32, x1 as i32, y1 as i32);
            let touches_corner = by0 < ry0 + r || by1 >= ry1 - r;
            if touches_corner && bx1 >= bx0 && by1 >= by0 {
                self.round_clip.set(None);
                let mut run_start: Option<i32> = None;
                for y in by0..=by1 {
                    let inset = crate::kernel::draw_clip::round_clip_inset(y, ry0, ry1, r);
                    if inset == 0 {
                        run_start.get_or_insert(y);
                        continue;
                    }
                    if let Some(s0) = run_start.take() {
                        self.boxfill(x0, s0 as u32, x1, (y - 1) as u32, color);
                    }
                    let lx = bx0.max(rx0 + inset);
                    let hx = bx1.min(rx1 - inset - 1);
                    if hx >= lx && y >= 0 {
                        self.boxfill(lx.max(0) as u32, y as u32, hx.max(0) as u32, y as u32, color);
                    }
                }
                if let Some(s0) = run_start {
                    self.boxfill(x0, s0 as u32, x1, y1, color);
                }
                self.round_clip.set(Some((rx0, ry0, rx1, ry1, r)));
                return;
            }
        }
        if a != 0xFF {
            self.boxfill_alpha(x0, y0, x1, y1, color, a as u8);
            return;
        }

        // 負値のキャスト（0x8000_0000 以上）を画面端 0 へ安全にクランプする保護
        let x0 = if x0 >= 0x8000_0000 {
            if x1 >= 0x8000_0000 { return; }
            0
        } else {
            x0
        };
        let y0 = if y0 >= 0x8000_0000 {
            if y1 >= 0x8000_0000 { return; }
            0
        } else {
            y0
        };

        let (target_ptr, w, h) = self.resolve_target();
        // 【2026-07-26診断】ヒーロー背景(#ff6b6b)の塗りつぶし時の描画先バッファを
        // 記録し、文字描画時（[GLYPH][DIAG]）と同一バッファかを突き合わせる。
        // 異なっていれば「背景と文字が別バッファへ描かれている」ことになり、
        // 「文字は書き込まれているのに画面に出ない」症状と完全に一致する。
        if (color.0 & 0x00FF_FFFF) == 0x00FF_6B6B {
            static BG_DIAG: core::sync::atomic::AtomicU32 =
                core::sync::atomic::AtomicU32::new(0);
            if BG_DIAG.fetch_add(1, core::sync::atomic::Ordering::Relaxed) < 3 {
                crate::warn!(
                    "[TARGET][BG] hero fill target=0x{:x} w={} h={} rect=({},{})-({},{})",
                    target_ptr as usize, w, h, x0, y0, x1, y1
                );
            }
        }
        // 画面サイズと追加クリップ矩形で切り詰める。
        // 【2026-09-08 カーネルパニック修正】この計算はかつてここに直書きされており、
        // 幅ゼロのクリップ矩形 (`kx1 == 0`) で `kx1 - 1` が u32 ラップし、
        // 43 億ピクセルの塗りつぶしが RAM 全域を破壊していた。
        // 減算を一切しない純粋関数へ切り出し、ホスト側で試験している
        // （`kernel::draw_clip` / `tests/src/test_draw_clip.rs`）。
        let (cx0, cy0, cx1, cy1) =
            match crate::kernel::draw_clip::clip_fill_rect(x0, y0, x1, y1, w, h, self.clip.get()) {
                Some(r) => r,
                None => return,
            };

        let rect_w = cx1 - cx0 + 1;
        let rect_h = cy1 - cy0 + 1;
        let stride = self.resolve_stride();

        if rect_w * rect_h >= DMA_THRESHOLD_PIXELS {
            let dst_offset = (cy0 * stride + cx0) * 4;
            let color_val = color.to_hardware_format();
            crate::kernel::dma::dma_fill_rect(
                5,
                &color_val as *const _ as u32,
                target_ptr as u32 + dst_offset,
                rect_w,
                rect_h,
                stride * 4,
            );
        } else {
            let c = color.to_hardware_format();
            for y in cy0..=cy1 {
                unsafe {
                    let row_ptr = target_ptr.add((y * stride + cx0) as usize);
                    let count = (cx1 - cx0 + 1) as usize;
                    let slice = core::slice::from_raw_parts_mut(row_ptr, count);
                    slice.fill(c);
                }
            }
        }
    }

    /// 半透明色による矩形塗りつぶし（スキャンライン直接合成による高速パス）。
    /// 計算量: O(W×H)。ピクセルごとの `draw_pixel_alpha` 呼び出しやバッファ再解決を排除し、
    /// スキャンライン単位で連続ポインタから直接ブレンド計算を行う。
    pub fn boxfill_alpha(&self, x0: u32, y0: u32, x1: u32, y1: u32, color: Color, alpha: u8) {
        if alpha == 0 {
            return;
        }

        // 負値のキャスト（0x8000_0000 以上）を画面端 0 へ安全にクランプする保護
        let x0 = if x0 >= 0x8000_0000 {
            if x1 >= 0x8000_0000 { return; }
            0
        } else {
            x0
        };
        let y0 = if y0 >= 0x8000_0000 {
            if y1 >= 0x8000_0000 { return; }
            0
        } else {
            y0
        };

        if alpha == 255 {
            self.boxfill(x0, y0, x1, y1, color);
            return;
        }
        // 角丸切り取りがある場合は、各ピクセル判定が必要なためフォールバック
        if self.round_clip.get().is_some() {
            let (target_w, target_h) = {
                let (_, w, h) = self.resolve_target();
                (w, h)
            };
            if let Some((cx0, cy0, cx1, cy1)) = crate::kernel::draw_clip::clip_fill_rect(
                x0,
                y0,
                x1,
                y1,
                target_w,
                target_h,
                self.clip.get(),
            ) {
                for y in cy0..=cy1 {
                    for x in cx0..=cx1 {
                        self.draw_pixel_alpha(x, y, color, alpha);
                    }
                }
            }
            return;
        }

        let (target_ptr, w, h) = self.resolve_target();
        let (cx0, cy0, cx1, cy1) =
            match crate::kernel::draw_clip::clip_fill_rect(x0, y0, x1, y1, w, h, self.clip.get()) {
                Some(r) => r,
                None => return,
            };

        let rect_w = cx1 - cx0 + 1;
        let stride = self.resolve_stride();

        let a = alpha as u32;
        let inv_a = 255 - a;
        let fg_r = (color.0 >> 16) & 0xFF;
        let fg_g = (color.0 >> 8) & 0xFF;
        let fg_b = color.0 & 0xFF;
        let fg_r_term = fg_r * a + 127;
        let fg_g_term = fg_g * a + 127;
        let fg_b_term = fg_b * a + 127;
        let fg_rb_term = (fg_b_term << 16) | fg_r_term;

        let rect_w_usize = rect_w as usize;
        let stride_usize = stride as usize;

        for y in cy0..=cy1 {
            unsafe {
                let mut ptr = target_ptr.add(y as usize * stride_usize + cx0 as usize);
                for _ in 0..rect_w_usize {
                    let bg_val = core::ptr::read_volatile(ptr);
                    // ハードウェアフォーマットは 0xAABBGGRR
                    // RB (Red & Blue) を 1 回の 32bit 整数乗算・加算で並列合成
                    let bg_rb = bg_val & 0x00FF_00FF;
                    let rb_prod = fg_rb_term + bg_rb * inv_a;
                    let r = (rb_prod & 0xFFFF) / 255;
                    let b = (rb_prod >> 16) / 255;
                    let g = (fg_g_term + ((bg_val >> 8) & 0xFF) * inv_a) / 255;

                    core::ptr::write_volatile(ptr, 0xFF00_0000 | (b << 16) | (g << 8) | r);
                    ptr = ptr.add(1);
                }
            }
        }
    }

    /// 1本の水平スキャンライン (x0..x0 + colors.len(), y) にピクセル配列を描画する。
    /// クリップ矩形判定を行単位で事前計算し、連続メモリアドレスへの直列アクセスを行う。
    /// 完全不透明ピクセル (alpha == 255) は直接ストア、半透明ピクセルは SWAR 並列ブレンドを行う。
    pub fn draw_scanline_colors(&self, x0: i32, y: i32, colors: &[u32]) {
        if colors.is_empty() {
            return;
        }

        // 角丸切り取りがある場合は、各ピクセル判定が必要なためフォールバック
        if self.round_clip.get().is_some() {
            for (i, &col) in colors.iter().enumerate() {
                let px = x0 + i as i32;
                if px >= 0 {
                    let a = ((col >> 24) & 0xFF) as u8;
                    self.draw_pixel_alpha(px as u32, y as u32, Color(col), a);
                }
            }
            return;
        }

        let (target_ptr, w, h) = self.resolve_target();
        if y < 0 || y >= h as i32 {
            return;
        }
        let (clip_x0, clip_y0, clip_x1, clip_y1) = match self.clip.get() {
            Some((cx0, cy0, cx1, cy1)) => (cx0.min(w), cy0.min(h), cx1.min(w), cy1.min(h)),
            None => (0, 0, w, h),
        };
        let uy = y as u32;
        if uy < clip_y0 || uy >= clip_y1 {
            return;
        }

        let len = colors.len() as i32;
        let line_x0 = x0;
        let line_x1 = x0 + len;
        let vis_x0 = line_x0.max(clip_x0 as i32);
        let vis_x1 = line_x1.min(clip_x1 as i32);
        if vis_x0 >= vis_x1 {
            return;
        }

        let src_start = (vis_x0 - line_x0) as usize;
        let count = (vis_x1 - vis_x0) as usize;
        let stride = self.resolve_stride() as usize;

        unsafe {
            let mut ptr = target_ptr.add(y as usize * stride + vis_x0 as usize);
            for i in 0..count {
                let c = colors[src_start + i];
                let a = ((c >> 24) & 0xFF) as u32;
                if a == 0 {
                    ptr = ptr.add(1);
                    continue;
                }
                let r = (c >> 16) & 0xFF;
                let g = (c >> 8) & 0xFF;
                let b = c & 0xFF;

                if a == 255 {
                    let hw = 0xFF00_0000 | (b << 16) | (g << 8) | r;
                    core::ptr::write_volatile(ptr, hw);
                } else {
                    let inv_a = 255 - a;
                    let bg_val = core::ptr::read_volatile(ptr);
                    let bg_rb = bg_val & 0x00FF_00FF;
                    let fg_rb_term = ((b * a + 127) << 16) | (r * a + 127);
                    let rb_prod = fg_rb_term + bg_rb * inv_a;
                    let out_r = (rb_prod & 0xFFFF) / 255;
                    let out_b = (rb_prod >> 16) / 255;
                    let out_g = ((g * a + 127) + ((bg_val >> 8) & 0xFF) * inv_a) / 255;
                    core::ptr::write_volatile(ptr, 0xFF00_0000 | (out_b << 16) | (out_g << 8) | out_r);
                }
                ptr = ptr.add(1);
            }
        }
    }

    pub fn draw_char(&self, x: u32, y: u32, c: char, color: Color) {
        let code = c as usize;
        if code >= 256 {
            return;
        }
        let font = &FONT_DATA[code];
        let (target_ptr, w, h) = self.resolve_target();
        let stride = self.resolve_stride();
        let clip = self.clip.get();
        let hw_color = color.to_hardware_format();

        for i in 0..16u32 {
            let py = y + i;
            if py >= h {
                continue;
            }
            if let Some((_, cy0, _, cy1)) = clip {
                if py < cy0 || py >= cy1 {
                    continue;
                }
            }
            let d = font[i as usize];
            if d == 0 {
                continue;
            }
            unsafe {
                let row_ptr = target_ptr.add((py * stride) as usize);
                for bit in 0..8u32 {
                    if (d & (0x80 >> bit)) != 0 {
                        let px = x + bit;
                        if px < w {
                            if let Some((cx0, _, cx1, _)) = clip {
                                if px < cx0 || px >= cx1 {
                                    continue;
                                }
                            }
                            core::ptr::write_volatile(row_ptr.add(px as usize), hw_color);
                        }
                    }
                }
            }
        }
    }

    pub fn draw_string(&self, x: u32, y: u32, s: &str, color: Color) {
        let mut cur_x = x;
        for c in s.chars() {
            self.draw_char(cur_x, y, c, color);
            cur_x += 8;
        }
    }

    pub fn measure_string_monospace(&self, s: &str) -> u32 {
        let mut font_lock = crate::kernel::vector_font::GLOBAL_TERMINAL_FONT.lock();
        if let Some(ref mut font) = *font_lock {
            font.get_string_width(s, 16)
        } else {
            let mut width = 0;
            for c in s.chars() {
                width += if (c as u32) < 128 { 8 } else { 16 };
            }
            width
        }
    }

    pub fn draw_string_monospace(&self, x: u32, y: u32, s: &str, color: Color) {
        let mut font_lock = crate::kernel::vector_font::GLOBAL_TERMINAL_FONT.lock();
        if let Some(font) = font_lock.as_mut() {
            let mut cur_x = x as i32;
            let mut cur_y = y as i32;
            let (target_ptr, w, h) = self.resolve_target();
            let stride = self.resolve_stride();
            let clip = self.clip.get();

            for c in s.chars() {
                if c == '\n' {
                    cur_x = x as i32;
                    cur_y += 16;
                    continue;
                }

                if let Some(glyph) = font.get_glyph(c, 16) {
                    let gx = cur_x + glyph.x_offset;
                    let gy = cur_y + glyph.y_offset + (16 * 14 / 16);

                    for row in 0..glyph.height {
                        let py = gy + row as i32;
                        if py < 0 || py >= h as i32 {
                            continue;
                        }
                        if let Some((_, cy0, _, cy1)) = clip {
                            if (py as u32) < cy0 || (py as u32) >= cy1 {
                                continue;
                            }
                        }
                        let row_offset = (py as usize) * (stride as usize);

                        for col in 0..glyph.width {
                            let px = gx + col as i32;
                            if px < 0 || px >= w as i32 {
                                continue;
                            }
                            if let Some((cx0, _, cx1, _)) = clip {
                                if (px as u32) < cx0 || (px as u32) >= cx1 {
                                    continue;
                                }
                            }
                            let alpha = glyph.data[(row * glyph.width + col) as usize];
                            if alpha > 0 {
                                unsafe {
                                    let ptr = target_ptr.add(row_offset + px as usize);
                                    let bg_val = Color::from_hardware_format(core::ptr::read_volatile(ptr)).0 | 0xFF00_0000;
                                    let blended = crate::os_lib::web_engine::alpha_blend::blend_argb_over(
                                        ((alpha as u32) << 24) | (color.0 & 0x00FF_FFFF),
                                        bg_val,
                                    );
                                    core::ptr::write_volatile(ptr, Color(blended).to_hardware_format());
                                }
                            }
                        }
                    }
                    cur_x += glyph.advance as i32;
                } else {
                    let char_width = if (c as u32) > 127 { 16 } else { 8 };
                    cur_x += char_width;
                }

                if cur_x > w as i32 - 16 {
                    break;
                }
            }
        } else {
            let mut cur_x = x;
            let (_, w, _) = self.resolve_target();
            for c in s.chars() {
                if c == '\n' {
                    continue;
                }
                let code = c as u32;
                if code < 128 {
                    self.draw_char(cur_x, y, c, color);
                    cur_x += 8;
                } else {
                    if let Some(bitmap) = crate::kernel::font_ja::get_font_bitmap(code) {
                        self.draw_char_ja_16x16(cur_x, y, bitmap, color);
                    } else {
                        self.draw_char_ja_tofu(cur_x, y, color);
                    }
                    cur_x += 16;
                }
                if cur_x >= w.saturating_sub(8) {
                    break;
                }
            }
        }
    }

    /// 等幅ベクターフォントを用いて、指定した背景色で文字列を描画します（カラーキャッシュによる高速化版）
    pub fn draw_string_monospace_bg(&self, x: u32, y: u32, s: &str, color: Color, bg: Color) {
        let mut font_lock = crate::kernel::vector_font::GLOBAL_TERMINAL_FONT.lock();
        if let Some(ref mut font) = *font_lock {
            let mut cur_x = x as i32;
            let mut cur_y = y as i32;
            let (_, w, h) = self.resolve_target();

            for c in s.chars() {
                if c == '\n' {
                    cur_x = x as i32;
                    cur_y += 16;
                    continue;
                }

                if let Some(glyph) = font.get_color_glyph(c, 16, color.0, bg.0) {
                    let gx = cur_x + glyph.x_offset;
                    let gy = cur_y + glyph.y_offset + (16 * 14 / 16);

                    for row in 0..glyph.height {
                        let py = gy + row as i32;
                        if py < 0 || py >= h as i32 {
                            continue;
                        }
                        for col in 0..glyph.width {
                            let px = gx + col as i32;
                            if px < 0 || px >= w as i32 {
                                continue;
                            }
                            let pixel_color = glyph.data[(row * glyph.width + col) as usize];
                            if (pixel_color >> 24) > 0 {
                                // 完全透明ピクセルはスキップ
                                self.draw_pixel(px as u32, py as u32, Color(pixel_color));
                            }
                        }
                    }
                    cur_x += glyph.advance as i32;
                } else {
                    let char_width = if (c as u32) > 127 { 16 } else { 8 };
                    cur_x += char_width;
                }

                if cur_x > w as i32 - 16 {
                    break;
                }
            }
        } else {
            // モノスペースフォント未初期化時の代替描画 (背景色塗りつぶし付き)
            let mut cur_x = x;
            let (_, w, _) = self.resolve_target();
            for c in s.chars() {
                if c == '\n' {
                    continue;
                }
                let code = c as u32;
                let char_w = if code < 128 { 8u32 } else { 16u32 };
                // 背景で塗りつぶしてから描画
                self.boxfill(cur_x, y, cur_x + char_w, y + 16, bg);
                if code < 128 {
                    self.draw_char(cur_x, y, c, color);
                    cur_x += 8;
                } else {
                    if let Some(bitmap) = crate::kernel::font_ja::get_font_bitmap(code) {
                        self.draw_char_ja_16x16(cur_x, y, bitmap, color);
                    } else {
                        self.draw_char_ja_tofu(cur_x, y, color);
                    }
                    cur_x += 16;
                }
                if cur_x >= w.saturating_sub(8) {
                    break;
                }
            }
        }
    }

    pub fn measure_string_ja(&self, s: &str, size: u32) -> u32 {
        let mut width = 0;
        let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
        if let Some(ref mut font) = *font_lock {
            for c in s.chars() {
                if let Some(glyph) = font.get_glyph(c, size) {
                    width += glyph.advance;
                } else {
                    width += if (c as u32) < 128 { size / 2 } else { size };
                }
            }
        } else {
            for c in s.chars() {
                width += if (c as u32) < 128 { 8 } else { 16 };
            }
        }
        width
    }

    /// 日本語（UTF-8）の半角・全角が混在した文字列を描画します
    pub fn draw_string_ja(&self, x: u32, y: u32, s: &str, color: Color) {
        self.draw_string_ja_size(x, y, s, 16, color);
    }

    pub fn draw_string_ja_size(&self, x: u32, y: u32, s: &str, size: u32, color: Color) {
        self.draw_string_ja_size_ext(x, y, s, size, color, false);
    }

    pub fn draw_string_ja_size_ext(
        &self,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        color: Color,
        italic: bool,
    ) {
        let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
        if let Some(font) = font_lock.as_mut() {
            let mut cur_x = x as i32;
            let mut cur_y = y as i32;
            let (_, w, h) = self.resolve_target();

            for c in s.chars() {
                if c == '\n' {
                    cur_x = x as i32;
                    cur_y += size as i32;
                    continue;
                }

                if let Some(glyph) = font.get_glyph(c, size) {
                    let gx = cur_x + glyph.x_offset;
                    let gy = cur_y + glyph.y_offset + (size as i32 * 14 / 16);

                    for row in 0..glyph.height {
                        let py = gy + row as i32;
                        if py < 0 || py >= h as i32 {
                            continue;
                        }
                        for col in 0..glyph.width {
                            let mut px = gx + col as i32;
                            if italic {
                                // Yの高さ(下端に近いほどシフト量を小さく、上端に近いほどシフト量を大きくする)
                                // ベースラインに近い下端（row = glyph.height - 1）ではシフト量ほぼ0
                                // 上端（row = 0）では、(glyph.height * 2 / 7) 程度のシフトを加える
                                let shift = ((glyph.height as i32 - 1 - row as i32) * 2) / 7;
                                px += shift;
                            }
                            if px < 0 || px >= w as i32 {
                                continue;
                            }
                            let alpha = glyph.data[(row * glyph.width + col) as usize];
                            self.draw_pixel_alpha(px as u32, py as u32, color, alpha);
                        }
                    }
                    cur_x += glyph.advance as i32;
                } else {
                    let code = c as u32;
                    let char_width = if code > 127 {
                        size as i32
                    } else {
                        size as i32 / 2
                    };
                    if code < 128 {
                        let mut cx = cur_x;
                        if italic {
                            cx += 2;
                        }
                        self.draw_char(cx as u32, cur_y as u32, c, color);
                    } else {
                        // ビットマップフォントでフォールバック描画
                        if let Some(bitmap) = crate::kernel::font_ja::get_font_bitmap(code) {
                            // 16x16 に拡大して描画（または現在のサイズに応じたスケール）
                            // 簡易的に直接 draw_char_ja_16x16 を呼ぶ
                            let mut cx = cur_x;
                            if italic {
                                cx += 3;
                            }
                            self.draw_char_ja_16x16(cx as u32, cur_y as u32, bitmap, color);
                        } else {
                            self.draw_char_ja_tofu(cur_x as u32, cur_y as u32, color);
                        }
                    }
                    cur_x += char_width;
                }

                if cur_x > w as i32 - size as i32 {
                    cur_x = x as i32;
                    cur_y += size as i32;
                    if cur_y >= h as i32 {
                        break;
                    }
                }
            }
        } else {
            let mut cur_x = x;
            for c in s.chars() {
                let code = c as u32;
                let mut cx = cur_x;
                if italic {
                    cx += 2;
                }
                if code < 128 {
                    self.draw_char(cx, y, c, color);
                    cur_x += size / 2;
                } else {
                    if let Some(bitmap) = crate::kernel::font_ja::get_font_bitmap(code) {
                        self.draw_char_ja_16x16(cx, y, bitmap, color);
                    } else {
                        self.draw_char_ja_tofu(cx, y, color);
                    }
                    cur_x += size;
                }
            }
        }
    }

    pub fn draw_string_ja_size_bg(
        &self,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        color: Color,
        bg: Color,
    ) {
        self.draw_string_ja_size_ext_bg(x, y, s, size, color, false, bg);
    }

    pub fn draw_string_ja_size_ext_bg(
        &self,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        color: Color,
        italic: bool,
        bg: Color,
    ) {
        self.draw_string_ja_size_ext_bg_ls(x, y, s, size, color, italic, bg, 0);
    }

    /// letter-spacing 対応版。ls(px, 負も可) を各文字 advance に加える。
    #[allow(clippy::too_many_arguments)]
    pub fn draw_string_ja_size_ext_bg_ls(
        &self,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        color: Color,
        italic: bool,
        bg: Color,
        ls: i32,
    ) {
        self.draw_string_ja_size_ext_bg_ls_ws(x, y, s, size, color, italic, bg, ls, 0);
    }

    /// letter-spacing + word-spacing 対応版。半角スペース1文字ごとに ws(px, 負も可) も加算する。
    #[allow(clippy::too_many_arguments)]
    /// 計算量: **O(N × G)** — N は文字数、G は 1 グリフの面積（ピクセル）。
    ///
    /// グリフのラスタライズ結果は `vector_font::get_glyph` が
    /// `(文字, サイズ)` をキャッシュしているため、**輪郭からの再ラスタライズは
    /// 初回のみ**（キャッシュは 8000 件で全クリア）。
    /// 2 回目以降はキャッシュ済みビットマップの転送だけになる。
    ///
    /// 実測: sugi-lab.net の 1 フレームで 0〜2 tick。**描画コストの支配項ではない**。
    /// `font-family` を指定して描く。
    ///
    /// 【2026-08-03】`@font-face` で登録した Web フォントは
    /// `CUSTOM_FONTS` に入るが、**描画側が `font-family` を受け取らず
    /// `GLOBAL_VECTOR_FONT` しか見ていなかった**ため、
    /// 取得・展開・登録まで成功しても字形に一切反映されなかった。
    ///
    /// `family` はカンマ区切りのリストをそのまま渡してよい。
    /// 先頭から順に見て、登録済みの family が見つかればそれで描く。
    /// 見つからなければ従来どおり既定フォントで描く（フォールバック）。
    /// 戻り値は実際に使った Web フォントのウェイト（既定フォントなら 0）。
    ///
    /// 計算量: **O(F + N×G)** — F は family リストの要素数、
    /// N は文字数、G は 1 グリフの面積。
    #[allow(clippy::too_many_arguments)]
    pub fn draw_string_family(
        &self,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        color: Color,
        italic: bool,
        bg: Color,
        ls: i32,
        ws: i32,
        family_list: &str,
        weight: u16,
    ) -> u16 {
        if !family_list.is_empty() {
            // 書体選択は計測側（`vector_font::with_family_font`）と共通（2026-09-26 一本化）。
            // 希望ウェイト → 文字列を描ける最も近いウェイト → family 名だけのキー、
            // さらに総称名（sans-serif 等）はページで読み込まれた該当系統の Web フォントへ。
            let drawn = crate::kernel::vector_font::with_family_font_ext(s, family_list, weight, |font, got| {
                self.draw_glyphs_with_font(font, x, y, s, size, color, italic, bg, ls, ws);
                got
            });
            if let Some(got) = drawn {
                return got;
            }
            // 一致するフォントが無くて既定へ落ちたことを記録する。
            // 黙ってフォールバックすると「登録したのに使われない」理由が
            // 分からない（`spec/logging_policy.md` L-1）。
            if !family_list.is_empty() {
                static MISS: spin::Mutex<alloc::collections::BTreeSet<alloc::string::String>> =
                    spin::Mutex::new(alloc::collections::BTreeSet::new());
                let mut m = MISS.lock();
                if m.insert(alloc::string::String::from(family_list)) {
                    crate::warn!("[FONT] 該当フォント無しで既定へ family={:?}", family_list);
                }
            }
        }
        self.draw_string_ja_size_ext_bg_ls_ws(x, y, s, size, color, italic, bg, ls, ws);
        0
    }

    #[allow(clippy::too_many_arguments)]
    pub fn draw_string_ja_size_ext_bg_ls_ws(
        &self,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        color: Color,
        italic: bool,
        bg: Color,
        ls: i32,
        ws: i32,
    ) {
        let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
        if let Some(font) = font_lock.as_mut() {
            self.draw_glyphs_with_font(font, x, y, s, size, color, italic, bg, ls, ws);
        }
    }

    /// 実際にグリフを並べて描く本体。フォントは呼び出し側が選んで渡す。
    #[allow(clippy::too_many_arguments)]
    fn draw_glyphs_with_font(
        &self,
        font: &mut crate::kernel::vector_font::VectorFont,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        color: Color,
        italic: bool,
        bg: Color,
        ls: i32,
        ws: i32,
    ) {
        // 引数で受け取ったフォントを使う。**ここで `GLOBAL_VECTOR_FONT` を
        // ロックしてはいけない**（呼び出し元が既に保持しており、
        // 再入不可の spin ロックで停止する。2026-08-03 に実際に踏んだ）。
        //
        // 下の `else` はベクタフォントが無い場合のビットマップ代替経路。
        // ここへは常にフォントが渡ってくるので実行されないが、
        // 元の構造をそのまま残す（削るとフォールバックの実装ごと失われる）。
        let font_opt: Option<&mut crate::kernel::vector_font::VectorFont> = Some(font);
        if let Some(font) = font_opt {
            let mut cur_x = x as i32;
            let mut cur_y = y as i32;
            let (target_ptr, w, h) = self.resolve_target();
            let stride = self.resolve_stride();
            let clip = self.clip.get();

            for c in s.chars() {
                if c == '\n' {
                    cur_x = x as i32;
                    cur_y += size as i32;
                    continue;
                }

                // 【2026-07-26診断】ヒーロー見出し(fs>=40)が画面に出ない件の切り分け。
                if size >= 40 {
                    static GLYPH_DIAG: core::sync::atomic::AtomicU32 =
                        core::sync::atomic::AtomicU32::new(0);
                    let n = GLYPH_DIAG.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
                    if n < 6 {
                        let g = font.get_color_glyph(c, size, color.0, bg.0);
                        match g {
                            Some(gl) => crate::warn!(
                                "[GLYPH][DIAG] c={:?} size={} target_w={} target_h={} cur=({},{}) gw={} gh={} xoff={} yoff={} adv={} px0=0x{:08x}",
                                c, size, w, h, cur_x, cur_y,
                                gl.width, gl.height, gl.x_offset, gl.y_offset, gl.advance,
                                gl.data.first().copied().unwrap_or(0)
                            ),
                            None => crate::warn!(
                                "[GLYPH][DIAG] c={:?} size={} target_w={} target_h={} -> NO GLYPH (fallback path)",
                                c, size, w, h
                            ),
                        }
                    }
                }

                if let Some(glyph) = font.get_color_glyph(c, size, color.0, bg.0) {
                    let gx = cur_x + glyph.x_offset;
                    let gy = cur_y + glyph.y_offset + (size as i32 * 14 / 16);

                    let mut written = 0u32;

                    let clip_y0 = clip.map(|c| c.1 as i32).unwrap_or(0).max(0);
                    let clip_y1 = clip.map(|c| c.3 as i32).unwrap_or(h as i32).min(h as i32);
                    let row_start = (clip_y0 - gy).clamp(0, glyph.height as i32) as usize;
                    let row_end = (clip_y1 - gy).clamp(0, glyph.height as i32) as usize;

                    if !italic {
                        let clip_x0 = clip.map(|c| c.0 as i32).unwrap_or(0).max(0);
                        let clip_x1 = clip.map(|c| c.2 as i32).unwrap_or(w as i32).min(w as i32);
                        let col_start = (clip_x0 - gx).clamp(0, glyph.width as i32) as usize;
                        let col_end = (clip_x1 - gx).clamp(0, glyph.width as i32) as usize;

                        if row_start < row_end && col_start < col_end {
                            let gw = glyph.width as usize;
                            let stride_usize = stride as usize;
                            for row in row_start..row_end {
                                let py = (gy + row as i32) as usize;
                                let row_offset = py * stride_usize;
                                let glyph_row_offset = row * gw;
                                unsafe {
                                    let mut dst_ptr = target_ptr.add(row_offset + ((gx + col_start as i32) as usize));
                                    let mut src_idx = glyph_row_offset + col_start;
                                    for _ in col_start..col_end {
                                        let pixel_color = *glyph.data.get_unchecked(src_idx);
                                        let a = (pixel_color >> 24) & 0xFF;
                                        if a == 0xFF {
                                            let hw = Color(pixel_color).to_hardware_format();
                                            core::ptr::write_volatile(dst_ptr, hw);
                                            written += 1;
                                        } else if a > 0 {
                                            let bg_val = Color::from_hardware_format(core::ptr::read_volatile(dst_ptr)).0 | 0xFF00_0000;
                                            let eff_a = crate::os_lib::web_engine::font_gamma::correct_glyph_coverage(
                                                a as u8,
                                                pixel_color,
                                                bg_val,
                                            );
                                            let adjusted_pixel_color = ((eff_a as u32) << 24) | (pixel_color & 0x00FF_FFFF);
                                            let blended = crate::os_lib::web_engine::alpha_blend::blend_argb_over(adjusted_pixel_color, bg_val);
                                            core::ptr::write_volatile(dst_ptr, Color(blended).to_hardware_format());
                                            written += 1;
                                        }
                                        dst_ptr = dst_ptr.add(1);
                                        src_idx += 1;
                                    }
                                }
                            }
                        }
                    } else {
                        // 斜体（italic）フォールバックパス
                        let gw = glyph.width as usize;
                        let gh = glyph.height as i32;
                        for row in row_start..row_end {
                            let py = gy + row as i32;
                            let row_offset = (py as usize) * (stride as usize);
                            let shift = ((gh - 1 - row as i32) * 2) / 7;

                            for col in 0..glyph.width {
                                let px = gx + col as i32 + shift;
                                if px < 0 || px >= w as i32 {
                                    continue;
                                }
                                if let Some((cx0, _, cx1, _)) = clip {
                                    if (px as u32) < cx0 || (px as u32) >= cx1 {
                                        continue;
                                    }
                                }
                                let pixel_color = glyph.data[row * gw + col as usize];
                                let a = (pixel_color >> 24) & 0xFF;
                                if a > 0 {
                                    unsafe {
                                        let ptr = target_ptr.add(row_offset + px as usize);
                                        if a == 0xFF {
                                            core::ptr::write_volatile(ptr, Color(pixel_color).to_hardware_format());
                                        } else {
                                            let bg_val = Color::from_hardware_format(core::ptr::read_volatile(ptr)).0 | 0xFF00_0000;
                                            let eff_a = crate::os_lib::web_engine::font_gamma::correct_glyph_coverage(
                                                a as u8,
                                                pixel_color,
                                                bg_val,
                                            );
                                            let adjusted_pixel_color = ((eff_a as u32) << 24) | (pixel_color & 0x00FF_FFFF);
                                            let blended = crate::os_lib::web_engine::alpha_blend::blend_argb_over(adjusted_pixel_color, bg_val);
                                            core::ptr::write_volatile(ptr, Color(blended).to_hardware_format());
                                        }
                                    }
                                    written += 1;
                                }
                            }
                        }
                    }
                    if size >= 40 {
                        static PX_DIAG: core::sync::atomic::AtomicU32 =
                            core::sync::atomic::AtomicU32::new(0);
                        // どのフレームでヒーロー文字を描いたかを記録する
                        // （表示中フレームとの突き合わせ用。上限なしで常に更新）。
                        HERO_TEXT_FRAME.store(
                            FRAME_NO.load(core::sync::atomic::Ordering::Relaxed),
                            core::sync::atomic::Ordering::Relaxed,
                        );
                        if PX_DIAG.fetch_add(1, core::sync::atomic::Ordering::Relaxed) < 4 {
                            let (tp, tw, th) = self.resolve_target();
                            // 【2026-07-26】`written` は draw_pixel の**呼び出し回数**であって
                            // 実書き込み数ではない。draw_pixel はクリップ矩形の外なら
                            // 黙って return するため、クリップ状態を併せて記録する。
                            crate::warn!(
                                "[TARGET][TEXT] c={:?} target=0x{:x} w={} h={} calls={} gx={} gy={} clip={:?} rt=0x{:x} bb=0x{:x} vram=0x{:x} use_bb={}",
                                c, tp as usize, tw, th, written, gx, gy, self.clip.get(),
                                self.render_target.get() as usize,
                                self.back_buffer as usize,
                                self.vram as usize,
                                self.use_back_buffer.get()
                            );
                        }
                    }
                    cur_x += glyph.advance as i32 + ls + if c == ' ' { ws } else { 0 };
                } else {
                    let code = c as u32;
                    let char_width = if code > 127 {
                        size as i32
                    } else {
                        size as i32 / 2
                    };
                    if code < 128 {
                        let mut cx = cur_x;
                        if italic {
                            cx += 2;
                        }
                        // 背景色でクリアしてからフォールバック文字を描画
                        self.boxfill(
                            cx as u32,
                            cur_y as u32,
                            cx as u32 + (size / 2),
                            cur_y as u32 + size,
                            bg,
                        );
                        self.draw_char(cx as u32, cur_y as u32, c, color);
                    } else {
                        // ビットマップフォントでフォールバック描画
                        let mut cx = cur_x;
                        if italic {
                            cx += 3;
                        }
                        self.boxfill(
                            cx as u32,
                            cur_y as u32,
                            cx as u32 + size,
                            cur_y as u32 + size,
                            bg,
                        );
                        if let Some(bitmap) = crate::kernel::font_ja::get_font_bitmap(code) {
                            self.draw_char_ja_16x16(cx as u32, cur_y as u32, bitmap, color);
                        } else {
                            self.draw_char_ja_tofu(cx as u32, cur_y as u32, color);
                        }
                    }
                    cur_x += char_width + ls + if c == ' ' { ws } else { 0 };
                }

                if cur_x > w as i32 - size as i32 {
                    cur_x = x as i32;
                    cur_y += size as i32;
                    if cur_y >= h as i32 {
                        break;
                    }
                }
            }
        } else {
            // ベクターフォント未初期化時の代替日本語・英語描画 (背景色クリア付き)
            let mut cur_x = x;
            let (_, _w, _) = self.resolve_target();
            for c in s.chars() {
                let code = c as u32;
                let mut cx = cur_x;
                if italic {
                    cx += 2;
                }
                let char_w = if code < 128 { size / 2 } else { size };
                self.boxfill(cx, y, cx + char_w, y + size, bg);
                if code < 128 {
                    self.draw_char(cx, y, c, color);
                    cur_x = (cur_x as i32 + size as i32 / 2 + ls).max(0) as u32;
                } else {
                    if let Some(bitmap) = crate::kernel::font_ja::get_font_bitmap(code) {
                        self.draw_char_ja_16x16(cx, y, bitmap, color);
                    } else {
                        self.draw_char_ja_tofu(cx, y, color);
                    }
                    cur_x = (cur_x as i32 + size as i32 + ls).max(0) as u32;
                }
            }
        }
    }

    /// `text-emphasis-style`（傍点・圏点）: `draw_string_ja_size_ext_bg_ls_ws` と同じ
    /// 文字送り幅の計算を再利用し、各文字（空白を除く）の中央上部に小さな印を描く。
    /// 横書き前提（`text-emphasis-position` は非対応で常に上に描く）。
    /// `mark` は "dot"（●）/"circle"（○）/"double-circle"（◎近似）/"triangle"（▲）/
    /// "sesame"（，に近い小さな2点）、またはそれ以外はカスタム1文字をそのまま
    /// 小さめのフォントで描く。
    pub fn draw_text_emphasis(
        &self,
        x: u32,
        y: u32,
        s: &str,
        size: u32,
        mark: &str,
        color: Color,
        ls: i32,
        ws: i32,
    ) {
        if mark.is_empty() {
            return;
        }
        let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
        let Some(font) = font_lock.as_mut() else {
            return;
        };
        let mut cur_x = x as i32;
        let mut cur_y = y as i32;
        let (_, w, h) = self.resolve_target();
        // マーク自体の半径（文字サイズの1/6程度。小さめに固定）。
        let r = ((size as i32) / 6).max(1);
        for c in s.chars() {
            if c == '\n' {
                cur_x = x as i32;
                cur_y += size as i32;
                continue;
            }
            // 文字送り幅は実描画（draw_string_ja_size_ext_bg_ls_ws）と同じ規則で測る。
            let advance = if let Some(glyph) = font.get_color_glyph(c, size, color.0, color.0) {
                glyph.advance as i32
            } else {
                let code = c as u32;
                if code > 127 {
                    size as i32
                } else {
                    size as i32 / 2
                }
            };
            if !c.is_whitespace() {
                let cx = cur_x + advance / 2;
                let cy = cur_y - r * 3;
                if cx >= 0 && cy >= 0 && (cx as u32) < w && (cy as u32) < h {
                    match mark {
                        "circle" => self.draw_circle_outline(cx as u32, cy as u32, r as u32, color),
                        "triangle" => self.draw_triangle_fill(cx as u32, cy as u32, r as u32, color),
                        "sesame" => {
                            self.draw_circle_fill((cx - r) as u32, cy as u32, (r / 2).max(1) as u32, color);
                            self.draw_circle_fill((cx + r) as u32, cy as u32, (r / 2).max(1) as u32, color);
                        }
                        // "dot"/"double-circle"/カスタム文字は全て塗りつぶし円で近似する
                        // （二重丸・カスタム字形の専用描画は非対応の簡略実装）。
                        _ => self.draw_circle_fill(cx as u32, cy as u32, r as u32, color),
                    }
                }
            }
            cur_x += advance + ls + if c == ' ' { ws } else { 0 };
        }
    }

    /// 塗りつぶし円（emphasis mark 用の小さな円）。
    fn draw_circle_fill(&self, cx: u32, cy: u32, r: u32, color: Color) {
        let r_i = r as i32;
        for dy in -r_i..=r_i {
            for dx in -r_i..=r_i {
                if dx * dx + dy * dy <= r_i * r_i {
                    let px = cx as i32 + dx;
                    let py = cy as i32 + dy;
                    if px >= 0 && py >= 0 {
                        self.draw_pixel(px as u32, py as u32, color);
                    }
                }
            }
        }
    }

    /// 輪郭のみの円（`circle` 用）。
    fn draw_circle_outline(&self, cx: u32, cy: u32, r: u32, color: Color) {
        let r_i = r as i32;
        let r_inner = (r_i - 1).max(0);
        for dy in -r_i..=r_i {
            for dx in -r_i..=r_i {
                let d2 = dx * dx + dy * dy;
                if d2 <= r_i * r_i && d2 >= r_inner * r_inner {
                    let px = cx as i32 + dx;
                    let py = cy as i32 + dy;
                    if px >= 0 && py >= 0 {
                        self.draw_pixel(px as u32, py as u32, color);
                    }
                }
            }
        }
    }

    /// 塗りつぶし三角形（`triangle` 用。上向き）。
    fn draw_triangle_fill(&self, cx: u32, cy: u32, r: u32, color: Color) {
        let r_i = r as i32;
        for dy in 0..=(r_i * 2) {
            let py = cy as i32 - r_i + dy;
            if py < 0 {
                continue;
            }
            let half_w = (dy * r_i) / (r_i * 2).max(1);
            for dx in -half_w..=half_w {
                let px = cx as i32 + dx;
                if px >= 0 {
                    self.draw_pixel(px as u32, py as u32, color);
                }
            }
        }
    }

    /// 8x8の日本語ビットマップデータを縦横2倍にして 16x16 で描画します (最近傍補間)
    fn draw_char_ja_16x16(&self, x: u32, y: u32, bitmap: &[u8; 8], color: Color) {
        for row in 0..8 {
            let byte = bitmap[row];
            for col in 0..8 {
                if (byte & (0x80 >> col)) != 0 {
                    let px = x + col as u32 * 2;
                    let py = y + row as u32 * 2;
                    self.draw_pixel(px, py, color);
                    self.draw_pixel(px + 1, py, color);
                    self.draw_pixel(px, py + 1, color);
                    self.draw_pixel(px + 1, py + 1, color);
                }
            }
        }
    }

    /// フォントデータが不足している場合の 16x16 豆腐 (枠線) 描画
    fn draw_char_ja_tofu(&self, x: u32, y: u32, color: Color) {
        for dy in 0..16 {
            for dx in 0..16 {
                if dx == 0 || dx == 15 || dy == 0 || dy == 15 {
                    self.draw_pixel(x + dx, y + dy, color);
                }
            }
        }
    }

    // チャットターミナル用の描画関数は terminal.rs 側で実装するため、
    // ここでは基本的な draw_pixel, boxfill, draw_string のみを提供する

    /// SVGアイコンをラスタライズしてアルファブレンドで描画します。
    /// tint: 描画色（SVGの塗り色を上書きする）。alphaは元のアルファマスクを使用。
    pub fn draw_svg_icon(&self, x: u32, y: u32, svg_data: &[u8], size: u32, tint: Color) {
        if let Some(alpha_mask) = crate::os_lib::svg::get_or_rasterize(svg_data, size) {
            for row in 0..size {
                for col in 0..size {
                    let alpha = alpha_mask[(row * size + col) as usize];
                    if alpha > 0 {
                        self.draw_pixel_alpha(x + col, y + row, tint, alpha);
                    }
                }
            }
        }
    }

    /// 簡易 BMP デコーダ。24ビットまたは32ビット無圧縮の BMP データを指定座標に、指定サイズへ Nearest Neighbor 拡大縮小して描画します。
    pub fn draw_bmp(
        &self,
        x: u32,
        y: u32,
        target_width: u32,
        target_height: u32,
        bmp_data: &[u8],
    ) -> Result<(), &'static str> {
        if bmp_data.len() < 54 {
            return Err("Data too short");
        }
        if &bmp_data[0..2] != b"BM" {
            return Err("Not a BMP file");
        }

        let off_bits =
            u32::from_le_bytes(bmp_data[10..14].try_into().map_err(|_| "Invalid offset")?) as usize;
        let width = i32::from_le_bytes(bmp_data[18..22].try_into().map_err(|_| "Invalid width")?);
        let height = i32::from_le_bytes(bmp_data[22..26].try_into().map_err(|_| "Invalid height")?);
        let bit_count = u16::from_le_bytes(
            bmp_data[28..30]
                .try_into()
                .map_err(|_| "Invalid bitcount")?,
        );
        let compression = u32::from_le_bytes(
            bmp_data[30..34]
                .try_into()
                .map_err(|_| "Invalid compression")?,
        );

        if compression != 0 {
            return Err("Only uncompressed BMP is supported");
        }
        if bit_count != 24 && bit_count != 32 {
            return Err("Only 24-bit or 32-bit BMP is supported");
        }

        let abs_height = height.unsigned_abs();
        let is_bottom_up = height > 0;
        let bytes_per_pixel = (bit_count / 8) as usize;
        let row_stride = (width as usize * bytes_per_pixel).div_ceil(4) * 4;

        if target_width == 0 || target_height == 0 {
            return Ok(());
        }

        for row in 0..target_height {
            let src_row_idx = (row * abs_height) / target_height;
            let src_row = if is_bottom_up {
                abs_height - 1 - src_row_idx
            } else {
                src_row_idx
            };
            let row_offset = off_bits + (src_row as usize * row_stride);
            if row_offset + (width as usize * bytes_per_pixel) > bmp_data.len() {
                return Err("BMP pixel data out of bounds");
            }
            for col in 0..target_width {
                let src_col = (col * width as u32) / target_width;
                let pixel_offset = row_offset + (src_col as usize * bytes_per_pixel);
                let b = bmp_data[pixel_offset];
                let g = bmp_data[pixel_offset + 1];
                let r = bmp_data[pixel_offset + 2];
                let a = if bytes_per_pixel == 4 {
                    bmp_data[pixel_offset + 3]
                } else {
                    255
                };

                let color = Color(0xFF000000 | ((r as u32) << 16) | ((g as u32) << 8) | (b as u32));
                self.draw_pixel_alpha(x + col, y + row, color, a);
            }
        }
        Ok(())
    }

    /// PNG, JPG, BMP をデコードし、指定サイズへ Nearest Neighbor 拡大縮小して描画します
    pub fn draw_image(
        &self,
        x: u32,
        y: u32,
        target_width: u32,
        target_height: u32,
        data: &[u8],
    ) -> Result<(), &'static str> {
        if target_width == 0 || target_height == 0 {
            return Ok(());
        }

        if data.len() > 8 && &data[0..8] == b"\x89PNG\r\n\x1a\n" {
            let mut decoder = zune_png::PngDecoder::new(data);
            match decoder.decode_raw() {
                Ok(pixels) => {
                    let info = decoder.get_info().ok_or("Failed to get PNG info")?;
                    let width = info.width as u32;
                    let height = info.height as u32;
                    let bytes_per_pixel = pixels.len() / (width as usize * height as usize).max(1);

                    for row in 0..target_height {
                        let src_row = (row * height) / target_height;
                        for col in 0..target_width {
                            let src_col = (col * width) / target_width;
                            let idx = ((src_row * width + src_col) as usize) * bytes_per_pixel;
                            if idx + bytes_per_pixel <= pixels.len() {
                                let (r, g, b, a) = match bytes_per_pixel {
                                    1 => (pixels[idx], pixels[idx], pixels[idx], 255),
                                    2 => (pixels[idx], pixels[idx], pixels[idx], pixels[idx + 1]),
                                    3 => (pixels[idx], pixels[idx + 1], pixels[idx + 2], 255),
                                    4 => (
                                        pixels[idx],
                                        pixels[idx + 1],
                                        pixels[idx + 2],
                                        pixels[idx + 3],
                                    ),
                                    _ => (0, 0, 0, 255),
                                };
                                let color = Color(
                                    0xFF000000
                                        | ((r as u32) << 16)
                                        | ((g as u32) << 8)
                                        | (b as u32),
                                );
                                self.draw_pixel_alpha(x + col, y + row, color, a);
                            }
                        }
                    }
                    Ok(())
                }
                Err(_) => Err("Failed to decode PNG"),
            }
        } else if data.len() > 2 && data[0] == 0xFF && data[1] == 0xD8 {
            let mut decoder = zune_jpeg::JpegDecoder::new(data);
            match decoder.decode() {
                Ok(pixels) => {
                    let info = decoder.info().ok_or("Failed to get JPEG info")?;
                    let width = info.width as u32;
                    let height = info.height as u32;
                    let bytes_per_pixel = pixels.len() / (width as usize * height as usize).max(1);

                    for row in 0..target_height {
                        let src_row = (row * height) / target_height;
                        for col in 0..target_width {
                            let src_col = (col * width) / target_width;
                            let idx = ((src_row * width + src_col) as usize) * bytes_per_pixel;
                            if idx + bytes_per_pixel <= pixels.len() {
                                let (r, g, b) = match bytes_per_pixel {
                                    1 => (pixels[idx], pixels[idx], pixels[idx]),
                                    3 => (pixels[idx], pixels[idx + 1], pixels[idx + 2]),
                                    _ => (0, 0, 0),
                                };
                                let color = Color(
                                    0xFF000000
                                        | ((r as u32) << 16)
                                        | ((g as u32) << 8)
                                        | (b as u32),
                                );
                                self.draw_pixel_alpha(x + col, y + row, color, 255);
                            }
                        }
                    }
                    Ok(())
                }
                Err(_) => Err("Failed to decode JPEG"),
            }
        } else if data.len() > 2 && &data[0..2] == b"BM" {
            self.draw_bmp(x, y, target_width, target_height, data)
        } else {
            Err("Unsupported image format")
        }
    }

    /// Draw a linear gradient rectangle. Interpolates between c1 and c2.
    /// If vertical=true, gradient goes top→bottom; otherwise left→right.
    pub fn draw_gradient_rect(
        &self,
        x0: u32,
        y0: u32,
        x1: u32,
        y1: u32,
        c1: Color,
        c2: Color,
        vertical: bool,
    ) {
        if x1 <= x0 || y1 <= y0 {
            return;
        }
        let r1 = ((c1.0 >> 16) & 0xFF) as f32;
        let g1 = ((c1.0 >> 8) & 0xFF) as f32;
        let b1 = (c1.0 & 0xFF) as f32;
        let r2 = ((c2.0 >> 16) & 0xFF) as f32;
        let g2 = ((c2.0 >> 8) & 0xFF) as f32;
        let b2 = (c2.0 & 0xFF) as f32;
        if vertical {
            let h = (y1 - y0) as f32;
            for dy in 0..(y1 - y0) {
                let t = dy as f32 / h.max(1.0);
                let r = ((1.0 - t) * r1 + t * r2) as u32;
                let g = ((1.0 - t) * g1 + t * g2) as u32;
                let b = ((1.0 - t) * b1 + t * b2) as u32;
                let c = 0xFF000000 | (r << 16) | (g << 8) | b;
                self.boxfill(x0, y0 + dy, x1, y0 + dy + 1, Color(c));
            }
        } else {
            let w = (x1 - x0) as f32;
            for dx in 0..(x1 - x0) {
                let t = dx as f32 / w.max(1.0);
                let r = ((1.0 - t) * r1 + t * r2) as u32;
                let g = ((1.0 - t) * g1 + t * g2) as u32;
                let b = ((1.0 - t) * b1 + t * b2) as u32;
                let c = 0xFF000000 | (r << 16) | (g << 8) | b;
                self.boxfill(x0 + dx, y0, x0 + dx + 1, y1, Color(c));
            }
        }
    }

    /// `radial-gradient(circle, c1, c2)` — 矩形の中心を起点に、中心から最も遠い角までの
    /// 距離を半径として c1(中心)→c2(外周) へ線形補間する。楕円/位置指定などは非対応の簡略実装。
    pub fn draw_radial_gradient_rect(&self, x0: u32, y0: u32, x1: u32, y1: u32, c1: Color, c2: Color) {
        if x1 <= x0 || y1 <= y0 {
            return;
        }
        let r1 = ((c1.0 >> 16) & 0xFF) as f32;
        let g1 = ((c1.0 >> 8) & 0xFF) as f32;
        let b1 = (c1.0 & 0xFF) as f32;
        let r2 = ((c2.0 >> 16) & 0xFF) as f32;
        let g2 = ((c2.0 >> 8) & 0xFF) as f32;
        let b2 = (c2.0 & 0xFF) as f32;
        let w = (x1 - x0) as f32;
        let h = (y1 - y0) as f32;
        let cx = w / 2.0;
        let cy = h / 2.0;
        let max_dist = libm::sqrtf(cx * cx + cy * cy).max(1.0);
        for dy in 0..(y1 - y0) {
            for dx in 0..(x1 - x0) {
                let px = dx as f32 - cx;
                let py = dy as f32 - cy;
                let dist = libm::sqrtf(px * px + py * py);
                let t = (dist / max_dist).min(1.0);
                let r = ((1.0 - t) * r1 + t * r2) as u32;
                let g = ((1.0 - t) * g1 + t * g2) as u32;
                let b = ((1.0 - t) * b1 + t * b2) as u32;
                let c = 0xFF000000 | (r << 16) | (g << 8) | b;
                self.boxfill(x0 + dx, y0 + dy, x0 + dx + 1, y0 + dy + 1, Color(c));
            }
        }
    }

    /// `conic-gradient(c1, c2)` — 矩形の中心を起点に、12時方向(真上)を角度0として
    /// 時計回りに掃引し c1(0°)→c2(360°直前)へ線形補間する（実ブラウザの2色既定と同様、
    /// 0°/360° の境界に色が不連続に戻る「継ぎ目」ができるのが正しい挙動）。
    /// `from`/位置指定・複数カラーストップは非対応の簡略実装。
    pub fn draw_conic_gradient_rect(&self, x0: u32, y0: u32, x1: u32, y1: u32, c1: Color, c2: Color) {
        if x1 <= x0 || y1 <= y0 {
            return;
        }
        let r1 = ((c1.0 >> 16) & 0xFF) as f32;
        let g1 = ((c1.0 >> 8) & 0xFF) as f32;
        let b1 = (c1.0 & 0xFF) as f32;
        let r2 = ((c2.0 >> 16) & 0xFF) as f32;
        let g2 = ((c2.0 >> 8) & 0xFF) as f32;
        let b2 = (c2.0 & 0xFF) as f32;
        let w = (x1 - x0) as f32;
        let h = (y1 - y0) as f32;
        let cx = w / 2.0;
        let cy = h / 2.0;
        const PI: f32 = core::f32::consts::PI;
        for dy in 0..(y1 - y0) {
            for dx in 0..(x1 - x0) {
                let px = dx as f32 - cx;
                let py = dy as f32 - cy;
                // atan2(px, -py): 真上(0,-1)方向を角度0とし、時計回りに増加させる。
                let mut angle = libm::atan2f(px, -py);
                if angle < 0.0 {
                    angle += 2.0 * PI;
                }
                let t = angle / (2.0 * PI); // 0.0-1.0 (0度→c1, 360度直前→c2)
                let r = ((1.0 - t) * r1 + t * r2) as u32;
                let g = ((1.0 - t) * g1 + t * g2) as u32;
                let b = ((1.0 - t) * b1 + t * b2) as u32;
                let c = 0xFF000000 | (r << 16) | (g << 8) | b;
                self.boxfill(x0 + dx, y0 + dy, x0 + dx + 1, y0 + dy + 1, Color(c));
            }
        }
    }

    /// 周期内の位置 `t`（0.0-1.0）における `colors` のN色均等割り補間色を得る。
    /// `colors` が空/1色の場合は先頭色（無ければ黒）を返す。
    fn sample_repeating_colors(colors: &[Color], t: f32) -> u32 {
        let Some(&first) = colors.first() else {
            return 0xFF000000;
        };
        if colors.len() < 2 {
            return first.0;
        }
        let scaled = t * (colors.len() - 1) as f32;
        let seg = (scaled as usize).min(colors.len() - 2);
        let local_t = scaled - seg as f32;
        let c1 = colors[seg];
        let c2 = colors[seg + 1];
        let r1 = ((c1.0 >> 16) & 0xFF) as f32;
        let g1 = ((c1.0 >> 8) & 0xFF) as f32;
        let b1 = (c1.0 & 0xFF) as f32;
        let r2 = ((c2.0 >> 16) & 0xFF) as f32;
        let g2 = ((c2.0 >> 8) & 0xFF) as f32;
        let b2 = (c2.0 & 0xFF) as f32;
        let r = ((1.0 - local_t) * r1 + local_t * r2) as u32;
        let g = ((1.0 - local_t) * g1 + local_t * g2) as u32;
        let b = ((1.0 - local_t) * b1 + local_t * b2) as u32;
        0xFF000000 | (r << 16) | (g << 8) | b
    }

    /// `repeating-linear-gradient(c1, c2, ..., cycle_px)` — `cycle_px` を周期として全色を
    /// 均等割りで補間しながら軸方向に繰り返す（`draw_gradient_rect` の周期版）。
    /// 以前は先頭2色 `c1`/`c2` 固定で3色目以降が失われていた。角度指定は引き続き非対応。
    pub fn draw_repeating_linear_gradient_rect(
        &self,
        x0: u32,
        y0: u32,
        x1: u32,
        y1: u32,
        colors: &[Color],
        cycle_px: i32,
        vertical: bool,
    ) {
        if x1 <= x0 || y1 <= y0 || colors.is_empty() {
            return;
        }
        let cycle = cycle_px.max(1) as f32;
        if vertical {
            for dy in 0..(y1 - y0) {
                let t = (dy as f32 % cycle) / cycle;
                let c = Self::sample_repeating_colors(colors, t);
                self.boxfill(x0, y0 + dy, x1, y0 + dy + 1, Color(c));
            }
        } else {
            for dx in 0..(x1 - x0) {
                let t = (dx as f32 % cycle) / cycle;
                let c = Self::sample_repeating_colors(colors, t);
                self.boxfill(x0 + dx, y0, x0 + dx + 1, y1, Color(c));
            }
        }
    }

    /// `repeating-radial-gradient(c1, c2, ..., cycle_px)` — 矩形中心からの距離を `cycle_px`
    /// で割った余りを使い、同心円状に全色を均等割りで繰り返す。以前は先頭2色固定で
    /// 3色目以降が失われていた。形状/位置指定は引き続き非対応。
    pub fn draw_repeating_radial_gradient_rect(
        &self,
        x0: u32,
        y0: u32,
        x1: u32,
        y1: u32,
        colors: &[Color],
        cycle_px: i32,
    ) {
        if x1 <= x0 || y1 <= y0 || colors.is_empty() {
            return;
        }
        let cycle = cycle_px.max(1) as f32;
        let w = (x1 - x0) as f32;
        let h = (y1 - y0) as f32;
        let cx = w / 2.0;
        let cy = h / 2.0;
        for dy in 0..(y1 - y0) {
            for dx in 0..(x1 - x0) {
                let px = dx as f32 - cx;
                let py = dy as f32 - cy;
                let dist = libm::sqrtf(px * px + py * py);
                let t = (dist % cycle) / cycle;
                let c = Self::sample_repeating_colors(colors, t);
                self.boxfill(x0 + dx, y0 + dy, x0 + dx + 1, y0 + dy + 1, Color(c));
            }
        }
    }

    /// Draw a semi-transparent shadow rectangle at offset (ox, oy).
    pub fn draw_shadow_rect(
        &self,
        x0: i32,
        y0: i32,
        x1: i32,
        y1: i32,
        ox: i32,
        oy: i32,
        color: Color,
    ) {
        if x1 <= x0 || y1 <= y0 {
            return;
        }
        let sx0 = (x0 + ox).max(0) as u32;
        let sy0 = (y0 + oy).max(0) as u32;
        let sx1 = (x1 + ox).max(0) as u32;
        let sy1 = (y1 + oy).max(0) as u32;
        let alpha = ((color.0 >> 24) & 0xFF) as u8;
        let alpha = if alpha == 0 { 80u8 } else { alpha }; // default semi-transparent
        if sx1 <= sx0 || sy1 <= sy0 {
            return;
        }
        for y in sy0..sy1 {
            for x in sx0..sx1 {
                self.draw_pixel_alpha(x, y, Color(color.0 | 0xFF000000), alpha);
            }
        }
    }

    /// Draw a semi-transparent shadow rectangle with optional rounded corners.
    ///
    /// 【2026-09-26】`blur`（ぼかし半径）に対応。影の矩形の縁からの距離に応じて
    /// 濃度を下げる（`web_engine::box_shadow::coverage`。縁で半分、幅 `blur` の勾配）。
    /// 従来はぼかしを無視して矩形をそのまま塗っており、Chrome の淡い影と見た目が大きく違った。
    /// ぼかしがあるときの角丸は、ぼかし自体が角を丸めるので矩形の距離で近似する。
    /// 計算量: **O((W+blur)×(H+blur))**。
    #[allow(clippy::too_many_arguments)]
    pub fn draw_shadow_rect_rounded(
        &self,
        x0: i32,
        y0: i32,
        x1: i32,
        y1: i32,
        ox: i32,
        oy: i32,
        blur: i32,
        radius: (i32, i32, i32, i32),
        color: Color,
    ) {
        if x1 <= x0 || y1 <= y0 {
            return;
        }
        let alpha = ((color.0 >> 24) & 0xFF) as u8;
        let alpha = if alpha == 0 { 80u8 } else { alpha };
        let blur = blur.max(0);
        let half = (blur + 1) / 2;
        // 影の矩形（ずらした後）と、ぼかしで広がる描画範囲。
        let (rx0, ry0, rx1, ry1) = (x0 + ox, y0 + oy, x1 + ox, y1 + oy);
        let sx0 = (rx0 - half).max(0);
        let sy0 = (ry0 - half).max(0);
        let sx1 = (rx1 + half).clamp(0, self.width as i32);
        let sy1 = (ry1 + half).clamp(0, self.height as i32);
        if sx1 <= sx0 || sy1 <= sy0 {
            return;
        }
        let w = x1 - x0;
        let h = y1 - y0;
        let has_radius = radius != (0, 0, 0, 0);
        let rgb = Color(color.0 | 0xFF000000);

        for y in sy0..sy1 {
            for x in sx0..sx1 {
                let a = if blur == 0 {
                    if has_radius
                        && !crate::os_lib::web_engine::draw_helpers::point_in_rounded_rect(
                            x - rx0,
                            y - ry0,
                            w,
                            h,
                            radius,
                        )
                    {
                        continue;
                    }
                    alpha
                } else {
                    // 矩形の縁からの符号付き距離（外が正）。
                    let dx = (rx0 - x).max(x - (rx1 - 1)).max(0) as f32;
                    let dy = (ry0 - y).max(y - (ry1 - 1)).max(0) as f32;
                    let d = if dx > 0.0 || dy > 0.0 {
                        libm::sqrtf(dx * dx + dy * dy)
                    } else {
                        -((x - rx0).min(rx1 - 1 - x).min(y - ry0).min(ry1 - 1 - y) as f32)
                    };
                    let c = crate::os_lib::web_engine::box_shadow::coverage(d, blur);
                    if c <= 0.0 {
                        continue;
                    }
                    (alpha as f32 * c) as u8
                };
                if a > 0 {
                    self.draw_pixel_alpha(x as u32, y as u32, rgb, a);
                }
            }
        }
    }

    /// Draw a semi-transparent inset shadow rectangle inside (x0, y0, x1, y1).
    pub fn draw_inset_shadow_rect(
        &self,
        x0: i32,
        y0: i32,
        x1: i32,
        y1: i32,
        ox: i32,
        oy: i32,
        blur: i32,
        radius: (i32, i32, i32, i32),
        color: Color,
    ) {
        if x1 <= x0 || y1 <= y0 {
            return;
        }
        let ix0 = x0.max(0) as u32;
        let iy0 = y0.max(0) as u32;
        let ix1 = x1.max(0) as u32;
        let iy1 = y1.max(0) as u32;
        let alpha = ((color.0 >> 24) & 0xFF) as u8;
        let alpha = if alpha == 0 { 90u8 } else { alpha };
        let shadow_color = color.0 | 0xFF000000;
        let w = x1 - x0;
        let h = y1 - y0;
        let has_radius = radius != (0, 0, 0, 0);
        let shadow_depth = blur.clamp(4, 30);

        for y in iy0..iy1 {
            let ry = (y as i32) - y0;
            for x in ix0..ix1 {
                let rx = (x as i32) - x0;
                if has_radius && !crate::os_lib::web_engine::draw_helpers::point_in_rounded_rect(rx, ry, w, h, radius) {
                    continue;
                }
                let d_left = rx - ox;
                let d_top = ry - oy;
                let d_right = (w - rx) + ox;
                let d_bottom = (h - ry) + oy;
                let min_dist = d_left.min(d_top).min(d_right).min(d_bottom);
                if min_dist >= 0 && min_dist < shadow_depth {
                    let factor = 1.0 - (min_dist as f32 / shadow_depth as f32);
                    let pix_alpha = ((alpha as f32) * factor) as u8;
                    if pix_alpha > 0 {
                        self.draw_pixel_alpha(x, y, Color(shadow_color), pix_alpha);
                    }
                }
            }
        }
    }

    /// 符号付き座標の塗り。画面外（負）は 0 に詰める（`draw_clip::signed_rect_to_fill`）。
    pub fn fill_signed(&self, x0: i32, y0: i32, x1: i32, y1: i32, color: Color) {
        if let Some((a, b, c, d)) = crate::kernel::draw_clip::signed_rect_to_fill(x0, y0, x1, y1) {
            self.boxfill(a, b, c, d, color);
        }
    }

    /// 符号付き座標の半透明塗り。画面外（負）は 0 に詰める（`draw_clip::signed_rect_to_fill`）。
    pub fn fill_signed_alpha(&self, x0: i32, y0: i32, x1: i32, y1: i32, color: Color, alpha: u8) {
        if let Some((a, b, c, d)) = crate::kernel::draw_clip::signed_rect_to_fill(x0, y0, x1, y1) {
            self.boxfill_alpha(a, b, c, d, color, alpha);
        }
    }

    pub fn draw_rounded_rect_fill(
        &self,
        x0: i32,
        y0: i32,
        x1: i32,
        y1: i32,
        radius: (i32, i32, i32, i32),
        color: Color,
    ) {
        let (tl, tr, br, bl) = radius;
        if tl <= 0 && tr <= 0 && br <= 0 && bl <= 0 {
            self.fill_signed(x0, y0, x1, y1, color);
            return;
        }
        let w = x1 - x0;
        let h = y1 - y0;
        
        let tl = tl.min(w / 2).min(h / 2).max(0);
        let tr = tr.min(w / 2).min(h / 2).max(0);
        let br = br.min(w / 2).min(h / 2).max(0);
        let bl = bl.min(w / 2).min(h / 2).max(0);
        
        // 中央の十字領域と4つの角領域を分けて塗るなど最適化できるが、
        // ひとまずシンプルに point_in_rounded_rect 相当の判定でピクセル描画するか、
        // あるいは矩形領域分割で描画する。
        // ここは OS のカーネル描画プリミティブなので、最適化のため領域分割する。
        
        // 1. 中央水平帯 (全体幅、高さは 上端最大R から 下端最大R)
        let top_max_r = tl.max(tr);
        let bot_max_r = bl.max(br);
        if top_max_r + bot_max_r <= h {
            self.fill_signed(x0, y0 + top_max_r, x1, y1 - bot_max_r, color);
        }
        
        // 2. 上部帯 (左右の角丸を除く)
        if top_max_r > 0 {
            self.fill_signed(x0 + tl, y0, x1 - tr, y0 + top_max_r, color);
        }
        
        // 3. 下部帯 (左右の角丸を除く)
        if bot_max_r > 0 {
            self.fill_signed(x0 + bl, y1 - bot_max_r, x1 - br, y1, color);
        }
        
        // 4. 左上・右上・左下・右下の余白領域で角丸内側のピクセルを描画
        // 左上
        if tl > 0 {
            let r2 = tl * tl;
            for dy in 0..tl {
                for dx in 0..tl {
                    if dx * dx + dy * dy <= r2 {
                        self.draw_pixel((x0 + tl - 1 - dx) as u32, (y0 + tl - 1 - dy) as u32, color);
                    }
                }
            }
            // 上端最大Rとの差分を埋める
            if top_max_r > tl {
                self.fill_signed(x0, y0 + tl, x0 + tl, y0 + top_max_r, color);
            }
        }
        // 右上
        if tr > 0 {
            let r2 = tr * tr;
            for dy in 0..tr {
                for dx in 0..tr {
                    if dx * dx + dy * dy <= r2 {
                        self.draw_pixel((x1 - tr + dx) as u32, (y0 + tr - 1 - dy) as u32, color);
                    }
                }
            }
            if top_max_r > tr {
                self.fill_signed(x1 - tr, y0 + tr, x1, y0 + top_max_r, color);
            }
        }
        // 左下
        if bl > 0 {
            let r2 = bl * bl;
            for dy in 0..bl {
                for dx in 0..bl {
                    if dx * dx + dy * dy <= r2 {
                        self.draw_pixel((x0 + bl - 1 - dx) as u32, (y1 - bl + dy) as u32, color);
                    }
                }
            }
            if bot_max_r > bl {
                self.fill_signed(x0, y1 - bot_max_r, x0 + bl, y1 - bl, color);
            }
        }
        // 右下
        if br > 0 {
            let r2 = br * br;
            for dy in 0..br {
                for dx in 0..br {
                    if dx * dx + dy * dy <= r2 {
                        self.draw_pixel((x1 - br + dx) as u32, (y1 - br + dy) as u32, color);
                    }
                }
            }
            if bot_max_r > br {
                self.fill_signed(x1 - br, y1 - bot_max_r, x1, y1 - br, color);
            }
        }
    }

    pub fn draw_rounded_rect_border(
        &self,
        x0: i32,
        y0: i32,
        x1: i32,
        y1: i32,
        radius: (i32, i32, i32, i32),
        color: Color,
        _border_style: &str,
    ) {
        // 【2026-08-05 発見・修正】完全透明（アルファ 0）の枠線は描かない。
        //
        // `draw_pixel` は互換上アルファ 0 を「不透明」として扱うため
        // （下位のほぼ全ての呼び出しがアルファを設定せず 0 のまま渡すので、
        //  仕様どおり透明にすると画面が消える）、
        // `border-color: transparent` の角丸枠が**黒い輪郭**として描かれていた。
        //
        // 実測: セクション見出しの周りと `#apps` の一覧に、
        // 実サイトに無い黒枠（角丸の輪郭・☐）が出ていた。
        if (color.0 >> 24) & 0xFF == 0 {
            return;
        }
        let (tl, tr, br, bl) = radius;
        if tl <= 0 && tr <= 0 && br <= 0 && bl <= 0 {
            // 直線枠線
            self.boxfill(x0 as u32, y0 as u32, x1 as u32, (y0 + 1) as u32, color);
            self.boxfill(x0 as u32, (y1 - 1) as u32, x1 as u32, y1 as u32, color);
            self.boxfill(x0 as u32, y0 as u32, (x0 + 1) as u32, y1 as u32, color);
            self.boxfill((x1 - 1) as u32, y0 as u32, x1 as u32, y1 as u32, color);
            return;
        }
        let w = x1 - x0;
        let h = y1 - y0;
        let tl = tl.min(w / 2).min(h / 2).max(0);
        let tr = tr.min(w / 2).min(h / 2).max(0);
        let br = br.min(w / 2).min(h / 2).max(0);
        let bl = bl.min(w / 2).min(h / 2).max(0);

        // 直線部分 (上下左右)
        self.boxfill((x0 + tl) as u32, y0 as u32, (x1 - tr) as u32, (y0 + 1) as u32, color);
        self.boxfill((x0 + bl) as u32, (y1 - 1) as u32, (x1 - br) as u32, y1 as u32, color);
        self.boxfill(x0 as u32, (y0 + tl) as u32, (x0 + 1) as u32, (y1 - bl) as u32, color);
        self.boxfill((x1 - 1) as u32, (y0 + tr) as u32, x1 as u32, (y1 - br) as u32, color);

        // 曲線部分
        let draw_arc = |cx: i32, cy: i32, r: i32, quadrant: i32| {
            if r <= 0 { return; }
            let mut x = r;
            let mut y = 0;
            let mut err = 0;
            while x >= y {
                let px1 = cx + x - 1; let py1 = cy + y;
                let px2 = cx + y - 1; let py2 = cy + x - 1;
                let px3 = cx - x; let py3 = cy + y;
                let px4 = cx - y; let py4 = cy + x - 1;
                let px5 = cx - x; let py5 = cy - y - 1;
                let px6 = cx - y; let py6 = cy - x;
                let px7 = cx + x - 1; let py7 = cy - y - 1;
                let px8 = cx + y - 1; let py8 = cy - x;

                match quadrant {
                    1 => { // 右下 (br)
                        self.draw_pixel(px1 as u32, py1 as u32, color);
                        self.draw_pixel(px2 as u32, py2 as u32, color);
                    }
                    2 => { // 左下 (bl)
                        self.draw_pixel(px3 as u32, py3 as u32, color);
                        self.draw_pixel(px4 as u32, py4 as u32, color);
                    }
                    3 => { // 左上 (tl)
                        self.draw_pixel(px5 as u32, py5 as u32, color);
                        self.draw_pixel(px6 as u32, py6 as u32, color);
                    }
                    4 => { // 右上 (tr)
                        self.draw_pixel(px7 as u32, py7 as u32, color);
                        self.draw_pixel(px8 as u32, py8 as u32, color);
                    }
                    _ => {}
                }

                if err <= 0 {
                    y += 1;
                    err += 2 * y + 1;
                }
                if err > 0 {
                    x -= 1;
                    err -= 2 * x + 1;
                }
            }
        };

        draw_arc(x0 + tl, y0 + tl, tl, 3);
        draw_arc(x1 - tr, y0 + tr, tr, 4);
        draw_arc(x1 - br, y1 - br, br, 1);
        draw_arc(x0 + bl, y1 - bl, bl, 2);
    }


}

/// 背景退避・描き戻し方式による動的マウスカーソル制御構造体
pub struct Mouse {
    pub x: u32,
    pub y: u32,
    pub is_clicked: bool,
    pub click_frame: u8,
    /// CSS `cursor: text` 用。矢印の代わりに I-beam（縦棒）を手続き的に描く。
    /// それ以外の非対応 `cursor` キーワード（pointer/wait/help 等）は既定の矢印にフォールバックする。
    pub is_text_cursor: bool,
}

impl Mouse {
    pub const SIZE: u32 = 32;

    pub const fn new(x: u32, y: u32) -> Self {
        Self {
            x,
            y,
            is_clicked: false,
            click_frame: 0,
            is_text_cursor: false,
        }
    }

    pub fn draw(&self, screen: &Screen) {
        let (target_ptr, w, h) = screen.resolve_target();
        let stride = screen.resolve_stride();
        let cursor_size = Self::SIZE;

        // クリック状態によるシフト（押し込み感）
        let (draw_x, draw_y) = if self.is_clicked {
            (self.x + 1, self.y + 1)
        } else {
            (self.x, self.y)
        };

        if self.is_text_cursor {
            self.draw_text_cursor(screen, draw_x, draw_y);
            return;
        }

        if let Some(alpha_mask) = crate::os_lib::svg::get_or_rasterize(ICON_CURSOR_64, cursor_size)
        {
            let theme = crate::kernel::config::get_config().theme;
            let mut c_fill = theme.mouse_cursor;
            let c_stroke = theme.mouse_stroke;

            // クリック時は Fill 色を少し暗くする（明度を落とす）
            if self.is_clicked {
                let r = ((c_fill >> 16) & 0xFF) * 8 / 10;
                let g = ((c_fill >> 8) & 0xFF) * 8 / 10;
                let b = (c_fill & 0xFF) * 8 / 10;
                c_fill = 0xFF000000 | (r << 16) | (g << 8) | b;
            }

            for row in 0..cursor_size {
                let py = draw_y + row;
                if py >= h {
                    continue;
                }

                let max_col = (w.saturating_sub(draw_x)).min(cursor_size) as usize;
                if max_col == 0 {
                    continue;
                }

                let offset = (py * stride + draw_x) as usize;
                unsafe {
                    let mut row_buf = [0u32; 32];
                    let dst = target_ptr.add(offset);

                    // 裏画面から背景を取得
                    let src = if !screen.back_buffer.is_null() {
                        let src_offset = (py * w + draw_x) as usize;
                        screen.back_buffer.add(src_offset)
                    } else {
                        dst
                    };

                    core::ptr::copy_nonoverlapping(src, row_buf.as_mut_ptr(), max_col);

                    // マウスカーソルを重ね合わせ (アルファブレンド)
                    for col in 0..max_col {
                        let mask_idx = (row * cursor_size + col as u32) as usize;
                        let alpha = alpha_mask[mask_idx];
                        if alpha > 0 {
                            // 近傍をチェックしてエッジ（輪郭線）判定を行う
                            let mut is_edge = false;
                            if row == 0
                                || row == cursor_size - 1
                                || col == 0
                                || col as u32 == cursor_size - 1
                            {
                                is_edge = true;
                            } else {
                                // 上下左右斜め8マスのアルファ値をチェック
                                'outer: for dy in -1..=1 {
                                    for dx in -1..=1 {
                                        let ny = row as i32 + dy;
                                        let nx = col as i32 + dx;
                                        let n_idx = (ny * cursor_size as i32 + nx) as usize;
                                        if alpha_mask[n_idx] < 80 {
                                            is_edge = true;
                                            break 'outer;
                                        }
                                    }
                                }
                            }

                            let bg = row_buf[col];
                            let r_bg = (bg >> 16) & 0xFF;
                            let g_bg = (bg >> 8) & 0xFF;
                            let b_bg = bg & 0xFF;

                            // エッジなら縁の色 (c_stroke)、内側なら本体の色 (c_fill) を適用
                            let fg_color = if is_edge { c_stroke } else { c_fill };
                            let r_fg = (fg_color >> 16) & 0xFF;
                            let g_fg = (fg_color >> 8) & 0xFF;
                            let b_fg = fg_color & 0xFF;

                            let a = alpha as u32;
                            let inv_a = 255 - a;

                            let r = (r_fg * a + r_bg * inv_a) / 255;
                            let g = (g_fg * a + g_bg * inv_a) / 255;
                            let b = (b_fg * a + b_bg * inv_a) / 255;

                            row_buf[col] = (r << 16) | (g << 8) | b;
                        }
                    }

                    // VRAMへ一気に書き戻し
                    core::ptr::copy_nonoverlapping(row_buf.as_ptr(), dst, max_col);
                }
            }

            // 集中線（クリック火花）エフェクト
            if self.is_clicked && self.click_frame > 0 && self.click_frame < 8 {
                let spark_color = theme.mouse_cursor; // カーソル本体と同色の火花
                let center_x = draw_x as i32;
                let center_y = draw_y as i32;
                let r1 = 4 + (self.click_frame as i32) * 2; // フレームと共に外へ広がる
                let r2 = r1 + 4; // 線の長さ

                // 8方向の簡易ベクトル (dx, dy)
                let dirs = [
                    (0, -1), (1, -1), (1, 0), (1, 1),
                    (0, 1), (-1, 1), (-1, 0), (-1, -1)
                ];

                for &(dx, dy) in dirs.iter() {
                    for r in r1..=r2 {
                        let px = center_x + dx * r;
                        let py = center_y + dy * r;
                        if px >= 0 && px < w as i32 && py >= 0 && py < h as i32 {
                            let offset = (py as u32 * stride + px as u32) as usize;
                            unsafe {
                                let dst = target_ptr.add(offset);
                                *dst = spark_color;
                            }
                        }
                    }
                }
            }
        }
    }

    /// CSS `cursor: text` 用の I-beam カーソルを手続き的に描画する。
    /// 新規 SVG アイコン資産を追加せず、`draw_pixel` の直描きだけで完結させる
    /// （矢印(SVGラスタライズ)と異なり、コード自体の正しさだけで見た目を保証できる形状）。
    /// `Self::SIZE` 四方のバウンディングボックス内に収め、既存のダーティ領域管理
    /// （`flush_with_cursor`/`flush_dirty_pageflip` が `Self::SIZE` 四方を前提に
    /// 保存/復元・ダーティ判定している）と矛盾しないようにする。
    fn draw_text_cursor(&self, screen: &Screen, draw_x: u32, draw_y: u32) {
        let theme = crate::kernel::config::get_config().theme;
        let color = Color(theme.mouse_cursor);
        let size = Self::SIZE;
        let bar_h = size.saturating_sub(4);
        let cx = draw_x + size / 2;
        let top_y = draw_y + 2;
        let bottom_y = top_y + bar_h;
        // 上下の「serif」（横棒）
        for dx in 0..=(size / 4) {
            screen.draw_pixel(cx.saturating_sub(size / 8) + dx, top_y, color);
            screen.draw_pixel(cx.saturating_sub(size / 8) + dx, bottom_y, color);
        }
        // 縦棒
        for y in top_y..=bottom_y {
            screen.draw_pixel(cx, y, color);
        }
    }

    /// マウスカーソルを新しい位置に移動します
    pub fn move_to(&mut self, screen: &Screen, new_x: u32, new_y: u32) {
        self.x = new_x.clamp(0, screen.width - 1);
        self.y = new_y.clamp(0, screen.height - 1);
    }
}

// --------------------------------------------------------------------
// 起動時スプラッシュ画面表示 (Logo & Log Scroll)
// --------------------------------------------------------------------
pub static mut SPLASH_ACTIVE: bool = false;
pub static LOGO_PNG: &[u8] = include_bytes!("../../images/os_logo.png");

static mut BOOT_LOG_COUNT: usize = 0;
static mut BOOT_LOG_BUFFER: [[u8; 128]; 16] = [[0; 128]; 16];
static mut BOOT_LOG_LENS: [usize; 16] = [0; 16];

static mut CURRENT_LINE_BUFFER: [u8; 256] = [0; 256];
static mut CURRENT_LINE_LEN: usize = 0;

/// # Safety
/// ブート時スプラッシュ専用。可変 static (`CURRENT_LINE_*`) にアクセスするため、
/// 単一スレッドのブートコンテキストからのみ呼び出すこと。
pub unsafe fn write_splash_char(c: u8) {
    if !SPLASH_ACTIVE {
        return;
    }
    // 【2026-10-17】複数スレッドの起動ログが競合すると長さが壊れることがあり、範囲外の
    // スライスでカーネルパニックしていた（JS の例外ログを増やした際に顕在化）。壊れていたら捨てる。
    if CURRENT_LINE_LEN > 255 {
        CURRENT_LINE_LEN = 0;
    }
    if c == b'\n' {
        if CURRENT_LINE_LEN > 0 {
            if let Ok(s) = core::str::from_utf8(&CURRENT_LINE_BUFFER[..CURRENT_LINE_LEN.min(255)]) {
                add_boot_log(s);
            }
            CURRENT_LINE_LEN = 0;
        }
    } else {
        if CURRENT_LINE_LEN < 255 {
            CURRENT_LINE_BUFFER[CURRENT_LINE_LEN] = c;
            CURRENT_LINE_LEN += 1;
        }
    }
}

/// # Safety
/// ブート時スプラッシュ専用。可変 static にアクセスするため、
/// 単一スレッドのブートコンテキストからのみ呼び出すこと。
pub unsafe fn write_splash_str(s: &str) {
    if !SPLASH_ACTIVE {
        return;
    }
    for &b in s.as_bytes() {
        write_splash_char(b);
    }
}

/// # Safety
/// ブート時スプラッシュ専用。可変 static (`BOOT_LOG*`) にアクセスするため、
/// 単一スレッドのブートコンテキストからのみ呼び出すこと。
pub unsafe fn add_boot_log(s: &str) {
    if !SPLASH_ACTIVE {
        return;
    }
    const MAX_LINE_CHARS: usize = 55;

    for line in s.lines() {
        let line = line.trim_end();
        if line.is_empty() {
            continue;
        }

        let mut chars = line.as_bytes();
        while !chars.is_empty() {
            let chunk_len = chars.len().min(MAX_LINE_CHARS);
            let chunk = &chars[..chunk_len];
            chars = &chars[chunk_len..];

            if BOOT_LOG_COUNT < 16 {
                let idx = BOOT_LOG_COUNT;
                BOOT_LOG_BUFFER[idx][..chunk_len].copy_from_slice(chunk);
                BOOT_LOG_LENS[idx] = chunk_len;
                BOOT_LOG_COUNT += 1;
            } else {
                for i in 0..15 {
                    BOOT_LOG_BUFFER[i] = BOOT_LOG_BUFFER[i + 1];
                    BOOT_LOG_LENS[i] = BOOT_LOG_LENS[i + 1];
                }
                BOOT_LOG_BUFFER[15][..chunk_len].copy_from_slice(chunk);
                BOOT_LOG_LENS[15] = chunk_len;
            }
        }
    }
    redraw_splash();
}

/// # Safety
/// ブート時スプラッシュ専用。可変 static (`SPLASH_ACTIVE` 等) と画面バッファに
/// アクセスするため、単一スレッドのブートコンテキストからのみ呼び出すこと。
pub unsafe fn draw_splash_logo() {
    if !SPLASH_ACTIVE {
        return;
    }
    if let Some(ref screen) = crate::CURRENT_SCREEN {
        screen.clear(Color(0xFF000000));
        let mut decoder = zune_png::PngDecoder::new(LOGO_PNG);
        if decoder.decode_raw().is_ok() {
            if let Some(info) = decoder.get_info() {
                let img_w = info.width as u32;
                let img_h = info.height as u32;
                let area_w = 480u32;
                let area_h = screen.height;
                let target_w = area_w.min(img_w);
                let target_h = (target_w * img_h) / img_w;
                let target_h = target_h.min(area_h);
                let target_w = (target_h * img_w) / img_h;

                let x = (area_w - target_w) / 2 + 20;
                let y = (screen.height - target_h) / 2;
                let _ = screen.draw_image(x, y, target_w, target_h, LOGO_PNG);
            }
        }
        redraw_splash();
    }
}

/// # Safety
/// ブート時スプラッシュ専用。可変 static と画面バッファにアクセスするため、
/// 単一スレッドのブートコンテキストからのみ呼び出すこと。
pub unsafe fn redraw_splash() {
    if !SPLASH_ACTIVE {
        return;
    }
    if let Some(ref screen) = crate::CURRENT_SCREEN {
        let area_x = 520u32;
        let area_y = 20u32;
        let area_w = screen.width.saturating_sub(area_x).saturating_sub(20);
        let area_h = screen.height.saturating_sub(area_y).saturating_sub(20);
        screen.boxfill(
            area_x,
            area_y,
            area_x + area_w,
            area_y + area_h,
            Color(0xFF000000),
        );

        let start_y = (screen.height.saturating_sub(40)) as i32;
        let line_height = 28i32;

        for i in 0..BOOT_LOG_COUNT {
            let y = start_y - (BOOT_LOG_COUNT - 1 - i) as i32 * line_height;
            if y >= area_y as i32 {
                if let Ok(s) = core::str::from_utf8(&BOOT_LOG_BUFFER[i][..BOOT_LOG_LENS[i]]) {
                    screen.draw_string_monospace(area_x + 10, y as u32, s, Color(0xFFCCCCCC));
                }
            }
        }
    }
}

pub struct SplashWriter;

impl core::fmt::Write for SplashWriter {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        unsafe {
            write_splash_str(s);
        }
        Ok(())
    }
}