Merge remote-tracking branch 'origin/dev' into fix/menu-accelerator

src-tauri/Cargo.toml

@@ -29,7 +29,7 @@ perf-harness = ["dep:tauri-plugin-wdio-webdriver"]
 identifier = "io.github.clash-verge-rev.clash-verge-rev"
 
 [build-dependencies]
-tauri-build = { version = "2.7.1", features = [] }
+tauri-build = { version = "2.7.3", features = [] }
 
 [dependencies]
 clash-verge-draft = { workspace = true }
@@ -72,55 +72,55 @@ sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs.git", branch
   "guard",
 ] }
 network-interface = { version = "2.0.5", features = ["serde"] }
-tauri-plugin-shell = "2.4.0"
-tauri-plugin-opener = "2.7.0"
-tauri-plugin-dialog = "2.8.1"
-tauri-plugin-fs = "2.6.0"
+tauri-plugin-shell = "2.5.0"
+tauri-plugin-opener = "2.7.2"
+tauri-plugin-dialog = "2.8.3"
+tauri-plugin-fs = "2.7.1"
 tauri-plugin-process = "2.4.0"
-tauri-plugin-deep-link = "2.6.1"
+tauri-plugin-deep-link = "2.6.2"
 tauri-plugin-window-state = "2.5.0"
-zip = "9.0.1"
+zip = "9.0.4"
 flate2 = "1.1.10"
 reqwest_dav = "0.3.3"
 aes-gcm = { version = "0.11.1" }
 base64 = "0.23.1"
 minisign-verify = "0.3.0"
-sha2 = "0.11"
+sha2 = "0.11.1"
 getrandom = "0.4.3"
 futures = "0.3.34"
 gethostname = "1.1.0"
 scopeguard = "1.2.0"
-tauri-plugin-notification = "2.5.1"
+tauri-plugin-notification = "2.7.0"
 tokio-stream = "0.1.19"
 backon = { version = "1.6.0", features = ["tokio-sleep"] }
-tauri-plugin-http = "2.8.0"
+tauri-plugin-http = "2.8.3"
 tracing = { workspace = true }
 tauri-plugin-devtools = { version = "2.2.2", optional = true }
-tauri-plugin-mihomo = { git = "https://github.com/clash-verge-rev/tauri-plugin-mihomo", branch = "main" }
+tauri-plugin-mihomo = { git = "https://github.com/clash-verge-rev/tauri-plugin-mihomo", rev = "7a03d16f4d39b1bb885b7babe66b9e153e34b615" }
 async-trait = "0.1.92"
 clash_verge_service_ipc = { git = "https://github.com/clash-verge-rev/clash-verge-service-ipc.git", tag = "v2.7.6", version = "2.7.6", features = [
   "client",
 ] }
 arc-swap = "1.9.2"
 tokio-rustls = "0.26.6"
-rustls = { version = "0.23.45", features = ["ring"] }
+rustls = { version = "0.23.46", features = ["ring"] }
 webpki-roots = "1.0.9"
 dark-light = "3.0.0"
 bytes = "1.12.1"
-tokio-util = { version = "0.7.19", features = ["time"] }
+tokio-util = { version = "0.7.20", features = ["time"] }
 specta = { version = "=2.0.0-rc.25", features = ["derive", "function", "serde_json"] }
 tauri-specta = { version = "=2.0.0-rc.25", features = ["derive", "typescript"] }
 specta-typescript = "=0.0.12"
 
 [target.'cfg(unix)'.dependencies]
-libc = "0.2.190"
+libc = "0.2.191"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 # Upstream has no session-end signal support on Linux; see crates/clash-verge-signal.
 clash-verge-signal = { workspace = true }
 
 [target.'cfg(target_os = "macos")'.dependencies]
-tauri-plugin-wdio-webdriver = { version = "=1.4.0", optional = true }
+tauri-plugin-wdio-webdriver = { version = "=1.5.0", optional = true }
 objc2 = "0.6.5"
 objc2-foundation = { version = "0.3.2", features = [
   "NSString",
@@ -153,8 +153,8 @@ windows-sys.workspace = true
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-autostart = "2.7.0"
-tauri-plugin-global-shortcut = "2.4.0"
-tauri-plugin-updater = "2.13.1"
+tauri-plugin-global-shortcut = "2.4.1"
+tauri-plugin-updater = "2.14.0"
 
 [dev-dependencies]
 criterion = { workspace = true }

src-tauri/build.rs

@@ -1,10 +1,9 @@
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows")
         && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("msvc")
-        && std::env::var_os("CARGO_FEATURE_CLIPPY").is_some()
     {
-        // Tauri's resource is linked to the app binary, but not to Rust unit-test harnesses.
-        // Give mock-context builds their own manifest so tests can resolve TaskDialogIndirect.
+        // Tauri's resource is linked to the app binary, but not to Rust unit-test harnesses or examples.
+        // Give non-app targets their own manifest so tests and examples can resolve TaskDialogIndirect.
         let out_dir = std::env::var_os("OUT_DIR").ok_or_else(|| std::io::Error::other("OUT_DIR is not set"))?;
         let manifest_path = std::path::PathBuf::from(out_dir).join("windows-test-manifest.xml");
         std::fs::write(
@@ -25,8 +24,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 </assembly>
 "#,
         )?;
-        println!("cargo:rustc-link-arg=/MANIFEST:EMBED");
-        println!("cargo:rustc-link-arg=/MANIFESTINPUT:{}", manifest_path.display());
+        let manifest_display = manifest_path.display();
+        if std::env::var_os("CARGO_FEATURE_CLIPPY").is_some() {
+            println!("cargo:rustc-link-arg=/MANIFEST:EMBED");
+            println!("cargo:rustc-link-arg=/MANIFESTINPUT:{manifest_display}");
+        } else {
+            println!("cargo:rustc-link-arg-examples=/MANIFEST:EMBED");
+            println!("cargo:rustc-link-arg-examples=/MANIFESTINPUT:{manifest_display}");
+        }
     }
 
     #[cfg(feature = "clippy")]

src-tauri/src/cmd/profile.rs

@@ -282,7 +282,9 @@ async fn handle_validation_failure(
 ) -> CmdResult<ValidationOutcome> {
     logging!(warn, Type::Cmd, "配置验证失败: {}", outcome);
     discard_and_restore(current_profile).await?;
-    handle_validation_notice(&outcome, ValidationNoticeTarget::Runtime, "运行时配置");
+    if !matches!(outcome, ValidationOutcome::Busy) {
+        handle_validation_notice(&outcome, ValidationNoticeTarget::Runtime, "运行时配置");
+    }
     Ok(outcome)
 }
 
@@ -311,9 +313,6 @@ async fn perform_config_update(
     current_value: Option<&String>,
     current_profile: Option<&String>,
 ) -> CmdResult<ValidationOutcome> {
-    defer! {
-        CURRENT_SWITCHING_PROFILE.store(false, Ordering::Release);
-    }
     let update_result = run_profile_config_update_transition(|| CoreManager::global().update_config_forced()).await;
 
     match update_result {
@@ -373,8 +372,6 @@ pub struct ProfilePatch {
     #[specta(type = Option<std::string::String>)]
     pub url: Option<String>,
     pub selected: Option<Vec<crate::config::PrfSelected>>,
-    #[specta(type = Option<std::collections::BTreeMap<std::string::String, std::string::String>>)]
-    pub latency_test_urls: Option<std::collections::BTreeMap<String, String>>,
     pub extra: Option<crate::config::PrfExtra>,
     pub updated: Option<usize>,
     pub option: Option<PrfOption>,
@@ -389,7 +386,6 @@ impl From<ProfilePatch> for PrfItem {
             file: patch.file,
             url: patch.url,
             selected: patch.selected,
-            latency_test_urls: patch.latency_test_urls,
             extra: patch.extra,
             updated: patch.updated,
             option: patch.option,
@@ -409,6 +405,9 @@ pub async fn patch_profiles_config(profiles: ProfileSelection) -> CmdResult<Vali
         logging!(info, Type::Cmd, "当前正在切换配置，放弃请求");
         return Ok(ValidationOutcome::Busy);
     }
+    defer! {
+        CURRENT_SWITCHING_PROFILE.store(false, Ordering::Release);
+    }
     let _profile_write_guard = PROFILE_WRITE_LOCK.lock().await;
 
     let profiles = IProfiles {

src-tauri/src/cmd/proxy.rs

@@ -108,32 +108,20 @@ fn runtime_group_scopes(config: Option<&Mapping>) -> BTreeMap<String, GroupScope
 #[tauri::command]
 #[specta::specta]
 pub async fn get_proxy_view() -> CmdResult<ProxyViewV1> {
-    proxy_view(None).await
-}
-
-pub(crate) async fn proxy_view(provider_timeout: Option<std::time::Duration>) -> CmdResult<ProxyViewV1> {
     let runtime = Config::runtime().await;
     let latest_runtime = runtime.latest_arc();
     let runtime_group_order = runtime_group_order(latest_runtime.config.as_ref());
     let group_scopes = runtime_group_scopes(latest_runtime.config.as_ref());
 
     let mihomo = Handle::mihomo();
-    let (proxies, providers) = tokio::join!(mihomo.get_proxies(), async {
-        match provider_timeout {
-            Some(timeout) => tokio::time::timeout(timeout, mihomo.get_proxy_providers())
-                .await
-                .ok()
-                .and_then(Result::ok),
-            None => mihomo.get_proxy_providers().await.ok(),
-        }
-    });
+    let (proxies, providers) = tokio::join!(mihomo.get_proxies(), mihomo.get_proxy_providers(),);
     let proxies = proxies.stringify_err()?;
 
     Ok(ProxyViewBuilder::build(ProxyViewInput {
         runtime_group_order,
         group_scopes,
         proxies,
-        providers,
+        providers: providers.ok(),
     }))
 }
 

src-tauri/src/config/prfitem.rs

@@ -53,10 +53,6 @@ pub struct PrfItem {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub selected: Option<Vec<PrfSelected>>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[specta(type = Option<std::collections::BTreeMap<std::string::String, std::string::String>>)]
-    pub latency_test_urls: Option<std::collections::BTreeMap<String, String>>,
-
     #[serde(skip_serializing_if = "Option::is_none")]
     pub extra: Option<PrfExtra>,
 
@@ -233,7 +229,6 @@ impl PrfItem {
             desc: Some(desc),
             file: Some(file),
             url: None,
-            latency_test_urls: None,
             selected: None,
             extra: None,
             option: Some(PrfOption {
@@ -413,7 +408,6 @@ impl PrfItem {
             desc: desc.cloned(),
             file: Some(file),
             url: Some(url.as_str().into()),
-            latency_test_urls: None,
             selected: None,
             extra,
             option: Some(PrfOption {

src-tauri/src/config/profiles.rs

@@ -250,7 +250,6 @@ impl IProfiles {
                 patch!(each, item, file);
                 patch!(each, item, url);
                 patch!(each, item, selected);
-                patch!(each, item, latency_test_urls);
                 patch!(each, item, extra);
                 patch!(each, item, updated);
                 patch!(each, item, option);

src-tauri/src/core/proxy_view.rs

@@ -1,8 +1,8 @@
-use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::collections::{BTreeMap, BTreeSet};
 
-use serde::{Serialize, Serializer, ser::SerializeMap as _};
+use serde::Serialize;
 use tauri_plugin_mihomo::models::{
-    DelayHistory, Extra, Proxies, Proxy, ProxyProvider, ProxyProviders, ProxyType, VehicleType,
+    DelayHistory, Proxies, Proxy, ProxyProvider, ProxyProviders, ProxyType, VehicleType,
 };
 
 pub struct ProxyViewInput {
@@ -57,28 +57,6 @@ pub struct ProxyCapabilities {
     pub smux: bool,
 }
 
-#[derive(Serialize, specta::Type)]
-struct ProxyLatencyHistory<'a> {
-    #[specta(type = Vec<crate::ipc::DelayHistory>)]
-    history: &'a [DelayHistory],
-}
-
-fn serialize_proxy_latency_history<S: Serializer>(
-    extra: &HashMap<String, Extra>,
-    serializer: S,
-) -> Result<S::Ok, S::Error> {
-    let mut map = serializer.serialize_map(Some(extra.len()))?;
-    for (url, extra) in extra {
-        map.serialize_entry(
-            url,
-            &ProxyLatencyHistory {
-                history: &extra.history,
-            },
-        )?;
-    }
-    map.end()
-}
-
 #[derive(Debug, PartialEq, Eq, Serialize, specta::Type)]
 #[serde(rename_all = "camelCase")]
 pub struct ProxyGroupView {
@@ -98,9 +76,6 @@ pub struct ProxyGroupView {
     pub test_url: Option<String>,
     #[specta(type = Vec<crate::ipc::DelayHistory>)]
     pub history: Vec<DelayHistory>,
-    #[serde(serialize_with = "serialize_proxy_latency_history")]
-    #[specta(type = HashMap<String, ProxyLatencyHistory<'static>>)]
-    pub extra: HashMap<String, Extra>,
     #[serde(flatten)]
     pub capabilities: ProxyCapabilities,
     pub members: Vec<ProxyMemberRef>,
@@ -116,9 +91,6 @@ pub struct ProxyNodeView {
     pub proxy_type: ProxyType,
     #[specta(type = Vec<crate::ipc::DelayHistory>)]
     pub history: Vec<DelayHistory>,
-    #[serde(serialize_with = "serialize_proxy_latency_history")]
-    #[specta(type = HashMap<String, ProxyLatencyHistory<'static>>)]
-    pub extra: HashMap<String, Extra>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub id: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -284,7 +256,7 @@ impl ProxyViewBuilder {
         } else {
             ProxyViewProviderState::Unavailable
         };
-        let (mut core_groups, core_nodes) = partition_core(proxies, providers.is_some());
+        let (mut core_groups, core_nodes) = partition_core(proxies);
         let (mut records, core_node_ids) = build_core_records(core_nodes);
         let (providers, provider_candidates) = build_provider_records(providers, &mut records);
         let resolver = MemberResolver {
@@ -317,14 +289,14 @@ impl ProxyViewBuilder {
     }
 }
 
-fn partition_core(proxies: Proxies, providers_available: bool) -> (BTreeMap<String, Proxy>, BTreeMap<String, Proxy>) {
+fn partition_core(proxies: Proxies) -> (BTreeMap<String, Proxy>, BTreeMap<String, Proxy>) {
     let mut groups = BTreeMap::new();
     let mut nodes = BTreeMap::new();
 
     for (name, proxy) in proxies.proxies {
         if proxy.all.is_some() {
             groups.insert(name, proxy);
-        } else if !providers_available || proxy.provider_name.is_empty() {
+        } else {
             nodes.insert(name, proxy);
         }
     }
@@ -431,7 +403,6 @@ fn build_group(name: String, proxy: Proxy, resolver: &MemberResolver<'_>) -> Pro
         now,
         test_url,
         history,
-        extra,
         udp,
         xudp,
         tfo,
@@ -464,7 +435,6 @@ fn build_group(name: String, proxy: Proxy, resolver: &MemberResolver<'_>) -> Pro
         icon,
         test_url,
         history,
-        extra,
         capabilities: ProxyCapabilities {
             udp,
             xudp,
@@ -483,7 +453,6 @@ fn build_node(record_id: String, name: String, proxy: Proxy, source: ProxyNodeSo
         icon,
         test_url,
         history,
-        extra,
         udp,
         xudp,
         tfo,
@@ -498,7 +467,6 @@ fn build_node(record_id: String, name: String, proxy: Proxy, source: ProxyNodeSo
         name,
         proxy_type,
         history,
-        extra,
         id,
         hidden,
         icon,
@@ -552,62 +520,3 @@ fn build_standalone(core_node_ids: &BTreeMap<String, String>) -> Vec<String> {
     );
     standalone
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn provider_echo_in_proxies_does_not_override_group_membership() -> anyhow::Result<()> {
-        let view = ProxyViewBuilder::build(ProxyViewInput {
-            runtime_group_order: vec!["A".into(), "B".into()],
-            group_scopes: ["A", "B"]
-                .into_iter()
-                .map(|name| {
-                    (
-                        name.into(),
-                        GroupScope {
-                            providers: vec![name.into()],
-                            exclude_types: vec![],
-                        },
-                    )
-                })
-                .collect(),
-            proxies: serde_json::from_value(json!({"proxies": {
-                "A": {"all": ["node"], "type": "Selector"},
-                "B": {"all": ["node"], "type": "Selector"},
-                "node": {"name": "node", "provider-name": "A", "history": [{"time": "2026-10-08T00:00:00Z", "delay": 32}]}
-            }}))?,
-            providers: Some(serde_json::from_value(json!({"providers": {
-                "A": {"vehicleType": "Inline", "proxies": [{"name": "node", "history": [{"time": "2026-10-08T00:00:00Z", "delay": 32}]}]},
-                "B": {"vehicleType": "Inline", "proxies": [{"name": "node", "history": [{"time": "2026-10-08T00:00:00Z", "delay": 123}]}]}
-            }}))?),
-        });
-        for (group, expected) in view.groups.iter().zip([32, 123]) {
-            let ProxyMemberRef::Node { record_id, .. } = &group.members[0] else {
-                anyhow::bail!("Expected node")
-            };
-            let record = &view.records[record_id];
-            assert_eq!(record.history.last().map(|entry| entry.delay), Some(expected));
-            assert!(
-                matches!(&record.source, ProxyNodeSource::Provider { provider_name, .. } if provider_name == &group.name)
-            );
-        }
-        Ok(())
-    }
-    #[test]
-    fn unavailable_provider_keeps_core_echo_interactable() -> anyhow::Result<()> {
-        let view = ProxyViewBuilder::build(ProxyViewInput {
-            runtime_group_order: vec!["A".into()],
-            group_scopes: BTreeMap::new(),
-            proxies: serde_json::from_value(json!({"proxies": {
-                "A": {"all": ["node"], "type": "Selector"},
-                "node": {"name": "node", "provider-name": "provider"}
-            }}))?,
-            providers: None,
-        });
-        assert!(matches!(&view.groups[0].members[0], ProxyMemberRef::Node { .. }));
-        Ok(())
-    }
-}

src-tauri/src/core/tray/latency.rs

@@ -1,156 +0,0 @@
-use super::Tray;
-use crate::{
-    Type, cmd,
-    config::Config,
-    core::{
-        handle,
-        notify::{Refresh, announce},
-        proxy_view::{ProxyMemberRef, ProxyNodeSource},
-    },
-    logging,
-};
-
-const TRAY_DELAY_TEST_CONCURRENCY: usize = 10;
-const TRAY_DEFAULT_LATENCY_URL: &str = "http://cp.cloudflare.com/generate_204";
-
-fn is_latency_test_url(raw: &str) -> bool {
-    let raw = raw.trim();
-    raw.split_once("://")
-        .is_some_and(|(scheme, _)| scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https"))
-        && tauri::Url::parse(raw).is_ok_and(|url| url.has_host() && matches!(url.scheme(), "http" | "https"))
-}
-
-pub(super) fn test_url(
-    group: &crate::core::proxy_view::ProxyGroupView,
-    verge: &crate::config::IVerge,
-    profiles: &crate::config::IProfiles,
-) -> String {
-    let custom_url = profiles
-        .current
-        .as_ref()
-        .and_then(|uid| profiles.get_item(uid).ok())
-        .and_then(|profile| profile.latency_test_urls.as_ref())
-        .and_then(|urls| urls.get(group.name.as_str()))
-        .map(|url| url.as_str())
-        .filter(|url| !url.trim().is_empty());
-    let group_url = group.test_url.as_deref().filter(|url| !url.trim().is_empty());
-    let default_url = verge
-        .default_latency_test
-        .as_deref()
-        .filter(|url| !url.trim().is_empty());
-    custom_url
-        .or(group_url)
-        .or(default_url)
-        .filter(|&url| is_latency_test_url(url))
-        .unwrap_or(TRAY_DEFAULT_LATENCY_URL)
-        .trim()
-        .to_owned()
-}
-
-static RUNNING: parking_lot::Mutex<std::collections::BTreeSet<String>> =
-    parking_lot::Mutex::new(std::collections::BTreeSet::new());
-
-pub(super) fn is_running(group_name: &str) -> bool {
-    RUNNING.lock().contains(group_name)
-}
-
-pub(super) async fn test_proxy_group_delay(group_name: &str) {
-    if !RUNNING.lock().insert(group_name.to_owned()) {
-        return;
-    }
-    Tray::global().refresh_latency_item(group_name);
-    let _running = scopeguard::guard(group_name, |name| {
-        RUNNING.lock().remove(name);
-        Tray::global().refresh_latency_item(name);
-    });
-    use futures::{StreamExt as _, stream};
-
-    let view = match cmd::proxy::get_proxy_view().await {
-        Ok(view) => view,
-        Err(err) => {
-            logging!(warn, Type::Tray, "Failed to read proxies for tray latency test: {err}");
-            return;
-        }
-    };
-    let verge = Config::verge().await.latest_arc();
-
-    let group = view
-        .groups
-        .iter()
-        .chain(view.global.iter())
-        .find(|group| group.name.as_str() == group_name);
-    let Some(group) = group else {
-        logging!(warn, Type::Tray, "Tray latency test group not found: {group_name}");
-        return;
-    };
-
-    let profiles = Config::profiles().await.latest_arc();
-    let url = test_url(group, &verge, &profiles);
-    let timeout = verge
-        .default_latency_timeout
-        .filter(|timeout| *timeout > 0)
-        .unwrap_or(10000) as u32;
-
-    let mut targets: Vec<(std::string::String, Option<std::string::String>)> = Vec::with_capacity(group.members.len());
-    for member in &group.members {
-        match member {
-            ProxyMemberRef::Node { name, record_id } => match view.records.get(record_id).map(|node| &node.source) {
-                Some(ProxyNodeSource::Provider {
-                    provider_name,
-                    proxy_name,
-                }) => targets.push((proxy_name.clone(), Some(provider_name.clone()))),
-                _ => targets.push((name.clone(), None)),
-            },
-            ProxyMemberRef::Group { name } => targets.push((name.clone(), None)),
-            ProxyMemberRef::Unresolved { .. } => {}
-        }
-    }
-    let mihomo = handle::Handle::mihomo();
-
-    stream::iter(targets.into_iter().map(move |(member, provider)| {
-        let url = url.clone();
-        async move {
-            let result = match provider {
-                Some(provider_name) => {
-                    mihomo
-                        .healthcheck_node_in_provider(&provider_name, &member, &url, timeout)
-                        .await
-                }
-                None => mihomo.delay_proxy_by_name(&member, &url, timeout).await,
-            };
-            if let Err(err) = result {
-                logging!(debug, Type::Tray, "Tray latency test failed: {member} - {err}");
-            }
-        }
-    }))
-    .buffer_unordered(TRAY_DELAY_TEST_CONCURRENCY)
-    .for_each(|()| std::future::ready(()))
-    .await;
-
-    if let Err(err) = cmd::proxy::sync_tray_proxy_selection().await {
-        logging!(warn, Type::Tray, "Failed to refresh tray after latency test: {err}");
-    }
-
-    announce(Refresh::Proxies);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn latency_urls_require_a_valid_http_host_and_port() {
-        for invalid in [
-            "http://?",
-            "http://host:invalid",
-            "http://bad host/",
-            "ftp://localhost",
-            "http:localhost",
-        ] {
-            assert!(!is_latency_test_url(invalid), "{invalid}");
-        }
-        for valid in ["http://localhost/", " https://example.com/ ", "HTTP://localhost:8080/"] {
-            assert!(is_latency_test_url(valid), "{valid}");
-        }
-    }
-}

src-tauri/src/core/tray/menu_def.rs

@@ -32,7 +32,6 @@ define_menu! {
     outbound_modes => OUTBOUND_MODES, "tray_outbound_modes", "tray.outboundModes",
     profiles => PROFILES, "tray_profiles", "tray.profiles",
     proxies => PROXIES, "tray_proxies", "tray.proxies",
-    test_latency => TEST_LATENCY, "tray_test_latency", "tray.testLatency",
     system_proxy => SYSTEM_PROXY, "tray_system_proxy", "tray.systemProxy",
     tun_mode => TUN_MODE, "tray_tun_mode", "tray.tunMode",
     close_all_connections => CLOSE_ALL_CONNECTIONS, "tray_close_all_connections", "tray.closeAllConnections",

src-tauri/src/core/tray/mod.rs

@@ -1,6 +1,5 @@
 use crate::config::{IProfilePreview, IVerge};
 use crate::core::lightweight;
-use crate::core::proxy_view::{ProxyGroupView, ProxyMemberRef, ProxyNodeSource, ProxyViewProviderState, ProxyViewV1};
 use crate::core::tray::menu_def::TrayAction;
 use crate::process::AsyncHandler;
 use crate::singleton;
@@ -15,6 +14,7 @@ use crate::{
 use clash_verge_limiter::{Limiter, SystemClock, SystemLimiter};
 use clash_verge_logging::logging_error;
 use tauri::tray::{MouseButton, MouseButtonState, TrayIcon, TrayIconBuilder, TrayIconEvent};
+use tauri_plugin_mihomo::models::Proxies;
 use tokio::fs;
 
 use super::handle;
@@ -28,7 +28,6 @@ use tauri::{
     menu::{CheckMenuItem, IsMenuItem, MenuEvent, MenuItem, PredefinedMenuItem, Submenu},
 };
 
-mod latency;
 mod menu_def;
 #[cfg(target_os = "macos")]
 mod speed_task;
@@ -56,25 +55,8 @@ enum IconKind {
     Tun,
 }
 
-struct LatencyMenuItem {
-    item: MenuItem<Wry>,
-    running: bool,
-    proxies: Vec<ProxyLatencyItem>,
-    provider_state: ProxyViewProviderState,
-}
-
-struct ProxyLatencyItem {
-    item: CheckMenuItem<Wry>,
-    name: std::string::String,
-    provider_name: Option<std::string::String>,
-    text: std::string::String,
-}
-
 pub struct Tray {
     limiter: SystemLimiter,
-    proxy_hover_limiter: SystemLimiter,
-    menu_update: tokio::sync::Mutex<()>,
-    latency_items: parking_lot::Mutex<HashMap<std::string::String, LatencyMenuItem>>,
     #[cfg(target_os = "macos")]
     speed_controller: speed_task::TraySpeedController,
 }
@@ -148,9 +130,6 @@ impl Default for Tray {
     fn default() -> Self {
         Self {
             limiter: Limiter::new(Duration::from_millis(TRAY_CLICK_DEBOUNCE_MS), SystemClock),
-            proxy_hover_limiter: Limiter::new(Duration::from_secs(1), SystemClock),
-            menu_update: tokio::sync::Mutex::new(()),
-            latency_items: parking_lot::Mutex::new(HashMap::new()),
             #[cfg(target_os = "macos")]
             speed_controller: speed_task::TraySpeedController::new(),
         }
@@ -216,7 +195,6 @@ impl Tray {
     }
 
     async fn update_menu_internal(&self, app_handle: &AppHandle, include_proxy_groups: bool) -> Result<()> {
-        let _update = self.menu_update.lock().await;
         let Some(tray) = app_handle.tray_by_id(TRAY_ID) else {
             logging!(warn, Type::Tray, "Failed to update tray menu: tray not found");
             return Ok(());
@@ -241,133 +219,29 @@ impl Tray {
         let profiles_preview = profiles_arc.profiles_preview().unwrap_or_default();
         let is_lightweight_mode = is_in_lightweight_mode();
 
-        let (menu, latency_items) = create_tray_menu(
-            app_handle,
-            Some(mode.as_str()),
-            *system_proxy,
-            *tun_mode,
-            tun_mode_available,
-            profiles_preview,
-            TrayMenuOptions {
-                is_lightweight_mode,
-                include_proxy_groups,
-            },
-        )
-        .await?;
-        tray.set_menu(Some(menu))?;
-        let groups: Vec<_> = latency_items.keys().cloned().collect();
-        *self.latency_items.lock() = latency_items;
-        for group in groups {
-            self.refresh_latency_item(&group);
-        }
+        logging_error!(
+            Type::Tray,
+            tray.set_menu(Some(
+                create_tray_menu(
+                    app_handle,
+                    Some(mode.as_str()),
+                    *system_proxy,
+                    *tun_mode,
+                    tun_mode_available,
+                    profiles_preview,
+                    TrayMenuOptions {
+                        is_lightweight_mode,
+                        include_proxy_groups,
+                    },
+                )
+                .await?,
+            ))
+        );
 
         logging!(debug, Type::Tray, "托盘菜单更新成功");
         Ok(())
     }
 
-    async fn refresh_proxy_items(&'static self) {
-        let Ok(update) = self.menu_update.try_lock() else {
-            return;
-        };
-        if self.latency_items.lock().is_empty() || handle::Handle::global().is_exiting() {
-            return;
-        }
-        let Ok(Ok(view)) = tokio::time::timeout(
-            Duration::from_secs(1),
-            cmd::proxy::proxy_view(Some(Duration::from_millis(750))),
-        )
-        .await
-        else {
-            return;
-        };
-        if self
-            .latency_items
-            .lock()
-            .values()
-            .any(|entry| entry.provider_state != view.provider_state)
-        {
-            // Provider fallback changes member identities; rebuild through the existing queue.
-            drop(update);
-            logging_error!(Type::Tray, cmd::proxy::sync_tray_proxy_selection().await);
-            return;
-        }
-        let verge = Config::verge().await.latest_arc();
-        let profiles = Config::profiles().await.latest_arc();
-        logging_error!(
-            Type::Tray,
-            handle::Handle::app_handle().run_on_main_thread(move || {
-                // Keep rebuilding serialized until these handles have received their snapshot.
-                let _update = update;
-                let mut items = self.latency_items.lock();
-                for (group_name, entry) in items.iter_mut() {
-                    let Some(group) = find_group(&view, group_name) else {
-                        continue;
-                    };
-                    let url = latency::test_url(group, &verge, &profiles);
-                    let mut members = HashMap::with_capacity(group.members.len());
-                    for member in &group.members {
-                        members
-                            .entry((member_name(member), member_provider(&view, member)))
-                            .or_insert(member);
-                    }
-                    for proxy in &mut entry.proxies {
-                        let Some(member) = members.get(&(proxy.name.as_str(), proxy.provider_name.as_deref())) else {
-                            continue;
-                        };
-                        let text = proxy_item_text(&view, member, &url, &verge);
-                        let checked = group.now.as_ref() == Some(&proxy.name);
-                        if text != proxy.text {
-                            match proxy.item.set_text(&text) {
-                                Ok(()) => proxy.text = text,
-                                Err(err) => logging!(warn, Type::Tray, "Failed to refresh proxy latency: {err}"),
-                            }
-                        }
-                        match proxy.item.is_checked() {
-                            Ok(current) if current != checked => {
-                                logging_error!(Type::Tray, proxy.item.set_checked(checked))
-                            }
-                            Err(err) => logging!(warn, Type::Tray, "Failed to read proxy selection: {err}"),
-                            _ => {}
-                        }
-                    }
-                }
-            })
-        );
-    }
-
-    fn refresh_latency_item(&self, group_name: &str) {
-        let group_name = group_name.to_owned();
-        logging_error!(
-            Type::Tray,
-            handle::Handle::app_handle().run_on_main_thread(move || {
-                Self::global().refresh_latency_item_on_main_thread(&group_name);
-            })
-        );
-    }
-
-    fn refresh_latency_item_on_main_thread(&self, group_name: &str) {
-        let running = latency::is_running(group_name);
-        let item = {
-            let mut items = self.latency_items.lock();
-            items.get_mut(group_name).and_then(|entry| {
-                if entry.running == running {
-                    return None;
-                }
-                entry.running = running;
-                Some(entry.item.clone())
-            })
-        };
-        if let Some(item) = item {
-            let label = if running {
-                clash_verge_i18n::t!("tray.testingLatency")
-            } else {
-                clash_verge_i18n::t!("tray.testLatency")
-            };
-            logging_error!(Type::Tray, item.set_text(label));
-            logging_error!(Type::Tray, item.set_enabled(!running));
-        }
-    }
-
     pub async fn update_icon(&self, verge: &IVerge) -> Result<()> {
         if handle::Handle::global().is_exiting() {
             logging!(debug, Type::Tray, "应用正在退出，跳过托盘图标更新");
@@ -582,175 +456,96 @@ fn create_profile_menu_item(
         .collect()
 }
 
-const UNTESTED_DELAY_TEXT: &str = "-ms";
-const TIMEOUT_DELAY_TEXT: &str = "T/O";
-const TRAY_GROUP_DEPTH_LIMIT: usize = 8;
-
-const fn member_name(member: &ProxyMemberRef) -> &str {
-    match member {
-        ProxyMemberRef::Node { name, .. }
-        | ProxyMemberRef::Group { name }
-        | ProxyMemberRef::Unresolved { name, .. } => name.as_str(),
-    }
-}
-
-fn find_group<'a>(view: &'a ProxyViewV1, name: &str) -> Option<&'a ProxyGroupView> {
-    view.groups
-        .iter()
-        .chain(view.global.iter())
-        .find(|group| group.name.as_str() == name)
-}
-
-/// The delay recorded for `url`, falling back to the node's latest measurement under any URL, so a
-/// node the core tested on its own still shows a value.
-fn node_delay(view: &ProxyViewV1, record_id: &str, url: &str) -> Option<u16> {
-    view.records
-        .get(record_id)
-        .map(|node| node.extra.get(url).map_or(&node.history, |extra| &extra.history))
-        .and_then(|history| history.last())
-        .map(|history| history.delay)
-}
-
-/// A group row shows the delay of the node the group currently selects. The core never writes a
-/// history for the group itself, so `now` is followed until the chain reaches a node.
-fn selected_member_delay(view: &ProxyViewV1, group_name: &str, url: &str) -> Option<u16> {
-    let mut current = group_name;
-    for _ in 0..TRAY_GROUP_DEPTH_LIMIT {
-        let Some(group) = find_group(view, current) else { break };
-        let Some(now) = group.now.as_deref().filter(|now| !now.is_empty() && *now != current) else {
-            break;
-        };
-        let Some(member) = group.members.iter().find(|member| member_name(member) == now) else {
-            break;
-        };
-        match member {
-            ProxyMemberRef::Node { record_id, .. } => return node_delay(view, record_id, url),
-            ProxyMemberRef::Group { name } => current = name.as_str(),
-            ProxyMemberRef::Unresolved { .. } => break,
-        }
-    }
-    find_group(view, group_name)
-        .map(|group| group.extra.get(url).map_or(&group.history, |extra| &extra.history))
-        .and_then(|history| history.last())
-        .map(|history| history.delay)
-}
-
-fn member_provider<'a>(view: &'a ProxyViewV1, member: &ProxyMemberRef) -> Option<&'a str> {
-    let ProxyMemberRef::Node { record_id, .. } = member else {
-        return None;
-    };
-    match &view.records.get(record_id)?.source {
-        ProxyNodeSource::Provider { provider_name, .. } => Some(provider_name),
-        ProxyNodeSource::Core { .. } => None,
-    }
-}
-
-fn proxy_item_text(view: &ProxyViewV1, member: &ProxyMemberRef, url: &str, verge: &IVerge) -> std::string::String {
-    let timeout = verge
-        .default_latency_timeout
-        .filter(|timeout| *timeout > 0)
-        .unwrap_or(10000);
-    let delay = match member {
-        ProxyMemberRef::Node { record_id, .. } => node_delay(view, record_id, url),
-        ProxyMemberRef::Group { name } => selected_member_delay(view, name, url),
-        ProxyMemberRef::Unresolved { .. } => None,
-    };
-    let delay_text = delay.map_or_else(
-        || UNTESTED_DELAY_TEXT.to_owned(),
-        |delay| {
-            if delay == 0 || u32::from(delay) >= timeout as u32 {
-                TIMEOUT_DELAY_TEXT.to_owned()
-            } else {
-                format!("{delay}ms")
-            }
-        },
-    );
-    format!("{}   | {delay_text}", member_name(member))
-}
-
 fn create_subcreate_proxy_menu_item(
     app_handle: &AppHandle,
     proxy_mode: &str,
-    view: Option<ProxyViewV1>,
-    latency_items: &mut HashMap<std::string::String, LatencyMenuItem>,
-    texts: &MenuTexts,
-    verge: &IVerge,
-    profiles: &crate::config::IProfiles,
+    proxy_group_order_map: Option<HashMap<String, usize>>,
+    proxy_nodes_data: Option<Proxies>,
 ) -> Vec<Submenu<Wry>> {
-    let Some(view) = view else { return Vec::new() };
-    view.groups
-        .iter()
-        .chain(view.global.iter())
-        .filter_map(|group| {
-            if group.hidden.unwrap_or_default() || (proxy_mode == "global") != (group.name == "GLOBAL") {
-                return None;
-            }
-            let url = latency::test_url(group, verge, profiles);
-            let proxies: Vec<ProxyLatencyItem> = group
-                .members
-                .iter()
-                .filter_map(|member| {
-                    let name = member_name(member);
-                    let text = proxy_item_text(&view, member, &url, verge);
-                    let checked = group.now.as_deref() == Some(name);
-                    CheckMenuItem::with_id(
-                        app_handle,
-                        format!("proxy_{}_{}", group.name, name),
-                        &text,
-                        true,
-                        checked,
-                        None::<&str>,
-                    )
-                    .map(|item| ProxyLatencyItem {
-                        item,
-                        name: name.to_owned(),
-                        provider_name: member_provider(&view, member).map(str::to_owned),
-                        text,
+    let proxy_submenus: Vec<Submenu<Wry>> = {
+        let mut submenus: Vec<(String, usize, Submenu<Wry>)> = Vec::new();
+
+        // TODO: 应用启动时，内核还未启动完全，无法获取代理节点信息
+        if let Some(proxy_nodes_data) = proxy_nodes_data {
+            for (group_name, group_data) in proxy_nodes_data.proxies.iter() {
+                let should_show = match proxy_mode {
+                    "global" => group_name == "GLOBAL",
+                    _ => group_name != "GLOBAL",
+                } && !group_data.hidden.unwrap_or_default();
+
+                if !should_show {
+                    continue;
+                }
+
+                let Some(all_proxies) = group_data.all.as_ref() else {
+                    continue;
+                };
+
+                let now_proxy = group_data.now.as_deref().unwrap_or_default();
+
+                let group_items: Vec<CheckMenuItem<Wry>> = all_proxies
+                    .iter()
+                    .filter_map(|proxy_str| {
+                        let is_selected = *proxy_str == now_proxy;
+                        let item_id = format!("proxy_{}_{}", group_name, proxy_str);
+
+                        let delay_text = proxy_nodes_data
+                            .proxies
+                            .get(proxy_str)
+                            .and_then(|h| h.history.last())
+                            .map(|h| match h.delay {
+                                0 => "-ms".into(),
+                                delay if delay >= 10000 => "-ms".into(),
+                                _ => format!("{}ms", h.delay),
+                            })
+                            .unwrap_or_else(|| "-ms".into());
+
+                        let display_text = format!("{}   | {}", proxy_str, delay_text);
+
+                        CheckMenuItem::with_id(app_handle, item_id, display_text, true, is_selected, None::<&str>)
+                            .map_err(|e| logging!(warn, Type::Tray, "Failed to create proxy menu item: {}", e))
+                            .ok()
                     })
-                    .map_err(|e| logging!(warn, Type::Tray, "Failed to create proxy menu item: {e}"))
-                    .ok()
-                })
-                .collect();
-            let group_items: Vec<_> = proxies.iter().map(|proxy| proxy.item.clone()).collect();
-            if group_items.is_empty() {
-                return None;
-            }
-            let running = latency::is_running(&group.name);
-            let test_item = MenuItem::with_id(
-                app_handle,
-                format!("{}_{}", MenuIds::TEST_LATENCY, group.name),
-                if running {
-                    clash_verge_i18n::t!("tray.testingLatency")
+                    .collect();
+
+                if group_items.is_empty() {
+                    continue;
+                }
+
+                let group_display_name = group_name.to_string();
+
+                let group_items_refs: Vec<&dyn IsMenuItem<Wry>> =
+                    group_items.iter().map(|item| item as &dyn IsMenuItem<Wry>).collect();
+
+                if let Ok(submenu) = Submenu::with_id_and_items(
+                    app_handle,
+                    format!("proxy_group_{}", group_name),
+                    group_display_name,
+                    true,
+                    &group_items_refs,
+                ) {
+                    let insertion_index = submenus.len();
+                    submenus.push((group_name.into(), insertion_index, submenu));
                 } else {
-                    texts.test_latency.clone()
-                },
-                !running,
-                None::<&str>,
-            )
-            .ok()?;
-            latency_items.insert(
-                group.name.clone(),
-                LatencyMenuItem {
-                    item: test_item.clone(),
-                    running,
-                    proxies,
-                    provider_state: view.provider_state,
-                },
-            );
-            let separator = PredefinedMenuItem::separator(app_handle).ok()?;
-            let mut items: Vec<&dyn IsMenuItem<Wry>> = vec![&test_item, &separator];
-            items.extend(group_items.iter().map(|item| item as &dyn IsMenuItem<Wry>));
-            Submenu::with_id_and_items(
-                app_handle,
-                format!("proxy_group_{}", group.name),
-                &group.name,
-                true,
-                &items,
-            )
-            .map_err(|e| logging!(warn, Type::Tray, "Failed to create proxy group submenu: {e}"))
-            .ok()
-        })
-        .collect()
+                    logging!(warn, Type::Tray, "Failed to create proxy group submenu: {}", group_name);
+                }
+            }
+        }
+
+        if let Some(order_map) = proxy_group_order_map.as_ref() {
+            submenus.sort_by(|(name_a, original_index_a, _), (name_b, original_index_b, _)| {
+                match (order_map.get(name_a), order_map.get(name_b)) {
+                    (Some(index_a), Some(index_b)) => index_a.cmp(index_b),
+                    (Some(_), None) => std::cmp::Ordering::Less,
+                    (None, Some(_)) => std::cmp::Ordering::Greater,
+                    (None, None) => original_index_a.cmp(original_index_b),
+                }
+            });
+        }
+
+        submenus.into_iter().map(|(_, _, submenu)| submenu).collect()
+    };
+    proxy_submenus
 }
 
 fn create_proxy_menu_item(
@@ -797,38 +592,54 @@ async fn create_tray_menu(
     tun_mode_available: bool,
     profiles_preview: Vec<IProfilePreview<'_>>,
     options: TrayMenuOptions,
-) -> Result<(tauri::menu::Menu<Wry>, HashMap<std::string::String, LatencyMenuItem>)> {
+) -> Result<tauri::menu::Menu<Wry>> {
     let current_proxy_mode = mode.unwrap_or("");
 
     let mut verge_settings = Config::verge().await.latest_arc();
     let fetch_proxy_groups =
         options.include_proxy_groups && verge_settings.tray_proxy_groups_display_mode.as_deref() != Some("disable");
 
-    // Proxy data must remain optional so a stopped Core cannot roll back unrelated settings.
-    let proxy_view = if fetch_proxy_groups {
-        tokio::time::timeout(
-            Duration::from_millis(1000),
-            cmd::proxy::proxy_view(Some(Duration::from_millis(750))),
-        )
-        .await
-        .ok()
-        .and_then(Result::ok)
+    // TODO: should update tray menu again when it was timeout error
+    let (proxy_nodes_data, runtime_proxy_groups_order) = if fetch_proxy_groups {
+        let proxy_nodes_data =
+            tokio::time::timeout(Duration::from_millis(1000), handle::Handle::mihomo().get_proxies())
+                .await
+                .map_or(None, |res| res.ok());
+
+        let runtime = Config::runtime().await.latest_arc();
+        let runtime_proxy_groups_order = runtime.config.as_ref().map(|config| {
+            config
+                .get("proxy-groups")
+                .and_then(|groups| groups.as_sequence())
+                .map(|groups| {
+                    groups
+                        .iter()
+                        .filter_map(|group| group.get("name"))
+                        .filter_map(|name| name.as_str())
+                        .enumerate()
+                        .map(|(index, name)| (name.into(), index))
+                        .collect::<HashMap<String, usize>>()
+                })
+                .unwrap_or_default()
+        });
+
+        (proxy_nodes_data, runtime_proxy_groups_order)
     } else {
-        None
+        (None, None)
     };
 
     if fetch_proxy_groups {
         verge_settings = Config::verge().await.latest_arc();
     }
 
-    let profiles_config = Config::profiles().await.latest_arc();
-
     let tray_proxy_groups_display_mode = verge_settings
         .tray_proxy_groups_display_mode
         .as_deref()
         .unwrap_or("default");
     let include_proxy_groups = options.include_proxy_groups && tray_proxy_groups_display_mode != "disable";
 
+    let proxy_group_order_map = runtime_proxy_groups_order;
+
     let show_outbound_modes_inline = verge_settings.tray_inline_outbound_modes.unwrap_or(false);
 
     let version = env!("CARGO_PKG_VERSION");
@@ -908,17 +719,9 @@ async fn create_tray_menu(
         &profile_menu_items_refs,
     )?;
 
-    let mut latency_items = HashMap::new();
     let (proxies_menu, inline_proxy_items) = if include_proxy_groups {
-        let proxy_sub_menus = create_subcreate_proxy_menu_item(
-            app_handle,
-            current_proxy_mode,
-            proxy_view,
-            &mut latency_items,
-            &texts,
-            &verge_settings,
-            &profiles_config,
-        );
+        let proxy_sub_menus =
+            create_subcreate_proxy_menu_item(app_handle, current_proxy_mode, proxy_group_order_map, proxy_nodes_data);
 
         match tray_proxy_groups_display_mode {
             "default" => create_proxy_menu_item(app_handle, false, proxy_sub_menus, &texts.proxies)?,
@@ -1062,25 +865,10 @@ async fn create_tray_menu(
     ]);
 
     let menu = tauri::menu::MenuBuilder::new(app_handle).items(&menu_items).build()?;
-    Ok((menu, latency_items))
+    Ok(menu)
 }
 
 fn on_tray_icon_event(_tray_icon: &TrayIcon, tray_event: TrayIconEvent) {
-    let refresh_proxies = match tray_event {
-        TrayIconEvent::Enter { .. } => Tray::global().proxy_hover_limiter.check(),
-        TrayIconEvent::Click {
-            button: MouseButton::Left | MouseButton::Right,
-            button_state: MouseButtonState::Down,
-            ..
-        } => true,
-        _ => false,
-    };
-    if refresh_proxies {
-        AsyncHandler::spawn(|| async {
-            Tray::global().refresh_proxy_items().await;
-        });
-    }
-
     if matches!(
         tray_event,
         TrayIconEvent::Move { .. } | TrayIconEvent::Leave { .. } | TrayIconEvent::Enter { .. }
@@ -1202,15 +990,6 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
                 };
                 feat::toggle_proxy_profile(profile_index.into()).await;
             }
-            id if id.starts_with(MenuIds::TEST_LATENCY) => {
-                let group_name = id
-                    .strip_prefix(MenuIds::TEST_LATENCY)
-                    .and_then(|rest| rest.strip_prefix('_'));
-                if let Some(group_name) = group_name {
-                    logging!(info, Type::Tray, "Tray menu: test group latency {}", group_name);
-                    latency::test_proxy_group_delay(group_name).await;
-                }
-            }
             id if id.starts_with("proxy_") => {
                 let rest = match id.strip_prefix("proxy_") {
                     Some(r) => r,

src-tauri/src/main.rs

@@ -16,7 +16,7 @@ fn main() -> ExitCode {
 #[cfg(not(all(feature = "perf-harness", target_os = "macos")))]
 fn main() -> ExitCode {
     let default_parallelism = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
-    let worker_limit = std::cmp::min(default_parallelism, 8);
+    let worker_limit = std::cmp::min(default_parallelism, 4);
     let blocking_limit = 2 * worker_limit;
 
     #[allow(clippy::unwrap_used)]

src-tauri/src/utils/tray_speed.rs

@@ -27,8 +27,12 @@ const TRAY_STATUS_ITEM_EXTRA_WIDTH: f64 = 30.0;
 const TRAY_STATUS_ITEM_MIN_LENGTH: f64 = 58.0;
 const NS_VARIABLE_STATUS_ITEM_LENGTH: f64 = -1.0;
 
+/// (button_height, mono_advance, attributes).
+type CachedAttrs = (f64, f64, Retained<NSDictionary<NSString, AnyObject>>);
+
 thread_local! {
     static LAST_DISPLAY_STR: RefCell<String> = const { RefCell::new(String::new()) };
+    static CACHED_ATTRS: RefCell<Option<CachedAttrs>> = const { RefCell::new(None) };
 }
 
 fn format_tray_speed(up: u64, down: u64) -> String {
@@ -74,8 +78,26 @@ fn create_attributed_string(
     }
 }
 
-fn status_item_length_for_speed(attr_str: &NSAttributedString) -> f64 {
-    (attr_str.size().width.ceil() + TRAY_STATUS_ITEM_EXTRA_WIDTH).max(TRAY_STATUS_ITEM_MIN_LENGTH)
+/// Attributes and per-glyph advance, rebuilt only when the button height changes.
+fn cached_attributes(button_height: f64) -> (f64, Retained<NSDictionary<NSString, AnyObject>>) {
+    CACHED_ATTRS.with(|cache| {
+        if let Some((height, advance, attrs)) = cache.borrow().as_ref()
+            && *height == button_height
+        {
+            return (*advance, attrs.clone());
+        }
+        let attrs = build_attributes(button_height);
+        let probe = NSString::from_str("0");
+        let advance = create_attributed_string(&probe, Some(&attrs)).size().width;
+        *cache.borrow_mut() = Some((button_height, advance, attrs.clone()));
+        (advance, attrs)
+    })
+}
+
+/// Longest line times the monospaced advance; matches `size().width` for the ASCII-only speed text.
+fn arithmetic_width(text: &str, advance: f64) -> f64 {
+    let glyphs = text.split('\n').map(str::len).max().unwrap_or(0) as f64;
+    glyphs * advance
 }
 
 fn sync_click_target_frame(button: &NSStatusBarButton) {
@@ -89,7 +111,7 @@ fn sync_click_target_frame(button: &NSStatusBarButton) {
 }
 
 /// `with_inner_tray_icon` should run this on the main thread; fail safely if it does not.
-fn apply_status_item_attributed_title(status_item: &NSStatusItem, text: &NSString, show_speed: bool) {
+fn apply_status_item_attributed_title(status_item: &NSStatusItem, text: &str, show_speed: bool) {
     let Some(mtm) = MainThreadMarker::new() else {
         logging!(warn, Type::Tray, "托盘速率富文本设置跳过：非主线程调用");
         return;
@@ -97,17 +119,19 @@ fn apply_status_item_attributed_title(status_item: &NSStatusItem, text: &NSStrin
     let Some(button) = status_item.button(mtm) else {
         return;
     };
+    let ns_string = NSString::from_str(text);
     let attr_str = if show_speed {
-        let attrs = build_attributes(button.bounds().size.height);
+        let (advance, attrs) = cached_attributes(button.bounds().size.height);
         let attrs: &NSDictionary<NSString, AnyObject> = &attrs;
-        let attr_str = create_attributed_string(text, Some(attrs));
-        let length = status_item_length_for_speed(&attr_str);
+        let attr_str = create_attributed_string(&ns_string, Some(attrs));
+        let width = arithmetic_width(text, advance);
+        let length = (width.ceil() + TRAY_STATUS_ITEM_EXTRA_WIDTH).max(TRAY_STATUS_ITEM_MIN_LENGTH);
         if status_item.length() != length {
             status_item.setLength(length);
         }
         attr_str
     } else {
-        create_attributed_string(text, None)
+        create_attributed_string(&ns_string, None)
     };
     button.setAttributedTitle(&attr_str);
     sync_click_target_frame(&button);
@@ -121,8 +145,7 @@ pub fn set_speed_attributed_title(status_item: &NSStatusItem, up: u64, down: u64
             return;
         }
         *last = speed_text;
-        let ns_string = NSString::from_str(last.as_str());
-        apply_status_item_attributed_title(status_item, &ns_string, true);
+        apply_status_item_attributed_title(status_item, last.as_str(), true);
     });
 }
 
@@ -130,7 +153,6 @@ pub fn clear_speed_attributed_title(status_item: &NSStatusItem) {
     LAST_DISPLAY_STR.with(|last| {
         last.borrow_mut().clear();
     });
-    let empty = NSString::from_str("");
     status_item.setLength(NS_VARIABLE_STATUS_ITEM_LENGTH);
-    apply_status_item_attributed_title(status_item, &empty, false);
+    apply_status_item_attributed_title(status_item, "", false);
 }