atmos/apps/browser/

mod.rs

//! AtmOS 内蔵 Webブラウザアプリ。
//!
//! [`crate::os_lib::web_engine::WebEngine`]（HTML/CSS パーサ・レイアウト・レンダラ・
//! JavaScript 連携）をタブごとに1インスタンス保持し、戻る/進む/アドレスバー等の
//! ブラウザ UI を提供する。各タブは完全に独立した `WebEngine` を持つため
//! （[`TabSlot`]）、タブ切替時にネットワーク再取得は発生しない。
//!
//! 詳細なアーキテクチャ・座標規約・境界仕様は `spec/DESIGN.md` §3「ブラウザエンジン
//! アーキテクチャ」を参照。
// browser.rs - Web Browser Application utilizing WebEngine for AtmOS
#![allow(dead_code)]

use crate::kernel::draw;
use crate::os_lib::web_engine::{draw_border, url_encode, WebEngine};
use alloc::string::String;
use alloc::vec::Vec;

/// コントロールバー (戻る/進む/アドレスバー等) の高さ。
/// コンテンツ描画の開始 Y 座標でもあり、描画・クリック判定・レイアウトが共通参照する。
const CONTROL_BAR_H: i32 = 40;

/// タブごとのページ状態を保存する
/// 各タブのスロット。タブごとに独立した WebEngine を保持する（完全分離方式）。
/// アクティブタブの engine は `WebBrowser::engine`（ライブ）へ「チェックアウト」され、
/// このスロットの `engine` は `None` になる。非アクティブタブは描画済み DOM・スクロール・
/// フォーム入力をそのまま保持するため、タブ切替でネットワーク再取得は発生しない。
struct TabSlot {
    title: String,
    engine: Option<WebEngine>,
}

static SVG_BACK: &[u8] = b"<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M12.5 16.5L6 10L12.5 3.5\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>";

static SVG_FORWARD: &[u8] = b"<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M7.5 3.5L14 10L7.5 16.5\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>";

static SVG_HOME: &[u8] = b"<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 2.5L3.5 8V16.5C3.5 17 4 17.5 4.5 17.5H7.5V12.5H12.5V17.5H15.5C16 17.5 16.5 17 16.5 16.5V8L10 2.5Z\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/></svg>";

static SVG_SHIELD_SECURE: &[u8] = b"<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 2.5C13 3.5 16.5 3.5 16.5 3.5V8.5C16.5 13 13 16.5 10 17.5C7 16.5 3.5 13 3.5 8.5V3.5C3.5 3.5 7 3.5 10 2.5Z\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/><path d=\"M7 10L9 12L13 8\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>";

static SVG_SHIELD_WARN: &[u8] = b"<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 2.5C13 3.5 16.5 3.5 16.5 3.5V8.5C16.5 13 13 16.5 10 17.5C7 16.5 3.5 13 3.5 8.5V3.5C3.5 3.5 7 3.5 10 2.5Z\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/><path d=\"M4.5 4.5L15.5 15.5\" stroke=\"currentColor\" stroke-width=\"2\"/></svg>";

static SVG_RELOAD: &[u8] = b"<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M17 10C17 13.866 13.866 17 10 17C6.13401 17 3 13.866 3 10C3 6.13401 6.13401 3 10 3C12.186 3 14.136 4.003 15.42 5.58M17 3V6H14\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>";

/// OS 内蔵の静的ホームページをエンジンへロードする（ネットワーク不要）。
fn render_home(engine: &mut WebEngine, top: i32) {
    engine.current_is_https = false;
    engine.load_html(crate::os_lib::web_engine::HOME_HTML, "home", top);
    engine.title = String::from("AtmOS Browser");
}

// 新しい WebBrowser (マルチタブ・アドレスバー等を持つ具体的なブラウザアプリケーション)
pub struct WebBrowser {
    /// アクティブタブのライブエンジン。tabs[active_tab_idx].engine は None。
    pub engine: WebEngine,
    pub address_bar_focused: bool,
    pub address_box: crate::kernel::text_box::TextBox,
    pub active_tab_idx: usize,
    tabs: Vec<TabSlot>,
}

/// 【2026-08-01計測】再描画に入った理由の内訳。
/// 描画 1 回が約 130 tick かかるので、冗長な再描画は直接コストになる。
static REDRAW_LOADING: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
static REDRAW_DIRTY: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
static REDRAW_VIDEO: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
static REDRAW_IMG: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);

/// 内訳をログへ出す（描画側から一定間隔で呼ぶ）。
pub fn log_redraw_reasons() {
}

impl WebBrowser {
    /// コンテンツ描画の開始 Y 座標 (コントロールバーの直下)。
    /// 描画・クリック判定・レイアウトすべてがこの値を共通参照する。
    pub fn top_offset(&self) -> i32 {
        CONTROL_BAR_H
    }

    /// アクティブエンジンのタイトルを現タブスロットに同期する（タブバー表示用）。
    fn sync_active_title(&mut self) {
        let title = if self.engine.title.is_empty() {
            self.engine.current_host.clone()
        } else {
            self.engine.title.clone()
        };
        if let Some(slot) = self.tabs.get_mut(self.active_tab_idx) {
            slot.title = title;
        }
    }

    /// アクティブタブを `idx` へ切り替える。ライブエンジンを現タブスロットへ戻し、
    /// 切替先スロットのエンジンを mem::swap でライブへ取り出す（クローン・再取得なし）。
    fn activate(&mut self, idx: usize) {
        if idx == self.active_tab_idx || idx >= self.tabs.len() {
            return;
        }
        self.sync_active_title();
        // 切替先のエンジンを取り出す
        if let Some(mut next) = self.tabs[idx].engine.take() {
            // self.engine(現アクティブ=A) と next(切替先=B) を入れ替える
            core::mem::swap(&mut self.engine, &mut next);
            // next は今や A のエンジン。元のアクティブスロットへ戻す
            self.tabs[self.active_tab_idx].engine = Some(next);
            self.active_tab_idx = idx;
        }
        self.engine.active = true;
        self.engine.dirty = true;
        self.engine.dirty_reason = "mod.rs:105";
        self.address_box.set_text(&self.engine.get_url());
        self.address_bar_focused = false;
    }
}

impl Default for WebBrowser {
    fn default() -> Self {
        Self::new()
    }
}

impl WebBrowser {
    pub fn new() -> Self {
        // 起動時に前回の古いキャッシュをクリア（壊れたキャッシュによる誤表示を防ぐ）
        crate::os_lib::web_engine::clear_browser_cache();
        let mut engine = WebEngine::new();
        engine.win_w = 800;
        engine.win_h = 600;
        // 起動時は OS 内蔵の静的ホームページを表示する（ネットワーク不要）
        render_home(&mut engine, CONTROL_BAR_H);
        let initial_url = engine.get_url();
        // 初期タブスロット（アクティブなので engine は None = ライブへチェックアウト済み）
        let initial_slot = TabSlot {
            title: String::from("AtmOS Browser"),
            engine: None,
        };
        Self {
            engine,
            address_bar_focused: false,
            address_box: crate::kernel::text_box::TextBox::with_text(&initial_url),
            active_tab_idx: 0,
            tabs: alloc::vec![initial_slot],
        }
    }
}

// グローバルなブラウザインスタンス
static mut GLOBAL_BROWSER: Option<WebBrowser> = None;

// グローバルインスタンスの初期化と取得
pub fn init() {
    unsafe {
        GLOBAL_BROWSER = Some(WebBrowser::new());
    }
}

pub fn get_instance() -> &'static mut WebBrowser {
    // init() 前に呼ばれた場合も panic せず、その場で初期化する
    unsafe { GLOBAL_BROWSER.get_or_insert_with(WebBrowser::new) }
}

pub fn is_active() -> bool {
    unsafe {
        match &GLOBAL_BROWSER {
            Some(b) => b.engine.active,
            None => false,
        }
    }
}

/// CSS `cursor: text` の要素上にマウスがあるか（OS 側の実マウスカーソル形状決定用）。
pub fn hovered_cursor_is_text() -> bool {
    unsafe {
        match &GLOBAL_BROWSER {
            Some(b) => b.engine.active && b.engine.hovered_cursor_is_text,
            None => false,
        }
    }
}

pub fn needs_render() -> bool {
    unsafe {
        match &GLOBAL_BROWSER {
            Some(b) => {
                // 【2026-08-01計測】実際に全画面描画を起動しているのは
                // `needs_timer_redraw` ではなく**こちら**。
                // 先に `needs_timer_redraw` 側で数えたが、呼ばれる頻度が
                // 違うため全画面描画の回数と突き合わせられなかった。
                let r = b.engine.active && (b.engine.loading || b.engine.dirty);
                if r {
                    if b.engine.loading {
                        RENDER_LOADING.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
                    }
                    if b.engine.dirty {
                        RENDER_DIRTY.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
                    }
                }
                r
            }
            None => false,
        }
    }
}

/// 【2026-08-01計測】`needs_render` が true を返した理由の内訳。
static RENDER_LOADING: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
static RENDER_DIRTY: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);

// === 新しい WindowManager への対応 ===
impl crate::kernel::window_mgr::App for WebBrowser {
    fn name(&self) -> &str {
        "browser"
    }

    fn instance_info(&self) -> alloc::string::String {
        self.engine.title.clone()
    }

    fn on_resize(&mut self, width: u32, height: u32) {
        let top = self.top_offset();
        self.engine.win_w = width;
        self.engine.win_h = height;
        let html = self.engine.last_html.clone();
        self.engine.parse_and_layout(&html, None, top, width, height);
        self.engine.js_runtime.fire_resize(width as i32, height as i32);
        self.engine.dirty = true;
        self.engine.dirty_reason = "mod.rs:202";
    }

    fn needs_timer_redraw(&self) -> bool {
        // loading 中、dirty、画像ロード完了、または動画再生中であればタイマー再描画を有効にする。
        // 【2026-08-01計測】描画が実行時間の約半分（95 回 × 約 130 tick）を
        // 占めている。そのうち何回が本当に必要だったかを知るため、
        // **どの条件で再描画に入ったか**を数える。
        // 推測で条件を外すと画面が更新されなくなるので、まず数える。
        let loading = self.engine.loading;
        let dirty = self.engine.dirty;
        let video = self.engine.video_playing;
        let img = crate::os_lib::web_engine::image_results_ready();
        // JS が canvas へ描いた分。画像完了と同じくエッジトリガで、
        // 変化があった一度だけ再描画する（`draw` が旗を降ろす）。
        let canvas = crate::os_lib::canvas2d::canvas_dirty();
        // 【2026-09-06 バグ修正】フォントの取得待ちを再描画条件に入れる。
        //
        // 取得のポンプ（`font_queue::pump`）は `draw()` の中にある。
        // 内容が出揃って他に変化が無くなると `draw()` が呼ばれなくなり、
        // **フォントが残っていても誰もポンプを回さなくなる**。
        // その結果、待ち行列に仕事があるのにワーカーが起きず、
        // 稼働本数だけが古いまま残って上限に張り付く。
        //
        // 実測（停滞時）: `font_pending=1 fw=4 ff=0`、
        // `[FQDIAG]` はページ読み込み前の 4 行しか出ておらず
        // （＝`draw()` が止まっている）、提示ループのフレームだけが進む。
        // 断続的に見えるのは、描画が静かになる瞬間にフォントが
        // 残っているかどうかで決まるため。
        let font_wait = crate::os_lib::web_engine::font_pending() > 0;
        if loading {
            REDRAW_LOADING.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        }
        if dirty {
            REDRAW_DIRTY.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
            // どこが立てたかをそのまま出す（推測せず現物を見る）。
        }
        if video {
            REDRAW_VIDEO.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        }
        if img {
            REDRAW_IMG.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        }
        // 【2026-08-01 性能修正】`loading` 単独で全フレーム強制再描画していた。
        //
        // 実測: 再描画 94 回すべてで `loading=true`。フォントの背景取得が
        // 続いている間ずっと true のままなので、**変化が無くても毎フレーム
        // 全画面を描き直していた**（1 回あたり約 130 tick）。
        //
        // ただしコンテンツがまだ 1 つも無い間は**ローディング表示の
        // アニメーション**を回す必要があるので、そこは従来どおり強制する。
        // コンテンツが出た後は `dirty` / 画像到着 / 動画という
        // **実際の変化シグナル**だけで再描画する。
        //
        // 取得を打ち切るわけではない（取得は背景スレッドで最後まで走り、
        // 届いた時点で `dirty` が立って反映される）。
        let showing_placeholder = loading && self.engine.elements.is_empty();
        showing_placeholder || dirty || video || img || canvas || font_wait
    }

    /// 【2026-08-01計測】再描画要求の内訳カウンタ。
    fn draw(
        &mut self,
        screen: &crate::kernel::draw::Screen,
        win_x: u32,
        win_y: u32,
        win_w: u32,
        win_h: u32,
    ) {
        crate::os_lib::web_engine::set_draw_stage(1);
        // canvas の変化はこの描画で画面に出る。ここで降ろさないと
        // 毎フレーム再描画が続いて画面が波打つ。
        let _ = crate::os_lib::canvas2d::take_canvas_dirty();
        let top = self.top_offset();
        // ウィンドウサイズまたは境界が変わったら再レイアウト
        if self.engine.win_w != win_w || self.engine.win_h != win_h || self.engine.top_offset != top
        {
            // ビューポートの幅・高さが実際に変化したか（top_offset のみの変化は resize ではない）。
            let size_changed = self.engine.win_w != win_w || self.engine.win_h != win_h;
            self.engine.win_w = win_w;
            self.engine.win_h = win_h;
            let html = self.engine.last_html.clone();
            self.engine.parse_and_layout(&html, None, top, win_w, win_h);
            // 再レイアウト後に window.resize リスナを発火（サイズ変化時のみ）。
            if size_changed {
                self.engine
                    .js_runtime
                    .fire_resize(win_w as i32, win_h as i32);
            }
        }
        let theme = crate::kernel::config::get_config().theme;
        screen.boxfill(
            win_x,
            win_y,
            win_x + win_w,
            win_y + win_h,
            crate::kernel::draw::Color(theme.app_bg),
        );

        // 1. コンテンツの描画 (Y=top 以降)。
        // バー類より先に描くことで、境界からはみ出した要素は後段のバー描画が
        // 必ず上書きする (バーが最前面のZ順になる)。
        self.engine.draw(screen, win_x, win_y, win_w, win_h, top);

        // 2. コントロールバーの描画 (上部 40px)
        screen.boxfill(
            win_x,
            win_y,
            win_x + win_w,
            win_y + CONTROL_BAR_H as u32,
            crate::kernel::draw::Color(theme.tab_area_bg),
        );

        // [Back] ボタン
        let can_back = self.engine.can_go_back();
        let back_fg = if can_back { theme.button_fg } else { theme.non_active_window_border };
        screen.boxfill(
            win_x + 10,
            win_y + 8,
            win_x + 42,
            win_y + 32,
            draw::Color(theme.button_bg),
        );
        draw_border(
            screen,
            (win_x + 10) as i32,
            (win_y + 8) as i32,
            (win_x + 42) as i32,
            (win_y + 32) as i32,
            theme.non_active_window_border,
        );
        screen.draw_svg_icon(win_x + 16, win_y + 10, SVG_BACK, 20, draw::Color(back_fg));

        // [Forward] ボタン
        let can_fwd = self.engine.can_go_forward();
        let fwd_fg = if can_fwd { theme.button_fg } else { theme.non_active_window_border };
        screen.boxfill(
            win_x + 48,
            win_y + 8,
            win_x + 80,
            win_y + 32,
            draw::Color(theme.button_bg),
        );
        draw_border(
            screen,
            (win_x + 48) as i32,
            (win_y + 8) as i32,
            (win_x + 80) as i32,
            (win_y + 32) as i32,
            theme.non_active_window_border,
        );
        screen.draw_svg_icon(win_x + 54, win_y + 10, SVG_FORWARD, 20, draw::Color(fwd_fg));

        // [Home] ボタン
        screen.boxfill(
            win_x + 86,
            win_y + 8,
            win_x + 118,
            win_y + 32,
            draw::Color(theme.button_bg),
        );
        draw_border(
            screen,
            (win_x + 86) as i32,
            (win_y + 8) as i32,
            (win_x + 118) as i32,
            (win_y + 32) as i32,
            theme.non_active_window_border,
        );
        screen.draw_svg_icon(
            win_x + 92,
            win_y + 10,
            SVG_HOME,
            20,
            draw::Color(theme.button_fg),
        );

        // [Reload] ボタン
        screen.boxfill(
            win_x + 124,
            win_y + 8,
            win_x + 156,
            win_y + 32,
            draw::Color(theme.button_bg),
        );
        draw_border(
            screen,
            (win_x + 124) as i32,
            (win_y + 8) as i32,
            (win_x + 156) as i32,
            (win_y + 32) as i32,
            theme.non_active_window_border,
        );
        screen.draw_svg_icon(
            win_x + 130,
            win_y + 10,
            SVG_RELOAD,
            20,
            draw::Color(theme.button_fg),
        );

        // [HTTPS/HTTP] セキュリティ盾バッジ
        let is_https = self.engine.current_is_https;
        let badge_w = if is_https { 95 } else { 125 };
        let badge_bg = if is_https { 0xFF1B4D3E } else { 0xFF4C1D1D };
        let badge_border = if is_https { 0xFF50FA7B } else { 0xFFFF5555 };
        let badge_lbl = if is_https { "Secure" } else { "Not Secure" };
        let badge_fg = if is_https { 0xFFECFDF5 } else { 0xFFFEE2E2 };
        let badge_svg = if is_https {
            SVG_SHIELD_SECURE
        } else {
            SVG_SHIELD_WARN
        };

        screen.boxfill(
            win_x + 162,
            win_y + 8,
            win_x + 162 + badge_w,
            win_y + 32,
            draw::Color(badge_bg),
        );
        draw_border(
            screen,
            (win_x + 162) as i32,
            (win_y + 8) as i32,
            (win_x + 162 + badge_w) as i32,
            (win_y + 32) as i32,
            badge_border,
        );
        screen.draw_svg_icon(
            win_x + 164,
            win_y + 10,
            badge_svg,
            20,
            draw::Color(badge_border),
        );
        screen.draw_string_vector(
            win_x + 189,
            win_y + 13,
            badge_lbl,
            draw::Color(badge_fg),
            11,
        );

        let badge_end = 162 + badge_w;

        // アドレスバー (Omnibar): セキュリティバッジの直後から右端まで
        let bar_right = (win_x + win_w).saturating_sub(10);
        let bar_left = win_x + badge_end + 6;
        if bar_right > bar_left {
            let addr_bg = if self.address_bar_focused {
                theme.terminal_bg
            } else {
                theme.tab_area_bg
            };
            let addr_border = if self.address_bar_focused {
                theme.focus_highlight
            } else {
                theme.non_active_window_border
            };
            screen.boxfill(
                bar_left,
                win_y + 8,
                bar_right,
                win_y + 32,
                draw::Color(addr_bg),
            );
            draw_border(
                screen,
                bar_left as i32,
                (win_y + 8) as i32,
                bar_right as i32,
                (win_y + 32) as i32,
                addr_border,
            );

            let is_placeholder = self.address_box.text.is_empty() && !self.address_bar_focused;
            let display_text = if is_placeholder {
                String::from("Search or enter address...")
            } else {
                self.address_box.text.clone()
            };
            let text_color = if is_placeholder {
                theme.non_active_window_border
            } else {
                theme.terminal_fg
            };
            screen.draw_string_vector(
                bar_left + 10,
                win_y + 12,
                &display_text,
                draw::Color(text_color),
                12,
            );

            // フォーカス中はカーソル位置に縦棒カーソルを描画（色はターミナルと共通の 0xFF756CE0）
            if self.address_bar_focused {
                let prefix: String = self
                    .address_box
                    .text
                    .chars()
                    .take(self.address_box.cursor_pos)
                    .collect();
                let pw = crate::kernel::vector_font::get_vector_string_width(&prefix, 12);
                let cursor_x = bar_left + 10 + pw;
                if cursor_x < bar_right {
                    screen.boxfill(
                        cursor_x,
                        win_y + 11,
                        cursor_x + 1,
                        win_y + 28,
                        draw::Color(crate::kernel::ime::cursor_color()),
                    );
                }
            }
        }

        screen.boxfill(
            win_x,
            win_y + 39,
            win_x + win_w,
            win_y + 40,
            crate::kernel::draw::Color(theme.tab_area_border),
        );

        // アドレス・タイトルを同調
        if !self.address_bar_focused && self.engine.dirty {
            self.address_box.set_text(&self.engine.get_url());
        }
        if !self.engine.title.is_empty() {
            if let Some(slot) = self.tabs.get_mut(self.active_tab_idx) {
                slot.title = self.engine.title.clone();
            }
        }
        crate::os_lib::web_engine::set_draw_stage(0);
    }

    fn on_mouse(
        &mut self,
        local_x: i32,
        local_y: i32,
        btn_left: bool,
        btn_right: bool,
        wheel: i32,
    ) {
        let top = self.top_offset();

        if btn_left && (0..CONTROL_BAR_H).contains(&local_y) {
            if (8..=32).contains(&local_y) {
                if (10..=42).contains(&local_x) {
                    self.engine.go_back(top);
                    self.address_bar_focused = false;
                    self.address_box.set_text(&self.engine.get_url());
                    self.engine.dirty = true;
                    self.engine.dirty_reason = "mod.rs:532";
                    return;
                }
                if (48..=80).contains(&local_x) {
                    self.engine.go_forward(top);
                    self.address_bar_focused = false;
                    self.address_box.set_text(&self.engine.get_url());
                    self.engine.dirty = true;
                    self.engine.dirty_reason = "mod.rs:539";
                    return;
                }
                if (86..=118).contains(&local_x) {
                    // [Home]: OS 内蔵の静的ホームページを表示
                    render_home(&mut self.engine, top);
                    self.address_bar_focused = false;
                    self.address_box.set_text(&self.engine.get_url());
                    self.engine.dirty = true;
                    self.engine.dirty_reason = "mod.rs:547";
                    return;
                }
                if (124..=156).contains(&local_x) {
                    // リロード
                    if self.engine.current_host == "localhost" {
                        let path = self.engine.current_path.clone();
                        if path == "/home" {
                            // 内蔵ホームページの再描画
                            render_home(&mut self.engine, top);
                        } else {
                            // 【2026-08-25 バグ修正】FS_LOCK を取らずに読んでいた。
                            // 前ページの画像・フォントワーカーはまだ生きており、
                            // 同時に FS_LOCK 下で書き込む。読み取りの間だけ保持する。
                            let loaded = {
                                let _fs_guard = crate::kernel::fs::FS_LOCK.lock();
                                crate::kernel::fs::get_fs().read_file(&path)
                            };
                            if let Some((_meta, content)) = loaded {
                                if let Ok(html) = core::str::from_utf8(&content) {
                                    self.engine.load_html(
                                        html,
                                        path.strip_prefix('/').unwrap_or(&path),
                                        top,
                                    );
                                }
                            }
                        }
                    } else {
                        self.engine.load_page(
                            self.engine.current_is_https,
                            &self.engine.current_host.clone(),
                            &self.engine.current_path.clone(),
                            false,
                            top,
                        );
                    }
                    self.address_bar_focused = false;
                    self.address_box.set_text(&self.engine.get_url());
                    return;
                }
                // アドレスバーはセキュリティバッジの直後から始まる (描画と同じ座標)
                let badge_end = 162
                    + if self.engine.current_is_https {
                        95
                    } else {
                        125
                    };
                let bar_left = badge_end + 6;
                if local_x >= bar_left {
                    self.address_bar_focused = true;
                    self.address_box.set_text(&self.engine.get_url());
                    self.engine.dirty = true;
                    self.engine.dirty_reason = "mod.rs:593";
                    return;
                }
            }
            self.address_bar_focused = false;
            self.engine.dirty = true;
            self.engine.dirty_reason = "mod.rs:598";
            return;
        }

        if btn_left {
            self.address_bar_focused = false;
            self.engine.dirty = true;
            self.engine.dirty_reason = "mod.rs:604";
        }

        self.engine
            .on_mouse(local_x, local_y, btn_left, btn_right, wheel, top);
    }

    fn on_key(&mut self, keycode: u8, pressed: bool, ascii: Option<char>) {
        if !pressed {
            return;
        }

        if self.address_bar_focused {
            if keycode == 0x1C {
                // Enter
                let trimmed = self.address_box.text.trim();
                if !trimmed.is_empty() {
                    let input = String::from(trimmed);
                    let top = self.top_offset();
                    if let Some(rest) = input.strip_prefix('/') {
                        // ローカル SylFS パス（例: /apps/imgtest/index.html）
                        // 【2026-08-25 バグ修正】同上。FS_LOCK を取ってから読む。
                        let loaded = {
                            let _fs_guard = crate::kernel::fs::FS_LOCK.lock();
                            crate::kernel::fs::get_fs().read_file(&input)
                        };
                        if let Some((_meta, content)) = loaded {
                            if let Ok(html) = core::str::from_utf8(&content) {
                                self.engine.load_html(html, rest, top);
                            }
                        }
                    } else if input.starts_with("http://") || input.starts_with("https://") {
                        // "http://" または "https://" で始まるURLの解析
                        let is_https = input.starts_with("https://");
                        let clean = if is_https {
                            input.get(8..).unwrap_or("")
                        } else {
                            input.get(7..).unwrap_or("")
                        };
                        // スラッシュでホスト名とパス名部分を分離する（最大2分割）
                        let parts: Vec<&str> = clean.splitn(2, '/').collect();
                        let host = parts[0];
                        let path = if parts.len() > 1 {
                            alloc::format!("/{}", parts[1])
                        } else {
                            String::from("/")
                        };
                        self.engine.load_page(is_https, host, &path, true, top);
                    } else if input.contains('.') && !input.contains(' ') {
                        // スキーマ無しだがドットを含みスペースを含まない場合（例: sugi-lab.net/abc）
                        // スラッシュでホスト名とパス名部分を分離する（最大2分割）
                        let parts: Vec<&str> = input.splitn(2, '/').collect();
                        let host = parts[0];
                        let path = if parts.len() > 1 {
                            alloc::format!("/{}", parts[1])
                        } else {
                            String::from("/")
                        };
                        let is_https = !host.starts_with("localhost");
                        self.engine.load_page(is_https, host, &path, true, top);
                    } else {
                        let query = url_encode(&input);
                        let path = alloc::format!("/lite/?q={}", query);
                        self.engine
                            .load_page(true, "lite.duckduckgo.com", &path, true, top);
                    }
                }
                self.address_bar_focused = false;
                self.address_box.set_text(&self.engine.get_url());
                self.engine.dirty = true;
                self.engine.dirty_reason = "mod.rs:669";
            } else {
                if self.address_box.handle_key(keycode, ascii) {
                    self.engine.dirty = true;
                    self.engine.dirty_reason = "mod.rs:672";
                }
            }
            return;
        }

        self.engine.on_key(keycode, pressed, ascii);

        if keycode == 0x0E && self.engine.focused_id.is_none() {
            let top = self.top_offset();
            self.engine.go_back(top);
            self.address_box.set_text(&self.engine.get_url());
        }

        // 【2026-08-03】キーボードによるスクロールが**丸ごと未対応**だった。
        //
        // ブラウザが処理していたキーは Enter(0x1C) と Backspace(0x0E) の 2 つだけで、
        // 矢印キーも PageDown も無視していた。実ブラウザなら当然動く操作であり、
        // 「ページ下部が正しく描けているか」を確認する手段も無かった
        // （`browser.scroll()` を端末へ送ろうとしても、ブラウザに
        //  フォーカスがあるためキーが端末へ届かない）。
        //
        // 入力欄にフォーカスがあるときは文字入力を優先するため何もしない。
        if self.engine.focused_id.is_none() && !self.address_bar_focused {
            // Set-1 スキャンコード。
            let page = (self.engine.win_h as i32 - self.top_offset()).max(80);
            let dy = match keycode {
                0x48 => Some(-60),          // ↑
                0x50 => Some(60),           // ↓
                0x49 => Some(-page),        // PageUp
                0x51 => Some(page),         // PageDown
                0x47 => Some(-self.engine.max_scroll_y), // Home
                0x4F => Some(self.engine.max_scroll_y),  // End
                _ => None,
            };
            if let Some(dy) = dy {
                self.engine.scroll(dy);
                self.engine.dirty = true;
                self.engine.dirty_reason = "browser/mod.rs:key_scroll";
            }
        }
    }

    fn tabs(&self) -> alloc::vec::Vec<alloc::string::String> {
        // アクティブタブのタイトルはライブエンジンから取る（スロットは古い可能性がある）
        self.tabs
            .iter()
            .enumerate()
            .map(|(i, t)| {
                if i == self.active_tab_idx {
                    if self.engine.title.is_empty() {
                        self.engine.current_host.clone()
                    } else {
                        self.engine.title.clone()
                    }
                } else {
                    t.title.clone()
                }
            })
            .collect()
    }

    fn active_tab(&self) -> usize {
        self.active_tab_idx
    }

    fn close_tab(&mut self, idx: usize) -> bool {
        if idx >= self.tabs.len() {
            return false;
        }

        let was_active = idx == self.active_tab_idx;
        self.tabs.remove(idx);

        if self.tabs.is_empty() {
            self.engine.active = false;
            crate::os_lib::web_engine::clear_browser_cache();
            return true;
        }

        if was_active {
            // 閉じたのがアクティブタブ: 隣のタブのエンジンをライブへ取り出す
            let new_idx = idx.min(self.tabs.len() - 1);
            if let Some(mut next) = self.tabs[new_idx].engine.take() {
                core::mem::swap(&mut self.engine, &mut next);
                // next(旧アクティブのエンジン)はタブ削除済みなので破棄される
            }
            self.active_tab_idx = new_idx;
            self.engine.active = true;
            self.engine.dirty = true;
            self.engine.dirty_reason = "mod.rs:733";
            self.address_box.set_text(&self.engine.get_url());
            self.address_bar_focused = false;
        } else if idx < self.active_tab_idx {
            // アクティブより前のタブが消えたのでインデックスを詰める
            self.active_tab_idx -= 1;
        }
        false
    }

    fn switch_tab(&mut self, idx: usize) {
        self.activate(idx);
    }

    fn add_tab(&mut self) {
        if self.tabs.len() >= 16 {
            return;
        }
        // 現アクティブエンジンを現スロットへ戻す
        self.sync_active_title();
        let old_active = self.active_tab_idx;
        let w = self.engine.win_w;
        let h = self.engine.win_h;

        // 新しい独立エンジンを生成
        let mut new_engine = WebEngine::new();
        new_engine.win_w = w;
        new_engine.win_h = h;
        new_engine.current_host = String::from("newtab");
        new_engine.current_path = String::from("/");
        new_engine.title = String::from("New Tab");
        new_engine.active = true;
        let top = self.top_offset();
        new_engine.parse_and_layout(
            "<h1>New Tab</h1><p>Enter URL in the address bar.</p>",
            None,
            top,
            w,
            h,
        );

        // 旧アクティブエンジンをスロットへ退避し、新エンジンをライブにする
        let prev = core::mem::replace(&mut self.engine, new_engine);
        self.tabs[old_active].engine = Some(prev);

        self.tabs.push(TabSlot {
            title: String::from("New Tab"),
            engine: None,
        });
        self.active_tab_idx = self.tabs.len() - 1;

        self.address_box.set_text("");
        self.address_bar_focused = true;
        self.engine.dirty = true;
        self.engine.dirty_reason = "mod.rs:786";
    }

    fn get_dom_value(&self, id: &str) -> Option<alloc::string::String> {
        self.engine.form_values.get(id).cloned()
    }

    fn set_dom_value(&mut self, id: &str, val: &str) {
        self.engine.form_values.insert(
            alloc::string::String::from(id),
            alloc::string::String::from(val),
        );
        self.engine.dirty = true;
        self.engine.dirty_reason = "mod.rs:798";
    }

    fn get_dom_content(&self, id: &str) -> Option<alloc::string::String> {
        self.engine.dom_contents.get(id).cloned()
    }

    fn set_dom_content(&mut self, id: &str, val: &str) {
        self.engine.set_dom_content(id, val);
    }
}