test(dev): retain focused React regression assertions

* docs(agents): add frontend liveness constraints

Add six liveness rules to the frontend guardrails covering dead state,
unused exposed surface, unreachable fallback paths, duplicate side
effects per interaction, unreachable mounts and unbounded resource
lifecycles. These target defect classes that the existing CI gates
(knip, eslint, arch:check) cannot detect mechanically.

* refactor(frontend): remove dead states, refs and unreachable branches

Drop state that can only hold its initial value (profiles page disabled
flag, traffic graph currentFPS), a write-only window controls ref with
its unconsumed imperative handle, a no-op appendData ref method, an
unreachable gradient branch, an invisible fadeIn shell, constant-true
subexpressions in the system info card, an empty click handler and a
pointless useMemo.

* refactor(frontend): drop unused params, props and api surface

Remove the never-read _revalidate argument of mutateVerge and its 16
call-site placeholders, seven never-passed props of the split chip
editor, the unconsumed refreshDecorated context member, the now-orphaned
toggleFullscreen control, the unused translate argument of the notice
message handler, the reserved-but-unset ServiceConfig.timeout field and
unreachable branches in parseNoticeExtras.

* refactor(types): remove dead provider view types superseded by bindings

Drop the handwritten IProxyProviderItem and IRuleProviderItem
interfaces: IProxyProviderItem is a stale duplicate of the generated
ProxyProviderView contract, and neither has any references left in
the tree.

Keep IProxyItem and IProxyGroupItem: IConfigData still declares
'proxy-groups'?: IProxyGroupItem[], which builds on IProxyItem.

* fix(rules): refresh once per visibility trigger

The mount effect fired refreshRules and refreshRuleProviders
unconditionally and again under the page-visible flag, double-firing
both queries on mount and on every hide-to-show transition. Gate the
refresh on visibility once so each trigger performs exactly one
revalidation.

* fix(setting): write auto launch patch once per toggle

GuardState applies the optimistic onChange write before onGuard runs,
so repeating the same onChangeData patch inside the guard handler
duplicated every cache write and subscriber notification for the auto
launch switch.

* fix(setting): build viewer form defaults from a single source

sysproxy, misc and tunnels viewers duplicated their form default
literals in useState and open(), and the two copies in misc-viewer had
already diverged (app log max size, app log max count, auto log clean).
Extract a buildInitialValues factory per viewer and unify on the open()
values, which are the only ones users could ever see.

* fix(setting): mount only reachable proxy control viewers

ProxyControlSwitches unconditionally mounted both SysproxyViewer and
TunViewer while its switch rows are mutually exclusive, so every
instance carried a dialog that could never open, each firing
getEmbeddedServerPort or a clash query subscription on mount. Mount
each viewer under the same condition as the switch row that opens it.

SettingSystem also mounted its own SysproxyViewer and TunViewer whose
refs were never opened there; the reachable entries are the
ProxyControlSwitches rows, so the dead pair is removed. Viewer mounts
across the app drop from eight (setting-system: two own + two per
instance, proxy-tun-card: two) to three (one per rendered switch
variant).

* fix(delay): write pending state once per node in batch checks

checkListDelay pre-marked every node as checking, help() re-marked it
when picked up and measureDelay marked it a third time on entry, so
each batch run queued three identical pending updates per node. Keep
the pre-mark (immediate feedback for queued nodes) and drop the
redundant marks along the chain.

* fix(services): make retries viable and align polling freshness window

Share no abort signal across retry attempts: after a timeout abort the
old signal stays dead and every later fetch rejects immediately, so
retries only burned backoff time. Also drop the system state query's
staleTime: the wrapper maps it to SWR's dedupingInterval, which
swallowed every other 3s poll tick while it exceeded the interval.

* refactor(traffic): drop unreachable inline monitor fallback

The inline traffic monitor duplicated the worker's message loop,
snapshot throttling and aging logic but only runs when Worker is
undefined or its constructor throws, which no supported Tauri webview
or browser hits. Keep the worker as the single implementation and
remove the mode switch and the pending-message queue that could only
ever buffer the init message.

* refactor(shared): replace the traffic error boundary with ErrorBoundary

TrafficErrorBoundary maintained a second boundary system beside
BaseErrorBoundary: a report builder that only console.logged constants
in the Tauri webview, an onError that re-logged what componentDidCatch
already logged, and a fallback wrapper with a single consumer. Fold
both mount points into react-error-boundary (the primitive behind
BaseErrorBoundary) with local fallbacks that keep the panel styling,
message text and retry reset, log each error once, and drop the retry
attempt cap and the stack-details collapse along with it.

* refactor(hooks): drop the write-only error channel and key-rotating refresh

The mihomo ws subscription's next callback accepted an error half that
baseNext silently discarded while traffic, memory and log consumers
kept constructing fallback payloads for it. Refresh minted a fresh
SWR key per call via a localStorage timestamp, abandoning old keys in
the cache forever. Reduce next to its data half and reset the snapshot
under a stable key instead.

* refactor(hooks): trim dead surface from proxy selection

Drop the connection-cleanup option nobody ever disabled (behavior now
unconditional), the returned changeProxy no consumer called and the two
one-caller argument adapters; both call sites use the shared select
entry directly.

* refactor(services): drop the bespoke retry engine from the query wrapper

The custom onErrorRetry existed only to honor a function-form
retryDelay, which exactly one caller (the app data provider) used for
exponential backoff. Fall back to SWR's built-in error retry and
express that caller's cadence with constant options.

.github/workflows/autobuild.yml

@@ -157,15 +157,12 @@ jobs:
           toolchain: '1.99.1'
           targets: ${{ matrix.target }}
 
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
         with:
           save-if: ${{ github.ref == 'refs/heads/dev' }}
           prefix-key: 'v1-rust'
-          key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
+          shared-key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
           workspaces: |
             . -> target
           cache-all-crates: true
@@ -188,14 +185,6 @@ jobs:
           node-version: '26.13.0'
           cache: 'pnpm'
 
-      - name: Pnpm Cache
-        uses: actions/cache@v6
-        with:
-          path: ~/.pnpm-store
-          key: 'pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
-          restore-keys: |
-            pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}
-
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -204,12 +193,6 @@ jobs:
       - name: Release ${{ env.TAG_CHANNEL }} Version
         run: pnpm release-version autobuild-latest
 
-      - name: Add Rust Target
-        run: |
-          rustup target add ${{ matrix.target }} --toolchain 1.99.1 || rustup target add ${{ matrix.target }}
-          rustup target list --installed
-          echo "Rust target ${{ matrix.target }} installed."
-
       - name: Tauri build for Windows-macOS-Linux
         uses: tauri-apps/tauri-action@v1
         env:
@@ -260,15 +243,12 @@ jobs:
           toolchain: '1.99.1'
           targets: ${{ matrix.target }}
 
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
         with:
           save-if: ${{ github.ref == 'refs/heads/dev' }}
           prefix-key: 'v1-rust'
-          key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
+          shared-key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
           workspaces: |
             . -> target
           cache-all-crates: true
@@ -285,14 +265,6 @@ jobs:
           node-version: '26.13.0'
           cache: 'pnpm'
 
-      - name: Pnpm Cache
-        uses: actions/cache@v6
-        with:
-          path: ~/.pnpm-store
-          key: 'pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
-          restore-keys: |
-            pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}
-
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -345,12 +317,6 @@ jobs:
             gcc-arm-linux-gnueabihf \
             g++-arm-linux-gnueabihf
 
-      - name: Add Rust Target
-        run: |
-          rustup target add ${{ matrix.target }} --toolchain 1.99.1 || rustup target add ${{ matrix.target }}
-          rustup target list --installed
-          echo "Rust target ${{ matrix.target }} installed."
-
       - name: Tauri Build for Linux
         run: |
           export PKG_CONFIG_ALLOW_CROSS=1
@@ -404,15 +370,18 @@ jobs:
       - name: Checkout Repository
         uses: actions/checkout@v7
 
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: '1.99.1'
+          targets: ${{ matrix.target }}
 
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
         with:
           save-if: ${{ github.ref == 'refs/heads/dev' }}
           prefix-key: 'v1-rust'
-          key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
+          shared-key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}-fixed-webview2'
           workspaces: |
             . -> target
           cache-all-crates: true
@@ -429,14 +398,6 @@ jobs:
           node-version: '26.13.0'
           cache: 'pnpm'
 
-      - name: Pnpm Cache
-        uses: actions/cache@v6
-        with:
-          path: ~/.pnpm-store
-          key: 'pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
-          restore-keys: |
-            pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}
-
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -452,12 +413,6 @@ jobs:
           Remove-Item .\src-tauri\tauri.windows.conf.json
           Rename-Item .\src-tauri\webview2.${{ matrix.arch }}.json tauri.windows.conf.json
 
-      - name: Add Rust Target
-        run: |
-          rustup target add ${{ matrix.target }} --toolchain 1.99.1 || rustup target add ${{ matrix.target }}
-          rustup target list --installed
-          echo "Rust target ${{ matrix.target }} installed."
-
       - name: Tauri build for Windows
         id: build
         uses: tauri-apps/tauri-action@v1

.github/workflows/dev.yml

@@ -77,11 +77,12 @@ jobs:
         uses: dtolnay/rust-toolchain@1.99.1
 
       - name: Rust Cache
+        if: github.event.inputs[matrix.input] == 'true'
         uses: Swatinem/rust-cache@v2
         with:
           save-if: ${{ github.ref == 'refs/heads/dev' }}
           prefix-key: 'v1-rust'
-          key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
+          shared-key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
           workspaces: |
             . -> target
           cache-all-crates: true
@@ -106,15 +107,6 @@ jobs:
           node-version: '26.13.0'
           cache: 'pnpm'
 
-      - name: Pnpm Cache
-        uses: actions/cache@v6
-        with:
-          path: ~/.pnpm-store
-          key: 'pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
-          restore-keys: |
-            pnpm-shared-stable-${{ matrix.os }}-${{ matrix.target }}
-          lookup-only: true
-
       - name: Pnpm install and check
         if: github.event.inputs[matrix.input] == 'true'
         run: |

.github/workflows/frontend-check.yml

@@ -39,14 +39,6 @@ jobs:
           node-version: '26.13.0'
           cache: 'pnpm'
 
-      - name: Restore pnpm cache
-        uses: actions/cache@v6
-        with:
-          path: ~/.pnpm-store
-          key: "pnpm-shared-stable-${{ runner.os }}-${{ hashFiles('pnpm-lock.yaml') }}"
-          restore-keys: |
-            pnpm-shared-stable-${{ runner.os }}-
-
       - run: pnpm install --frozen-lockfile
 
       - name: Run Prettier check

.github/workflows/release.yml

@@ -206,15 +206,12 @@ jobs:
           toolchain: '1.99.1'
           targets: ${{ matrix.target }}
 
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
         with:
           save-if: ${{ github.ref == 'refs/heads/dev' }}
           prefix-key: 'v1-rust'
-          key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
+          shared-key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
           workspaces: |
             . -> target
           cache-all-crates: true
@@ -226,27 +223,22 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 
-      - name: Install Node
-        uses: actions/setup-node@v7
-        with:
-          node-version: '26.13.0'
-
       - uses: pnpm/action-setup@v6
         name: Install pnpm
         with:
           run_install: false
 
+      - name: Install Node
+        uses: actions/setup-node@v7
+        with:
+          node-version: '26.13.0'
+          cache: 'pnpm'
+
       - name: Pnpm install and check
         run: |
           pnpm i
           pnpm run prebuild ${{ matrix.target }}
 
-      - name: Add Rust Target
-        run: |
-          rustup target add ${{ matrix.target }} --toolchain 1.99.1 || rustup target add ${{ matrix.target }}
-          rustup target list --installed
-          echo "Rust target ${{ matrix.target }} installed."
-
       - name: Tauri build
         uses: tauri-apps/tauri-action@v1.0.0
         env:
@@ -319,30 +311,28 @@ jobs:
           toolchain: '1.99.1'
           targets: ${{ matrix.target }}
 
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
         with:
           save-if: ${{ github.ref == 'refs/heads/dev' }}
           prefix-key: 'v1-rust'
-          key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
+          shared-key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
           workspaces: |
             . -> target
           cache-all-crates: true
           cache-workspace-crates: true
 
-      - name: Install Node
-        uses: actions/setup-node@v7
-        with:
-          node-version: '26.13.0'
-
       - name: Install pnpm
         uses: pnpm/action-setup@v6
         with:
           run_install: false
 
+      - name: Install Node
+        uses: actions/setup-node@v7
+        with:
+          node-version: '26.13.0'
+          cache: 'pnpm'
+
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -392,12 +382,6 @@ jobs:
             gcc-arm-linux-gnueabihf \
             g++-arm-linux-gnueabihf
 
-      - name: Add Rust Target
-        run: |
-          rustup target add ${{ matrix.target }} --toolchain 1.99.1 || rustup target add ${{ matrix.target }}
-          rustup target list --installed
-          echo "Rust target ${{ matrix.target }} installed."
-
       - name: Build for Linux
         run: |
           export PKG_CONFIG_ALLOW_CROSS=1
@@ -458,30 +442,28 @@ jobs:
           toolchain: '1.99.1'
           targets: ${{ matrix.target }}
 
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
         with:
           save-if: ${{ github.ref == 'refs/heads/dev' }}
           prefix-key: 'v1-rust'
-          key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}'
+          shared-key: 'rust-shared-stable-${{ matrix.os }}-${{ matrix.target }}-fixed-webview2'
           workspaces: |
             . -> target
           cache-all-crates: true
           cache-workspace-crates: true
 
-      - name: Install Node
-        uses: actions/setup-node@v7
-        with:
-          node-version: '26.13.0'
-
       - uses: pnpm/action-setup@v6
         name: Install pnpm
         with:
           run_install: false
 
+      - name: Install Node
+        uses: actions/setup-node@v7
+        with:
+          node-version: '26.13.0'
+          cache: 'pnpm'
+
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -494,12 +476,6 @@ jobs:
           Remove-Item .\src-tauri\tauri.windows.conf.json
           Rename-Item .\src-tauri\webview2.${{ matrix.arch }}.json tauri.windows.conf.json
 
-      - name: Add Rust Target
-        run: |
-          rustup target add ${{ matrix.target }} --toolchain 1.99.1 || rustup target add ${{ matrix.target }}
-          rustup target list --installed
-          echo "Rust target ${{ matrix.target }} installed."
-
       - name: Tauri build
         uses: tauri-apps/tauri-action@v1.0.0
         env:

Cargo.lock

@@ -1081,7 +1081,7 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
 [[package]]
 name = "clash-verge"
-version = "2.5.10"
+version = "2.6.0"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -1111,7 +1111,6 @@ dependencies = [
  "getrandom 0.4.3",
  "libc",
  "log",
- "minisign-verify",
  "nanoid",
  "network-interface",
  "objc2",

Changelog.md

@@ -19,19 +19,12 @@
        scripts-workflow/group_platforms.sh regroups, --check verifies
      HTML comments are stripped by the update dialog's sanitizer and hidden on
      GitHub, so they never reach users. -->
-## v2.5.10
+## v2.6.0
 
 <details>
 <summary><strong> 🐞 修复问题 </strong></summary>
 
-- 修复全局模式缺少 `GLOBAL` 策略组，无法单独选择全局出口
-- 修复服务模式下，SSH 节点的 `private-key` 使用私钥文件时内核无法启动
-- 修复服务模式下，内核更新的 GEO 数据库不会同步回应用目录，导致使用新分类的规则无法通过校验
-- 修复订阅的 DNS 配置变化后，「DNS 覆写」实际已关闭但开关仍显示开启且没有提示
-
-**🖥️ Windows**
-
-- Windows：修复安装程序重新安装或覆盖时未提示退出运行中应用，导致卸载报错或覆盖失败
+- 修复检测更新后又发布新版时，应用内更新失败
 
 </details>
 

docs/Changelog.history.md

@@ -1,3 +1,32 @@
+## v2.5.10
+
+<details>
+<summary><strong> 🐞 修复问题 </strong></summary>
+
+- 修复全局模式缺少 `GLOBAL` 策略组，无法单独选择全局出口
+- 修复服务模式下，SSH 节点的 `private-key` 使用私钥文件时内核无法启动
+- 修复服务模式下，内核更新的 GEO 数据库不会同步回应用目录，导致使用新分类的规则无法通过校验
+- 修复订阅的 DNS 配置变化后，「DNS 覆写」实际已关闭但开关仍显示开启且没有提示
+
+**🖥️ Windows**
+
+- Windows：修复安装程序重新安装或覆盖时未提示退出运行中应用，导致卸载报错或覆盖失败
+
+</details>
+
+<details>
+<summary><strong> ✨ 新增功能 </strong></summary>
+
+
+</details>
+
+<details>
+<summary><strong> 🚀 优化改进 </strong></summary>
+
+
+</details>
+
+
 ## v2.5.9
 
 - **Mihomo(Meta) 内核升级至 v1.19.33**

eslint.config.ts

@@ -256,6 +256,40 @@ export default defineConfig([
       },
     },
   },
+  {
+    files: ['scripts/react/*.{mjs,mts,ts,tsx}'],
+    languageOptions: {
+      globals: { ...globals.browser, ...globals.node },
+      parserOptions: {
+        projectService: false,
+        project: './scripts/react/tsconfig.json',
+      },
+    },
+    settings: {
+      'import-x/resolver-next': [
+        createTypeScriptImportResolver({
+          project: './scripts/react/tsconfig.json',
+        }),
+      ],
+    },
+  },
+  {
+    files: ['scripts/react/*.{mjs,mts}'],
+    languageOptions: {
+      parserOptions: {
+        projectService: false,
+        project: './scripts/react/tsconfig.node.json',
+      },
+    },
+  },
+  {
+    files: ['scripts/react/{boundaries,material,scene}.tsx'],
+    // The isolated fixtures use full reloads and preserve aliased Hook names.
+    rules: {
+      'react-refresh/only-export-components': 'off',
+      '@eslint-react/no-unnecessary-use-prefix': 'off',
+    },
+  },
   {
     files: ['src/**/*.{ts,tsx,js,jsx,mts,mjs}'],
     rules: ipcBoundaryRules(),

knip.json

@@ -1,6 +1,15 @@
 {
   "$schema": "https://unpkg.com/knip@6/schema.json",
-  "entry": ["src/polyfills/*.js!", "scripts/check-contract-changes.mjs!"],
+  "entry": [
+    "src/polyfills/*.js!",
+    "scripts/check-contract-changes.mjs!",
+    "scripts/react/scene.tsx!",
+    "scripts/react/profiler.ts!",
+    "scripts/react/boundaries.tsx!",
+    "scripts/react/material.tsx!",
+    "scripts/react/yaml.ts!",
+    "scripts/react/wdyr.ts!"
+  ],
   "project": ["src/**/*.{js,jsx,ts,tsx,sass,scss}!", "scripts/**/*.{js,mjs}!"],
   "include": [
     "files",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "clash-verge",
-  "version": "2.5.10",
+  "version": "2.6.0",
   "license": "GPL-3.0-only",
   "scripts": {
     "prepare": "husky || true",
@@ -40,7 +40,11 @@
     "perf:build": "node scripts/perf/build.mjs",
     "perf:run": "node scripts/perf/run.mjs",
     "perf:compare": "node scripts/perf/compare.mjs",
-    "perf:test": "node --test scripts/perf/report.test.mjs"
+    "perf:test": "node --test scripts/perf/report.test.mjs",
+    "dev:profile": "cross-env CVR_REACT_DIAGNOSTICS=profiler node scripts/dev.mjs dev",
+    "react:ab": "node scripts/react/ab.mjs",
+    "dev:wdyr": "cross-env CVR_REACT_DIAGNOSTICS=wdyr node scripts/dev.mjs dev",
+    "audit:react": "node scripts/react/doctor.mjs"
   },
   "dependencies": {
     "@dnd-kit/collision": "^0.5.0",
@@ -134,7 +138,10 @@
     "vite-plugin-svgr": "^5.2.0",
     "vitest": "^5.0.1",
     "webdriverio": "10.1.0",
-    "ws": "8.22.1"
+    "ws": "8.22.1",
+    "playwright": "1.64.1",
+    "@welldone-software/why-did-you-render": "10.0.1",
+    "react-doctor": "0.9.21"
   },
   "lint-staged": {
     "*.{ts,tsx,js,mjs}": [

scripts-workflow/release.mjs

@@ -345,6 +345,8 @@ function releaseBody(tag, sha, tags, publishing) {
       .join('\n\n') || 'No new commits.'
   return `## ${titleFor(tag)}
 
+@clash-verge-rev/release
+
 Source: \`dev\` · [${sha}](${url}/commit/${sha})  \n${comparison}
 ${
   publishing

scripts/prebuild.mjs

@@ -266,13 +266,13 @@ async function getLatestReleaseVersion() {
 }
 
 if (!META_MAP[`${platform}-${arch}`]) {
-  throw new Error(`clash meta unsupported platform "${platform}-${arch}"`)
+  throw new Error(`mihomo unsupported platform "${platform}-${arch}"`)
 }
 if (!META_ALPHA_MAP[`${platform}-${arch}`]) {
-  throw new Error(`clash meta alpha unsupported platform "${platform}-${arch}"`)
+  throw new Error(`mihomo alpha unsupported platform "${platform}-${arch}"`)
 }
 
-function clashMetaAlpha() {
+function mihomoAlpha() {
   const name = META_ALPHA_MAP[`${platform}-${arch}`]
   const isWin = platform === 'win32'
   const urlExt = isWin ? 'zip' : 'gz'
@@ -285,7 +285,7 @@ function clashMetaAlpha() {
   }
 }
 
-function clashMeta() {
+function mihomo() {
   const name = META_MAP[`${platform}-${arch}`]
   const isWin = platform === 'win32'
   const urlExt = isWin ? 'zip' : 'gz'
@@ -733,13 +733,12 @@ const tasks = [
   {
     name: 'verge-mihomo-alpha',
     func: () =>
-      getLatestAlphaVersion().then(() => resolveSidecar(clashMetaAlpha())),
+      getLatestAlphaVersion().then(() => resolveSidecar(mihomoAlpha())),
     retry: 5,
   },
   {
     name: 'verge-mihomo',
-    func: () =>
-      getLatestReleaseVersion().then(() => resolveSidecar(clashMeta())),
+    func: () => getLatestReleaseVersion().then(() => resolveSidecar(mihomo())),
     retry: 5,
   },
   // After both sidecar tasks: it hashes what they downloaded.

scripts/react/README.md

@@ -0,0 +1,47 @@
+# React diagnostics
+
+`pnpm dev:profile` runs the usual development launcher with a root React
+Profiler. In WebView DevTools, `window.__CVR_REACT_PROFILER__.read()` returns
+copies of the latest 1,000 standard Profiler callback records; `.clear()` drops
+them. Records contain timing and commit metadata, never business props. Normal
+development and production builds do not load the collector.
+
+`pnpm dev:wdyr` instead initializes why-did-you-render before loading the app
+and uses its development JSX runtime. It reports avoidable renders for
+`ProxyItem`, `ProxyItemMini` and `ProxyTunCard` in the console. The modes are
+mutually exclusive; `CVR_REACT_DIAGNOSTICS` accepts only `profiler` or `wdyr` on
+the development server. Each mode uses its own Vite cache. Production builds
+ignore this variable and include neither diagnostic entry nor runtime.
+
+`pnpm audit:react` scans supported source files under `src`. Pass file paths to
+limit the scan, for example `pnpm audit:react src/hooks/use-proxy-delay-state.ts`;
+add `--json` for the original structured report. Diagnostics are advisory.
+Execution errors and incomplete scans fail the command. Telemetry, remote scores
+and supply-chain scanning are disabled; the command does not fix code, erase
+historical diagnostics or run in CI.
+
+Install the browser explicitly with `pnpm exec playwright install chromium`.
+Then run `pnpm react:ab --base <ref> --head <ref>`. Both Git trees run against
+one installed dependency set and the same fixed DNS, delay-hook and proxy-tab
+fixtures. The command never installs a browser or changes either checkout.
+It retains source hashes, dependency identity, browser/environment information,
+behavior assertions, render observations and profiles under `/tmp/cvr-react-ab-*`.
+Each version and mode has separate Vite caches and output. Three pairs alternate
+order in ordinary development, Strict Mode and production. A behavior failure
+returns a nonzero exit status. DNS stale serialization and same-value renders
+are observations so a known baseline can be compared with its fix. Append
+`--assert dns` to require the head version to keep the latest serialized YAML in sync with
+continuous field edits; this is the focused DNS regression assertion.
+`--assert delay` requires same-value delay updates to retain their reference and memoized consumer,
+while each changed field (including clearing elapsed time) propagates.
+`--assert tabs` requires zero tab renders during unrelated parent updates. Use
+`--assert dns --assert delay --assert tabs` for a cumulative candidate.
+
+The fixtures execute the actual selected components and hook. IPC, data,
+editor and UI rendering boundaries are replaced, and outgoing network requests
+are rejected. DNS serialization is observed at `js-yaml.dump`; tab execution is
+observed at the Material Paper boundary. These are component results, not native
+Tauri integration, real DNS/proxy/TUN writes, or whole-application CPU/RSS gains.
+Production React does not emit Profiler callbacks. Timing is diagnostic and has
+no hard acceptance threshold; measure native release CPU/RSS separately and
+calibrate A/A before claiming a performance gain. Keep raw reports out of Git.

scripts/react/ab.mjs

@@ -0,0 +1,596 @@
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import {
+  cp,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  realpath,
+  symlink,
+  writeFile,
+} from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parseArgs } from 'node:util'
+
+import react from '@vitejs/plugin-react'
+import { chromium } from 'playwright'
+import { build, createServer, preview } from 'vite'
+
+const { values } = parseArgs({
+  options: {
+    base: { type: 'string' },
+    head: { type: 'string' },
+    assert: { type: 'string', multiple: true },
+  },
+})
+if (!values.base || !values.head)
+  throw new Error('Usage: pnpm react:ab --base <ref> --head <ref>')
+const assertions = new Set(values.assert ?? [])
+for (const name of assertions) {
+  if (!['dns', 'delay', 'tabs'].includes(name))
+    throw new Error(`Unknown regression assertion: ${name}`)
+}
+const harness = path.dirname(fileURLToPath(import.meta.url))
+const root = path.resolve(harness, '../..')
+const output = await mkdtemp('/tmp/cvr-react-ab-')
+const dependencies = path.join(root, 'node_modules')
+const frozenHarness = path.join(output, 'harness')
+await cp(harness, frozenHarness, {
+  recursive: true,
+  filter: (file) => !path.basename(file).startsWith('tsconfig'),
+})
+const files = [
+  'src/components/setting/mods/dns-viewer.tsx',
+  'src/hooks/use-proxy-delay-state.ts',
+  'src/components/home/proxy-tun-card.tsx',
+]
+const hash = (content) => createHash('sha256').update(content).digest('hex')
+function git(...args) {
+  const result = spawnSync('git', args, {
+    cwd: root,
+    maxBuffer: 128 * 1024 * 1024,
+  })
+  if (result.status !== 0) throw new Error(result.stderr.toString())
+  return result.stdout
+}
+const manifest = {
+  assertions: [...assertions],
+  environment: {
+    platform: process.platform,
+    architecture: process.arch,
+    node: process.version,
+    os: os.release(),
+    lock: hash(await readFile(path.join(root, 'pnpm-lock.yaml'))),
+  },
+  harness: Object.fromEntries(
+    await Promise.all(
+      (await readdir(frozenHarness)).map(async (file) => [
+        file,
+        hash(await readFile(path.join(frozenHarness, file))),
+      ]),
+    ),
+  ),
+  installedLock: hash(
+    await readFile(path.join(dependencies, '.pnpm/lock.yaml')),
+  ),
+  sources: {},
+  runs: [],
+}
+let browser
+try {
+  // Playwright intentionally fails here if its explicitly installed browser is missing.
+  browser = await chromium.launch({ headless: true })
+  manifest.environment.browser = browser.version()
+  for (const [variant, ref] of Object.entries({
+    base: values.base,
+    head: values.head,
+  })) {
+    const tree = git('rev-parse', '--verify', `${ref}^{tree}`).toString().trim()
+    const source = path.join(output, variant)
+    await mkdir(source)
+    const archive = git('archive', tree, 'src')
+    const extracted = spawnSync('tar', ['-x', '-C', source], { input: archive })
+    if (extracted.status !== 0) throw new Error(extracted.stderr.toString())
+    await cp(frozenHarness, path.join(source, 'fixture'), { recursive: true })
+    await symlink(dependencies, path.join(source, 'node_modules'), 'dir')
+    manifest.sources[variant] = {
+      ref,
+      tree,
+      files: Object.fromEntries(
+        await Promise.all(
+          files.map(async (file) => [
+            file,
+            hash(await readFile(path.join(source, file))),
+          ]),
+        ),
+      ),
+    }
+  }
+  for (const mode of ['development', 'strict', 'production']) {
+    const servers = {}
+    try {
+      for (const variant of ['base', 'head']) {
+        const source = path.join(output, variant)
+        const fixture = path.join(source, 'fixture')
+        const boundary = path.join(fixture, 'boundaries.tsx')
+        const aliases = [
+          '@/hooks/use-clash',
+          '@/hooks/use-verge',
+          '@/hooks/use-profiles',
+          '@/hooks/use-system-state',
+          '@/hooks/use-system-proxy-state',
+          '@/services/states',
+          '@/services/cmds',
+          '@/services/mutate',
+          '@/services/notice-service',
+          '@/components/base',
+          '@/components/shared/proxy-control-switches',
+          'react-i18next',
+        ].map((find) => ({ find, replacement: boundary }))
+        const config = {
+          configFile: false,
+          root: fixture,
+          cacheDir: path.join(output, 'cache', variant, mode),
+          plugins: [react()],
+          resolve: {
+            alias: [
+              ...aliases,
+              {
+                find: '@/services/delay',
+                replacement: path.join(fixture, 'delay.ts'),
+              },
+              {
+                find: /^@mui\/material$/,
+                replacement: path.join(fixture, 'material.tsx'),
+              },
+              {
+                find: 'fixture-material',
+                replacement: path.join(dependencies, '@mui/material/index.mjs'),
+              },
+              { find: 'js-yaml', replacement: path.join(fixture, 'yaml.ts') },
+              {
+                find: 'fixture-yaml',
+                replacement: path.join(
+                  dependencies,
+                  'js-yaml/dist/js-yaml.mjs',
+                ),
+              },
+              { find: '@', replacement: path.join(source, 'src') },
+              {
+                find: /^react(?=\/|$)/,
+                replacement: path.join(dependencies, 'react'),
+              },
+              {
+                find: /^react-dom(?=\/|$)/,
+                replacement: path.join(dependencies, 'react-dom'),
+              },
+            ],
+            dedupe: ['react', 'react-dom'],
+          },
+          define: { OS_PLATFORM: JSON.stringify(process.platform) },
+          server: {
+            host: '127.0.0.1',
+            port: 0,
+            hmr: false,
+            fs: {
+              allow: [
+                output,
+                await realpath(output),
+                await realpath(dependencies),
+              ],
+            },
+          },
+          build: {
+            outDir: path.join(output, 'dist', variant, mode),
+            emptyOutDir: true,
+          },
+          preview: { host: '127.0.0.1', port: 0 },
+        }
+        if (mode === 'production') {
+          await build(config)
+          servers[variant] = await preview(config)
+        } else {
+          servers[variant] = await createServer(config)
+          await servers[variant].listen()
+        }
+      }
+      for (const [pair, order] of [
+        ['base', 'head'],
+        ['head', 'base'],
+        ['base', 'head'],
+      ].entries()) {
+        for (const variant of order) {
+          const label = `${mode}-${pair + 1}-${variant}`
+          const context = await browser.newContext()
+          const errors = []
+          const address = servers[variant].httpServer.address()
+          const origin = `http://127.0.0.1:${address.port}`
+          await context.route('**/*', (route) => {
+            if (new URL(route.request().url()).origin === origin)
+              return route.continue()
+            errors.push(`Unexpected network: ${route.request().url()}`)
+            return route.abort()
+          })
+          const page = await context.newPage()
+          page.on('pageerror', (error) => errors.push(String(error)))
+          const result = { label, variant, mode, pair: pair + 1, errors }
+          try {
+            await page.goto(`${origin}/${mode === 'strict' ? '?strict' : ''}`)
+            await page.waitForSelector('#delay', { timeout: 60000 })
+            await page.waitForFunction(
+              () => window.__REACT_AB__.read().listeners.length === 1,
+            )
+            result.tabs = await tabs(page)
+            if (variant === 'head' && assertions.has('tabs')) {
+              assert.equal(
+                result.tabs.unrelated,
+                0,
+                'Unrelated parent updates must not rerender the memoized tabs',
+              )
+            }
+            result.dns = await dns(page)
+            if (variant === 'head' && assertions.has('dns')) {
+              for (const edit of result.dns.edits) {
+                assert.equal(
+                  edit.serialized.at(-1),
+                  edit.value,
+                  'Latest DNS serialization must match the edited field',
+                )
+              }
+            }
+            result.delay = await delay(page)
+            if (variant === 'head' && assertions.has('delay')) {
+              for (const [index, observation] of result.delay.entries()) {
+                assert.equal(
+                  observation.sameReference,
+                  index === 1,
+                  'Preserve the reference only when all three delay fields match',
+                )
+              }
+              assert.equal(
+                result.delay[1].childRenders,
+                result.delay[0].childRenders,
+                'Equal delay state must not rerender the memoized consumer',
+              )
+            }
+            result.profile = await page.evaluate(() => {
+              const before = window.__CVR_REACT_PROFILER__.read()
+              window.__CVR_REACT_PROFILER__.clear()
+              return { before, after: window.__CVR_REACT_PROFILER__.read() }
+            })
+            assert.equal(result.profile.after.length, 0)
+            result.collector = await page.evaluate(() =>
+              window.__REACT_AB__.checkCollector(),
+            )
+            assert.deepEqual(result.collector, {
+              length: 1000,
+              first: '5',
+              last: '1004',
+              copied: true,
+              cleared: true,
+            })
+            if (mode !== 'production')
+              assert(
+                result.profile.before.length > 0 &&
+                  result.profile.before.length <= 1000,
+              )
+            assert.deepEqual(errors, [])
+            assert.deepEqual(
+              await page.evaluate(() =>
+                window.__REACT_AB__.fixture.notices.filter(
+                  (notice) => notice.error,
+                ),
+              ),
+              [],
+            )
+            result.ok = true
+          } catch (error) {
+            result.snapshot = await page
+              .evaluate(() => window.__REACT_AB__?.read())
+              .catch(() => null)
+            result.ok = false
+            result.error = String(error)
+            throw error
+          } finally {
+            manifest.runs.push(result)
+            await writeFile(
+              path.join(output, `${label}.json`),
+              JSON.stringify(result, null, 2),
+            )
+            await context.close()
+            console.log(`${label}: ${result.ok ? 'pass' : 'FAIL'}`)
+          }
+        }
+      }
+    } finally {
+      for (const server of Object.values(servers)) {
+        if (server.close) await server.close()
+        else
+          await new Promise((resolve, reject) =>
+            server.httpServer.close((error) =>
+              error ? reject(error) : resolve(),
+            ),
+          )
+      }
+    }
+  }
+} finally {
+  await browser?.close()
+  await writeFile(
+    path.join(output, 'report.json'),
+    JSON.stringify(manifest, null, 2),
+  )
+  console.log(`Evidence: ${output}`)
+}
+
+async function settle(page) {
+  await page.waitForTimeout(100)
+}
+async function tabs(page) {
+  const buttons = page.locator('#tabs .MuiPaper-root')
+  const readTabs = () =>
+    page.evaluate(() =>
+      Object.fromEntries(
+        window.__REACT_AB__.fixture.tabRenders.map((tab) => [
+          tab.label.split('.').at(-1),
+          tab,
+        ]),
+      ),
+    )
+
+  assert.equal(await buttons.count(), 2)
+  assert.equal((await readTabs()).systemProxy.active, true)
+  assert.equal((await readTabs()).tunMode.active, false)
+  const before = await page.evaluate(
+    () => window.__REACT_AB__.fixture.tabRenders.length,
+  )
+  for (let index = 0; index < 5; index++) {
+    await page.evaluate(() => window.__REACT_AB__.update())
+    await settle(page)
+  }
+  const unrelated =
+    (await page.evaluate(() => window.__REACT_AB__.fixture.tabRenders.length)) -
+    before
+  await buttons.nth(1).click()
+  await settle(page)
+  assert.equal((await readTabs()).systemProxy.active, false)
+  assert.equal((await readTabs()).tunMode.active, true)
+  assert.equal(
+    await page.evaluate(() =>
+      localStorage.getItem('clash-verge-proxy-active-tab'),
+    ),
+    'tun',
+  )
+  assert(
+    (await page.locator('#fixture-controls').textContent()).endsWith(
+      'toggles.tunMode',
+    ),
+  )
+  await page.evaluate(() => window.__REACT_AB__.update({ mounted: false }))
+  await settle(page)
+  assert(
+    (await page.locator('#fixture-controls').textContent()).endsWith(
+      'toggles.tunMode',
+    ),
+  )
+  await page.evaluate(() => window.__REACT_AB__.update({ mounted: true }))
+  await settle(page)
+  assert.equal((await readTabs()).tunMode.active, true)
+  assert.equal((await readTabs()).systemProxy.active, false)
+  await buttons.nth(0).click()
+  await settle(page)
+  assert.equal((await readTabs()).systemProxy.active, true)
+  assert.equal((await readTabs()).tunMode.active, false)
+  assert.equal(
+    await page.evaluate(() =>
+      localStorage.getItem('clash-verge-proxy-active-tab'),
+    ),
+    'system',
+  )
+  await page.evaluate(() => {
+    window.__REACT_AB__.fixture.indicator = true
+    window.__REACT_AB__.fixture.verge.enable_tun_mode = true
+    window.__REACT_AB__.update()
+  })
+  await settle(page)
+  assert(Object.values(await readTabs()).every((tab) => tab.indicator))
+  await page.evaluate(() => {
+    window.__REACT_AB__.fixture.language = 'zh'
+    window.__REACT_AB__.update()
+  })
+  await settle(page)
+  const updated = Object.values(await readTabs())
+  assert(updated.every((tab) => tab.label.startsWith('zh:')))
+  assert(
+    (await page.locator('#tabs').textContent()).includes(
+      'zh:home.components.proxyTun.status.systemProxyEnabled',
+    ),
+  )
+  const beforeColor = await buttons
+    .nth(0)
+    .evaluate((element) => getComputedStyle(element).backgroundColor)
+  await page.evaluate(() => {
+    window.__REACT_AB__.fixture.theme = 'dark'
+    window.__REACT_AB__.update()
+  })
+  await settle(page)
+  const color = await buttons
+    .nth(0)
+    .evaluate((element) => getComputedStyle(element).backgroundColor)
+  assert.notEqual(color, beforeColor)
+  return { unrelated, updated, beforeColor, color }
+}
+async function dns(page) {
+  await page.evaluate(() => window.__REACT_AB__.open())
+  const listen = page.locator('#dns input[placeholder=":53"]')
+  await page.waitForFunction(
+    () =>
+      document.querySelector('#dns input[placeholder=":53"]')?.value ===
+      ':5353',
+  )
+  const edits = []
+  for (const value of [':54', ':55', ':56']) {
+    await page.evaluate(() => {
+      window.__REACT_AB__.fixture.serialized.length = 0
+    })
+    await listen.fill(value)
+    await settle(page)
+    assert.equal(await listen.inputValue(), value)
+    edits.push({
+      value,
+      serialized: await page.evaluate(() =>
+        window.__REACT_AB__.fixture.serialized.map(
+          (config) => config.dns.listen,
+        ),
+      ),
+    })
+  }
+  await page.evaluate(() => {
+    window.__REACT_AB__.fixture.serialized.length = 0
+  })
+  await listen.fill(':')
+  await listen.pressSequentially('567', { delay: 0 })
+  await settle(page)
+  assert.equal(await listen.inputValue(), ':567')
+  edits.push({
+    value: ':567',
+    rapid: true,
+    serialized: await page.evaluate(() =>
+      window.__REACT_AB__.fixture.serialized.map((config) => config.dns.listen),
+    ),
+  })
+  await page.locator('#save-dns').click()
+  await page.waitForFunction(
+    () => window.__REACT_AB__.fixture.saved.length === 1,
+  )
+  assert.equal(
+    await page.evaluate(() => window.__REACT_AB__.fixture.saved[0].dns.listen),
+    ':567',
+  )
+  await page.evaluate(() => window.__REACT_AB__.open())
+  await page.waitForSelector('#dns')
+  await page
+    .getByRole('button', { name: /shared.actions.resetToDefault$/ })
+    .click()
+  await settle(page)
+  assert.equal(await listen.inputValue(), ':53')
+  await page
+    .getByRole('button', { name: /shared.editorModes.advanced$/ })
+    .click()
+  await settle(page)
+  const editor = page.locator('#fixture-monaco')
+  assert.match(await editor.inputValue(), /listen: ["']?:53/)
+  await editor.fill(
+    'dns:\n  enable: true\n  listen: ":8053"\nhosts:\n  example.test: 127.0.0.1\n',
+  )
+  await page
+    .getByRole('button', { name: /shared.editorModes.visualization$/ })
+    .click()
+  await settle(page)
+  assert.equal(await listen.inputValue(), ':8053')
+  await page
+    .getByRole('button', { name: /shared.editorModes.advanced$/ })
+    .click()
+  await settle(page)
+  await page.locator('#save-dns').click()
+  await page.waitForFunction(
+    () => window.__REACT_AB__.fixture.saved.length === 2,
+  )
+  const saved = await page.evaluate(() => window.__REACT_AB__.fixture.saved)
+  assert.equal(saved[1].dns.listen, ':8053')
+  assert.equal(saved[1].hosts['example.test'], '127.0.0.1')
+  return { edits, saved }
+}
+async function delay(page) {
+  const updates = [
+    { delay: 10, elapsed: 12, updatedAt: 100 },
+    { delay: 10, elapsed: 12, updatedAt: 100 },
+    { delay: 11, elapsed: 12, updatedAt: 100 },
+    { delay: 11, elapsed: 13, updatedAt: 100 },
+    { delay: 11, elapsed: 13, updatedAt: 101 },
+    { delay: 11, updatedAt: 101 },
+    { delay: -1, updatedAt: 102 },
+    { delay: 0, updatedAt: 103 },
+    { delay: 1000000, elapsed: 20, updatedAt: 104 },
+  ]
+  const observations = []
+  for (const update of updates) {
+    await page.evaluate((value) => {
+      window.__REACT_AB__.remember()
+      window.__REACT_AB__.delay.emit('Node 1', 'Group 1', value)
+    }, update)
+    await settle(page)
+    const result = await page.evaluate(() => window.__REACT_AB__.read())
+    assert.deepEqual(result.delay, update)
+    observations.push({
+      update,
+      sameReference: result.sameReference,
+      childRenders: result.childRenders,
+    })
+  }
+  await page.evaluate(() => window.__REACT_AB__.request())
+  await settle(page)
+  assert.equal(
+    await page.evaluate(() => window.__REACT_AB__.read().delay.delay),
+    -2,
+  )
+  await page.evaluate(() =>
+    window.__REACT_AB__.delay.finish({ delay: 0, updatedAt: 200 }),
+  )
+  await settle(page)
+  assert.equal(
+    await page.evaluate(() => window.__REACT_AB__.read().delay.delay),
+    0,
+  )
+  await page.evaluate(() => window.__REACT_AB__.request())
+  await settle(page)
+  assert.equal(
+    await page.evaluate(() => window.__REACT_AB__.read().delay.delay),
+    -2,
+  )
+  await page.evaluate(() =>
+    window.__REACT_AB__.delay.finish({
+      delay: 1000000,
+      elapsed: 20,
+      updatedAt: 201,
+    }),
+  )
+  await settle(page)
+  assert.deepEqual(
+    await page.evaluate(() => window.__REACT_AB__.read().delay),
+    { delay: 1000000, elapsed: 20, updatedAt: 201 },
+  )
+  await page.evaluate(() => window.__REACT_AB__.update({ name: 'Node 2' }))
+  await settle(page)
+  let state = await page.evaluate(() => window.__REACT_AB__.read())
+  assert.deepEqual(state.listeners, ['Group 1:Node 2'])
+  assert.deepEqual(state.delay, { delay: -1, updatedAt: 0 })
+  await page.evaluate(() => window.__REACT_AB__.update({ group: 'Group 2' }))
+  await settle(page)
+  state = await page.evaluate(() => window.__REACT_AB__.read())
+  assert.deepEqual(state.listeners, ['Group 2:Node 2'])
+  for (const name of ['DIRECT', 'Unknown']) {
+    await page.evaluate((name) => window.__REACT_AB__.update({ name }), name)
+    await settle(page)
+    const preset = await page.evaluate(() => window.__REACT_AB__.read())
+    assert.deepEqual(preset.listeners, [])
+    assert.deepEqual(preset.delay, { delay: -1, updatedAt: 0 })
+  }
+  await page.evaluate(() => window.__REACT_AB__.update({ name: 'Node 2' }))
+  await settle(page)
+  assert.deepEqual(
+    await page.evaluate(() => window.__REACT_AB__.read().listeners),
+    ['Group 2:Node 2'],
+  )
+  await page.evaluate(() => window.__REACT_AB__.update({ mounted: false }))
+  await settle(page)
+  assert.deepEqual(
+    await page.evaluate(() => window.__REACT_AB__.read().listeners),
+    [],
+  )
+  return observations
+}

scripts/react/boundaries.tsx

@@ -0,0 +1,68 @@
+import { Switch as MuiSwitch } from '@mui/material'
+
+import { fixture } from './state'
+
+const translations = {
+  en: (key: string) => `en:${key}`,
+  zh: (key: string) => `zh:${key}`,
+}
+export const useTranslation = () => ({
+  t: translations[fixture.language as 'en' | 'zh'],
+})
+export const useVerge = () => ({ verge: fixture.verge })
+export const useProfiles = () => ({ current: { uid: 'fixture' } })
+export const useClash = () => ({
+  mutateClash: () => {
+    throw new Error('Unexpected mutateClash')
+  },
+})
+export const useSystemState = () => ({ isTunModeAvailable: fixture.available })
+export const useSystemProxyState = () => ({ indicator: fixture.indicator })
+export const useThemeMode = () => fixture.theme
+export const getDnsConfigContent = async () => {
+  fixture.commands.push('getDnsConfigContent')
+  return fixture.initialDns
+}
+export const saveDnsConfig = async (config: any) => {
+  fixture.commands.push('saveDnsConfig')
+  fixture.saved.push(structuredClone(config))
+}
+export const validateDnsConfig = async () => {
+  fixture.commands.push('validateDnsConfig')
+  return { status: 'valid' }
+}
+export const applyDnsConfig = () => {
+  throw new Error('Unexpected applyDnsConfig')
+}
+export const mutate = (fn: () => unknown) => fn()
+export const showNotice = {
+  error: (...args: any[]) => fixture.notices.push({ error: args }),
+  success: (...args: any[]) => fixture.notices.push({ success: args }),
+}
+export const Switch = MuiSwitch
+export function BaseDialog({ open, title, children, onClose, onOk }: any) {
+  return open ? (
+    <section id="dns">
+      {title}
+      <button id="close-dns" onClick={onClose}>
+        close
+      </button>
+      <button id="save-dns" onClick={onOk}>
+        save
+      </button>
+      {children}
+    </section>
+  ) : null
+}
+export function MonacoEditor({ value, onChange }: any) {
+  return (
+    <textarea
+      id="fixture-monaco"
+      value={value}
+      onChange={(event) => onChange(event.target.value)}
+    />
+  )
+}
+export default function ProxyControlSwitches({ label }: any) {
+  return <output id="fixture-controls">{label}</output>
+}

scripts/react/delay.ts

@@ -0,0 +1,36 @@
+type Update = { delay: number; elapsed?: number; updatedAt: number }
+const listeners = new Map<string, (update: Update) => void>()
+const cache = new Map<string, Update>()
+let finish: ((update: Update) => void) | undefined
+const key = (name: string, group: string) => `${group}:${name}`
+export const delayFixture = {
+  listeners,
+  emit(name: string, group: string, update: Update) {
+    cache.set(key(name, group), update)
+    listeners.get(key(name, group))?.(update)
+  },
+  finish(update: Update) {
+    if (!finish) throw new Error('No pending delay request')
+    finish(update)
+    finish = undefined
+  },
+}
+export default {
+  setListener(name: string, group: string, listener: (update: Update) => void) {
+    listeners.set(key(name, group), listener)
+  },
+  removeListener(name: string, group: string) {
+    listeners.delete(key(name, group))
+  },
+  getDelayUpdate(name: string, group: string) {
+    return cache.get(key(name, group))
+  },
+  getDelayFix() {
+    return -1
+  },
+  checkDelay() {
+    return new Promise<Update>((resolve) => {
+      finish = resolve
+    })
+  },
+}

scripts/react/doctor.mjs

@@ -0,0 +1,77 @@
+import { spawnSync } from 'node:child_process'
+import { statSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parseArgs } from 'node:util'
+
+import { globSync } from 'glob'
+
+const { values, positionals } = parseArgs({
+  options: { json: { type: 'boolean' } },
+  allowPositionals: true,
+})
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
+const files = positionals.length
+  ? positionals
+  : globSync('src/**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts,html}', {
+      cwd: root,
+      nodir: true,
+    }).sort()
+if (files.length === 0) throw new Error('No source files found')
+for (const file of files) {
+  if (
+    !/\.(?:[jt]sx?|[cm][jt]s|html)$/.test(file) ||
+    !statSync(path.resolve(root, file)).isFile()
+  )
+    throw new Error(`Expected a source file: ${file}`)
+}
+const executable = fileURLToPath(
+  new URL('../bin/react-doctor.js', import.meta.resolve('react-doctor')),
+)
+const result = spawnSync(
+  process.execPath,
+  [
+    executable,
+    ...files,
+    '--json',
+    '--no-telemetry',
+    '--no-supply-chain',
+    '--blocking',
+    'none',
+    '--yes',
+  ],
+  {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'inherit'],
+    maxBuffer: 64 * 1024 * 1024,
+  },
+)
+if (result.error) throw result.error
+if (result.signal)
+  throw new Error(`React Doctor terminated by ${result.signal}`)
+const report = JSON.parse(result.stdout)
+if (values.json) {
+  process.stdout.write(result.stdout)
+} else {
+  for (const diagnostic of report.diagnostics) {
+    console.log(
+      `${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column} ${diagnostic.severity} ${diagnostic.plugin}/${diagnostic.rule}\n  ${diagnostic.message}`,
+    )
+  }
+  console.log(
+    `${report.summary.totalDiagnosticCount} advisory diagnostics across ${report.projects.reduce((count, project) => count + project.analyzedFileCount, 0)} analyzed files`,
+  )
+}
+// In 0.9.21, --blocking none also masks linter execution failures.
+const incomplete = report.projects.filter((project) => !project.complete)
+if (report.error) console.error(report.error.message)
+for (const project of incomplete) {
+  console.error(
+    'Incomplete React Doctor scan:',
+    project.directory,
+    project.skippedCheckReasons,
+  )
+}
+process.exitCode =
+  result.status || (!report.ok || incomplete.length > 0 ? 1 : 0)

scripts/react/index.html

@@ -0,0 +1,5 @@
+<!doctype html>
+<html lang="en">
+  <head><meta charset="UTF-8" /><title>React component A/B</title></head>
+  <body><div id="root"></div><script type="module" src="./scene.tsx"></script></body>
+</html>

scripts/react/material.tsx

@@ -0,0 +1,16 @@
+import { Paper as MuiPaper } from 'fixture-material'
+export * from 'fixture-material'
+
+import { fixture } from './state'
+
+export function Paper(props: any) {
+  const { onClick, elevation, children, sx } = props
+  if (onClick && sx?.maxWidth === 160) {
+    fixture.tabRenders.push({
+      active: elevation === 2,
+      indicator: Boolean(children[2]),
+      label: children[1].props.children,
+    })
+  }
+  return <MuiPaper {...props} />
+}

scripts/react/profiler.ts

@@ -0,0 +1,19 @@
+import type { ProfilerOnRenderCallback } from 'react'
+
+export type ProfileRecord = Parameters<ProfilerOnRenderCallback>
+
+const records: ProfileRecord[] = []
+
+export const recordRender: ProfilerOnRenderCallback = (...record) => {
+  if (records.length === 1000) records.shift()
+  records.push(record)
+}
+
+export const profiler = {
+  read: () => records.map((record) => [...record]),
+  clear: () => {
+    records.length = 0
+  },
+}
+
+Object.assign(window, { __CVR_REACT_PROFILER__: profiler })

scripts/react/scene.tsx

@@ -0,0 +1,124 @@
+import { ThemeProvider, createTheme } from '@mui/material'
+import {
+  Profiler,
+  StrictMode,
+  memo,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react'
+import { createRoot } from 'react-dom/client'
+
+import { ProxyTunCard } from '@/components/home/proxy-tun-card'
+import { DnsViewer } from '@/components/setting/mods/dns-viewer'
+import { useProxyDelayState } from '@/hooks/use-proxy-delay-state'
+
+import { delayFixture } from './delay'
+import { profiler, recordRender } from './profiler'
+import { fixture } from './state'
+
+const member = (name: string): any =>
+  name === 'Unknown'
+    ? {
+        kind: 'unresolved',
+        ref: { kind: 'unresolved', name, reason: 'missing' },
+      }
+    : {
+        kind: 'node',
+        ref: { kind: 'node', recordId: name, name },
+        node: { name, history: [], source: { kind: 'core', proxyName: name } },
+      }
+let update: (patch?: any) => void
+let open: () => void
+let delay: ReturnType<typeof useProxyDelayState>
+let previous: unknown
+let childRenders = 0
+const DelayValue = memo(({ state }: any) => {
+  childRenders++
+  return <output id="delay">{JSON.stringify(state)}</output>
+})
+function DelayProbe({ name, group }: any) {
+  const resolved = useMemo(() => member(name), [name])
+  const current = useProxyDelayState(resolved, group)
+  useEffect(() => {
+    delay = current
+  })
+  return <DelayValue state={current.delayState} />
+}
+function Scene() {
+  const [state, setState] = useState({
+    revision: 0,
+    name: 'Node 1',
+    group: 'Group 1',
+    mounted: true,
+  })
+  const ref = useRef<any>(null)
+  useEffect(() => {
+    update = (patch = {}) =>
+      setState((old) => ({ ...old, ...patch, revision: old.revision + 1 }))
+    open = () => ref.current.open()
+  }, [])
+  const mode = fixture.theme
+  const theme = useMemo(() => createTheme({ palette: { mode } }), [mode])
+  return (
+    <ThemeProvider theme={theme}>
+      <main data-revision={state.revision}>
+        <section id="tabs" key={state.mounted ? 'mounted' : 'reset'}>
+          <ProxyTunCard />
+        </section>
+        <DnsViewer ref={ref} />
+        {state.mounted && <DelayProbe name={state.name} group={state.group} />}
+      </main>
+    </ThemeProvider>
+  )
+}
+const strict = new URLSearchParams(location.search).has('strict')
+const app = (
+  <Profiler id="fixtures" onRender={recordRender}>
+    <Scene />
+  </Profiler>
+)
+createRoot(document.getElementById('root')!).render(
+  strict ? <StrictMode>{app}</StrictMode> : app,
+)
+Object.assign(window, {
+  __REACT_AB__: {
+    update: (patch?: any) => update(patch),
+    open: () => open(),
+    fixture,
+    delay: delayFixture,
+    request: () => {
+      void delay.onDelay()
+    },
+    remember: () => {
+      previous = delay.delayState
+    },
+    checkCollector: () => {
+      profiler.clear()
+      for (let index = 0; index < 1005; index++)
+        recordRender(String(index), 'update', 1, 2, 3, 4)
+      const records = profiler.read()
+      records[0][0] = 'changed copy'
+      const preserved = profiler.read()
+      const result = {
+        length: preserved.length,
+        first: preserved[0][0],
+        last: preserved.at(-1)![0],
+        copied: preserved[0][0] === '5',
+        cleared: false,
+      }
+      profiler.clear()
+      result.cleared = profiler.read().length === 0
+      return result
+    },
+    read: () => ({
+      fixture,
+      profile: profiler.read(),
+      childRenders,
+      sameReference: previous === delay.delayState,
+      delay: delay.delayState,
+      listeners: [...delayFixture.listeners.keys()],
+    }),
+  },
+})

scripts/react/state.ts

@@ -0,0 +1,13 @@
+export const fixture = {
+  language: 'en',
+  theme: 'light' as 'light' | 'dark',
+  verge: { enable_tun_mode: false },
+  indicator: false,
+  available: true,
+  initialDns: 'dns:\n  enable: true\n  listen: ":5353"\n',
+  saved: [] as any[],
+  serialized: [] as any[],
+  tabRenders: [] as any[],
+  notices: [] as any[],
+  commands: [] as string[],
+}

scripts/react/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["../../src/*"],
+      "@root/*": ["../../*"],
+      "fixture-material": ["../../node_modules/@mui/material"],
+      "fixture-yaml": ["../../node_modules/js-yaml"]
+    }
+  },
+  "include": ["./*.ts", "./*.tsx", "../../src"]
+}

scripts/react/tsconfig.node.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "types": ["node"]
+  },
+  "include": ["./*.mjs", "./*.mts"]
+}

scripts/react/vite.mts

@@ -0,0 +1,61 @@
+import path from 'node:path'
+
+import { normalizePath, type Plugin } from 'vite'
+
+export function reactDiagnostics(mode: string | undefined): Plugin[] {
+  if (!mode) return []
+  return [
+    {
+      name: 'react-diagnostics',
+      enforce: 'pre',
+      apply: 'serve',
+      config() {
+        if (mode !== 'profiler' && mode !== 'wdyr')
+          throw new Error(`Unknown CVR_REACT_DIAGNOSTICS mode: ${mode}`)
+        return {
+          cacheDir: path.resolve('node_modules/.vite', mode),
+          ...(mode === 'wdyr'
+            ? {
+                oxc: {
+                  jsx: {
+                    importSource: '@welldone-software/why-did-you-render',
+                  },
+                },
+                optimizeDeps: {
+                  include: [
+                    '@welldone-software/why-did-you-render',
+                    '@welldone-software/why-did-you-render/jsx-dev-runtime',
+                  ],
+                },
+              }
+            : {}),
+        }
+      },
+      transformIndexHtml(html) {
+        if (mode !== 'wdyr') return html
+        const entry = 'src="./main.tsx"'
+        if (!html.includes(entry))
+          throw new Error('WDYR entry no longer matches index.html')
+        return html.replace(
+          entry,
+          `src="/@fs/${normalizePath(path.resolve('scripts/react/wdyr.ts'))}"`,
+        )
+      },
+      transform(code, id) {
+        if (mode !== 'profiler') return
+        if (id !== normalizePath(path.resolve('src/main.tsx'))) return
+        const open = '<React.StrictMode>'
+        const close = '</React.StrictMode>'
+        if (!code.includes(open) || !code.includes(close)) {
+          throw new Error('React profiling entry no longer matches main.tsx')
+        }
+        return {
+          code: `import { Profiler } from 'react'\nimport { recordRender } from '../scripts/react/profiler'\n${code}`
+            .replace(open, `<Profiler id="app" onRender={recordRender}>${open}`)
+            .replace(close, `${close}</Profiler>`),
+          map: null,
+        }
+      },
+    },
+  ]
+}

scripts/react/wdyr.ts

@@ -0,0 +1,10 @@
+import whyDidYouRender from '@welldone-software/why-did-you-render'
+import React from 'react'
+
+whyDidYouRender(React, {
+  include: [/^(ProxyItem|ProxyItemMini|ProxyTunCard)$/],
+  trackAllPureComponents: false,
+  trackHooks: true,
+})
+
+await import('../../src/main')

scripts/react/yaml.ts

@@ -0,0 +1,9 @@
+import * as yaml from 'fixture-yaml'
+export * from 'fixture-yaml'
+
+import { fixture } from './state'
+
+export function dump(value: any, options: any) {
+  fixture.serialized.push(structuredClone(value))
+  return yaml.dump(value, options)
+}

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clash-verge"
-version = "2.5.10"
+version = "2.6.0"
 description = "clash verge"
 authors = ["zzzgydi", "Tunglies", "wonfen", "MystiPanda"]
 license = "GPL-3.0-only"
@@ -84,7 +84,6 @@ 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.1"
 getrandom = "0.4.3"
 futures = "0.3.34"

src-tauri/src/cmd/app.rs

@@ -1,7 +1,10 @@
 use super::CmdResult;
 use crate::{
     cmd::StringifyErr as _,
-    core::{SilentUpdater, updater::DownloadEvent},
+    core::{
+        SilentUpdater,
+        updater::{DownloadEvent, InstallUpdateOutcome},
+    },
     feat,
     utils::dirs,
 };
@@ -61,8 +64,7 @@ pub async fn install_update(
     app_handle: AppHandle,
     version: std::string::String,
     on_event: Channel<DownloadEvent>,
-) -> CmdResult<bool> {
-    let version: String = version.into();
+) -> CmdResult<InstallUpdateOutcome> {
     SilentUpdater::global()
         .install_update(&app_handle, &version, |event| {
             let _ = on_event.send(event);

src-tauri/src/config/clash.rs

@@ -184,84 +184,41 @@ impl IClashTemp {
             _ => None,
         })
     }
-    #[cfg(not(target_os = "windows"))]
-    fn guard_redir_port(config: &Mapping) -> u16 {
+    fn guard_port_value(config: &Mapping, key: &str, default: u16) -> u16 {
         let mut port = config
-            .get("redir-port")
+            .get(key)
             .and_then(|value| match value {
                 Value::String(val_str) => val_str.parse().ok(),
                 Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
                 _ => None,
             })
-            .unwrap_or(7895);
+            .unwrap_or(default);
         if port == 0 {
-            port = 7895;
+            port = default;
         }
         port
     }
 
+    #[cfg(not(target_os = "windows"))]
+    fn guard_redir_port(config: &Mapping) -> u16 {
+        Self::guard_port_value(config, "redir-port", network::ports::DEFAULT_REDIR)
+    }
+
     #[cfg(target_os = "linux")]
     fn guard_tproxy_port(config: &Mapping) -> u16 {
-        let mut port = config
-            .get("tproxy-port")
-            .and_then(|value| match value {
-                Value::String(val_str) => val_str.parse().ok(),
-                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
-                _ => None,
-            })
-            .unwrap_or(network::ports::DEFAULT_TPROXY);
-        if port == 0 {
-            port = network::ports::DEFAULT_TPROXY;
-        }
-        port
+        Self::guard_port_value(config, "tproxy-port", network::ports::DEFAULT_TPROXY)
     }
 
     fn guard_mixed_port(config: &Mapping) -> u16 {
-        let raw_value = config.get("mixed-port");
-
-        let mut port = raw_value
-            .and_then(|value| match value {
-                Value::String(val_str) => val_str.parse().ok(),
-                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
-                _ => None,
-            })
-            .unwrap_or(network::ports::DEFAULT_MIXED);
-
-        if port == 0 {
-            port = network::ports::DEFAULT_MIXED;
-        }
-
-        port
+        Self::guard_port_value(config, "mixed-port", network::ports::DEFAULT_MIXED)
     }
 
     fn guard_socks_port(config: &Mapping) -> u16 {
-        let mut port = config
-            .get("socks-port")
-            .and_then(|value| match value {
-                Value::String(val_str) => val_str.parse().ok(),
-                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
-                _ => None,
-            })
-            .unwrap_or(7898);
-        if port == 0 {
-            port = 7898;
-        }
-        port
+        Self::guard_port_value(config, "socks-port", network::ports::DEFAULT_SOCKS)
     }
 
     fn guard_port(config: &Mapping) -> u16 {
-        let mut port = config
-            .get("port")
-            .and_then(|value| match value {
-                Value::String(val_str) => val_str.parse().ok(),
-                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
-                _ => None,
-            })
-            .unwrap_or(7899);
-        if port == 0 {
-            port = 7899;
-        }
-        port
+        Self::guard_port_value(config, "port", network::ports::DEFAULT_HTTP)
     }
 
     pub(super) fn guard_server_ctrl(config: &Mapping) -> String {

src-tauri/src/config/mod.rs

@@ -14,6 +14,15 @@ mod verge;
 pub(crate) use self::config::Config;
 pub use self::{clash::*, encrypt::*, mixed_port::*, prfitem::*, profiles::*, verge::*};
 
+macro_rules! patch_opt_field {
+    ($lv:expr, $rv:expr, $key:tt) => {
+        if ($rv.$key).is_some() {
+            $lv.$key = $rv.$key.clone();
+        }
+    };
+}
+pub(crate) use patch_opt_field;
+
 pub const DEFAULT_PAC: &str = r#"function FindProxyForURL(url, host) {
   return "PROXY 127.0.0.1:%mixed-port%; SOCKS5 127.0.0.1:%mixed-port%; DIRECT;";
 }

src-tauri/src/config/prfitem.rs

@@ -1,3 +1,5 @@
+use super::patch_opt_field;
+
 use crate::{
     config::profiles,
     utils::{
@@ -131,19 +133,18 @@ impl PrfOption {
         match (one, other) {
             (Some(a_ref), Some(b_ref)) => {
                 let mut result = a_ref.clone();
-                result.user_agent = b_ref.user_agent.clone().or(result.user_agent);
-                result.with_proxy = b_ref.with_proxy.or(result.with_proxy);
-                result.self_proxy = b_ref.self_proxy.or(result.self_proxy);
-                result.danger_accept_invalid_certs =
-                    b_ref.danger_accept_invalid_certs.or(result.danger_accept_invalid_certs);
-                result.allow_auto_update = b_ref.allow_auto_update.or(result.allow_auto_update);
-                result.update_interval = b_ref.update_interval.or(result.update_interval);
-                result.merge = b_ref.merge.clone().or(result.merge);
-                result.script = b_ref.script.clone().or(result.script);
-                result.rules = b_ref.rules.clone().or(result.rules);
-                result.proxies = b_ref.proxies.clone().or(result.proxies);
-                result.groups = b_ref.groups.clone().or(result.groups);
-                result.timeout_seconds = b_ref.timeout_seconds.or(result.timeout_seconds);
+                patch_opt_field!(result, b_ref, user_agent);
+                patch_opt_field!(result, b_ref, with_proxy);
+                patch_opt_field!(result, b_ref, self_proxy);
+                patch_opt_field!(result, b_ref, danger_accept_invalid_certs);
+                patch_opt_field!(result, b_ref, allow_auto_update);
+                patch_opt_field!(result, b_ref, update_interval);
+                patch_opt_field!(result, b_ref, merge);
+                patch_opt_field!(result, b_ref, script);
+                patch_opt_field!(result, b_ref, rules);
+                patch_opt_field!(result, b_ref, proxies);
+                patch_opt_field!(result, b_ref, groups);
+                patch_opt_field!(result, b_ref, timeout_seconds);
                 Some(result)
             }
             (Some(a_ref), None) => Some(a_ref.clone()),
@@ -181,6 +182,38 @@ impl PrfItem {
         }
     }
 
+    async fn append_companion_item(item: &mut Self) -> Result<String> {
+        profiles::profiles_append_item_safe(item).await?;
+        item.uid
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("appended companion item has no uid"))
+    }
+
+    async fn ensure_companion_items(
+        merge: &mut Option<String>,
+        script: &mut Option<String>,
+        rules: &mut Option<String>,
+        proxies: &mut Option<String>,
+        groups: &mut Option<String>,
+    ) -> Result<()> {
+        if merge.is_none() {
+            *merge = Some(Self::append_companion_item(&mut Self::from_merge(None)).await?);
+        }
+        if script.is_none() {
+            *script = Some(Self::append_companion_item(&mut Self::from_script(None)).await?);
+        }
+        if rules.is_none() {
+            *rules = Some(Self::append_companion_item(&mut Self::from_rules()).await?);
+        }
+        if proxies.is_none() {
+            *proxies = Some(Self::append_companion_item(&mut Self::from_proxies()).await?);
+        }
+        if groups.is_none() {
+            *groups = Some(Self::append_companion_item(&mut Self::from_groups()).await?);
+        }
+        Ok(())
+    }
+
     async fn from_local(
         name: String,
         desc: String,
@@ -197,31 +230,7 @@ impl PrfItem {
         let mut proxies = opt_ref.and_then(|o| o.proxies.clone());
         let mut groups = opt_ref.and_then(|o| o.groups.clone());
 
-        if merge.is_none() {
-            let merge_item = &mut Self::from_merge(None);
-            profiles::profiles_append_item_safe(merge_item).await?;
-            merge = merge_item.uid.clone();
-        }
-        if script.is_none() {
-            let script_item = &mut Self::from_script(None);
-            profiles::profiles_append_item_safe(script_item).await?;
-            script = script_item.uid.clone();
-        }
-        if rules.is_none() {
-            let rules_item = &mut Self::from_rules();
-            profiles::profiles_append_item_safe(rules_item).await?;
-            rules = rules_item.uid.clone();
-        }
-        if proxies.is_none() {
-            let proxies_item = &mut Self::from_proxies();
-            profiles::profiles_append_item_safe(proxies_item).await?;
-            proxies = proxies_item.uid.clone();
-        }
-        if groups.is_none() {
-            let groups_item = &mut Self::from_groups();
-            profiles::profiles_append_item_safe(groups_item).await?;
-            groups = groups_item.uid.clone();
-        }
+        Self::ensure_companion_items(&mut merge, &mut script, &mut rules, &mut proxies, &mut groups).await?;
         Ok(Self {
             uid: Some(uid),
             itype: Some("local".into()),
@@ -375,31 +384,7 @@ impl PrfItem {
             bail!("profile does not contain `proxies` or `proxy-providers`");
         }
 
-        if merge.is_none() {
-            let merge_item = &mut Self::from_merge(None);
-            profiles::profiles_append_item_safe(merge_item).await?;
-            merge = merge_item.uid.clone();
-        }
-        if script.is_none() {
-            let script_item = &mut Self::from_script(None);
-            profiles::profiles_append_item_safe(script_item).await?;
-            script = script_item.uid.clone();
-        }
-        if rules.is_none() {
-            let rules_item = &mut Self::from_rules();
-            profiles::profiles_append_item_safe(rules_item).await?;
-            rules = rules_item.uid.clone();
-        }
-        if proxies.is_none() {
-            let proxies_item = &mut Self::from_proxies();
-            profiles::profiles_append_item_safe(proxies_item).await?;
-            proxies = proxies_item.uid.clone();
-        }
-        if groups.is_none() {
-            let groups_item = &mut Self::from_groups();
-            profiles::profiles_append_item_safe(groups_item).await?;
-            groups = groups_item.uid.clone();
-        }
+        Self::ensure_companion_items(&mut merge, &mut script, &mut rules, &mut proxies, &mut groups).await?;
 
         Ok(Self {
             uid: Some(uid),
@@ -461,46 +446,30 @@ impl PrfItem {
         }
     }
 
-    fn from_rules() -> Self {
-        let uid = help::get_uid("r").into();
+    fn new_seq_item(prefix: &str, itype: &str, template: &str) -> Self {
+        let uid = help::get_uid(prefix).into();
         let file = format!("{uid}.yaml").into(); // yaml ext
 
         Self {
             uid: Some(uid),
-            itype: Some("rules".into()),
+            itype: Some(itype.into()),
             file: Some(file),
             updated: Some(chrono::Local::now().timestamp() as usize),
-            file_data: Some(tmpl::ITEM_RULES.into()),
+            file_data: Some(template.into()),
             ..Default::default()
         }
     }
 
+    fn from_rules() -> Self {
+        Self::new_seq_item("r", "rules", tmpl::ITEM_RULES)
+    }
+
     fn from_proxies() -> Self {
-        let uid = help::get_uid("p").into();
-        let file = format!("{uid}.yaml").into(); // yaml ext
-
-        Self {
-            uid: Some(uid),
-            itype: Some("proxies".into()),
-            file: Some(file),
-            updated: Some(chrono::Local::now().timestamp() as usize),
-            file_data: Some(tmpl::ITEM_PROXIES.into()),
-            ..Default::default()
-        }
+        Self::new_seq_item("p", "proxies", tmpl::ITEM_PROXIES)
     }
 
     fn from_groups() -> Self {
-        let uid = help::get_uid("g").into();
-        let file = format!("{uid}.yaml").into(); // yaml ext
-
-        Self {
-            uid: Some(uid),
-            itype: Some("groups".into()),
-            file: Some(file),
-            updated: Some(chrono::Local::now().timestamp() as usize),
-            file_data: Some(tmpl::ITEM_GROUPS.into()),
-            ..Default::default()
-        }
+        Self::new_seq_item("g", "groups", tmpl::ITEM_GROUPS)
     }
 
     pub(crate) async fn read_file(&self) -> Result<String> {
@@ -516,26 +485,20 @@ impl PrfItem {
     }
 }
 
+macro_rules! current_field {
+    ($name:ident, $field:ident) => {
+        pub(crate) fn $name(&self) -> Option<&String> {
+            self.option.as_ref().and_then(|o| o.$field.as_ref())
+        }
+    };
+}
+
 impl PrfItem {
-    pub(crate) fn current_merge(&self) -> Option<&String> {
-        self.option.as_ref().and_then(|o| o.merge.as_ref())
-    }
-
-    pub(crate) fn current_script(&self) -> Option<&String> {
-        self.option.as_ref().and_then(|o| o.script.as_ref())
-    }
-
-    pub(crate) fn current_rules(&self) -> Option<&String> {
-        self.option.as_ref().and_then(|o| o.rules.as_ref())
-    }
-
-    pub(crate) fn current_proxies(&self) -> Option<&String> {
-        self.option.as_ref().and_then(|o| o.proxies.as_ref())
-    }
-
-    pub(crate) fn current_groups(&self) -> Option<&String> {
-        self.option.as_ref().and_then(|o| o.groups.as_ref())
-    }
+    current_field!(current_merge, merge);
+    current_field!(current_script, script);
+    current_field!(current_rules, rules);
+    current_field!(current_proxies, proxies);
+    current_field!(current_groups, groups);
 }
 
 fn allow_auto_update_enabled(option: Option<&PrfOption>) -> bool {

src-tauri/src/config/profiles.rs

@@ -1,5 +1,5 @@
 use super::{
-    PrfOption,
+    PrfOption, patch_opt_field,
     prfitem::{PrfItem, PrfSelected, normalize_profile_home_url},
 };
 use crate::core::notify::{Refresh, announce};
@@ -86,14 +86,6 @@ impl ProfileDeletePlan {
     }
 }
 
-macro_rules! patch {
-    ($lv: expr, $rv: expr, $key: tt) => {
-        if ($rv.$key).is_some() {
-            $lv.$key = $rv.$key.to_owned();
-        }
-    };
-}
-
 impl IProfiles {
     fn take_item_file_by_uid(items: &mut Vec<PrfItem>, target_uid: Option<&str>) -> Option<String> {
         let index = items.iter().position(|item| item.uid.as_deref() == target_uid)?;
@@ -244,15 +236,15 @@ impl IProfiles {
 
         for each in items.iter_mut() {
             if each.uid.as_deref() == Some(uid) {
-                patch!(each, item, itype);
-                patch!(each, item, name);
-                patch!(each, item, desc);
-                patch!(each, item, file);
-                patch!(each, item, url);
-                patch!(each, item, selected);
-                patch!(each, item, extra);
-                patch!(each, item, updated);
-                patch!(each, item, option);
+                patch_opt_field!(each, item, itype);
+                patch_opt_field!(each, item, name);
+                patch_opt_field!(each, item, desc);
+                patch_opt_field!(each, item, file);
+                patch_opt_field!(each, item, url);
+                patch_opt_field!(each, item, selected);
+                patch_opt_field!(each, item, extra);
+                patch_opt_field!(each, item, updated);
+                patch_opt_field!(each, item, option);
 
                 self.items = Some(items);
                 return self.save_file().await;
@@ -420,6 +412,21 @@ pub(crate) async fn profiles_append_item_with_filedata_safe(item: &PrfItem, file
     profiles_append_item_safe(item).await
 }
 
+/// Applies `edit` to the committed profiles; commits only when the edit succeeds.
+async fn with_profiles_edit<F, Fut>(edit: F) -> Result<()>
+where
+    F: FnOnce(IProfiles) -> Fut + Send,
+    Fut: std::future::Future<Output = Result<IProfiles>> + Send,
+{
+    Config::profiles()
+        .await
+        .with_data_modify(|profiles| async move {
+            let profiles = edit(profiles).await?;
+            Ok((profiles, ()))
+        })
+        .await
+}
+
 pub(crate) async fn profiles_append_item_safe(item: &mut PrfItem) -> Result<()> {
     let profiles = Config::profiles().await;
     profiles_append_item_to_safe(&profiles, item).await
@@ -435,43 +442,19 @@ pub(super) async fn profiles_append_item_to_safe(profiles: &Draft<IProfiles>, it
 }
 
 pub(crate) async fn profiles_patch_item_safe(index: &str, item: &PrfItem) -> Result<()> {
-    Config::profiles()
-        .await
-        .with_data_modify(|mut profiles| async move {
-            profiles.patch_item(index, item).await?;
-            Ok((profiles, ()))
-        })
-        .await
+    with_profiles_edit(|mut profiles| async move { profiles.patch_item(index, item).await.map(|_| profiles) }).await
 }
 
 pub(crate) async fn profiles_reorder_safe(active_id: &str, over_id: &str) -> Result<()> {
-    Config::profiles()
-        .await
-        .with_data_modify(|mut profiles| async move {
-            profiles.reorder(active_id, over_id).await?;
-            Ok((profiles, ()))
-        })
-        .await
+    with_profiles_edit(|mut profiles| async move { profiles.reorder(active_id, over_id).await.map(|_| profiles) }).await
 }
 
 pub(crate) async fn profiles_save_file_safe() -> Result<()> {
-    Config::profiles()
-        .await
-        .with_data_modify(|profiles| async move {
-            profiles.save_file().await?;
-            Ok((profiles, ()))
-        })
-        .await
+    with_profiles_edit(|profiles| async move { profiles.save_file().await.map(|_| profiles) }).await
 }
 
 pub(crate) async fn profiles_update_item_safe(index: &str, item: &mut PrfItem) -> Result<()> {
-    Config::profiles()
-        .await
-        .with_data_modify(|mut profiles| async move {
-            profiles.update_item(index, item).await?;
-            Ok((profiles, ()))
-        })
-        .await
+    with_profiles_edit(|mut profiles| async move { profiles.update_item(index, item).await.map(|_| profiles) }).await
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -713,19 +696,21 @@ where
     Ok(())
 }
 
+fn current_item_mut(profiles: &mut IProfiles) -> Option<&mut PrfItem> {
+    let current = profiles.current.clone()?;
+    profiles
+        .items
+        .as_mut()?
+        .iter_mut()
+        .find(|item| item.uid.as_ref() == Some(&current))
+}
+
 /// Records a backend-made selection so the next core start restores it.
 pub(crate) async fn record_selected_node(group_name: &str, node: &str) -> Result<()> {
     let group_name = String::from(group_name);
     let node = String::from(node);
     persist_selected_update(true, move |mut profiles| async move {
-        let Some(current) = profiles.current.clone() else {
-            return Ok((profiles, false));
-        };
-        let Some(item) = profiles
-            .items
-            .as_mut()
-            .and_then(|items| items.iter_mut().find(|item| item.uid.as_ref() == Some(&current)))
-        else {
+        let Some(item) = current_item_mut(&mut profiles) else {
             return Ok((profiles, false));
         };
 
@@ -760,14 +745,7 @@ fn remove_selected_node(selected: &mut Vec<PrfSelected>, group_name: &str) -> bo
 
 pub(crate) async fn forget_selected_node(group_name: &str) -> Result<()> {
     persist_selected_update(true, move |mut profiles| async move {
-        let Some(current) = profiles.current.clone() else {
-            return Ok((profiles, false));
-        };
-        let Some(item) = profiles
-            .items
-            .as_mut()
-            .and_then(|items| items.iter_mut().find(|item| item.uid.as_ref() == Some(&current)))
-        else {
+        let Some(item) = current_item_mut(&mut profiles) else {
             return Ok((profiles, false));
         };
 

src-tauri/src/config/verge.rs

@@ -1,6 +1,6 @@
 use crate::config::Config;
 use crate::{
-    config::{DEFAULT_PAC, deserialize_encrypted, serialize_encrypted},
+    config::{DEFAULT_PAC, deserialize_encrypted, patch_opt_field, serialize_encrypted},
     constants::network,
     utils::{dirs, help},
 };
@@ -39,7 +39,7 @@ pub struct IVerge {
 
     pub traffic_graph: Option<bool>,
 
-    /// show memory info (only for Clash Meta)
+    /// show memory info (only for Mihomo)
     pub enable_memory_usage: Option<bool>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -432,98 +432,90 @@ impl IVerge {
 
     #[allow(clippy::cognitive_complexity)]
     pub fn patch_config(&mut self, patch: &Self) {
-        macro_rules! patch {
-            ($key: tt) => {
-                if patch.$key.is_some() {
-                    self.$key = patch.$key.clone();
-                }
-            };
-        }
+        patch_opt_field!(self, patch, app_log_level);
+        patch_opt_field!(self, patch, app_log_max_size);
+        patch_opt_field!(self, patch, app_log_max_count);
 
-        patch!(app_log_level);
-        patch!(app_log_max_size);
-        patch!(app_log_max_count);
-
-        patch!(language);
-        patch!(theme_mode);
-        patch!(tray_event);
-        patch!(env_type);
-        patch!(start_page);
-        patch!(startup_script);
-        patch!(traffic_graph);
-        patch!(enable_memory_usage);
-        patch!(enable_group_icon);
-        patch!(pause_render_traffic_stats_on_blur);
+        patch_opt_field!(self, patch, language);
+        patch_opt_field!(self, patch, theme_mode);
+        patch_opt_field!(self, patch, tray_event);
+        patch_opt_field!(self, patch, env_type);
+        patch_opt_field!(self, patch, start_page);
+        patch_opt_field!(self, patch, startup_script);
+        patch_opt_field!(self, patch, traffic_graph);
+        patch_opt_field!(self, patch, enable_memory_usage);
+        patch_opt_field!(self, patch, enable_group_icon);
+        patch_opt_field!(self, patch, pause_render_traffic_stats_on_blur);
         #[cfg(target_os = "macos")]
-        patch!(tray_icon);
-        patch!(menu_icon);
-        patch!(menu_order);
-        patch!(proxy_group_tools_position);
-        patch!(notice_position);
-        patch!(collapse_navbar);
-        patch!(common_tray_icon);
-        patch!(sysproxy_tray_icon);
-        patch!(tun_tray_icon);
+        patch_opt_field!(self, patch, tray_icon);
+        patch_opt_field!(self, patch, menu_icon);
+        patch_opt_field!(self, patch, menu_order);
+        patch_opt_field!(self, patch, proxy_group_tools_position);
+        patch_opt_field!(self, patch, notice_position);
+        patch_opt_field!(self, patch, collapse_navbar);
+        patch_opt_field!(self, patch, common_tray_icon);
+        patch_opt_field!(self, patch, sysproxy_tray_icon);
+        patch_opt_field!(self, patch, tun_tray_icon);
 
-        patch!(enable_tun_mode);
-        patch!(enable_auto_launch);
-        patch!(enable_silent_start);
-        patch!(enable_hover_jump_navigator);
-        patch!(hover_jump_navigator_delay);
+        patch_opt_field!(self, patch, enable_tun_mode);
+        patch_opt_field!(self, patch, enable_auto_launch);
+        patch_opt_field!(self, patch, enable_silent_start);
+        patch_opt_field!(self, patch, enable_hover_jump_navigator);
+        patch_opt_field!(self, patch, hover_jump_navigator_delay);
         #[cfg(not(target_os = "windows"))]
-        patch!(verge_redir_port);
+        patch_opt_field!(self, patch, verge_redir_port);
         #[cfg(not(target_os = "windows"))]
-        patch!(verge_redir_enabled);
+        patch_opt_field!(self, patch, verge_redir_enabled);
         #[cfg(target_os = "linux")]
-        patch!(verge_tproxy_port);
+        patch_opt_field!(self, patch, verge_tproxy_port);
         #[cfg(target_os = "linux")]
-        patch!(verge_tproxy_enabled);
-        patch!(verge_mixed_port);
-        patch!(verge_socks_port);
-        patch!(verge_socks_enabled);
-        patch!(verge_port);
-        patch!(verge_http_enabled);
-        patch!(enable_system_proxy);
-        patch!(enable_proxy_guard);
-        patch!(enable_bypass_check);
-        patch!(use_default_bypass);
-        patch!(system_proxy_bypass);
-        patch!(proxy_guard_duration);
-        patch!(proxy_auto_config);
-        patch!(pac_file_content);
-        patch!(proxy_host);
-        patch!(theme_setting);
-        patch!(web_ui_list);
-        patch!(clash_core);
-        patch!(hotkeys);
-        patch!(enable_global_hotkey);
+        patch_opt_field!(self, patch, verge_tproxy_enabled);
+        patch_opt_field!(self, patch, verge_mixed_port);
+        patch_opt_field!(self, patch, verge_socks_port);
+        patch_opt_field!(self, patch, verge_socks_enabled);
+        patch_opt_field!(self, patch, verge_port);
+        patch_opt_field!(self, patch, verge_http_enabled);
+        patch_opt_field!(self, patch, enable_system_proxy);
+        patch_opt_field!(self, patch, enable_proxy_guard);
+        patch_opt_field!(self, patch, enable_bypass_check);
+        patch_opt_field!(self, patch, use_default_bypass);
+        patch_opt_field!(self, patch, system_proxy_bypass);
+        patch_opt_field!(self, patch, proxy_guard_duration);
+        patch_opt_field!(self, patch, proxy_auto_config);
+        patch_opt_field!(self, patch, pac_file_content);
+        patch_opt_field!(self, patch, proxy_host);
+        patch_opt_field!(self, patch, theme_setting);
+        patch_opt_field!(self, patch, web_ui_list);
+        patch_opt_field!(self, patch, clash_core);
+        patch_opt_field!(self, patch, hotkeys);
+        patch_opt_field!(self, patch, enable_global_hotkey);
 
-        patch!(auto_close_connection);
-        patch!(auto_check_update);
-        patch!(default_latency_test);
-        patch!(default_latency_timeout);
-        patch!(enable_auto_delay_detection);
-        patch!(auto_delay_detection_interval_minutes);
-        patch!(enable_builtin_enhanced);
-        patch!(proxy_layout_column);
-        patch!(test_list);
-        patch!(auto_log_clean);
-        patch!(enable_auto_backup_schedule);
-        patch!(auto_backup_interval_hours);
-        patch!(auto_backup_on_change);
+        patch_opt_field!(self, patch, auto_close_connection);
+        patch_opt_field!(self, patch, auto_check_update);
+        patch_opt_field!(self, patch, default_latency_test);
+        patch_opt_field!(self, patch, default_latency_timeout);
+        patch_opt_field!(self, patch, enable_auto_delay_detection);
+        patch_opt_field!(self, patch, auto_delay_detection_interval_minutes);
+        patch_opt_field!(self, patch, enable_builtin_enhanced);
+        patch_opt_field!(self, patch, proxy_layout_column);
+        patch_opt_field!(self, patch, test_list);
+        patch_opt_field!(self, patch, auto_log_clean);
+        patch_opt_field!(self, patch, enable_auto_backup_schedule);
+        patch_opt_field!(self, patch, auto_backup_interval_hours);
+        patch_opt_field!(self, patch, auto_backup_on_change);
 
-        patch!(webdav_url);
-        patch!(webdav_username);
-        patch!(webdav_password);
+        patch_opt_field!(self, patch, webdav_url);
+        patch_opt_field!(self, patch, webdav_username);
+        patch_opt_field!(self, patch, webdav_password);
         #[cfg(target_os = "macos")]
-        patch!(enable_tray_speed);
-        patch!(tray_proxy_groups_display_mode);
-        patch!(tray_inline_outbound_modes);
-        patch!(enable_auto_light_weight_mode);
-        patch!(auto_light_weight_minutes);
-        patch!(enable_dns_settings);
-        patch!(home_cards);
-        patch!(enable_external_controller);
+        patch_opt_field!(self, patch, enable_tray_speed);
+        patch_opt_field!(self, patch, tray_proxy_groups_display_mode);
+        patch_opt_field!(self, patch, tray_inline_outbound_modes);
+        patch_opt_field!(self, patch, enable_auto_light_weight_mode);
+        patch_opt_field!(self, patch, auto_light_weight_minutes);
+        patch_opt_field!(self, patch, enable_dns_settings);
+        patch_opt_field!(self, patch, home_cards);
+        patch_opt_field!(self, patch, enable_external_controller);
     }
 
     pub fn get_log_level(&self) -> LevelFilter {

src-tauri/src/constants.rs

@@ -14,6 +14,13 @@ pub mod network {
     }
 }
 
+pub mod sysproxy {
+    /// Single source of the macOS default bypass list; both proxy backends compose from it.
+    #[cfg(target_os = "macos")]
+    pub const MACOS_DEFAULT_BYPASS: &str =
+        "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,localhost,*.local,*.crashlytics.com,<local>";
+}
+
 pub mod timing {
     use super::Duration;
 

src-tauri/src/core/auto_backup.rs

@@ -7,11 +7,10 @@ use crate::{
 use anyhow::Result;
 use chrono::Local;
 use clash_verge_logging::{Type, logging};
-use parking_lot::RwLock;
 use std::{
     path::PathBuf,
     sync::{
-        Arc, OnceLock,
+        OnceLock,
         atomic::{AtomicBool, AtomicI64, Ordering},
     },
     time::{Duration, UNIX_EPOCH},
@@ -82,8 +81,9 @@ impl Default for AutoBackupSettings {
 }
 
 pub struct AutoBackupManager {
-    settings: Arc<RwLock<AutoBackupSettings>>,
     settings_tx: watch::Sender<AutoBackupSettings>,
+    // The watch channel is the single settings store; no duplicate copies.
+    settings_rx: watch::Receiver<AutoBackupSettings>,
     runner_started: AtomicBool,
     exec_lock: Mutex<()>,
     last_backup: AtomicI64,
@@ -93,10 +93,10 @@ impl AutoBackupManager {
     pub fn global() -> &'static Self {
         static INSTANCE: OnceLock<AutoBackupManager> = OnceLock::new();
         INSTANCE.get_or_init(|| {
-            let (tx, _rx) = watch::channel(AutoBackupSettings::default());
+            let (settings_tx, settings_rx) = watch::channel(AutoBackupSettings::default());
             Self {
-                settings: Arc::new(RwLock::new(AutoBackupSettings::default())),
-                settings_tx: tx,
+                settings_tx,
+                settings_rx,
                 runner_started: AtomicBool::new(false),
                 exec_lock: Mutex::new(()),
                 last_backup: AtomicI64::new(0),
@@ -106,9 +106,6 @@ impl AutoBackupManager {
 
     pub async fn init(&self) -> Result<()> {
         let settings = Self::load_settings().await;
-        {
-            *self.settings.write() = settings;
-        }
         let _ = self.settings_tx.send_replace(settings);
         self.maybe_start_runner(settings);
         Ok(())
@@ -116,9 +113,6 @@ impl AutoBackupManager {
 
     pub async fn refresh_settings(&self) -> Result<()> {
         let settings = Self::load_settings().await;
-        {
-            *self.settings.write() = settings;
-        }
         let _ = self.settings_tx.send_replace(settings);
         self.maybe_start_runner(settings);
         Ok(())
@@ -193,7 +187,7 @@ impl AutoBackupManager {
     }
 
     async fn execute_trigger(&self, trigger: AutoBackupTrigger) -> Result<()> {
-        let snapshot = *self.settings.read();
+        let snapshot = *self.settings_rx.borrow();
 
         if trigger.is_schedule() && !snapshot.schedule_enabled {
             return Ok(());

src-tauri/src/core/hotkey.rs

@@ -466,12 +466,3 @@ impl Hotkey {
         (del_list, add_list)
     }
 }
-
-impl Drop for Hotkey {
-    fn drop(&mut self) {
-        let app_handle = handle::Handle::app_handle();
-        if let Err(e) = app_handle.global_shortcut().unregister_all() {
-            logging!(error, Type::Hotkey, "Error unregistering all hotkeys: {:?}", e);
-        }
-    }
-}

src-tauri/src/core/lightweight.rs

@@ -40,8 +40,47 @@ impl LightweightState {
 
 static LIGHTWEIGHT_STATE: AtomicU8 = AtomicU8::new(LightweightState::Normal as u8);
 
-static WINDOW_CLOSE_HANDLER_ID: AtomicU32 = AtomicU32::new(0);
-static WEBVIEW_FOCUS_HANDLER_ID: AtomicU32 = AtomicU32::new(0);
+struct WindowListener {
+    handler_id: AtomicU32,
+    event: &'static str,
+    label: &'static str,
+}
+
+impl WindowListener {
+    fn setup(&self, on_event: impl Fn() + Send + 'static) {
+        if let Some(window) = WindowManager::get_main_window() {
+            let previous_handler_id = self.handler_id.swap(0, Ordering::AcqRel);
+            if previous_handler_id != 0 {
+                window.unlisten(previous_handler_id);
+                logging!(debug, Type::Lightweight, "覆盖旧的{}监听", self.label);
+            }
+            let handler_id = window.listen(self.event, move |_event| on_event());
+            self.handler_id.store(handler_id, Ordering::Release);
+        }
+    }
+
+    fn cancel(&self) {
+        let id = self.handler_id.swap(0, Ordering::AcqRel);
+        if id != 0 {
+            if let Some(window) = WindowManager::get_main_window() {
+                window.unlisten(id);
+            }
+            logging!(debug, Type::Lightweight, "取消了{}监听", self.label);
+        }
+    }
+}
+
+static WINDOW_CLOSE_LISTENER: WindowListener = WindowListener {
+    handler_id: AtomicU32::new(0),
+    event: "tauri://close-requested",
+    label: "窗口关闭",
+};
+
+static WEBVIEW_FOCUS_LISTENER: WindowListener = WindowListener {
+    handler_id: AtomicU32::new(0),
+    event: "tauri://focus",
+    label: "窗口焦点",
+};
 
 static CANCEL_TX: Mutex<Option<oneshot::Sender<()>>> = Mutex::new(None);
 
@@ -154,55 +193,27 @@ pub async fn add_light_weight_timer() {
 }
 
 fn setup_window_close_listener() {
-    if let Some(window) = WindowManager::get_main_window() {
-        let previous_handler_id = WINDOW_CLOSE_HANDLER_ID.swap(0, Ordering::AcqRel);
-        if previous_handler_id != 0 {
-            window.unlisten(previous_handler_id);
-            logging!(debug, Type::Lightweight, "覆盖旧的窗口关闭监听");
-        }
-        let handler_id = window.listen("tauri://close-requested", move |_event| {
-            std::mem::drop(AsyncHandler::spawn(|| async {
-                setup_light_weight_timer().await;
-            }));
-            logging!(info, Type::Lightweight, "监听到关闭请求，开始轻量模式计时");
-        });
-        WINDOW_CLOSE_HANDLER_ID.store(handler_id, Ordering::Release);
-    }
+    WINDOW_CLOSE_LISTENER.setup(|| {
+        std::mem::drop(AsyncHandler::spawn(|| async {
+            setup_light_weight_timer().await;
+        }));
+        logging!(info, Type::Lightweight, "监听到关闭请求，开始轻量模式计时");
+    });
 }
 
 fn cancel_window_close_listener() {
-    let id = WINDOW_CLOSE_HANDLER_ID.swap(0, Ordering::AcqRel);
-    if id != 0 {
-        if let Some(window) = WindowManager::get_main_window() {
-            window.unlisten(id);
-        }
-        logging!(debug, Type::Lightweight, "取消了窗口关闭监听");
-    }
+    WINDOW_CLOSE_LISTENER.cancel();
 }
 
 fn setup_webview_focus_listener() {
-    if let Some(window) = WindowManager::get_main_window() {
-        let previous_handler_id = WEBVIEW_FOCUS_HANDLER_ID.swap(0, Ordering::AcqRel);
-        if previous_handler_id != 0 {
-            window.unlisten(previous_handler_id);
-            logging!(debug, Type::Lightweight, "覆盖旧的窗口焦点监听");
-        }
-        let handler_id = window.listen("tauri://focus", move |_event| {
-            cancel_light_weight_timer();
-            logging!(debug, Type::Lightweight, "监听到窗口获得焦点，取消轻量模式计时");
-        });
-        WEBVIEW_FOCUS_HANDLER_ID.store(handler_id, Ordering::Release);
-    }
+    WEBVIEW_FOCUS_LISTENER.setup(|| {
+        cancel_light_weight_timer();
+        logging!(debug, Type::Lightweight, "监听到窗口获得焦点，取消轻量模式计时");
+    });
 }
 
 fn cancel_webview_focus_listener() {
-    let id = WEBVIEW_FOCUS_HANDLER_ID.swap(0, Ordering::AcqRel);
-    if id != 0 {
-        if let Some(window) = WindowManager::get_main_window() {
-            window.unlisten(id);
-        }
-        logging!(debug, Type::Lightweight, "取消了窗口焦点监听");
-    }
+    WEBVIEW_FOCUS_LISTENER.cancel();
 }
 
 async fn setup_light_weight_timer() {

src-tauri/src/core/proxy_control.rs

@@ -6,7 +6,7 @@ use crate::{
         notification::{self, FailedOperation},
         runstate::RUN_STATE,
         service,
-        sysopt::Sysopt,
+        sysopt::{Sysopt, format_bypass},
     },
     process::AsyncHandler,
     utils::{
@@ -204,8 +204,6 @@ const fn refusal_classification(service_usable: Option<bool>) -> SysproxyFailure
 }
 
 const LOOPBACK_HOST: &str = "127.0.0.1";
-const MACOS_DEFAULT_BYPASS: &str =
-    "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,localhost,*.local,*.crashlytics.com,<local>";
 const MAX_SERVICE_BYPASS_LEN: usize = 8192;
 
 static SERVICE_PROXY_OPERATIONS: ServiceProxyOperations = ServiceProxyOperations::new();
@@ -327,13 +325,7 @@ fn service_bypass(verge: &IVerge) -> Result<String> {
     let custom = verge.system_proxy_bypass.as_deref().unwrap_or("");
     ensure!(!custom.contains('\0'), "system proxy bypass contains NUL");
 
-    let mut bypass = if custom.is_empty() {
-        MACOS_DEFAULT_BYPASS.to_owned()
-    } else if verge.use_default_bypass.unwrap_or(true) {
-        format!("{MACOS_DEFAULT_BYPASS},{custom}")
-    } else {
-        custom.to_owned()
-    };
+    let mut bypass: String = format_bypass(verge.use_default_bypass.unwrap_or(true), custom).into();
     truncate_utf8(&mut bypass, MAX_SERVICE_BYPASS_LEN);
     Ok(bypass)
 }

src-tauri/src/core/service.rs

@@ -603,50 +603,71 @@ fn packaged_service_tool_path(file_name: &str, packaged_path: impl FnOnce() -> R
 }
 
 #[cfg(target_os = "windows")]
-fn uninstall_service() -> Result<()> {
-    logging!(info, Type::Service, "uninstall service");
-
+pub(super) fn run_maybe_elevated(program: &Path, hide_window: bool) -> Result<std::process::ExitStatus> {
     use deelevate::{PrivilegeLevel, Token};
     use runas::Command as RunasCommand;
     use std::os::windows::process::CommandExt as _;
 
-    let uninstall_path = packaged_service_tool_path("clash-verge-service-uninstall.exe", || {
-        Ok(dirs::service_path()?.with_file_name("clash-verge-service-uninstall.exe"))
-    })?;
-
-    if !uninstall_path.exists() {
-        bail!(format!("uninstaller not found: {uninstall_path:?}"));
-    }
-
     let token = Token::with_current_process()?;
     let level = token.privilege_level()?;
     let status = match level {
-        PrivilegeLevel::NotPrivileged => RunasCommand::new(uninstall_path).show(false).status()?,
-        _ => StdCommand::new(uninstall_path).creation_flags(0x08000000).status()?,
+        PrivilegeLevel::NotPrivileged => {
+            let mut command = RunasCommand::new(program);
+            if hide_window {
+                command.show(false);
+            }
+            command.status()?
+        }
+        _ => {
+            let mut command = StdCommand::new(program);
+            if hide_window {
+                // 0x08000000 is CREATE_NO_WINDOW, the direct counterpart of runas's show(false).
+                command.creation_flags(0x08000000);
+            }
+            command.status()?
+        }
     };
+    Ok(status)
+}
 
+fn uninstaller_tool_path(file_name: &str, packaged_path: impl FnOnce() -> Result<PathBuf>) -> Result<PathBuf> {
+    let uninstall_path = packaged_service_tool_path(file_name, packaged_path)?;
+    if !uninstall_path.exists() {
+        bail!(format!("uninstaller not found: {uninstall_path:?}"));
+    }
+    Ok(uninstall_path)
+}
+
+fn ensure_uninstall_success(status: &std::process::ExitStatus) -> Result<()> {
     if !status.success() {
         bail!(
             "failed to uninstall service with status {}",
             status.code().unwrap_or(-1)
         );
     }
-
     Ok(())
 }
 
+#[cfg(target_os = "windows")]
+fn uninstall_service() -> Result<()> {
+    logging!(info, Type::Service, "uninstall service");
+
+    let uninstall_path = uninstaller_tool_path("clash-verge-service-uninstall.exe", || {
+        Ok(dirs::service_path()?.with_file_name("clash-verge-service-uninstall.exe"))
+    })?;
+
+    let status = run_maybe_elevated(&uninstall_path, true)?;
+    ensure_uninstall_success(&status)
+}
+
 #[cfg(target_os = "linux")]
 fn uninstall_service() -> Result<()> {
     logging!(info, Type::Service, "uninstall service");
 
-    let uninstall_path = packaged_service_tool_path("clash-verge-service-uninstall", || {
+    let uninstall_path = uninstaller_tool_path("clash-verge-service-uninstall", || {
         Ok(tauri::utils::platform::current_exe()?.with_file_name("clash-verge-service-uninstall"))
     })?;
 
-    if !uninstall_path.exists() {
-        bail!(format!("uninstaller not found: {uninstall_path:?}"));
-    }
-
     let elevator = crate::utils::help::linux_elevator();
     let status = if linux_running_as_root() {
         StdCommand::new(&uninstall_path).status()?
@@ -676,14 +697,7 @@ fn uninstall_service() -> Result<()> {
         status.code().unwrap_or(-1)
     );
 
-    if !status.success() {
-        bail!(
-            "failed to uninstall service with status {}",
-            status.code().unwrap_or(-1)
-        );
-    }
-
-    Ok(())
+    ensure_uninstall_success(&status)
 }
 
 #[cfg(target_os = "linux")]
@@ -698,14 +712,10 @@ fn linux_running_as_root() -> bool {
 fn uninstall_service() -> Result<()> {
     logging!(info, Type::Service, "uninstall service");
 
-    let uninstall_path = packaged_service_tool_path("clash-verge-service-uninstall", || {
+    let uninstall_path = uninstaller_tool_path("clash-verge-service-uninstall", || {
         Ok(dirs::service_path()?.with_file_name("clash-verge-service-uninstall"))
     })?;
 
-    if !uninstall_path.exists() {
-        bail!(format!("uninstaller not found: {uninstall_path:?}"));
-    }
-
     let uninstall_path = macos_service_tool_path(&uninstall_path)?;
     let uninstall_shell: String = uninstall_path.to_string_lossy().into_owned();
 
@@ -721,14 +731,7 @@ fn uninstall_service() -> Result<()> {
 
     let status = StdCommand::new("osascript").args(vec!["-e", &command]).status()?;
 
-    if !status.success() {
-        bail!(
-            "failed to uninstall service with status {}",
-            status.code().unwrap_or(-1)
-        );
-    }
-
-    Ok(())
+    ensure_uninstall_success(&status)
 }
 
 fn install_service() -> Result<()> {

src-tauri/src/core/sysopt.rs

@@ -241,20 +241,19 @@ async fn current_os_proxy_state(sys: Sysproxy, auto: Autoproxy) -> OsProxyState
 }
 
 pub(crate) struct Sysopt {
-    update_lock: TokioMutex<()>,
+    // Owns the proxy target pair; every reader and writer goes through this lock.
+    proxy_state_lock: TokioMutex<(Sysproxy, Autoproxy)>,
     guard_operation_lock: TokioMutex<()>,
     reset_sysproxy: AtomicBool,
-    inner_proxy: Arc<RwLock<(Sysproxy, Autoproxy)>>,
     guard: Arc<RwLock<GuardMonitor>>,
 }
 
 impl Default for Sysopt {
     fn default() -> Self {
         Self {
-            update_lock: TokioMutex::new(()),
+            proxy_state_lock: TokioMutex::new((Sysproxy::default(), Autoproxy::default())),
             guard_operation_lock: TokioMutex::new(()),
             reset_sysproxy: AtomicBool::new(false),
-            inner_proxy: Arc::new(RwLock::new((Sysproxy::default(), Autoproxy::default()))),
             guard: Arc::new(RwLock::new(GuardMonitor::new(GuardType::None, Duration::from_secs(30)))),
         }
     }
@@ -269,10 +268,9 @@ static DEFAULT_BYPASS: &str = "localhost,127.0.0.1,192.168.0.0/16,10.0.0.0/8,172
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 static BYPASS_SEPARATOR: &str = ",";
 #[cfg(target_os = "macos")]
-static DEFAULT_BYPASS: &str =
-    "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,localhost,*.local,*.crashlytics.com,<local>";
+static DEFAULT_BYPASS: &str = crate::constants::sysproxy::MACOS_DEFAULT_BYPASS;
 
-fn format_bypass(use_default: bool, custom_bypass: &str) -> String {
+pub(super) fn format_bypass(use_default: bool, custom_bypass: &str) -> String {
     if custom_bypass.is_empty() {
         DEFAULT_BYPASS.into()
     } else if use_default {
@@ -361,7 +359,7 @@ impl Sysopt {
             }
         }
         while self.access_guard().read().get_state().is_pendding() {
-            tokio::task::yield_now().await;
+            tokio::time::sleep(Duration::from_millis(10)).await;
         }
         // `start()` false may also mean a guard was already running.
         !self.access_guard().read().get_state().is_stopped()
@@ -409,18 +407,21 @@ impl Sysopt {
     /// configuration instead of a partially-applied one (e.g. SOCKS already
     /// disabled but HTTP still enabled mid-transition).
     pub(crate) async fn wait_idle(&self) {
-        let _ = self.update_lock.lock().await;
+        let _ = self.proxy_state_lock.lock().await;
     }
 
     /// init the sysproxy
+    #[allow(
+        clippy::significant_drop_tightening,
+        reason = "the proxy state lock must stay held until the OS write finishes; wait_idle relies on it"
+    )]
     pub(super) async fn update_sysproxy(&self) -> Result<()> {
-        let _lock = self.update_lock.lock().await;
+        let mut proxy_state = self.proxy_state_lock.lock().await;
         let verge = Config::verge().await.latest_arc();
         // Configured, not live: this runs while the Core is being started or restarted, and
         // asking a Core that is not up yet would only fall back here anyway.
         let port = MixedPort::desired().await;
         let pac_port = server::embedded_server_port()?;
-        // 先 await, 避免持有锁导致的 Send 问题
         let bypass = get_bypass().await;
 
         let (sys_enable, pac_enable, proxy_host, proxy_guard) = (
@@ -431,7 +432,7 @@ impl Sysopt {
         );
 
         let (sys, auto, guard_type) = {
-            let (sys, auto) = &mut *self.inner_proxy.write();
+            let (sys, auto) = &mut *proxy_state;
             sys.host = proxy_host.into();
             sys.port = port;
             sys.bypass = bypass.into();
@@ -528,6 +529,10 @@ impl Sysopt {
     }
 
     /// reset the sysproxy
+    #[allow(
+        clippy::significant_drop_tightening,
+        reason = "the proxy state lock must stay held until the disable finishes; wait_idle relies on it"
+    )]
     pub(super) async fn reset_sysproxy(&self) -> Result<()> {
         if self
             .reset_sysproxy
@@ -539,13 +544,13 @@ impl Sysopt {
         defer! {
             self.reset_sysproxy.store(false, Ordering::SeqCst);
         }
-        let _lock = self.update_lock.lock().await;
+        let mut proxy_state = self.proxy_state_lock.lock().await;
         let _guard_operation = self.guard_operation_lock.lock().await;
         let drained = self.stop_proxy_guard_locked().await;
 
         // 直接关闭所有代理
         let (sys, auto) = {
-            let (sys, auto) = &mut *self.inner_proxy.write();
+            let (sys, auto) = &mut *proxy_state;
             sys.enable = false;
             auto.enable = false;
             (sys.clone(), auto.clone())

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

@@ -636,7 +636,8 @@ async fn create_tray_menu(
         .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 include_proxy_groups =
+        options.include_proxy_groups && verge_settings.tray_proxy_groups_display_mode.as_deref() != Some("disable");
 
     let proxy_group_order_map = runtime_proxy_groups_order;
 

src-tauri/src/core/updater.rs

@@ -18,6 +18,14 @@ pub struct SilentUpdater {
     background_cancel: Mutex<Option<CancellationToken>>,
 }
 
+#[derive(Serialize, specta::Type)]
+#[serde(rename_all = "snake_case")]
+pub enum InstallUpdateOutcome {
+    Installed,
+    Cancelled,
+    UpdateChanged,
+}
+
 singleton!(SilentUpdater, SILENT_UPDATER);
 
 impl SilentUpdater {
@@ -34,7 +42,7 @@ impl SilentUpdater {
     }
 }
 
-#[derive(Serialize, Deserialize, specta::Type)]
+#[derive(Serialize, Deserialize)]
 struct UpdateCacheMeta {
     version: String,
     downloaded_at: String,
@@ -101,11 +109,11 @@ impl SilentUpdater {
     }
 
     /// Returns the cached installer for `update`, deleting a cache that does not match it.
-    fn verified_cache(app_handle: &tauri::AppHandle, update: &Update) -> Option<Vec<u8>> {
+    fn verified_cache(update: &Update) -> Option<Vec<u8>> {
         let meta = Self::read_cache_meta().ok()?;
         let bytes = if meta.version == update.version {
             Self::read_cache_bytes().and_then(|bytes| {
-                verify_signature(app_handle, &bytes, &update.signature, &update.version)?;
+                update.verify(&bytes)?;
                 Ok(bytes)
             })
         } else {
@@ -127,46 +135,6 @@ impl SilentUpdater {
     }
 }
 
-/// The cache directory is user-writable and feeds an elevated installer, so it is re-verified
-/// with the same rules `Update::download` applies.
-fn verify_signature(app_handle: &tauri::AppHandle, bytes: &[u8], signature: &str, version: &str) -> Result<()> {
-    use base64::Engine as _;
-
-    let decode = |value: &str| -> Result<String> {
-        Ok(String::from_utf8(
-            base64::engine::general_purpose::STANDARD.decode(value)?,
-        )?)
-    };
-    let config: tauri_plugin_updater::Config = serde_json::from_value(
-        app_handle
-            .config()
-            .plugins
-            .0
-            .get("updater")
-            .cloned()
-            .context("updater is not configured")?,
-    )?;
-
-    let public_key = minisign_verify::PublicKey::decode(&decode(&config.pubkey)?)?;
-    let signature = minisign_verify::Signature::decode(&decode(signature)?)?;
-    public_key
-        .verify(bytes, &signature, true)
-        .context("signature mismatch")?;
-
-    match signature
-        .trusted_comment()
-        .split('\t')
-        .find_map(|field| field.strip_prefix("version:"))
-    {
-        Some(signed) => anyhow::ensure!(
-            signed.trim_start_matches('v') == version,
-            "signed for v{signed}, not v{version}"
-        ),
-        None => anyhow::ensure!(!config.require_signed_version, "signature carries no version"),
-    }
-    Ok(())
-}
-
 pub fn is_build_to_stable(current: &str, remote: &str) -> bool {
     let Some((base, build)) = current.trim_start_matches('v').split_once('+') else {
         return false;
@@ -391,7 +359,7 @@ impl SilentUpdater {
             }
         };
 
-        let Some(bytes) = Self::verified_cache(app_handle, &update) else {
+        let Some(bytes) = Self::verified_cache(&update) else {
             return false;
         };
 
@@ -424,13 +392,13 @@ impl SilentUpdater {
     }
 
     /// Installs `version` for the update dialog, reusing the cache when it holds that version;
-    /// `false` when cancelled before the installer starts.
+    /// A changed offer must be confirmed again before downloading or installing it.
     pub async fn install_update(
         &self,
         app_handle: &tauri::AppHandle,
         version: &str,
         on_event: impl Fn(DownloadEvent) + Sync,
-    ) -> Result<bool> {
+    ) -> Result<InstallUpdateOutcome> {
         let cancel = CancellationToken::new();
         *self.manual_cancel.lock() = Some(cancel.clone());
         let prepared = tokio::select! {
@@ -440,31 +408,36 @@ impl SilentUpdater {
         // `cancel_download` cancels under the lock, so once the token is taken back its state is
         // final; a cancel during the last synchronous poll of `prepare_install` still wins.
         self.manual_cancel.lock().take();
-        let Some((update, bytes)) = prepared.filter(|_| !cancel.is_cancelled()).transpose()? else {
+        let Some(prepared) = prepared.filter(|_| !cancel.is_cancelled()).transpose()? else {
             logging!(info, Type::System, "Update v{version} cancelled");
-            return Ok(false);
+            return Ok(InstallUpdateOutcome::Cancelled);
+        };
+        let Some((update, bytes)) = prepared else {
+            return Ok(InstallUpdateOutcome::UpdateChanged);
         };
 
         logging!(info, Type::System, "Installing update v{version}...");
         Self::install(update, bytes).await?;
         Self::delete_cache();
-        Ok(true)
+        Ok(InstallUpdateOutcome::Installed)
     }
 
     async fn prepare_install(
         app_handle: &tauri::AppHandle,
         version: &str,
         on_event: impl Fn(DownloadEvent) + Sync,
-    ) -> Result<(Update, Vec<u8>)> {
-        let update = Self::check(app_handle)
+    ) -> Result<Option<(Update, Vec<u8>)>> {
+        let Some(update) = Self::check(app_handle)
             .await?
             .filter(|update| update.version == version)
-            .with_context(|| format!("v{version} is no longer offered"))?;
-        let bytes = match Self::verified_cache(app_handle, &update) {
+        else {
+            return Ok(None);
+        };
+        let bytes = match Self::verified_cache(&update) {
             Some(bytes) => bytes,
             None => download(&update, on_event).await?,
         };
-        Ok((update, bytes))
+        Ok(Some((update, bytes)))
     }
 
     pub fn cancel_download(&self) {
@@ -641,7 +614,7 @@ impl SilentUpdater {
             return Ok(());
         }
 
-        if Self::verified_cache(app_handle, &update).is_some() {
+        if Self::verified_cache(&update).is_some() {
             logging!(info, Type::System, "Silent updater: v{version} already cached");
         } else {
             logging!(info, Type::System, "Silent updater: downloading v{version}...");

src-tauri/src/core/win_uwp.rs

@@ -1,10 +1,7 @@
 #![cfg(target_os = "windows")]
 
-use crate::utils::dirs;
+use crate::{core::service, utils::dirs};
 use anyhow::{Result, bail};
-use deelevate::{PrivilegeLevel, Token};
-use runas::Command as RunasCommand;
-use std::process::Command as StdCommand;
 
 pub fn invoke_uwptools() -> Result<()> {
     let resource_dir = dirs::app_resources_dir()?;
@@ -14,13 +11,7 @@ pub fn invoke_uwptools() -> Result<()> {
         bail!("enableLoopback exe not found");
     }
 
-    let token = Token::with_current_process()?;
-    let level = token.privilege_level()?;
-
-    match level {
-        PrivilegeLevel::NotPrivileged => RunasCommand::new(tool_path).status()?,
-        _ => StdCommand::new(tool_path).status()?,
-    };
+    service::run_maybe_elevated(&tool_path, false)?;
 
     Ok(())
 }

src-tauri/src/enhance/builtin/meta_guard.js

@@ -1,8 +0,0 @@
-// This function is exported for use by the Clash core
-// eslint-disable-next-line unused-imports/no-unused-vars
-function main(config, _name) {
-  if (config.mode === 'script') {
-    config.mode = 'rule'
-  }
-  return config
-}

src-tauri/src/enhance/builtin/meta_hy_alpn.js

@@ -1,12 +0,0 @@
-// This function is exported for use by the Clash core
-// eslint-disable-next-line unused-imports/no-unused-vars
-function main(config, _name) {
-  if (Array.isArray(config.proxies)) {
-    config.proxies.forEach((p, i) => {
-      if (p.type === 'hysteria' && typeof p.alpn === 'string') {
-        config.proxies[i].alpn = [p.alpn]
-      }
-    })
-  }
-  return config
-}

src-tauri/src/enhance/chain.rs

@@ -22,12 +22,6 @@ pub enum ChainType {
     Groups(SeqMap),
 }
 
-#[derive(Debug, Clone)]
-pub enum ChainSupport {
-    ClashMeta,
-    ClashMetaAlpha,
-}
-
 // Helper trait to allow async conversion
 pub trait AsyncChainItemFrom {
     async fn from_async(item: &PrfItem) -> Option<ChainItem>;
@@ -53,70 +47,16 @@ impl AsyncChainItemFrom for Option<ChainItem> {
                 uid,
                 data: ChainType::Merge(help::read_mapping(&path).await.ok()?),
             }),
-            "rules" => {
+            "rules" | "proxies" | "groups" => {
                 let seq_map = help::read_yaml::<SeqMap>(&path).await.ok()?;
-                Some(ChainItem {
-                    uid,
-                    data: ChainType::Rules(seq_map),
-                })
-            }
-            "proxies" => {
-                let seq_map = help::read_yaml::<SeqMap>(&path).await.ok()?;
-                Some(ChainItem {
-                    uid,
-                    data: ChainType::Proxies(seq_map),
-                })
-            }
-            "groups" => {
-                let seq_map = help::read_yaml::<SeqMap>(&path).await.ok()?;
-                Some(ChainItem {
-                    uid,
-                    data: ChainType::Groups(seq_map),
-                })
+                let data = match itype {
+                    "rules" => ChainType::Rules(seq_map),
+                    "proxies" => ChainType::Proxies(seq_map),
+                    _ => ChainType::Groups(seq_map),
+                };
+                Some(ChainItem { uid, data })
             }
             _ => None,
         }
     }
 }
-impl ChainItem {
-    /// 内建支持一些脚本
-    pub fn builtin() -> Vec<(ChainSupport, Self)> {
-        // meta 的一些处理
-        let meta_guard = Self::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
-
-        // meta 1.13.2 alpn string 转 数组
-        let hy_alpn = Self::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
-
-        // meta 的一些处理
-        let meta_guard_alpha = Self::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
-
-        // meta 1.13.2 alpn string 转 数组
-        let hy_alpn_alpha = Self::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
-
-        vec![
-            (ChainSupport::ClashMeta, hy_alpn),
-            (ChainSupport::ClashMeta, meta_guard),
-            (ChainSupport::ClashMetaAlpha, hy_alpn_alpha),
-            (ChainSupport::ClashMetaAlpha, meta_guard_alpha),
-        ]
-    }
-
-    pub fn to_script<U: Into<String>, D: Into<String>>(uid: U, data: D) -> Self {
-        Self {
-            uid: uid.into(),
-            data: ChainType::Script(data.into()),
-        }
-    }
-}
-
-impl ChainSupport {
-    pub fn is_support(&self, core: Option<&String>) -> bool {
-        match core {
-            Some(core) => matches!(
-                (self, core.as_str()),
-                (Self::ClashMeta, "verge-mihomo") | (Self::ClashMetaAlpha, "verge-mihomo-alpha")
-            ),
-            None => true,
-        }
-    }
-}

src-tauri/src/enhance/field.rs

@@ -27,7 +27,7 @@ fn lowercase_key(key: &str) -> Value {
 pub fn use_lowercase(config: &Mapping) -> Mapping {
     let mut lowercased = Mapping::new();
 
-    for (key, value) in config.into_iter() {
+    for (key, value) in config.iter() {
         if let Some(key_str) = key.as_str() {
             lowercased.insert(lowercase_key(key_str), value.clone());
         }
@@ -35,17 +35,6 @@ pub fn use_lowercase(config: &Mapping) -> Mapping {
     lowercased
 }
 
-pub fn use_lowercase_owned(config: Mapping) -> Mapping {
-    let mut lowercased = Mapping::new();
-
-    for (key, value) in config {
-        if let Some(key_str) = key.as_str() {
-            lowercased.insert(lowercase_key(key_str), value);
-        }
-    }
-    lowercased
-}
-
 pub fn use_sort(mut config: Mapping) -> Mapping {
     let mut sorted = Mapping::new();
     HANDLE_FIELDS.into_iter().for_each(|key| {

src-tauri/src/enhance/mod.rs

@@ -8,7 +8,7 @@ mod tun;
 
 use self::{
     chain::{AsyncChainItemFrom as _, ChainItem, ChainType},
-    field::{use_keys, use_lowercase_owned, use_sort},
+    field::{use_keys, use_lowercase, use_sort},
     merge::use_merge,
     script::use_script,
     seq::{SeqMap, use_seq},
@@ -34,7 +34,6 @@ type ResultLog = Vec<(String, String)>;
 #[derive(Debug)]
 struct ConfigValues {
     clash_config: Mapping,
-    clash_core: Option<String>,
     enable_tun: bool,
     enable_builtin: bool,
     socks_enabled: bool,
@@ -128,8 +127,7 @@ async fn get_config_values(profile_uid: &str) -> ConfigValues {
     let dns_settings = verge_arc.dns_settings_for(profile_uid);
     let dns_override_confirmation = dns_settings.confirmation;
 
-    let (clash_core, enable_tun, enable_builtin, socks_enabled, http_enabled, enable_dns_settings) = (
-        Some(verge_arc.get_valid_clash_core()),
+    let (enable_tun, enable_builtin, socks_enabled, http_enabled, enable_dns_settings) = (
         enable_tun_mode.unwrap_or(false),
         enable_builtin_enhanced.unwrap_or(true),
         verge_socks_enabled.unwrap_or(false),
@@ -148,7 +146,6 @@ async fn get_config_values(profile_uid: &str) -> ConfigValues {
 
     ConfigValues {
         clash_config,
-        clash_core,
         enable_tun,
         enable_builtin,
         socks_enabled,
@@ -199,35 +196,25 @@ async fn collect_profile_items(profiles: &IProfiles) -> Result<ProfileItems> {
 
     let name = current_item.name.clone().unwrap_or_default();
 
+    let ProfileItems {
+        merge_item: default_merge,
+        script_item: default_script,
+        rules_item: default_rules,
+        proxies_item: default_proxies,
+        groups_item: default_groups,
+        global_merge: default_global_merge,
+        global_script: default_global_script,
+        ..
+    } = ProfileItems::default();
+
     let (merge_item, script_item, rules_item, proxies_item, groups_item, global_merge, global_script) = tokio::join!(
-        chain_item_or_default(profiles.get_item(&merge_uid).ok(), || ChainItem {
-            uid: "".into(),
-            data: ChainType::Merge(Mapping::new()),
-        },),
-        chain_item_or_default(profiles.get_item(&script_uid).ok(), || ChainItem {
-            uid: "".into(),
-            data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
-        },),
-        chain_item_or_default(profiles.get_item(&rules_uid).ok(), || ChainItem {
-            uid: "".into(),
-            data: ChainType::Rules(SeqMap::default()),
-        },),
-        chain_item_or_default(profiles.get_item(&proxies_uid).ok(), || ChainItem {
-            uid: "".into(),
-            data: ChainType::Proxies(SeqMap::default()),
-        },),
-        chain_item_or_default(profiles.get_item(&groups_uid).ok(), || ChainItem {
-            uid: "".into(),
-            data: ChainType::Groups(SeqMap::default()),
-        },),
-        chain_item_or_default(profiles.get_item("Merge").ok(), || ChainItem {
-            uid: "Merge".into(),
-            data: ChainType::Merge(Mapping::new()),
-        },),
-        chain_item_or_default(profiles.get_item("Script").ok(), || ChainItem {
-            uid: "Script".into(),
-            data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
-        },),
+        chain_item_or_default(profiles.get_item(&merge_uid).ok(), || default_merge,),
+        chain_item_or_default(profiles.get_item(&script_uid).ok(), || default_script,),
+        chain_item_or_default(profiles.get_item(&rules_uid).ok(), || default_rules,),
+        chain_item_or_default(profiles.get_item(&proxies_uid).ok(), || default_proxies,),
+        chain_item_or_default(profiles.get_item(&groups_uid).ok(), || default_groups,),
+        chain_item_or_default(profiles.get_item("Merge").ok(), || default_global_merge,),
+        chain_item_or_default(profiles.get_item("Script").ok(), || default_global_script,),
     );
 
     Ok(ProfileItems {
@@ -243,16 +230,16 @@ async fn collect_profile_items(profiles: &IProfiles) -> Result<ProfileItems> {
     })
 }
 
-async fn process_global_items(
+async fn process_override_items(
     mut config: Mapping,
     mut exists_keys: Vec<String>,
     mut result_map: HashMap<String, ResultLog>,
-    global_merge: ChainItem,
-    global_script: ChainItem,
+    merge_item: ChainItem,
+    script_item: ChainItem,
     profile_name: &String,
     authoritative: &AuthoritativeFields,
 ) -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
-    if let ChainType::Merge(merge) = global_merge.data {
+    if let ChainType::Merge(merge) = merge_item.data {
         exists_keys.extend(use_keys(&merge));
         let before = authoritative.current(&config);
         config = use_merge(&merge, config);
@@ -262,11 +249,11 @@ async fn process_global_items(
             .map(discarded_note)
             .collect();
         if !notes.is_empty() {
-            result_map.entry(global_merge.uid).or_default().extend(notes);
+            result_map.entry(merge_item.uid).or_default().extend(notes);
         }
     }
 
-    if let ChainType::Script(script) = global_script.data {
+    if let ChainType::Script(script) = script_item.data {
         let before = authoritative.current(&config);
         let (res_config, changed_keys, mut logs) = use_script(script, config, profile_name.clone()).await;
         exists_keys.extend(changed_keys);
@@ -277,7 +264,7 @@ async fn process_global_items(
                 .into_iter()
                 .map(discarded_note),
         );
-        result_map.insert(global_script.uid, logs);
+        result_map.insert(script_item.uid, logs);
     }
 
     (config, exists_keys, result_map)
@@ -544,46 +531,6 @@ fn ensure_lan_bind_address(mut config: Mapping) -> Mapping {
     config
 }
 
-async fn process_profile_items(
-    mut config: Mapping,
-    mut exists_keys: Vec<String>,
-    mut result_map: HashMap<String, ResultLog>,
-    merge_item: ChainItem,
-    script_item: ChainItem,
-    profile_name: &String,
-    authoritative: &AuthoritativeFields,
-) -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
-    if let ChainType::Merge(merge) = merge_item.data {
-        exists_keys.extend(use_keys(&merge));
-        let before = authoritative.current(&config);
-        config = use_merge(&merge, config);
-        let notes: ResultLog = authoritative
-            .overridden(&before, &authoritative.current(&config))
-            .into_iter()
-            .map(discarded_note)
-            .collect();
-        if !notes.is_empty() {
-            result_map.entry(merge_item.uid).or_default().extend(notes);
-        }
-    }
-
-    if let ChainType::Script(script) = script_item.data {
-        let before = authoritative.current(&config);
-        let (res_config, changed_keys, mut logs) = use_script(script, config, profile_name.clone()).await;
-        exists_keys.extend(changed_keys);
-        config = res_config;
-        logs.extend(
-            authoritative
-                .overridden(&before, &authoritative.current(&config))
-                .into_iter()
-                .map(discarded_note),
-        );
-        result_map.insert(script_item.uid, logs);
-    }
-
-    (config, exists_keys, result_map)
-}
-
 /// Merges the app's clash config over the profile; switches are parameters to keep it pure.
 fn merge_default_config(
     mut config: Mapping,
@@ -655,25 +602,12 @@ fn merge_default_config(
     config
 }
 
-fn apply_builtin_scripts(mut config: Mapping, clash_core: Option<String>, enable_builtin: bool) -> Mapping {
+fn apply_builtin_scripts(mut config: Mapping, enable_builtin: bool) -> Mapping {
     if enable_builtin {
-        let items: Vec<_> = ChainItem::builtin()
-            .into_iter()
-            .filter(|(s, _)| s.is_support(clash_core.as_ref()))
-            .map(|(_, c)| c)
-            .collect();
-        if !items.is_empty() {
-            // The JS path saw a lowercased view; lowercase once, only when a builtin runs.
-            config = use_lowercase_owned(config);
-            for item in items {
-                logging!(debug, Type::Core, "run builtin script {}", item.uid);
-                config = match item.uid.as_str() {
-                    "verge_hy_alpn" => builtin_hy_alpn(config),
-                    "verge_meta_guard" => builtin_meta_guard(config),
-                    _ => config,
-                };
-            }
-        }
+        // The JS path saw a lowercased view; lowercase once, only when the builtin runs.
+        config = use_lowercase(&config);
+        logging!(debug, Type::Core, "run builtin script verge_hy_alpn");
+        config = builtin_hy_alpn(config);
     }
 
     config
@@ -693,14 +627,6 @@ fn builtin_hy_alpn(mut config: Mapping) -> Mapping {
     config
 }
 
-fn builtin_meta_guard(mut config: Mapping) -> Mapping {
-    if config.get("mode").and_then(Value::as_str) == Some("script") {
-        config.insert(Value::from("mode"), Value::from("rule"));
-    }
-
-    config
-}
-
 fn cleanup_proxy_groups(mut config: Mapping) -> Mapping {
     // built-in proxies docs: https://wiki.metacubex.one/config/proxies/built-in
     const BUILTIN_POLICIES: &[&str] = &["DIRECT", "REJECT", "REJECT-DROP", "PASS", "PASS-RULE"];
@@ -879,7 +805,6 @@ pub async fn enhance(
     let cfg_vals = get_config_values(profile_uid).await;
     let ConfigValues {
         clash_config,
-        clash_core,
         enable_tun,
         enable_builtin,
         socks_enabled,
@@ -929,13 +854,13 @@ pub async fn enhance(
         tproxy_enabled,
     );
 
-    let config = apply_builtin_scripts(config, clash_core, enable_builtin);
+    let config = apply_builtin_scripts(config, enable_builtin);
     let config = use_tun(config, enable_tun);
     let (config, dns_settings) = apply_dns_settings(config, enable_dns_settings).await;
 
     let authoritative = AuthoritativeFields::capture(&config, &gui_tun_keys, dns_settings);
 
-    let (config, exists_keys, result_map) = process_global_items(
+    let (config, exists_keys, result_map) = process_override_items(
         config,
         exists_keys,
         result_map,
@@ -946,7 +871,7 @@ pub async fn enhance(
     )
     .await;
 
-    let (config, exists_keys, result_map) = process_profile_items(
+    let (config, exists_keys, result_map) = process_override_items(
         config,
         exists_keys,
         result_map,
@@ -1428,7 +1353,7 @@ mod authoritative_field_tests {
 mod tests {
     use super::{
         AuthoritativeFields, ChainItem, ChainType, Mapping, cleanup_proxy_groups, ensure_lan_bind_address,
-        process_global_items, process_profile_items, use_keys,
+        process_override_items, use_keys,
     };
     use std::collections::HashMap;
 
@@ -1476,22 +1401,28 @@ mod tests {
                 data: ChainType::Merge(merge.clone()),
             };
             let profile_name = "test-profile".into();
-            let (config, keys, logs) = process_global_items(
+            let (config, keys, logs) = process_override_items(
                 config,
                 vec![],
                 HashMap::new(),
                 merge_item("global-merge"),
-                ChainItem::to_script("global-script", script),
+                ChainItem {
+                    uid: "global-script".into(),
+                    data: ChainType::Script(script.into()),
+                },
                 &profile_name,
                 &authoritative,
             )
             .await;
-            let (config, _, logs) = process_profile_items(
+            let (config, _, logs) = process_override_items(
                 config,
                 keys,
                 logs,
                 merge_item("profile-merge"),
-                ChainItem::to_script("profile-script", script),
+                ChainItem {
+                    uid: "profile-script".into(),
+                    data: ChainType::Script(script.into()),
+                },
                 &profile_name,
                 &authoritative,
             )
@@ -1536,16 +1467,19 @@ mod tests {
                    nested: {winner: global-merge}, dns: {enable: false}, tun: {enable: false}}",
             )),
         };
-        let global_script = ChainItem::to_script(
-            "Script",
-            r#"function main(config) {
+        let global_script = ChainItem {
+            uid: "Script".into(),
+            data: ChainType::Script(
+                r#"function main(config) {
               config["global-script-wins"] = "global-script";
               config["profile-merge-wins"] = "global-script";
               config["profile-script-wins"] = "global-script";
               config.nested.winner = "global-script";
               return config;
-            }"#,
-        );
+            }"#
+                .into(),
+            ),
+        };
         let profile_merge = ChainItem {
             uid: "profile-merge".into(),
             data: ChainType::Merge(mapping(
@@ -1553,18 +1487,21 @@ mod tests {
                    nested: {winner: profile-merge}}",
             )),
         };
-        let profile_script = ChainItem::to_script(
-            "profile-script",
-            r#"function main(config) {
+        let profile_script = ChainItem {
+            uid: "profile-script".into(),
+            data: ChainType::Script(
+                r#"function main(config) {
               config["profile-script-wins"] = "profile-script";
               config.nested.winner = "profile-script";
               return config;
-            }"#,
-        );
+            }"#
+                .into(),
+            ),
+        };
 
         let profile_name = "test-profile".into();
         let authoritative = AuthoritativeFields::capture(&config, &[], Mapping::new());
-        let (config, exists_keys, result_map) = process_global_items(
+        let (config, exists_keys, result_map) = process_override_items(
             config,
             exists_keys,
             HashMap::new(),
@@ -1574,7 +1511,7 @@ mod tests {
             &authoritative,
         )
         .await;
-        let (config, exists_keys, _) = process_profile_items(
+        let (config, exists_keys, _) = process_override_items(
             config,
             exists_keys,
             result_map,

src-tauri/src/enhance/script.rs

@@ -1,6 +1,6 @@
 use crate::{process::AsyncHandler, utils::tmpl};
 
-use super::field::{use_lowercase, use_lowercase_owned};
+use super::field::use_lowercase;
 use anyhow::{Error, Result};
 use boa_engine::{Context, JsString, JsValue, Source, js_string, native_function::NativeFunction, property::Attribute};
 use clash_verge_logging::{Type, logging};
@@ -22,7 +22,7 @@ type EvalOutcome = (Result<Mapping, std::string::String>, Vec<(String, String)>)
 pub(super) async fn use_script(script: String, config: Mapping, name: String) -> ScriptResult {
     // The template is identity-plus-lowercasing; skip the Boa round-trip.
     if script == tmpl::ITEM_SCRIPT {
-        return (use_lowercase_owned(config), vec![], vec![]);
+        return (use_lowercase(&config), vec![], vec![]);
     }
 
     let json = match serde_json::to_string(&use_lowercase(&config)) {
@@ -173,7 +173,7 @@ fn eval_script(script: &str, config_json: &str, name: &String) -> EvalOutcome {
     }
 
     match parse_json_safely(&result) {
-        Ok(config) => (Ok(use_lowercase_owned(config)), outputs.lock().to_vec()),
+        Ok(config) => (Ok(use_lowercase(&config)), outputs.lock().to_vec()),
         Err(err) => {
             logging!(
                 error,

src-tauri/src/enhance/tun.rs

@@ -28,7 +28,7 @@ pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
             .and_then(|v| v.as_str())
             .unwrap_or("fake-ip");
 
-        if current_mode == "fake-ip" || !dns_val.contains_key(Value::from("enhanced-mode")) {
+        if current_mode == "fake-ip" {
             revise!(dns_val, "enable", true);
             revise!(dns_val, "ipv6", ipv6_val);
 

src-tauri/src/feat/backup.rs

@@ -33,6 +33,8 @@ async fn finalize_restored_verge_config(
     webdav_username: Option<String>,
     webdav_password: Option<String>,
 ) -> Result<()> {
+    let config_write = Config::lock_config_write().await;
+
     // A broken restored `verge.yaml` is a restore failure, not a reason to load defaults.
     let mut restored = help::read_yaml::<IVerge>(&verge_path()?).await?;
     restored.webdav_url = webdav_url;
@@ -43,43 +45,42 @@ async fn finalize_restored_verge_config(
     let restored_clash = IClashTemp::new().await;
     let clash_draft = Config::clash().await;
     clash_draft.edit_draft(|d| {
-        *d = restored_clash.clone();
+        *d = restored_clash;
     });
     clash_draft.apply();
 
     let restored_profiles = IProfiles::new().await;
     let profiles_draft = Config::profiles().await;
     profiles_draft.edit_draft(|d| {
-        *d = restored_profiles.clone();
+        *d = restored_profiles;
     });
     profiles_draft.apply();
 
     let verge_draft = Config::verge().await;
-    {
-        // Hold the write lock so a concurrent patch cannot stage a draft the proxy write reads.
-        let _config_write = Config::lock_config_write().await;
-        verge_draft.edit_draft(|d| {
-            *d = restored.clone();
-        });
-        verge_draft.apply();
+    verge_draft.edit_draft(|d| {
+        *d = restored.clone();
+    });
+    verge_draft.apply();
 
-        // Turn it off here; a failing core side effect below would otherwise skip this step.
-        if !restored.enable_system_proxy.unwrap_or_default() {
-            let result = async {
-                let _lifecycle = CoreManager::global().lifecycle_lock.lock().await;
-                proxy_control::apply().await?;
-                proxy_control::refresh_guard().await
-            }
-            .await;
-            if let Err(err) = result {
-                logging!(error, Type::Backup, "Failed to turn the system proxy off: {err:#}");
-                if SystemProxyStateUnknown::is_in(&err) {
-                    return Err(err);
-                }
+    // Turn it off here; a failing core side effect below would otherwise skip this step.
+    if !restored.enable_system_proxy.unwrap_or_default() {
+        let result = async {
+            let _lifecycle = CoreManager::global().lifecycle_lock.lock().await;
+            proxy_control::apply().await?;
+            proxy_control::refresh_guard().await
+        }
+        .await;
+        if let Err(err) = result {
+            logging!(error, Type::Backup, "Failed to turn the system proxy off: {err:#}");
+            if SystemProxyStateUnknown::is_in(&err) {
+                return Err(err);
             }
         }
     }
 
+    // `patch_verge` re-acquires the configuration write lock.
+    drop(config_write);
+
     // Run configuration side effects without rewriting the already-restored file.
     if let Err(err) = super::patch_verge(&restored, true).await {
         logging!(error, Type::Backup, "Failed to apply restored verge config: {err:#}");
@@ -133,14 +134,34 @@ pub async fn delete_webdav_backup(filename: String) -> Result<()> {
     })
 }
 
+/// Backup creation strips the WebDAV credentials, so the live ones are kept.
+async fn restore_backup_archive(path: PathBuf) -> Result<()> {
+    let (webdav_url, webdav_username, webdav_password) = {
+        let verge = Config::verge().await;
+        let verge = verge.latest_arc();
+        (
+            verge.webdav_url.clone(),
+            verge.webdav_username.clone(),
+            verge.webdav_password.clone(),
+        )
+    };
+
+    let home_dir = app_home_dir()?;
+    AsyncHandler::spawn_blocking(move || -> Result<()> {
+        let file = std::fs::File::open(&path)?;
+        let mut zip = zip::ZipArchive::new(file)?;
+        zip.extract(&home_dir)?;
+        Ok(())
+    })
+    .await
+    .map_err(|join| anyhow!("backup extraction task failed: {join}"))??;
+
+    let _profile_write = crate::config::profiles::PROFILE_WRITE_LOCK.lock().await;
+    finalize_restored_verge_config(webdav_url, webdav_username, webdav_password).await
+}
+
 #[tracing::instrument(skip_all, level = "info", fields(filename = %filename))]
 pub async fn restore_webdav_backup(filename: String) -> Result<()> {
-    let verge = Config::verge().await;
-    let verge_data = verge.latest_arc();
-    let webdav_url = verge_data.webdav_url.clone();
-    let webdav_username = verge_data.webdav_username.clone();
-    let webdav_password = verge_data.webdav_password.clone();
-
     let backup_storage_path = app_home_dir()
         .map_err(|e| anyhow::anyhow!("Failed to get app home dir: {e}"))?
         .join(filename.as_str());
@@ -157,12 +178,7 @@ pub async fn restore_webdav_backup(filename: String) -> Result<()> {
             err
         })?;
 
-    let value = backup_storage_path.clone();
-    let file = AsyncHandler::spawn_blocking(move || std::fs::File::open(&value)).await??;
-    let mut zip = zip::ZipArchive::new(file)?;
-    let _profile_write = crate::config::profiles::PROFILE_WRITE_LOCK.lock().await;
-    zip.extract(app_home_dir()?)?;
-    let res = finalize_restored_verge_config(webdav_url, webdav_username, webdav_password).await;
+    let res = restore_backup_archive(backup_storage_path.clone()).await;
     let _ = backup_storage_path.remove_if_exists().await;
     res
 }
@@ -331,22 +347,7 @@ pub async fn restore_local_backup(filename: String) -> Result<()> {
         return Err(anyhow!("Backup file not found: {}", filename));
     }
 
-    let (webdav_url, webdav_username, webdav_password) = {
-        let verge = Config::verge().await;
-        let verge = verge.latest_arc();
-        (
-            verge.webdav_url.clone(),
-            verge.webdav_username.clone(),
-            verge.webdav_password.clone(),
-        )
-    };
-
-    let file = AsyncHandler::spawn_blocking(move || std::fs::File::open(&target_path)).await??;
-    let mut zip = zip::ZipArchive::new(file)?;
-    let _profile_write = crate::config::profiles::PROFILE_WRITE_LOCK.lock().await;
-    zip.extract(app_home_dir()?)?;
-    finalize_restored_verge_config(webdav_url, webdav_username, webdav_password).await?;
-    Ok(())
+    restore_backup_archive(target_path).await
 }
 
 #[tracing::instrument(skip_all, level = "info", fields(filename = %filename, destination = %destination))]

src-tauri/src/feat/clash.rs

@@ -3,7 +3,7 @@ use crate::core::notify::{Refresh, announce};
 use crate::{
     config::{Config, MixedPort},
     core::{CoreManager, handle, tray},
-    feat::clean_async,
+    feat::run_exit_cleanup_flow,
     process::AsyncHandler,
     utils,
 };
@@ -14,15 +14,8 @@ use smartstring::alias::String;
 use std::sync::{Arc, LazyLock};
 
 #[allow(clippy::expect_used)]
-static TLS_CONFIG: LazyLock<Arc<rustls::ClientConfig>> = LazyLock::new(|| {
-    let root_store = rustls::RootCertStore::from_iter(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
-    let config = rustls::ClientConfig::builder_with_provider(Arc::new(rustls::crypto::ring::default_provider()))
-        .with_safe_default_protocol_versions()
-        .expect("Failed to set TLS versions")
-        .with_root_certificates(root_store)
-        .with_no_client_auth();
-    Arc::new(config)
-});
+static TLS_CONFIG: LazyLock<Arc<rustls::ClientConfig>> =
+    LazyLock::new(|| Arc::new(utils::network::build_webpki_rooted_tls_config().expect("Failed to set TLS versions")));
 
 pub async fn restart_clash_core() {
     match CoreManager::global().restart_core().await {
@@ -38,38 +31,9 @@ pub async fn restart_clash_core() {
 
 pub async fn restart_app() {
     logging!(debug, Type::System, "启动重启应用流程");
-    handle::Handle::global().set_is_exiting();
-
-    Config::apply_all_and_save_file().await;
-
-    let cleanup_result = clean_async().await;
-
-    logging!(
-        info,
-        Type::System,
-        "资源清理完成，退出代码: {}",
-        if cleanup_result.all_success { 0 } else { 1 }
-    );
+    let cleanup_result = run_exit_cleanup_flow(NoticeStatus::AppRestartCoreStopFailed).await;
 
     if !cleanup_result.core_stopped {
-        handle::Handle::global().clear_is_exiting();
-        // A failed stop may still have marked the core stopped, and exit cleanup skipped the DNS restore.
-        // A core that kept running keeps its DNS, whatever an unapplied config draft says.
-        #[cfg(target_os = "macos")]
-        {
-            let manager = CoreManager::global();
-            let _lifecycle = manager.lifecycle_lock.lock().await;
-            if matches!(
-                *manager.get_running_mode(),
-                crate::core::manager::RunningMode::NotRunning
-            ) {
-                crate::utils::resolve::dns::sync_public_dns().await;
-            }
-        }
-        handle::Handle::notice(
-            NoticeStatus::AppRestartCoreStopFailed,
-            cleanup_result.stop_error.unwrap_or_default(),
-        );
         return;
     }
 
@@ -103,11 +67,13 @@ pub async fn change_clash_mode(mode: String) -> Result<(), String> {
     }
 
     let clash = Config::clash().await;
-    clash.edit_draft(|d| d.patch_config(&mapping));
-    clash.apply();
-
-    let clash_data = clash.data_arc();
-    if clash_data.save_config().await.is_ok() {
+    let save_result = {
+        let _config_write = Config::lock_config_write().await;
+        clash.edit_draft(|d| d.patch_config(&mapping));
+        clash.apply();
+        clash.data_arc().save_config().await
+    };
+    if save_result.is_ok() {
         announce(Refresh::Clash);
         tray::Tray::global().update_menu_and_icon().await;
     }

src-tauri/src/feat/profile.rs

@@ -47,26 +47,11 @@ pub async fn switch_proxy_node(group_name: &str, proxy_name: &str) {
             record_switched_node(group_name, proxy_name).await;
             announce(Refresh::Proxies);
             let _ = tray::Tray::global().update_menu().await;
-            return;
         }
         Err(err) => {
             logging!(error, Type::Tray, "切换代理失败: {err:?}");
         }
     }
-
-    match handle::Handle::mihomo()
-        .select_node_for_group(group_name, proxy_name)
-        .await
-    {
-        Ok(_) => {
-            logging!(info, Type::Tray, "代理切换回退成功: {} -> {}", group_name, proxy_name);
-            record_switched_node(group_name, proxy_name).await;
-            let _ = tray::Tray::global().update_menu().await;
-        }
-        Err(err) => {
-            logging!(error, Type::Tray, "代理切换最终失败: {err:?}");
-        }
-    }
 }
 
 async fn should_update_profile(uid: &String, ignore_auto_update: bool) -> Result<Option<(String, Option<PrfOption>)>> {

src-tauri/src/feat/window.rs

@@ -130,9 +130,7 @@ pub async fn open_or_close_dashboard() {
     logging!(info, Type::Window, "Window toggle result: {result:?}");
 }
 
-pub async fn quit() {
-    logging!(debug, Type::System, "启动退出流程");
-    // 设置退出标志
+pub(crate) async fn run_exit_cleanup_flow(stop_failed_notice: NoticeStatus) -> CleanupResult {
     handle::Handle::global().set_is_exiting();
 
     Config::apply_all_and_save_file().await;
@@ -162,11 +160,18 @@ pub async fn quit() {
             }
         }
         handle::Handle::notice(
-            NoticeStatus::AppQuitCoreStopFailed,
-            cleanup_result.stop_error.unwrap_or_default(),
+            stop_failed_notice,
+            cleanup_result.stop_error.clone().unwrap_or_default(),
         );
     }
 
+    cleanup_result
+}
+
+pub async fn quit() {
+    logging!(debug, Type::System, "启动退出流程");
+    let cleanup_result = run_exit_cleanup_flow(NoticeStatus::AppQuitCoreStopFailed).await;
+
     utils::server::shutdown_embedded_server();
     let app_handle = handle::Handle::app_handle();
     app_handle.exit(if cleanup_result.all_success { 0 } else { 1 });

src-tauri/src/utils/init.rs

@@ -354,7 +354,6 @@ pub(super) async fn init_dns_config() -> Result<()> {
                 Value::String("*.arpa".into()),
                 Value::String("time.*.com".into()),
                 Value::String("ntp.*.com".into()),
-                Value::String("time.*.com".into()),
                 Value::String("+.market.xiaomi.com".into()),
                 Value::String("localhost.ptlogin2.qq.com".into()),
                 Value::String("*.msftncsi.com".into()),
@@ -509,11 +508,9 @@ pub async fn init_resources() -> Result<()> {
     let app_dir = dirs::app_home_dir()?;
     let res_dir = dirs::app_resources_dir()?;
 
-    if !app_dir.exists() {
-        std::mem::drop(fs::create_dir_all(&app_dir).await);
-    }
+    // app_home is created by `ensure_directories` in `init_config`, which always runs first.
     if !res_dir.exists() {
-        std::mem::drop(fs::create_dir_all(&res_dir).await);
+        fs::create_dir_all(&res_dir).await?;
     }
 
     let file_list = ["Country.mmdb", "ASN.mmdb", "geoip.dat", "geosite.dat"];

src-tauri/src/utils/network.rs

@@ -48,6 +48,17 @@ enum TlsRootMode {
     StaticWebpkiRoots,
 }
 
+/// ALPN stays unset: raw TLS connectors offer none, while reqwest needs the h2 offer.
+pub(crate) fn build_webpki_rooted_tls_config() -> Result<rustls::ClientConfig> {
+    let root_store = rustls::RootCertStore::from_iter(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
+    let config = rustls::ClientConfig::builder_with_provider(Arc::new(rustls::crypto::ring::default_provider()))
+        .with_safe_default_protocol_versions()?
+        .with_root_certificates(root_store)
+        .with_no_client_auth();
+
+    Ok(config)
+}
+
 pub struct NetworkManager;
 
 impl NetworkManager {
@@ -102,13 +113,7 @@ impl NetworkManager {
     }
 
     fn build_static_webpki_tls_config() -> Result<rustls::ClientConfig> {
-        let root_store = rustls::RootCertStore::from_iter(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
-        let mut config =
-            rustls::ClientConfig::builder_with_provider(Arc::new(rustls::crypto::ring::default_provider()))
-                .with_safe_default_protocol_versions()?
-                .with_root_certificates(root_store)
-                .with_no_client_auth();
-
+        let mut config = build_webpki_rooted_tls_config()?;
         config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
 
         Ok(config)
@@ -155,6 +160,23 @@ impl NetworkManager {
         detail.contains("protocolversion") || detail.contains("protocol version")
     }
 
+    /// `allow_fallback` stays false when the caller already disabled certificate verification.
+    async fn request_with_static_webpki_fallback<T, F, Fut>(allow_fallback: bool, mut request: F) -> Result<T>
+    where
+        F: FnMut(TlsRootMode) -> Fut,
+        Fut: std::future::Future<Output = Result<T>>,
+    {
+        match request(TlsRootMode::PlatformVerifier).await {
+            Ok(value) => Ok(value),
+            Err(err) if allow_fallback && Self::should_retry_with_static_webpki_roots(&err) => {
+                request(TlsRootMode::StaticWebpkiRoots).await.map_err(|fallback_err| {
+                    fallback_err.context("static webpki roots fallback failed after platform TLS verifier failed")
+                })
+            }
+            Err(err) => Err(err),
+        }
+    }
+
     async fn get_with_tls_mode(
         &self,
         url: &str,
@@ -264,34 +286,21 @@ impl NetworkManager {
         user_agent: Option<String>,
         accept_invalid_certs: bool,
     ) -> Result<HttpResponse> {
-        let platform_result = self
-            .get_with_tls_mode(
-                url,
-                proxy_type,
-                timeout_secs,
-                user_agent.clone(),
-                accept_invalid_certs,
-                TlsRootMode::PlatformVerifier,
-            )
-            .await;
-
-        match platform_result {
-            Ok(response) => Ok(response),
-            Err(err) if !accept_invalid_certs && Self::should_retry_with_static_webpki_roots(&err) => self
-                .get_with_tls_mode(
+        Self::request_with_static_webpki_fallback(!accept_invalid_certs, |tls_root_mode| {
+            let user_agent = user_agent.clone();
+            async move {
+                self.get_with_tls_mode(
                     url,
                     proxy_type,
                     timeout_secs,
                     user_agent,
                     accept_invalid_certs,
-                    TlsRootMode::StaticWebpkiRoots,
+                    tls_root_mode,
                 )
                 .await
-                .map_err(|fallback_err| {
-                    fallback_err.context("static webpki roots fallback failed after platform TLS verifier failed")
-                }),
-            Err(err) => Err(err),
-        }
+            }
+        })
+        .await
     }
 
     async fn get_bytes_with_tls_mode(
@@ -340,19 +349,10 @@ impl NetworkManager {
         timeout_secs: Option<u64>,
         max_bytes: usize,
     ) -> Result<Vec<u8>> {
-        let platform_result = self
-            .get_bytes_with_tls_mode(url, proxy_type, timeout_secs, max_bytes, TlsRootMode::PlatformVerifier)
-            .await;
-
-        match platform_result {
-            Ok(body) => Ok(body),
-            Err(err) if Self::should_retry_with_static_webpki_roots(&err) => self
-                .get_bytes_with_tls_mode(url, proxy_type, timeout_secs, max_bytes, TlsRootMode::StaticWebpkiRoots)
+        Self::request_with_static_webpki_fallback(true, |tls_root_mode| async move {
+            self.get_bytes_with_tls_mode(url, proxy_type, timeout_secs, max_bytes, tls_root_mode)
                 .await
-                .map_err(|fallback_err| {
-                    fallback_err.context("static webpki roots fallback failed after platform TLS verifier failed")
-                }),
-            Err(err) => Err(err),
-        }
+        })
+        .await
     }
 }

src-tauri/src/utils/resolve/mod.rs

@@ -1,8 +1,6 @@
 use crate::core::notify::NoticeStatus;
 use std::sync::atomic::{AtomicBool, Ordering};
 
-use anyhow::Result;
-
 use crate::{
     config::Config,
     core::{
@@ -97,18 +95,6 @@ async fn resolve_setup() {
     resolve_done();
 }
 
-pub async fn resolve_reset_async() -> Result<(), anyhow::Error> {
-    CoreManager::global().stop_core().await?;
-
-    #[cfg(target_os = "macos")]
-    {
-        use dns::restore_public_dns;
-        restore_public_dns().await?;
-    }
-
-    Ok(())
-}
-
 fn init_scheme() {
     logging_error!(Type::Setup, init::init_scheme());
 }

src-tauri/tauri.conf.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.5.10",
+  "version": "2.6.0",
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "bundle": {
     "active": true,

src/AGENTS.md

@@ -21,3 +21,27 @@ These rules supplement the repository's root `AGENTS.md`.
 - **Command ownership.** `services` owns backend command invocation and transport
   wrappers. Components and hooks use those boundaries; plugin mutations follow
   the same intent ownership as backend commands.
+- **State liveness.** Every `useState`/`useRef` member has a reachable write
+  that differs from its initial value and a read that observes the difference.
+  A value that can only ever hold its initial value is a constant: declare the
+  constant and delete the state. A ref nothing reads is deleted, not kept.
+- **Surface liveness.** Anything a module exposes — props, parameters, context
+  members, imperative-handle methods — ships with at least one external caller
+  in the same change. "Reserved for future use" fields, `_`-prefixed params
+  that callers still pass, and error or callback channels that every receiver
+  ignores are removed, not maintained.
+- **Path liveness.** A fallback or branch names the concrete runtime condition
+  that reaches it. If no supported runtime can reach it, the branch is not
+  added — or it replaces the primary path. Constant subexpressions and cleanup
+  of resources that cannot exist yet are simplified away.
+- **Effect economy.** One user interaction produces one state write and one
+  command. A handler does not re-apply a value its wrapper already applied,
+  and an effect does not re-run a refresh another branch of the same effect
+  just ran.
+- **Mount economy.** Components that issue commands or subscriptions on mount
+  are mounted only where their UI is reachable. A dialog no rendered control
+  can open stays unmounted, not mounted-and-idle.
+- **Resource bounds.** Every cache key, timer and subscription a feature
+  allocates is reused or released on refresh; refresh never allocates an
+  unbounded sequence of new keys. Retries re-create per-attempt resources so
+  a retry can actually succeed.

src/components/base/base-split-chip-editor.tsx

@@ -22,23 +22,16 @@ interface BaseSplitChipEditorProps {
   error?: boolean
   helperText?: ReactNode
   placeholder?: string
-  rows?: number
   separator?: string
-  splitPattern?: RegExp
-  defaultMode?: BaseSplitChipEditorMode
-  showModeToggle?: boolean
   ariaLabel?: string
-  addLabel?: ReactNode
-  emptyLabel?: ReactNode
-  modeLabels?: Partial<Record<BaseSplitChipEditorMode, ReactNode>>
   renderHeader?: (modeToggle: ReactNode) => ReactNode
 }
 
 const DEFAULT_SPLIT_PATTERN = /[,\n;\r]+/
 
-const splitValue = (value: string, splitPattern: RegExp) =>
+const splitValue = (value: string) =>
   value
-    .split(splitPattern)
+    .split(DEFAULT_SPLIT_PATTERN)
     .map((item) => item.trim())
     .filter(Boolean)
 
@@ -49,35 +42,25 @@ export const BaseSplitChipEditor = ({
   error = false,
   helperText,
   placeholder,
-  rows = 4,
   separator = ',',
-  splitPattern = DEFAULT_SPLIT_PATTERN,
-  defaultMode = 'visual',
-  showModeToggle = true,
   ariaLabel,
-  addLabel,
-  emptyLabel,
-  modeLabels,
   renderHeader,
 }: BaseSplitChipEditorProps) => {
   const { t } = useTranslation()
-  const [mode, setMode] = useState<BaseSplitChipEditorMode>(defaultMode)
+  const [mode, setMode] = useState<BaseSplitChipEditorMode>('visual')
   const [draft, setDraft] = useState('')
 
   const resolvedLabels = useMemo(
     () => ({
-      visual: modeLabels?.visual ?? t('shared.editorModes.visualization'),
-      advanced: modeLabels?.advanced ?? t('shared.editorModes.advanced'),
-      add: addLabel ?? t('shared.actions.new'),
-      empty: emptyLabel ?? t('shared.statuses.empty'),
+      visual: t('shared.editorModes.visualization'),
+      advanced: t('shared.editorModes.advanced'),
+      add: t('shared.actions.new'),
+      empty: t('shared.statuses.empty'),
     }),
-    [t, modeLabels, addLabel, emptyLabel],
+    [t],
   )
 
-  const values = useMemo(
-    () => splitValue(value, splitPattern),
-    [value, splitPattern],
-  )
+  const values = useMemo(() => splitValue(value), [value])
 
   const items = useMemo(() => {
     const counts = new Map<string, number>()
@@ -92,7 +75,7 @@ export const BaseSplitChipEditor = ({
   }, [values])
 
   const handleAddDraft = () => {
-    const nextValues = splitValue(draft, splitPattern)
+    const nextValues = splitValue(draft)
     if (!nextValues.length) {
       return
     }
@@ -113,7 +96,7 @@ export const BaseSplitChipEditor = ({
   const resolvedAriaLabel =
     ariaLabel ?? (typeof toggleLabel === 'string' ? toggleLabel : undefined)
 
-  const modeToggle = showModeToggle ? (
+  const modeToggle = (
     <Tooltip title={toggleLabel}>
       <IconButton
         size="small"
@@ -128,7 +111,7 @@ export const BaseSplitChipEditor = ({
         <ToggleIcon fontSize="small" />
       </IconButton>
     </Tooltip>
-  ) : null
+  )
 
   return (
     <>
@@ -202,7 +185,7 @@ export const BaseSplitChipEditor = ({
           disabled={disabled}
           size="small"
           multiline
-          rows={rows}
+          rows={4}
           sx={{ width: '100%' }}
           value={value}
           helperText={helperText}

src/components/home/current-proxy-card.tsx

@@ -596,7 +596,7 @@ export const CurrentProxyCard = () => {
     [getProfileStorageKey],
   )
 
-  const { handleSelectChange } = useProxySelection({
+  const { select } = useProxySelection({
     onSuccess: () => {
       refreshProxy()
     },
@@ -766,15 +766,9 @@ export const CurrentProxyCard = () => {
       const previousProxy = selectedGroup.now
       const nextName = option.member.ref.name
       // The profile selection is the durable source across core restarts and run modes.
-      handleSelectChange(
-        selectedGroup.name,
-        previousProxy!,
-        selectedGroup.fixed!,
-      )({
-        target: { value: nextName },
-      })
+      select(selectedGroup.name, nextName, previousProxy!, selectedGroup.fixed!)
     },
-    [handleSelectChange, isDirectMode, selectedGroup, unsortedProxyOptions],
+    [isDirectMode, select, selectedGroup, unsortedProxyOptions],
   )
 
   const goToProxies = useCallback(() => {

src/components/home/enhanced-canvas-traffic-graph.tsx

@@ -14,7 +14,6 @@ import { useTranslation } from 'react-i18next'
 
 import { useTrafficGraphDataEnhanced } from '@/hooks/use-traffic-monitor'
 import { useVerge } from '@/hooks/use-verge'
-import { debugLog } from '@/utils/debug'
 import parseTraffic from '@/utils/parse-traffic'
 import {
   formatTrafficHourMinute,
@@ -23,14 +22,7 @@ import {
   isSameTrafficData,
 } from '@/utils/traffic-sampler'
 
-interface ITrafficItem {
-  up: number
-  down: number
-  timestamp?: number
-}
-
 export interface EnhancedCanvasTrafficGraphRef {
-  appendData: (data: ITrafficItem) => void
   toggleStyle: () => void
 }
 
@@ -142,7 +134,6 @@ export const EnhancedCanvasTrafficGraph = memo(
       [],
     )
     const debounceTimeoutRef = useRef<number | null>(null)
-    const [currentFPS, setCurrentFPS] = useState(GRAPH_CONFIG.targetFPS)
 
     const colors = useMemo(
       () => ({
@@ -183,8 +174,6 @@ export const EnhancedCanvasTrafficGraph = memo(
       if (displayData.length === 0) {
         lastDataTimestampRef.current = 0
         dataStaleRef.current = false
-        // eslint-disable-next-line @eslint-react/set-state-in-effect
-        setCurrentFPS(GRAPH_CONFIG.targetFPS)
         return
       }
 
@@ -200,18 +189,11 @@ export const EnhancedCanvasTrafficGraph = memo(
       }
     }, [displayData])
 
-    const handleFocusStateChange = useCallback(
-      (focused: boolean) => {
-        isWindowFocusedRef.current = focused
+    const handleFocusStateChange = useCallback((focused: boolean) => {
+      isWindowFocusedRef.current = focused
 
-        if (focused || !pause_render_traffic_stats_on_blur) {
-          setCurrentFPS(GRAPH_CONFIG.targetFPS)
-        }
-
-        scheduleDrawGraphRef.current()
-      },
-      [pause_render_traffic_stats_on_blur],
-    )
+      scheduleDrawGraphRef.current()
+    }, [])
 
     useEffect(() => {
       if (typeof window === 'undefined' || typeof document === 'undefined') {
@@ -684,19 +666,13 @@ export const EnhancedCanvasTrafficGraph = memo(
           ctx.beginPath()
           ctx.moveTo(getX(0), getY(0))
 
-          if (chartStyle === 'bezier') {
-            for (let i = 1; i < data.length; i++) {
-              const currentX = getX(i)
-              const currentY = getY(i)
-              const nextIndex = Math.min(i + 1, lastIndex)
-              const controlX = (currentX + getX(nextIndex)) / 2
-              const controlY = (currentY + getY(nextIndex)) / 2
-              ctx.quadraticCurveTo(currentX, currentY, controlX, controlY)
-            }
-          } else {
-            for (let i = 1; i < data.length; i++) {
-              ctx.lineTo(getX(i), getY(i))
-            }
+          for (let i = 1; i < data.length; i++) {
+            const currentX = getX(i)
+            const currentY = getY(i)
+            const nextIndex = Math.min(i + 1, lastIndex)
+            const controlX = (currentX + getX(nextIndex)) / 2
+            const controlY = (currentY + getY(nextIndex)) / 2
+            ctx.quadraticCurveTo(currentX, currentY, controlX, controlY)
           }
 
           ctx.lineTo(getX(lastIndex), height - padding.bottom)
@@ -984,21 +960,7 @@ export const EnhancedCanvasTrafficGraph = memo(
       setChartStyle((prev) => (prev === 'bezier' ? 'line' : 'bezier'))
     }, [])
 
-    const appendData = useCallback((data: ITrafficItem) => {
-      debugLog(
-        '[EnhancedCanvasTrafficGraphV2] appendData called (using global data):',
-        data,
-      )
-    }, [])
-
-    useImperativeHandle(
-      ref,
-      () => ({
-        appendData,
-        toggleStyle,
-      }),
-      [appendData, toggleStyle],
-    )
+    useImperativeHandle(ref, () => ({ toggleStyle }), [toggleStyle])
 
     const getTimeRangeText = useCallback(() => {
       return t('home.components.traffic.patterns.minutes', {
@@ -1142,7 +1104,7 @@ export const EnhancedCanvasTrafficGraph = memo(
             {t('home.components.traffic.diagnostics', {
               points: displayData.length,
               compressed: samplerStats.compressedBufferSize,
-              fps: currentFPS,
+              fps: GRAPH_CONFIG.targetFPS,
             })}
           </Box>
 

src/components/home/enhanced-traffic-stats.tsx

@@ -3,10 +3,14 @@ import {
   ArrowUpwardRounded,
   CloudDownloadRounded,
   CloudUploadRounded,
+  ErrorOutlineRounded,
   LinkRounded,
   MemoryRounded,
 } from '@mui/icons-material'
 import {
+  Alert,
+  Box,
+  Button,
   Grid,
   PaletteColor,
   Paper,
@@ -15,9 +19,9 @@ import {
   useTheme,
 } from '@mui/material'
 import { ReactNode, memo, useMemo, useRef } from 'react'
+import { ErrorBoundary, FallbackProps } from 'react-error-boundary'
 import { useTranslation } from 'react-i18next'
 
-import { TrafficErrorBoundary } from '@/components/shared/traffic-error-boundary'
 import { useConnectionSummaryData } from '@/hooks/use-connection-data'
 import { useMemoryData } from '@/hooks/use-memory-data'
 import { useTrafficData } from '@/hooks/use-traffic-data'
@@ -127,6 +131,50 @@ const CompactStatCard = memo(
 // 添加显示名称
 CompactStatCard.displayName = 'CompactStatCard'
 
+const fallbackSx = {
+  p: 2,
+  minHeight: 200,
+  display: 'flex',
+  flexDirection: 'column',
+  alignItems: 'center',
+  justifyContent: 'center',
+  border: '1px dashed',
+  borderColor: 'error.main',
+  borderRadius: 2,
+  bgcolor: 'error.light',
+}
+
+const reloadPage = () => window.location.reload()
+
+const TrafficFallback = ({ error, resetErrorBoundary }: FallbackProps) => {
+  const { t } = useTranslation()
+
+  return (
+    <Box sx={fallbackSx}>
+      <ErrorOutlineRounded color="error" sx={{ fontSize: 48, mb: 2 }} />
+      <Typography variant="h6" gutterBottom>
+        {t('shared.feedback.errors.trafficStats')}
+      </Typography>
+      <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
+        {t('shared.feedback.errors.trafficStatsDescription')}
+      </Typography>
+      <Alert severity="error" sx={{ mb: 2, maxWidth: 400 }}>
+        {error instanceof Error
+          ? error.message
+          : t('shared.feedback.errors.unknown')}
+      </Alert>
+      <Box sx={{ display: 'flex', gap: 1 }}>
+        <Button variant="contained" size="small" onClick={resetErrorBoundary}>
+          {t('shared.actions.retry')}
+        </Button>
+        <Button variant="outlined" size="small" onClick={reloadPage}>
+          {t('shared.actions.refreshPage')}
+        </Button>
+      </Box>
+    </Box>
+  )
+}
+
 export const EnhancedTrafficStats = () => {
   const { t } = useTranslation()
   const theme = useTheme()
@@ -254,10 +302,11 @@ export const EnhancedTrafficStats = () => {
   }, [t, parsedData, displayMemory])
 
   return (
-    <TrafficErrorBoundary
-      onError={(error, errorInfo) => {
-        console.error('[EnhancedTrafficStats] 组件错误:', error, errorInfo)
-      }}
+    <ErrorBoundary
+      FallbackComponent={TrafficFallback}
+      onError={(error, errorInfo) =>
+        console.error('[EnhancedTrafficStats]', error, errorInfo)
+      }
     >
       <Grid container spacing={1} columns={{ xs: 8, sm: 8, md: 12 }}>
         {trafficGraph && (
@@ -273,6 +322,6 @@ export const EnhancedTrafficStats = () => {
           </Grid>
         ))}
       </Grid>
-    </TrafficErrorBoundary>
+    </ErrorBoundary>
   )
 }

src/components/home/system-info-card.tsx

@@ -86,16 +86,11 @@ export const SystemInfoCard = () => {
   }, [verge, patchVerge])
 
   const handleRunningModeClick = useCallback(async () => {
-    if (isSidecarMode || (isAdminMode && isSidecarMode)) {
+    if (isSidecarMode) {
       await installServiceAndRestartCore()
       await mutateSystemState()
     }
-  }, [
-    isSidecarMode,
-    isAdminMode,
-    installServiceAndRestartCore,
-    mutateSystemState,
-  ])
+  }, [isSidecarMode, installServiceAndRestartCore, mutateSystemState])
 
   const onCheckUpdate = useLockFn(async () => {
     try {
@@ -122,18 +117,16 @@ export const SystemInfoCard = () => {
 
   const runningModeStyle = useMemo(
     () => ({
-      cursor:
-        isSidecarMode || (isAdminMode && isSidecarMode) ? 'pointer' : 'default',
-      textDecoration:
-        isSidecarMode || (isAdminMode && isSidecarMode) ? 'underline' : 'none',
+      cursor: isSidecarMode ? 'pointer' : 'default',
+      textDecoration: isSidecarMode ? 'underline' : 'none',
       display: 'flex',
       alignItems: 'center',
       gap: 0.5,
       '&:hover': {
-        opacity: isSidecarMode || (isAdminMode && isSidecarMode) ? 0.7 : 1,
+        opacity: isSidecarMode ? 0.7 : 1,
       },
     }),
-    [isSidecarMode, isAdminMode],
+    [isSidecarMode],
   )
 
   const getModeIcon = () => {

src/components/home/test-card.tsx

@@ -87,7 +87,7 @@ export const TestCard = () => {
         x.uid === uid ? { ...x, ...patch } : x,
       )
 
-      mutateVerge({ ...verge, test_list: newList }, false)
+      mutateVerge({ ...verge, test_list: newList })
     },
     [testList, verge, mutateVerge],
   )
@@ -96,7 +96,7 @@ export const TestCard = () => {
     (uid: string) => {
       const newList = testList.filter((x) => x.uid !== uid)
       patchVerge({ test_list: newList })
-      mutateVerge({ ...verge, test_list: newList }, false)
+      mutateVerge({ ...verge, test_list: newList })
     },
     [testList, verge, patchVerge, mutateVerge],
   )
@@ -129,7 +129,7 @@ export const TestCard = () => {
       newList.splice(newIndex, 0, removed)
 
       // 优化：先本地更新，再异步 patch，避免UI卡死
-      mutateVerge({ ...verge, test_list: newList }, false)
+      mutateVerge({ ...verge, test_list: newList })
       const patchFn = () => {
         try {
           patchVerge({ test_list: newList })

src/components/layout/layout-sidebar.tsx

@@ -35,10 +35,7 @@ export const LayoutSidebar = (props: LayoutSidebarProps) => {
 
   const handleMenuOrderOptimisticUpdate = useCallback(
     (order: string[]) => {
-      mutateVerge(
-        (prev) => (prev ? { ...prev, menu_order: order } : prev),
-        false,
-      )
+      mutateVerge((prev) => (prev ? { ...prev, menu_order: order } : prev))
     },
     [mutateVerge],
   )

src/components/layout/layout-traffic.tsx

@@ -1,14 +1,15 @@
 import {
   ArrowDownwardRounded,
   ArrowUpwardRounded,
+  ErrorOutlineRounded,
   MemoryRounded,
 } from '@mui/icons-material'
 import type { BoxProps, SvgIconProps, TypographyProps } from '@mui/material'
 import { Box, Typography } from '@mui/material'
 import { useEffect, useRef } from 'react'
+import { ErrorBoundary } from 'react-error-boundary'
 import { useTranslation } from 'react-i18next'
 
-import { LightweightTrafficErrorBoundary } from '@/components/shared/traffic-error-boundary'
 import { useMemoryData } from '@/hooks/use-memory-data'
 import { useTrafficData } from '@/hooks/use-traffic-data'
 import { useVerge } from '@/hooks/use-verge'
@@ -17,6 +18,30 @@ import parseTraffic from '@/utils/parse-traffic'
 
 import { TrafficGraph, type TrafficRef } from './traffic-graph'
 
+const unavailableSx = {
+  p: 1,
+  minHeight: 60,
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'center',
+  bgcolor: 'error.light',
+  borderRadius: 1,
+  color: 'error.contrastText',
+}
+
+const TrafficUnavailableFallback = () => {
+  const { t } = useTranslation()
+
+  return (
+    <Box sx={unavailableSx}>
+      <ErrorOutlineRounded sx={{ mr: 1, fontSize: 20 }} />
+      <Typography variant="caption">
+        {t('shared.feedback.errors.trafficUnavailable')}
+      </Typography>
+    </Box>
+  )
+}
+
 export const LayoutTraffic = () => {
   const { t } = useTranslation()
   const { verge } = useVerge()
@@ -75,7 +100,12 @@ export const LayoutTraffic = () => {
   }
 
   return (
-    <LightweightTrafficErrorBoundary>
+    <ErrorBoundary
+      FallbackComponent={TrafficUnavailableFallback}
+      onError={(error, errorInfo) =>
+        console.error('[LayoutTraffic]', error, errorInfo)
+      }
+    >
       <Box sx={{ position: 'relative' }}>
         {trafficGraph && pageVisible && (
           <div
@@ -130,7 +160,6 @@ export const LayoutTraffic = () => {
                 cursor: 'auto',
               }}
               color={'disabled'}
-              onClick={async () => {}}
             >
               <MemoryRounded {...iconStyle} />
               <Typography {...valStyle}>{inuse}</Typography>
@@ -139,6 +168,6 @@ export const LayoutTraffic = () => {
           )}
         </Box>
       </Box>
-    </LightweightTrafficErrorBoundary>
+    </ErrorBoundary>
   )
 }

src/components/layout/window-controller.tsx

@@ -1,11 +1,6 @@
 import { Close, CropSquare, FilterNone, Minimize } from '@mui/icons-material'
 import { Box, IconButton } from '@mui/material'
-import {
-  forwardRef,
-  type PointerEvent,
-  useCallback,
-  useImperativeHandle,
-} from 'react'
+import { type PointerEvent, useCallback } from 'react'
 
 import { useWindowControls } from '@/hooks/use-window'
 import getSystem from '@/utils/get-system'
@@ -63,36 +58,9 @@ export const WindowResizeHandles = () => {
   )
 }
 
-export const WindowControls = forwardRef(function WindowControls(props, ref) {
+export const WindowControls = () => {
   const OS = getSystem()
-  const {
-    currentWindow,
-    maximized,
-    minimize,
-    close,
-    toggleFullscreen,
-    toggleMaximize,
-  } = useWindowControls()
-
-  useImperativeHandle(
-    ref,
-    () => ({
-      currentWindow,
-      maximized,
-      minimize,
-      close,
-      toggleFullscreen,
-      toggleMaximize,
-    }),
-    [
-      currentWindow,
-      maximized,
-      minimize,
-      close,
-      toggleFullscreen,
-      toggleMaximize,
-    ],
-  )
+  const { maximized, minimize, close, toggleMaximize } = useWindowControls()
 
   // 通过前端对 tauri 窗口进行翻转全屏时会短暂地与系统图标重叠渲染。
   // 这可能是上游缺陷，保险起见跨平台以窗口的最大化翻转为准。
@@ -186,4 +154,4 @@ export const WindowControls = forwardRef(function WindowControls(props, ref) {
       )}
     </Box>
   )
-})
+}

src/components/proxy/proxy-groups.tsx

@@ -462,7 +462,7 @@ function NormalProxyGroups(props: { mode: string }) {
     }
   }, [handleScroll])
 
-  const { handleProxyGroupChange } = useProxySelection({
+  const { select } = useProxySelection({
     onSuccess: () => {
       onProxies()
     },
@@ -477,9 +477,9 @@ function NormalProxyGroups(props: { mode: string }) {
       if (!['Selector', 'URLTest', 'Fallback'].includes(group.type)) return
       if (!isInteractableMember(member)) return
 
-      handleProxyGroupChange(group, { name: member.ref.name })
+      select(group.name, member.ref.name, group.now!, group.fixed!)
     },
-    [handleProxyGroupChange],
+    [select],
   )
 
   const handleLocation = useStableCallback((group: ProxyGroupView) => {

src/components/proxy/use-proxy-group-header-layout.ts

@@ -30,10 +30,8 @@ export const useProxyGroupHeaderLayout = () => {
       if (canceled || !operation.source || !operation.target) return
 
       const position = toolsOnLeft ? 'right' : 'left'
-      mutateVerge(
-        (prev) =>
-          prev ? { ...prev, proxy_group_tools_position: position } : prev,
-        false,
+      mutateVerge((prev) =>
+        prev ? { ...prev, proxy_group_tools_position: position } : prev,
       )
       try {
         await patchVerge({ proxy_group_tools_position: position })

src/components/setting/mods/backup-config-viewer.tsx

@@ -114,17 +114,15 @@ export const BackupConfigViewer = memo(
             errorNotice: false,
           },
         )
-        await mutateVerge(
-          (current) =>
-            current
-              ? {
-                  ...current,
-                  webdav_url: trimmedUrl,
-                  webdav_username: trimmedUsername,
-                  webdav_password: data.password,
-                }
-              : current,
-          false,
+        await mutateVerge((current) =>
+          current
+            ? {
+                ...current,
+                webdav_url: trimmedUrl,
+                webdav_username: trimmedUsername,
+                webdav_password: data.password,
+              }
+            : current,
         )
         setWebdavStatus(signature, 'unknown')
         showNotice.success('settings.modals.backup.messages.webdavConfigSaved')

src/components/setting/mods/layout-viewer.tsx

@@ -107,7 +107,7 @@ export const LayoutViewer = forwardRef<DialogRef>((_, ref) => {
     showNotice.error(err)
   }
   const onChangeData = (patch: Partial<IVergeConfig>) => {
-    mutateVerge({ ...verge, ...patch }, false)
+    mutateVerge({ ...verge, ...patch })
   }
 
   return (

src/components/setting/mods/misc-viewer.tsx

@@ -15,44 +15,33 @@ import { BaseDialog, DialogRef, Switch, TooltipIcon } from '@/components/base'
 import { useVerge } from '@/hooks/use-verge'
 import { showNotice } from '@/services/notice-service'
 
+const buildInitialValues = (verge?: IVergeConfig | null) => ({
+  appLogLevel: verge?.app_log_level ?? 'warn',
+  appLogMaxSize: verge?.app_log_max_size ?? 128,
+  appLogMaxCount: verge?.app_log_max_count ?? 8,
+  autoCloseConnection: verge?.auto_close_connection ?? true,
+  autoCheckUpdate: verge?.auto_check_update ?? true,
+  enableBuiltinEnhanced: verge?.enable_builtin_enhanced ?? true,
+  proxyLayoutColumn: verge?.proxy_layout_column || 6,
+  enableAutoDelayDetection: verge?.enable_auto_delay_detection ?? false,
+  autoDelayDetectionIntervalMinutes:
+    verge?.auto_delay_detection_interval_minutes ?? 5,
+  defaultLatencyTest: verge?.default_latency_test || '',
+  autoLogClean: verge?.auto_log_clean || 0,
+  defaultLatencyTimeout: verge?.default_latency_timeout || 10000,
+})
+
 export const MiscViewer = forwardRef<DialogRef>((props, ref) => {
   const { t } = useTranslation()
   const { verge, patchVerge } = useVerge()
 
   const [open, setOpen] = useState(false)
-  const [values, setValues] = useState({
-    appLogLevel: 'warn',
-    appLogMaxSize: 8,
-    appLogMaxCount: 12,
-    autoCloseConnection: true,
-    autoCheckUpdate: true,
-    enableBuiltinEnhanced: true,
-    proxyLayoutColumn: 6,
-    enableAutoDelayDetection: false,
-    autoDelayDetectionIntervalMinutes: 5,
-    defaultLatencyTest: '',
-    autoLogClean: 2,
-    defaultLatencyTimeout: 10000,
-  })
+  const [values, setValues] = useState(() => buildInitialValues(null))
 
   useImperativeHandle(ref, () => ({
     open: () => {
       setOpen(true)
-      setValues({
-        appLogLevel: verge?.app_log_level ?? 'warn',
-        appLogMaxSize: verge?.app_log_max_size ?? 128,
-        appLogMaxCount: verge?.app_log_max_count ?? 8,
-        autoCloseConnection: verge?.auto_close_connection ?? true,
-        autoCheckUpdate: verge?.auto_check_update ?? true,
-        enableBuiltinEnhanced: verge?.enable_builtin_enhanced ?? true,
-        proxyLayoutColumn: verge?.proxy_layout_column || 6,
-        enableAutoDelayDetection: verge?.enable_auto_delay_detection ?? false,
-        autoDelayDetectionIntervalMinutes:
-          verge?.auto_delay_detection_interval_minutes ?? 5,
-        defaultLatencyTest: verge?.default_latency_test || '',
-        autoLogClean: verge?.auto_log_clean || 0,
-        defaultLatencyTimeout: verge?.default_latency_timeout || 10000,
-      })
+      setValues(buildInitialValues(verge))
     },
     close: () => setOpen(false),
   }))

src/components/setting/mods/sysproxy-viewer.tsx

@@ -87,6 +87,17 @@ const splitBypass = (value?: string) =>
     .map((item) => item.trim())
     .filter(Boolean)
 
+const buildInitialValues = (verge?: IVergeConfig | null) => ({
+  guard: verge?.enable_proxy_guard,
+  enable_bypass_check: verge?.enable_bypass_check ?? true,
+  bypass: verge?.system_proxy_bypass,
+  duration: verge?.proxy_guard_duration ?? 10,
+  use_default: verge?.use_default_bypass ?? true,
+  pac: verge?.proxy_auto_config,
+  pac_content: verge?.pac_file_content ?? DEFAULT_PAC,
+  proxy_host: verge?.proxy_host ?? '127.0.0.1',
+})
+
 export const SysproxyViewer = forwardRef<DialogRef>((props, ref) => {
   const { t } = useTranslation()
   const systemName = getSystem()
@@ -116,16 +127,7 @@ export const SysproxyViewer = forwardRef<DialogRef>((props, ref) => {
     proxy_host,
   } = verge ?? {}
 
-  const [value, setValue] = useState({
-    guard: enable_proxy_guard,
-    enable_bypass_check: enable_bypass_check ?? true,
-    bypass: system_proxy_bypass,
-    duration: proxy_guard_duration ?? 10,
-    use_default: use_default_bypass ?? true,
-    pac: proxy_auto_config,
-    pac_content: pac_file_content ?? DEFAULT_PAC,
-    proxy_host: proxy_host ?? '127.0.0.1',
-  })
+  const [value, setValue] = useState(() => buildInitialValues(null))
   const [embeddedServerPort, setEmbeddedServerPort] = useState<number | null>(
     null,
   )
@@ -192,16 +194,7 @@ export const SysproxyViewer = forwardRef<DialogRef>((props, ref) => {
   useImperativeHandle(ref, () => ({
     open: () => {
       setOpen(true)
-      setValue({
-        guard: enable_proxy_guard,
-        enable_bypass_check: enable_bypass_check ?? true,
-        bypass: system_proxy_bypass,
-        duration: proxy_guard_duration ?? 10,
-        use_default: use_default_bypass ?? true,
-        pac: proxy_auto_config,
-        pac_content: pac_file_content ?? DEFAULT_PAC,
-        proxy_host: proxy_host ?? '127.0.0.1',
-      })
+      setValue(buildInitialValues(verge))
       fetchNetworkInterfaces()
     },
     close: () => setOpen(false),
@@ -339,7 +332,7 @@ export const SysproxyViewer = forwardRef<DialogRef>((props, ref) => {
     Promise.resolve().then(async () => {
       try {
         if (Object.keys(patch).length > 0) {
-          mutateVerge({ ...verge, ...patch }, false)
+          mutateVerge({ ...verge, ...patch })
         }
         if (Object.keys(patch).length > 0) {
           await patchVerge(patch)

src/components/setting/mods/tunnels-viewer.tsx

@@ -76,34 +76,28 @@ const proxyOptionToken = ({ memberIndex, member }: TunnelProxyOption) =>
     member.kind === 'node' ? member.node.recordId : member.ref.name
   }`
 
+const buildInitialValues = (): TunnelFormValues => ({
+  localAddr: '',
+  localPort: '',
+  targetAddr: '',
+  targetPort: '',
+  network: 'tcp+udp',
+  group: '',
+  proxy: null,
+})
+
 export const TunnelsViewer = forwardRef<TunnelsViewerRef>((_, ref) => {
   const { t } = useTranslation()
   const { clash, mutateClash, patchClash } = useClash()
 
   const [open, setOpen] = useState(false)
   const [expanded, setExpanded] = useState(false)
-  const [values, setValues] = useState<TunnelFormValues>({
-    localAddr: '',
-    localPort: '',
-    targetAddr: '',
-    targetPort: '',
-    network: 'tcp+udp',
-    group: '',
-    proxy: null,
-  })
+  const [values, setValues] = useState<TunnelFormValues>(buildInitialValues)
   const [draftTunnels, setDraftTunnels] = useState<TunnelEntry[]>([])
 
   useImperativeHandle(ref, () => ({
     open: () => {
-      setValues(() => ({
-        localAddr: '',
-        localPort: '',
-        targetAddr: '',
-        targetPort: '',
-        network: 'tcp+udp',
-        group: '',
-        proxy: null,
-      }))
+      setValues(buildInitialValues())
       setDraftTunnels(() => clash?.tunnels ?? [])
       setOpen(true)
       // 如果没有隧道，则自动展开

src/components/setting/mods/update-viewer.tsx

@@ -1,14 +1,8 @@
 import { alpha, Box, Button, LinearProgress } from '@mui/material'
+import type { Update } from '@tauri-apps/plugin-updater'
 import { useLockFn } from 'ahooks'
 import type { Ref } from 'react'
-import {
-  lazy,
-  Suspense,
-  useImperativeHandle,
-  useMemo,
-  useRef,
-  useState,
-} from 'react'
+import { lazy, Suspense, useImperativeHandle, useMemo, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import type { Options as ReactMarkdownOptions } from 'react-markdown'
 
@@ -180,12 +174,16 @@ export function UpdateViewer({ ref }: { ref?: Ref<DialogRef> }) {
   const updateState = useUpdateState()
   const setUpdateState = useSetUpdateState()
 
-  const { updateInfo } = useUpdate()
+  const { updateInfo: detectedUpdate, checkUpdate } = useUpdate()
+  const [refreshedUpdate, setRefreshedUpdate] = useState<Update | null>()
+  const updateInfo =
+    refreshedUpdate === undefined ? detectedUpdate : refreshedUpdate
 
-  const [downloaded, setDownloaded] = useState(0)
-  const [total, setTotal] = useState(0)
-  const downloadedRef = useRef(0)
-  const totalRef = useRef(0)
+  const [download, setDownload] = useState({
+    downloaded: 0,
+    total: 0,
+  })
+  const { downloaded, total } = download
 
   const openUrlWithNotice = (url: string) => {
     void openExternalUrl(url).catch(showNotice.error)
@@ -197,7 +195,10 @@ export function UpdateViewer({ ref }: { ref?: Ref<DialogRef> }) {
   }, [downloaded, total])
 
   useImperativeHandle(ref, () => ({
-    open: () => setOpen(true),
+    open: () => {
+      setRefreshedUpdate(undefined)
+      setOpen(true)
+    },
     close: () => setOpen(false),
   }))
 
@@ -242,32 +243,21 @@ export function UpdateViewer({ ref }: { ref?: Ref<DialogRef> }) {
     }
     if (updateState) return
     setUpdateState(true)
-    setDownloaded(0)
-    setTotal(0)
-    downloadedRef.current = 0
-    totalRef.current = 0
+    setDownload({ downloaded: 0, total: 0 })
 
     const onDownloadEvent = (event: DownloadEvent) => {
       if (event.event === 'Started') {
-        const contentLength = event.data.contentLength ?? 0
-        totalRef.current = contentLength
-        setTotal(contentLength)
-        setDownloaded(0)
-        downloadedRef.current = 0
-        return
-      }
-
-      if (event.event === 'Progress') {
-        setDownloaded((prev) => {
-          const next = prev + event.data.chunkLength
-          downloadedRef.current = next
-          return next
-        })
-      }
-
-      if (event.event === 'Finished' && totalRef.current === 0) {
-        totalRef.current = downloadedRef.current
-        setTotal(downloadedRef.current)
+        setDownload({ downloaded: 0, total: event.data.contentLength ?? 0 })
+      } else if (event.event === 'Progress') {
+        setDownload((prev) => ({
+          ...prev,
+          downloaded: prev.downloaded + event.data.chunkLength,
+        }))
+      } else if (event.event === 'Finished') {
+        setDownload((prev) => ({
+          ...prev,
+          total: prev.total || prev.downloaded,
+        }))
       }
     }
 
@@ -279,7 +269,18 @@ export function UpdateViewer({ ref }: { ref?: Ref<DialogRef> }) {
           errorNotice: false,
         },
       )
-      if (result.ok && result.value) {
+      if (result.ok && result.value === 'update_changed') {
+        const { data } = await checkUpdate()
+        setRefreshedUpdate(data)
+        if (data) {
+          showNotice.info('settings.modals.update.messages.available')
+        } else {
+          setOpen(false)
+          showNotice.info(
+            'settings.components.verge.advanced.notifications.latestVersion',
+          )
+        }
+      } else if (result.ok && result.value === 'installed') {
         await mutate(() => restartApp(), {
           id: 'restart-app',
           errorNotice: false,
@@ -289,10 +290,7 @@ export function UpdateViewer({ ref }: { ref?: Ref<DialogRef> }) {
       showNotice.error(err)
     } finally {
       setUpdateState(false)
-      setDownloaded(0)
-      setTotal(0)
-      downloadedRef.current = 0
-      totalRef.current = 0
+      setDownload({ downloaded: 0, total: 0 })
     }
   })
 

src/components/setting/mods/web-ui-viewer.tsx

@@ -50,21 +50,21 @@ export function WebUIViewer({ ref }: { ref?: Ref<DialogRef> }) {
 
   const handleAdd = useLockFn(async (value: string) => {
     const newList = [...webUIList, value]
-    mutateVerge((old) => (old ? { ...old, web_ui_list: newList } : old), false)
+    mutateVerge((old) => (old ? { ...old, web_ui_list: newList } : old))
     await patchVerge({ web_ui_list: newList })
   })
 
   const handleChange = useLockFn(async (index: number, value?: string) => {
     const newList = [...webUIList]
     newList[index] = value ?? ''
-    mutateVerge((old) => (old ? { ...old, web_ui_list: newList } : old), false)
+    mutateVerge((old) => (old ? { ...old, web_ui_list: newList } : old))
     await patchVerge({ web_ui_list: newList })
   })
 
   const handleDelete = useLockFn(async (index: number) => {
     const newList = [...webUIList]
     newList.splice(index, 1)
-    mutateVerge((old) => (old ? { ...old, web_ui_list: newList } : old), false)
+    mutateVerge((old) => (old ? { ...old, web_ui_list: newList } : old))
     await patchVerge({ web_ui_list: newList })
   })
 

src/components/setting/setting-system.tsx

@@ -1,14 +1,12 @@
-import React, { useRef } from 'react'
+import React from 'react'
 import { useTranslation } from 'react-i18next'
 
-import { DialogRef, Switch, TooltipIcon } from '@/components/base'
+import { Switch, TooltipIcon } from '@/components/base'
 import ProxyControlSwitches from '@/components/shared/proxy-control-switches'
 import { useVerge } from '@/hooks/use-verge'
 
 import { GuardState } from './mods/guard-state'
 import { SettingList, SettingItem } from './mods/setting-comp'
-import { SysproxyViewer } from './mods/sysproxy-viewer'
-import { TunViewer } from './mods/tun-viewer'
 
 interface Props {
   onError?: (err: Error) => void
@@ -21,22 +19,16 @@ const SettingSystem = ({ onError }: Props) => {
 
   const { enable_auto_launch, enable_silent_start } = verge ?? {}
 
-  const sysproxyRef = useRef<DialogRef>(null)
-  const tunRef = useRef<DialogRef>(null)
-
   const onSwitchFormat = (
     _e: React.ChangeEvent<HTMLInputElement>,
     value: boolean,
   ) => value
   const onChangeData = (patch: Partial<IVergeConfig>) => {
-    mutateVerge({ ...verge, ...patch }, false)
+    mutateVerge({ ...verge, ...patch })
   }
 
   return (
     <SettingList title={t('settings.sections.system.title')}>
-      <SysproxyViewer ref={sysproxyRef} />
-      <TunViewer ref={tunRef} />
-
       <ProxyControlSwitches
         label={t('settings.sections.system.toggles.tunMode')}
         onError={onError}
@@ -58,8 +50,6 @@ const SettingSystem = ({ onError }: Props) => {
           }}
           onGuard={async (e) => {
             try {
-              // 先触发UI更新立即看到反馈
-              onChangeData({ enable_auto_launch: e })
               await patchVerge({ enable_auto_launch: e })
               return Promise.resolve()
             } catch (error) {

src/components/setting/setting-verge-basic.tsx

@@ -72,7 +72,7 @@ const SettingVergeBasic = ({ onError }: Props) => {
   const backupRef = useRef<DialogRef>(null)
 
   const onChangeData = (patch: any) => {
-    mutateVerge({ ...verge, ...patch }, false)
+    mutateVerge({ ...verge, ...patch })
   }
 
   const onCopyClashEnv = useCallback(async () => {

src/components/shared/proxy-control-switches.tsx

@@ -163,7 +163,7 @@ const ProxyControlSwitches = ({
       })
       return false
     }
-    mutateVerge({ ...verge, enable_tun_mode: value }, false)
+    mutateVerge({ ...verge, enable_tun_mode: value })
     await patchVerge({ enable_tun_mode: value })
   }
 
@@ -229,8 +229,8 @@ const ProxyControlSwitches = ({
         />
       )}
 
-      <SysproxyViewer ref={sysproxyRef} />
-      <TunViewer ref={tunRef} />
+      {isSystemProxyMode && <SysproxyViewer ref={sysproxyRef} />}
+      {isTunMode && <TunViewer ref={tunRef} />}
     </Box>
   )
 }

src/components/shared/traffic-error-boundary.tsx

@@ -1,301 +0,0 @@
-import {
-  ErrorOutlineRounded,
-  RefreshRounded,
-  BugReportRounded,
-} from '@mui/icons-material'
-import { Box, Typography, Button, Alert, Collapse } from '@mui/material'
-import React, { Component, ErrorInfo, ReactNode } from 'react'
-import { useTranslation } from 'react-i18next'
-
-interface Props {
-  children: ReactNode
-  fallbackComponent?: ReactNode
-  onError?: (error: Error, errorInfo: ErrorInfo) => void
-}
-
-interface State {
-  hasError: boolean
-  error: Error | null
-  errorInfo: ErrorInfo | null
-  showDetails: boolean
-}
-
-export class TrafficErrorBoundary extends Component<Props, State> {
-  private retryCount = 0
-  private maxRetries = 3
-
-  constructor(props: Props) {
-    super(props)
-    this.state = {
-      hasError: false,
-      error: null,
-      errorInfo: null,
-      showDetails: false,
-    }
-  }
-
-  static getDerivedStateFromError(error: Error): Partial<State> {
-    return { hasError: true, error }
-  }
-
-  componentDidCatch(error: Error, errorInfo: ErrorInfo) {
-    console.error('[TrafficErrorBoundary] 捕获到组件错误:', error, errorInfo)
-
-    this.setState({
-      error,
-      errorInfo,
-    })
-
-    if (this.props.onError) {
-      this.props.onError(error, errorInfo)
-    }
-
-    this.reportError(error, errorInfo)
-  }
-
-  private reportError = (error: Error, errorInfo: ErrorInfo) => {
-    const errorReport = {
-      message: error.message,
-      stack: error.stack,
-      componentStack: errorInfo.componentStack,
-      timestamp: new Date().toISOString(),
-      userAgent: navigator.userAgent,
-      url: window.location.href,
-    }
-
-    console.error('[TrafficErrorBoundary] 错误报告:', errorReport)
-  }
-
-  private handleRetry = () => {
-    if (this.retryCount < this.maxRetries) {
-      this.retryCount++
-      console.log(
-        `[TrafficErrorBoundary] 尝试重试 (${this.retryCount}/${this.maxRetries})`,
-      )
-
-      this.setState({
-        hasError: false,
-        error: null,
-        errorInfo: null,
-        showDetails: false,
-      })
-    } else {
-      console.warn('[TrafficErrorBoundary] 已达到最大重试次数')
-    }
-  }
-
-  private handleRefresh = () => {
-    window.location.reload()
-  }
-
-  private toggleDetails = () => {
-    this.setState((prev) => ({ showDetails: !prev.showDetails }))
-  }
-
-  render() {
-    if (this.state.hasError) {
-      if (this.props.fallbackComponent) {
-        return this.props.fallbackComponent
-      }
-
-      return (
-        <TrafficErrorFallback
-          error={this.state.error}
-          errorInfo={this.state.errorInfo}
-          showDetails={this.state.showDetails}
-          canRetry={this.retryCount < this.maxRetries}
-          retryCount={this.retryCount}
-          maxRetries={this.maxRetries}
-          onRetry={this.handleRetry}
-          onRefresh={this.handleRefresh}
-          onToggleDetails={this.toggleDetails}
-        />
-      )
-    }
-
-    return this.props.children
-  }
-}
-
-interface TrafficErrorFallbackProps {
-  error: Error | null
-  errorInfo: ErrorInfo | null
-  showDetails: boolean
-  canRetry: boolean
-  retryCount: number
-  maxRetries: number
-  onRetry: () => void
-  onRefresh: () => void
-  onToggleDetails: () => void
-}
-
-const TrafficErrorFallback: React.FC<TrafficErrorFallbackProps> = ({
-  error,
-  errorInfo,
-  showDetails,
-  canRetry,
-  retryCount,
-  maxRetries,
-  onRetry,
-  onRefresh,
-  onToggleDetails,
-}) => {
-  const { t } = useTranslation()
-
-  return (
-    <Box
-      sx={{
-        p: 2,
-        minHeight: 200,
-        display: 'flex',
-        flexDirection: 'column',
-        alignItems: 'center',
-        justifyContent: 'center',
-        border: '1px dashed',
-        borderColor: 'error.main',
-        borderRadius: 2,
-        bgcolor: 'error.light',
-        color: 'error.contrastText',
-      }}
-    >
-      <ErrorOutlineRounded sx={{ fontSize: 48, mb: 2, color: 'error.main' }} />
-
-      <Typography variant="h6" gutterBottom>
-        {t('shared.feedback.errors.trafficStats')}
-      </Typography>
-
-      <Typography
-        variant="body2"
-        color="text.secondary"
-        sx={{ mb: 2, textAlign: 'center' }}
-      >
-        {t('shared.feedback.errors.trafficStatsDescription')}
-      </Typography>
-
-      <Alert severity="error" sx={{ mb: 2, maxWidth: 400 }}>
-        <Typography variant="body2">
-          <strong>{t('shared.feedback.errors.label')}:</strong>{' '}
-          {error instanceof Error
-            ? error.message
-            : t('shared.feedback.errors.unknown')}
-        </Typography>
-        {retryCount > 0 && (
-          <Typography variant="caption" sx={{ mt: 1, display: 'block' }}>
-            {t('shared.labels.retryAttempts')}: {retryCount}/{maxRetries}
-          </Typography>
-        )}
-      </Alert>
-
-      <Box sx={{ display: 'flex', gap: 1, mb: 2 }}>
-        {canRetry && (
-          <Button
-            variant="contained"
-            color="primary"
-            startIcon={<RefreshRounded />}
-            onClick={onRetry}
-            size="small"
-          >
-            {t('shared.actions.retry')}
-          </Button>
-        )}
-
-        <Button variant="outlined" onClick={onRefresh} size="small">
-          {t('shared.actions.refreshPage')}
-        </Button>
-
-        <Button
-          variant="text"
-          startIcon={<BugReportRounded />}
-          onClick={onToggleDetails}
-          size="small"
-        >
-          {showDetails
-            ? t('shared.actions.hideDetails')
-            : t('shared.actions.showDetails')}
-        </Button>
-      </Box>
-
-      <Collapse in={showDetails} sx={{ width: '100%', maxWidth: 600 }}>
-        <Box
-          sx={{
-            p: 2,
-            bgcolor: 'background.paper',
-            borderRadius: 1,
-            border: '1px solid',
-            borderColor: 'divider',
-          }}
-        >
-          <Typography variant="subtitle2" gutterBottom>
-            {t('shared.feedback.errors.details')}:
-          </Typography>
-          <Typography
-            variant="caption"
-            component="pre"
-            sx={{
-              whiteSpace: 'pre-wrap',
-              wordBreak: 'break-word',
-              fontFamily: 'monospace',
-              fontSize: '0.75rem',
-              color: 'text.secondary',
-            }}
-          >
-            {error?.stack}
-          </Typography>
-
-          {errorInfo?.componentStack && (
-            <>
-              <Typography variant="subtitle2" gutterBottom sx={{ mt: 2 }}>
-                {t('shared.feedback.errors.componentStack')}:
-              </Typography>
-              <Typography
-                variant="caption"
-                component="pre"
-                sx={{
-                  whiteSpace: 'pre-wrap',
-                  wordBreak: 'break-word',
-                  fontFamily: 'monospace',
-                  fontSize: '0.75rem',
-                  color: 'text.secondary',
-                }}
-              >
-                {errorInfo.componentStack}
-              </Typography>
-            </>
-          )}
-        </Box>
-      </Collapse>
-    </Box>
-  )
-}
-
-export const LightweightTrafficErrorBoundary: React.FC<{
-  children: ReactNode
-}> = ({ children }) => {
-  const { t } = useTranslation()
-
-  return (
-    <TrafficErrorBoundary
-      fallbackComponent={
-        <Box
-          sx={{
-            p: 1,
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            minHeight: 60,
-            bgcolor: 'error.light',
-            borderRadius: 1,
-            color: 'error.contrastText',
-          }}
-        >
-          <ErrorOutlineRounded sx={{ mr: 1, fontSize: 20 }} />
-          <Typography variant="caption">
-            {t('shared.feedback.errors.trafficUnavailable')}
-          </Typography>
-        </Box>
-      }
-    >
-      {children}
-    </TrafficErrorBoundary>
-  )
-}

src/hooks/use-icon-cache.ts

@@ -1,5 +1,4 @@
 import { convertFileSrc } from '@tauri-apps/api/core'
-import { useMemo } from 'react'
 
 import { downloadIconCache } from '@/services/cmds'
 import { useQuery } from '@/services/query-client'
@@ -23,9 +22,8 @@ export const useIconCache = ({
   const iconValue = icon?.trim() ?? ''
   const cacheKeyValue = cacheKey?.trim() ?? ''
 
-  const isEnabled = useMemo(() => {
-    return enabled && iconValue.startsWith('http') && cacheKeyValue !== ''
-  }, [enabled, iconValue, cacheKeyValue])
+  const isEnabled =
+    enabled && iconValue.startsWith('http') && cacheKeyValue !== ''
 
   const { data } = useQuery({
     queryKey: ['icon-cache', iconValue, cacheKeyValue],

src/hooks/use-log-data.ts

@@ -54,8 +54,7 @@ export const useLogData = () => {
   const hasLoadedInitialLogsRef = useRef(false)
 
   const { response, refresh, setData } = useMihomoWsSubscription<ILogItem[]>({
-    storageKey: 'mihomo_logs_date',
-    buildSubscriptKey: (date) => (enableLog ? `getClashLog-${date}` : null),
+    subscriptionKey: enableLog ? 'getClashLog' : null,
     fallbackData: [],
     connect: () => MihomoWebSocket.connect_logs(logLevel),
     setupHandlers: ({ next, scheduleReconnect, isMounted }) => {
@@ -77,14 +76,13 @@ export const useLogData = () => {
         }
         const pendingLogs = buffer.splice(0, buffer.length)
         flushTimeStr = null
-        next(null, (current) => appendLogs(current, pendingLogs))
+        next((current) => appendLogs(current, pendingLogs))
         flushTimer = null
       }
 
       return {
         handleMessage: (data) => {
           if (data.startsWith('Websocket error')) {
-            next(data)
             void scheduleReconnect()
             return
           }
@@ -108,9 +106,7 @@ export const useLogData = () => {
             if (!flushTimer) {
               flushTimer = setTimeout(flush, FLUSH_DELAY_MS)
             }
-          } catch (error) {
-            next(error)
-          }
+          } catch {}
         },
         async onConnected() {
           if (hasLoadedInitialLogsRef.current) {
@@ -119,7 +115,7 @@ export const useLogData = () => {
           const logs = await getClashLogs()
           hasLoadedInitialLogsRef.current = true
           if (isMounted()) {
-            next(null, (current) => {
+            next((current) => {
               if (!current || current.length === 0) {
                 return clampLogs(filterLogsByLevel(logs, allowedTypes))
               }

src/hooks/use-memory-data.ts

@@ -33,15 +33,13 @@ export const useMemoryData = (options?: { enabled?: boolean }) => {
   const enabled = options?.enabled ?? true
 
   const { response, refresh } = useMihomoWsSubscription<IMemoryUsageItem>({
-    storageKey: 'mihomo_memory_date',
-    buildSubscriptKey: (date) => (enabled ? `getClashMemory-${date}` : null),
+    subscriptionKey: enabled ? 'getClashMemory' : null,
     fallbackData: FALLBACK_MEMORY_USAGE,
     connect: () => MihomoWebSocket.connect_memory(),
     throttleMs: 500,
     setupHandlers: ({ next, scheduleReconnect }) => ({
       handleMessage: (data) => {
         if (data.startsWith('Websocket error')) {
-          next(data, FALLBACK_MEMORY_USAGE)
           void scheduleReconnect()
           return
         }
@@ -51,10 +49,8 @@ export const useMemoryData = (options?: { enabled?: boolean }) => {
           if (shouldSkipDuplicateMemory(parsed)) {
             return
           }
-          next(null, parsed)
-        } catch (error) {
-          next(error, FALLBACK_MEMORY_USAGE)
-        }
+          next(parsed)
+        } catch {}
       },
     }),
   })

src/hooks/use-mihomo-ws-subscription.ts

@@ -1,12 +1,7 @@
-import { useLocalStorage } from 'foxact/use-local-storage'
-import { useCallback, useEffect, useRef } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { type Message, type MihomoWebSocket } from 'tauri-plugin-mihomo-api'
 
-import {
-  removeCacheData,
-  setCacheData,
-  useQuery,
-} from '@/services/query-client'
+import { setCacheData, useQuery } from '@/services/query-client'
 
 const RECONNECT_DELAY_MS = 1000
 
@@ -31,7 +26,6 @@ interface SharedSubscriptionEntry {
 
 const sharedSubscriptions = new Map<string, SharedSubscriptionEntry>()
 const subscriptionSnapshots = new Map<string, unknown>()
-const initialSubscriptionDate = Date.now()
 
 const getSubscriptionSnapshot = <T>(key: string) =>
   subscriptionSnapshots.get(key) as T | undefined
@@ -136,15 +130,13 @@ const createSharedSubscriptionEntry = (
   return entry
 }
 
+type Updater<T> = (current?: T) => T
+
 /**
- * Mirrors SWR's MutatorCallback: consumers can pass either a plain value or a
- * functional updater `(current?: T) => T`.  The functional form is resolved
- * against the current subscription snapshot before updating SWR.
+ * Pass either a plain value or a functional updater; the updater is resolved
+ * against the current subscription snapshot before the cache is written.
  */
-type NextFn<T> = (
-  error?: any,
-  data?: T | ((current?: T) => T | undefined),
-) => void
+type NextFn<T> = (data: T | Updater<T>) => void
 
 interface HandlerContext<T> {
   next: NextFn<T>
@@ -159,8 +151,7 @@ interface HandlerResult {
 }
 
 interface UseMihomoWsSubscriptionOptions<T> {
-  storageKey: string
-  buildSubscriptKey: (date: number) => string | null
+  subscriptionKey: string | null
   fallbackData: T
   connect: () => Promise<MihomoWebSocket>
   /**
@@ -178,18 +169,12 @@ interface UseMihomoWsSubscriptionOptions<T> {
 export const useMihomoWsSubscription = <T>(
   options: UseMihomoWsSubscriptionOptions<T>,
 ) => {
-  const {
-    storageKey,
-    buildSubscriptKey,
-    fallbackData,
-    connect,
-    throttleMs,
-    setupHandlers,
-  } = options
+  const { subscriptionKey, fallbackData, connect, throttleMs, setupHandlers } =
+    options
 
-  const [date, setDate] = useLocalStorage(storageKey, initialSubscriptionDate)
-  const subscriptKey = buildSubscriptKey(date)
-  const subscriptionCacheKey = subscriptKey ? `$sub$${subscriptKey}` : null
+  const subscriptionCacheKey = subscriptionKey
+    ? `$sub$${subscriptionKey}`
+    : null
   const lastSubscriptionCacheKeyRef = useRef<string | null>(null)
   if (subscriptionCacheKey) {
     lastSubscriptionCacheKeyRef.current = subscriptionCacheKey
@@ -197,20 +182,9 @@ export const useMihomoWsSubscription = <T>(
   const responseCacheKey =
     subscriptionCacheKey ?? lastSubscriptionCacheKeyRef.current
 
-  const resolveNextData = useCallback(
-    (
-      data: T | ((current?: T) => T | undefined) | undefined,
-      cacheKey: string,
-    ): T => {
-      if (typeof data === 'function') {
-        const updater = data as (current?: T) => T | undefined
-        const current = getSubscriptionSnapshot<T>(cacheKey)
-        return updater(current) ?? fallbackData
-      }
-      return data ?? fallbackData
-    },
-    [fallbackData],
-  )
+  // Bumping the epoch re-runs the subscription effect, rebuilding the shared
+  // entry (and its captured `connect`/handler closures) under the same key.
+  const [refreshEpoch, setRefreshEpoch] = useState(0)
 
   const response = useQuery<T>({
     queryKey: responseCacheKey ? [responseCacheKey] : ['$sub$__disabled__'],
@@ -238,44 +212,35 @@ export const useMihomoWsSubscription = <T>(
     let throttleCleanup: (() => void) | undefined
     let wrappedNext: NextFn<T>
 
-    const baseNext: NextFn<T> = (error, data) => {
-      if (error !== undefined && error !== null) {
-        return
-      }
-      if (data === undefined) return
-      const resolved = resolveNextData(data, subscriptionCacheKey)
+    const baseNext: NextFn<T> = (data) => {
+      const resolved =
+        typeof data === 'function'
+          ? (data as Updater<T>)(
+              getSubscriptionSnapshot<T>(subscriptionCacheKey),
+            )
+          : (data as T)
       writeSubscriptionSnapshot(subscriptionCacheKey, resolved)
     }
 
     if (throttleMs && throttleMs > 0) {
-      let pendingData: T | ((current?: T) => T | undefined) | undefined
-      let hasPending = false
+      let pendingData: T | Updater<T> | undefined
       let timerId: ReturnType<typeof setTimeout> | null = null
 
       const flush = () => {
         timerId = null
-        if (hasPending) {
+        if (pendingData !== undefined) {
           const data = pendingData
           pendingData = undefined
-          hasPending = false
-          baseNext(undefined, data)
+          baseNext(data)
         }
       }
 
-      wrappedNext = (
-        error?: any,
-        data?: T | ((current?: T) => T | undefined),
-      ) => {
-        if (error !== undefined && error !== null) {
-          baseNext(error, data)
-          return
-        }
+      wrappedNext = (data) => {
         if (!timerId) {
-          baseNext(undefined, data)
+          baseNext(data)
           timerId = setTimeout(flush, throttleMs)
         } else {
           pendingData = data
-          hasPending = true
         }
       }
 
@@ -341,15 +306,14 @@ export const useMihomoWsSubscription = <T>(
     }
     // eslint-disable-next-line react-compiler/react-compiler
     // eslint-disable-next-line react-hooks/exhaustive-deps, @eslint-react/exhaustive-deps
-  }, [subscriptionCacheKey])
+  }, [subscriptionCacheKey, refreshEpoch])
 
   const refresh = useCallback(() => {
     if (subscriptionCacheKey) {
-      subscriptionSnapshots.delete(subscriptionCacheKey)
-      void removeCacheData([subscriptionCacheKey])
+      writeSubscriptionSnapshot(subscriptionCacheKey, fallbackData)
     }
-    setDate(Date.now())
-  }, [subscriptionCacheKey, setDate])
+    setRefreshEpoch((epoch) => epoch + 1)
+  }, [subscriptionCacheKey, fallbackData])
 
   const setData = useCallback(
     (data: T) => {

src/hooks/use-proxy-selection.test.ts

@@ -35,8 +35,8 @@ it('applies and records independent group selections while another group is pend
   const secondSuccess = vi.fn()
   const first = useProxySelection({ onSuccess: firstSuccess })
   const second = useProxySelection({ onSuccess: secondSuccess })
-  first.changeProxy('Group A', 'Node A')
-  second.changeProxy('Group B', 'Node B')
+  first.select('Group A', 'Node A')
+  second.select('Group B', 'Node B')
   await vi.waitFor(() =>
     expect(record).toHaveBeenCalledWith('Group B', 'Node B'),
   )

src/hooks/use-proxy-selection.ts

@@ -35,7 +35,6 @@ const cleanupConnections = async (previousProxy: string) => {
 interface ProxySelectionOptions {
   onSuccess?: () => void
   onError?: (error: any) => void
-  enableConnectionCleanup?: boolean
 }
 
 interface ProxyChangeRequest {
@@ -53,7 +52,7 @@ export const useProxySelection = (options: ProxySelectionOptions = {}) => {
   const pendingRequestRef = useRef<ProxyChangeRequest | null>(null)
   const isProcessingRef = useRef(false)
 
-  const { onSuccess, onError, enableConnectionCleanup = true } = options
+  const { onSuccess, onError } = options
 
   const autoCloseConnection = verge?.auto_close_connection ?? false
 
@@ -98,7 +97,7 @@ export const useProxySelection = (options: ProxySelectionOptions = {}) => {
           )
         }
 
-        if (enableConnectionCleanup && autoCloseConnection && previousProxy) {
+        if (autoCloseConnection && previousProxy) {
           void cleanupConnections(previousProxy)
         }
       } catch (error) {
@@ -112,7 +111,6 @@ export const useProxySelection = (options: ProxySelectionOptions = {}) => {
     [
       autoCloseConnection,
       forgetSelection,
-      enableConnectionCleanup,
       onError,
       onSuccess,
       recordSelection,
@@ -138,7 +136,7 @@ export const useProxySelection = (options: ProxySelectionOptions = {}) => {
     }
   }, [executeChange])
 
-  const changeProxy = useCallback(
+  const select = useCallback(
     (
       groupName: string,
       proxyName: string,
@@ -156,27 +154,5 @@ export const useProxySelection = (options: ProxySelectionOptions = {}) => {
     [flushChangeQueue],
   )
 
-  const handleSelectChange = useCallback(
-    (groupName: string, previousProxy?: string, fixed?: string) =>
-      (event: { target: { value: string } }) => {
-        changeProxy(groupName, event.target.value, previousProxy, fixed)
-      },
-    [changeProxy],
-  )
-
-  const handleProxyGroupChange = useCallback(
-    (
-      group: { name: string; now?: string | null; fixed?: string | null },
-      proxy: { name: string },
-    ) => {
-      changeProxy(group.name, proxy.name, group.now!, group.fixed!)
-    },
-    [changeProxy],
-  )
-
-  return {
-    changeProxy,
-    handleSelectChange,
-    handleProxyGroupChange,
-  }
+  return { select }
 }

src/hooks/use-system-proxy-state.ts

@@ -52,9 +52,8 @@ export const useSystemProxyState = () => {
   const toggleSystemProxy = async (enabled: boolean) => {
     // Roll failed optimistic writes back to the latest confirmed state.
     let confirmed = verge?.enable_system_proxy ?? false
-    mutateVerge(
-      (prev) => (prev ? { ...prev, enable_system_proxy: enabled } : prev),
-      false,
+    mutateVerge((prev) =>
+      prev ? { ...prev, enable_system_proxy: enabled } : prev,
     )
     pendingRef.current = enabled
 
@@ -78,9 +77,8 @@ export const useSystemProxyState = () => {
         }
       }
     } catch (error) {
-      mutateVerge(
-        (prev) => (prev ? { ...prev, enable_system_proxy: confirmed } : prev),
-        false,
+      mutateVerge((prev) =>
+        prev ? { ...prev, enable_system_proxy: confirmed } : prev,
       )
       // Queued requests were based on a state that never landed.
       pendingRef.current = null

src/hooks/use-system-state.ts

@@ -41,7 +41,8 @@ export function useAppUptime() {
   const { data: uptime = 0 } = useQuery({
     queryKey: appUptimeQueryKey,
     queryFn: getAppUptime,
-    staleTime: 5000,
+    // The wrapper maps staleTime to SWR's dedupingInterval, which drops
+    // refetchInterval ticks while it exceeds the interval.
     refetchInterval: 3000,
     refetchOnWindowFocus: false,
     refetchOnReconnect: false,

src/hooks/use-traffic-data.ts

@@ -32,15 +32,13 @@ export const useTrafficData = (options?: { enabled?: boolean }) => {
     graphData: { appendData },
   } = useTrafficMonitorEnhanced({ subscribe: false, enabled })
   const { response, refresh } = useMihomoWsSubscription<ITrafficItem>({
-    storageKey: 'mihomo_traffic_date',
-    buildSubscriptKey: (date) => (enabled ? `getClashTraffic-${date}` : null),
+    subscriptionKey: enabled ? 'getClashTraffic' : null,
     fallbackData: FALLBACK_TRAFFIC,
     connect: () => MihomoWebSocket.connect_traffic(),
     throttleMs: 200,
     setupHandlers: ({ next, scheduleReconnect }) => ({
       handleMessage: (data) => {
         if (data.startsWith('Websocket error')) {
-          next(data, FALLBACK_TRAFFIC)
           void scheduleReconnect()
           return
         }
@@ -51,10 +49,8 @@ export const useTrafficData = (options?: { enabled?: boolean }) => {
             return
           }
           appendData(parsed)
-          next(null, parsed)
-        } catch (error) {
-          next(error, FALLBACK_TRAFFIC)
-        }
+          next(parsed)
+        } catch {}
       },
     }),
   })

src/hooks/use-traffic-monitor.ts

@@ -3,7 +3,6 @@ import { Traffic } from 'tauri-plugin-mihomo-api'
 
 import { useVisibility } from '@/hooks/use-visibility'
 import { debugLog } from '@/utils/debug'
-import { TrafficDataSampler, isSameTrafficData } from '@/utils/traffic-sampler'
 
 // 引用计数管理器
 class ReferenceCounter {
@@ -32,119 +31,11 @@ const WORKER_CONFIG = {
   defaultRangeMinutes: 10,
 }
 
-class InlineTrafficMonitor {
-  private config = { ...WORKER_CONFIG }
-  private sampler = new TrafficDataSampler(this.config)
-  private throttleTimer: ReturnType<typeof setTimeout> | null = null
-  private agingTimer: ReturnType<typeof setInterval> | null = null
-  private currentRange = this.config.defaultRangeMinutes
-  private lastTimestamp: number | undefined
-  private lastBroadcast: ITrafficDataPoint[] = []
-
-  constructor(
-    private emit: (snapshot: ITrafficWorkerSnapshotMessage) => void,
-  ) {}
-
-  start(rangeMinutes?: number) {
-    this.currentRange = rangeMinutes ?? this.currentRange
-    this.handle({
-      type: 'init',
-      config: {
-        ...this.config,
-        defaultRangeMinutes: this.currentRange,
-      },
-    })
-  }
-
-  stop() {
-    if (this.throttleTimer !== null) {
-      clearTimeout(this.throttleTimer)
-      this.throttleTimer = null
-    }
-    if (this.agingTimer !== null) {
-      clearInterval(this.agingTimer)
-      this.agingTimer = null
-    }
-    this.sampler.clear()
-    this.lastTimestamp = undefined
-  }
-
-  handle(message: TrafficWorkerRequestMessage) {
-    switch (message.type) {
-      case 'init': {
-        this.config = { ...message.config }
-        this.sampler = new TrafficDataSampler(this.config)
-        this.currentRange = message.config.defaultRangeMinutes
-        // Re-broadcast when points age out of the range, not on every tick
-        this.agingTimer = setInterval(() => {
-          if (this.throttleTimer !== null) return
-          const slice = this.sampler.getDataForTimeRange(this.currentRange)
-          if (!isSameTrafficData(this.lastBroadcast, slice)) {
-            this.emitSnapshot()
-          }
-        }, 1000)
-        this.emitSnapshot()
-        break
-      }
-      case 'append': {
-        const timestamp = message.payload.timestamp ?? Date.now()
-        const dataPoint: ITrafficDataPoint = {
-          up: message.payload.up || 0,
-          down: message.payload.down || 0,
-          timestamp,
-        }
-
-        this.lastTimestamp = timestamp
-        this.sampler.addDataPoint(dataPoint)
-        this.scheduleSnapshot()
-        break
-      }
-      case 'setRange': {
-        if (this.currentRange !== message.minutes) {
-          this.currentRange = message.minutes
-          this.emitSnapshot()
-        }
-        break
-      }
-      case 'requestSnapshot': {
-        this.emitSnapshot()
-        break
-      }
-      default:
-        break
-    }
-  }
-
-  private emitSnapshot() {
-    const dataPoints = this.sampler.getDataForTimeRange(this.currentRange)
-
-    this.emit({
-      type: 'snapshot',
-      dataPoints,
-      samplerStats: this.sampler.getStats(),
-      lastTimestamp: this.lastTimestamp,
-    })
-    this.lastBroadcast = dataPoints
-  }
-
-  private scheduleSnapshot() {
-    if (this.throttleTimer !== null) return
-    this.throttleTimer = setTimeout(() => {
-      this.throttleTimer = null
-      this.emitSnapshot()
-    }, this.config.snapshotIntervalMs)
-  }
-}
-
 class TrafficWorkerClient {
   private worker: Worker | null = null
-  private inlineMonitor: InlineTrafficMonitor | null = null
-  private mode: 'worker' | 'inline' | null = null
   private listeners = new Set<
     (snapshot: ITrafficWorkerSnapshotMessage) => void
   >()
-  private pendingMessages: TrafficWorkerRequestMessage[] = []
-  private ready = false
   private currentRange = WORKER_CONFIG.defaultRangeMinutes
 
   start(rangeMinutes?: number) {
@@ -155,101 +46,52 @@ class TrafficWorkerClient {
 
     this.currentRange = rangeMinutes ?? this.currentRange
 
-    if (this.ready) return
+    if (this.worker) return
 
     const initMessage: TrafficWorkerRequestMessage = {
       type: 'init',
-      config: {
-        rawDataMinutes: WORKER_CONFIG.rawDataMinutes,
-        compressedDataMinutes: WORKER_CONFIG.compressedDataMinutes,
-        compressionRatio: WORKER_CONFIG.compressionRatio,
-        snapshotIntervalMs: WORKER_CONFIG.snapshotIntervalMs,
-        defaultRangeMinutes: this.currentRange,
-      },
+      config: { ...WORKER_CONFIG, defaultRangeMinutes: this.currentRange },
     }
 
-    if (typeof Worker !== 'undefined') {
-      try {
-        this.worker = new Worker(
-          new URL('../services/traffic-monitor-worker.ts', import.meta.url),
-          { type: 'module' },
-        )
-        this.mode = 'worker'
+    this.worker = new Worker(
+      new URL('../services/traffic-monitor-worker.ts', import.meta.url),
+      { type: 'module' },
+    )
 
-        this.worker.onmessage = (
-          event: MessageEvent<TrafficWorkerResponseMessage>,
-        ) => {
-          const message = event.data
-          if (message.type === 'snapshot') {
-            if (import.meta.env.MODE === 'perf') {
-              document.documentElement.dataset.perfWorker = String(
-                message.lastTimestamp ?? 0,
-              )
-              document.documentElement.dataset.perfPoints = String(
-                message.dataPoints.length,
-              )
-              const last = message.dataPoints.at(-1)
-              document.documentElement.dataset.perfLastUp = String(
-                last?.up ?? 0,
-              )
-              document.documentElement.dataset.perfLastDown = String(
-                last?.down ?? 0,
-              )
-            }
-            this.listeners.forEach((listener) => {
-              listener(message)
-            })
-          }
+    this.worker.onmessage = (
+      event: MessageEvent<TrafficWorkerResponseMessage>,
+    ) => {
+      const message = event.data
+      if (message.type === 'snapshot') {
+        if (import.meta.env.MODE === 'perf') {
+          document.documentElement.dataset.perfWorker = String(
+            message.lastTimestamp ?? 0,
+          )
+          document.documentElement.dataset.perfPoints = String(
+            message.dataPoints.length,
+          )
+          const last = message.dataPoints.at(-1)
+          document.documentElement.dataset.perfLastUp = String(last?.up ?? 0)
+          document.documentElement.dataset.perfLastDown = String(
+            last?.down ?? 0,
+          )
         }
-
-        this.worker.onerror = (error) => {
-          debugLog(`[TrafficWorkerClient] Worker error: ${String(error)}`)
-        }
-
-        this.ready = true
-        this.post(initMessage)
-        this.flushQueue()
-        return
-      } catch (error) {
-        debugLog(
-          `[TrafficWorkerClient] Worker initialization failed, falling back to inline sampler: ${String(error)}`,
-        )
-        this.worker = null
-        this.mode = null
+        this.listeners.forEach((listener) => {
+          listener(message)
+        })
       }
-    } else {
-      debugLog(
-        '[TrafficWorkerClient] Worker not supported, using inline sampler',
-      )
     }
 
-    this.startInline(initMessage)
-  }
+    this.worker.onerror = (error) => {
+      debugLog(`[TrafficWorkerClient] Worker error: ${String(error)}`)
+    }
 
-  private startInline(initMessage: TrafficWorkerRequestMessage) {
-    this.inlineMonitor = new InlineTrafficMonitor((snapshot) => {
-      this.listeners.forEach((listener) => {
-        listener(snapshot)
-      })
-    })
-    this.mode = 'inline'
-    this.ready = true
     this.post(initMessage)
-    this.flushQueue()
   }
 
   stop() {
-    if (this.worker) {
-      this.worker.terminate()
-    }
-    if (this.inlineMonitor) {
-      this.inlineMonitor.stop()
-    }
+    this.worker?.terminate()
     this.worker = null
-    this.inlineMonitor = null
-    this.mode = null
-    this.ready = false
-    this.pendingMessages = []
   }
 
   onSnapshot(listener: (snapshot: ITrafficWorkerSnapshotMessage) => void) {
@@ -260,37 +102,11 @@ class TrafficWorkerClient {
   }
 
   private post(message: TrafficWorkerRequestMessage) {
-    if (!this.ready) {
-      this.pendingMessages.push(message)
-      return
-    }
-
-    if (this.mode === 'worker' && this.worker) {
-      this.worker.postMessage(message)
-      return
-    }
-
-    if (this.mode === 'inline' && this.inlineMonitor) {
-      this.inlineMonitor.handle(message)
-      return
-    }
-
-    this.pendingMessages.push(message)
-  }
-
-  private flushQueue() {
-    if (!this.ready || this.pendingMessages.length === 0) {
-      return
-    }
-    const queued = [...this.pendingMessages]
-    this.pendingMessages = []
-    queued.forEach((message) => {
-      this.post(message)
-    })
+    this.worker?.postMessage(message)
   }
 
   private ensureStarted() {
-    if (!this.ready) {
+    if (!this.worker) {
       this.start(this.currentRange)
     }
   }

src/hooks/use-verge.ts

@@ -25,7 +25,6 @@ export const useVerge = () => {
       | IVergeConfig
       | ((prev: IVergeConfig | undefined) => IVergeConfig | undefined)
       | undefined,
-    _revalidate?: boolean,
   ) => {
     if (updaterOrData === undefined) {
       void refetch()

src/hooks/use-window.ts

@@ -11,36 +11,24 @@ const useWindow = () => {
 }
 
 export const useWindowControls = () => {
-  const {
-    maximized,
-    minimize,
-    toggleMaximize,
-    close,
-    toggleFullscreen,
-    currentWindow,
-  } = useWindow()
+  const { maximized, minimize, toggleMaximize, close, currentWindow } =
+    useWindow()
   return {
     maximized,
     minimize,
     toggleMaximize,
     close,
-    toggleFullscreen,
     currentWindow,
   } satisfies Pick<
     WindowContextType,
-    | 'maximized'
-    | 'minimize'
-    | 'toggleMaximize'
-    | 'close'
-    | 'toggleFullscreen'
-    | 'currentWindow'
+    'maximized' | 'minimize' | 'toggleMaximize' | 'close' | 'currentWindow'
   >
 }
 
 export const useWindowDecorations = () => {
-  const { decorated, toggleDecorations, refreshDecorated } = useWindow()
-  return { decorated, toggleDecorations, refreshDecorated } satisfies Pick<
+  const { decorated, toggleDecorations } = useWindow()
+  return { decorated, toggleDecorations } satisfies Pick<
     WindowContextType,
-    'decorated' | 'toggleDecorations' | 'refreshDecorated'
+    'decorated' | 'toggleDecorations'
   >
 }

src/pages/_layout.tsx

@@ -1,8 +1,7 @@
 import { Paper, ThemeProvider } from '@mui/material'
 import dayjs from 'dayjs'
 import relativeTime from 'dayjs/plugin/relativeTime'
-import { useCallback, useEffect, useMemo, useRef } from 'react'
-import { useTranslation } from 'react-i18next'
+import { useCallback, useEffect, useMemo } from 'react'
 import { Outlet, useNavigate } from 'react-router'
 
 import { BaseErrorBoundary } from '@/components/base'
@@ -38,7 +37,6 @@ const OS = getSystem()
 const Layout = () => {
   const mode = useThemeMode()
   const isDark = mode !== 'light'
-  const { t } = useTranslation()
   const { theme } = useCustomTheme()
   const { verge } = useVerge()
   const { language } = verge ?? {}
@@ -46,7 +44,6 @@ const Layout = () => {
   const { switchLanguage } = useI18n()
   const navigate = useNavigate()
   const themeReady = useMemo(() => Boolean(theme), [theme])
-  const windowControlsRef = useRef<any>(null)
   const { decorated } = useWindowDecorations()
 
   const customTitlebar = useMemo(
@@ -57,7 +54,7 @@ const Layout = () => {
             className="the_titlebar-drag-region"
             data-tauri-drag-region="true"
           />
-          <WindowControls ref={windowControlsRef} />
+          <WindowControls />
         </div>
       ) : null,
     [decorated],
@@ -69,12 +66,12 @@ const Layout = () => {
     (payload: [string, string]) => {
       const [status, msg] = payload
       try {
-        handleNoticeMessage(status, msg, t, navigate)
+        handleNoticeMessage(status, msg, navigate)
       } catch (error) {
         console.error('[通知处理] 失败:', error)
       }
     },
-    [t, navigate],
+    [navigate],
   )
 
   useEventBus(handleNotice)
@@ -110,20 +107,6 @@ const Layout = () => {
       <NoticeManager position={verge?.notice_position} />
       <ServiceMigrationDialog />
       <SysproxyPrivilegeDialog />
-      <div
-        style={{
-          animation: 'fadeIn 0.5s',
-          WebkitAnimation: 'fadeIn 0.5s',
-        }}
-      />
-      <style>
-        {`
-            @keyframes fadeIn {
-              from { opacity: 0; }
-              to { opacity: 1; }
-            }
-          `}
-      </style>
       <Paper
         square
         elevation={0}

src/pages/profiles.tsx

@@ -83,7 +83,6 @@ const ProfilePage = () => {
   const { t } = useTranslation()
   const location = useLocation()
   const [url, setUrl] = useState('')
-  const [disabled, setDisabled] = useState(false)
   const [profileDndRevision, setProfileDndRevision] = useState(0)
   const [activatings, setActivatings] = useState<string[]>([])
   const [switchTarget, setSwitchTarget] = useState<string | null>(null)
@@ -257,7 +256,6 @@ const ProfilePage = () => {
         )
       }
     } finally {
-      setDisabled(false)
       setLoading(false)
     }
   }
@@ -824,7 +822,7 @@ const ProfilePage = () => {
             if (event.key !== 'Enter' || event.nativeEvent.isComposing) {
               return
             }
-            if (!url || disabled || loading) {
+            if (!url || loading) {
               return
             }
             event.preventDefault()
@@ -857,7 +855,7 @@ const ProfilePage = () => {
           }}
         />
         <Button
-          disabled={!url || disabled}
+          disabled={!url}
           loading={loading}
           variant="contained"
           size="small"

src/pages/rules.tsx

@@ -24,11 +24,8 @@ const RulesPage = () => {
   const [showScrollTop, setShowScrollTop] = useState(false)
   const pageVisible = useVisibility()
 
-  // 在组件挂载时和页面获得焦点时刷新规则数据
+  // 页面可见时刷新规则数据：挂载时可见或从隐藏恢复可见各触发一次
   useEffect(() => {
-    refreshRules()
-    refreshRuleProviders()
-
     if (pageVisible) {
       refreshRules()
       refreshRuleProviders()

src/providers/app-data-provider.tsx

@@ -26,7 +26,9 @@ const TQ_MIHOMO = {
   refetchOnReconnect: false,
   staleTime: 1500,
   retry: 3,
-  retryDelay: (attempt: number) => Math.min(200 * 2 ** attempt, 3000),
+  // SWR's default retry waits about 2^retryCount * errorRetryInterval with
+  // jitter, so 100 reproduces the previous 200 * 2^attempt backoff.
+  retryDelay: 100,
 } as const
 
 const TQ_DEFAULTS = {

src/providers/window/window-context.ts

@@ -5,11 +5,9 @@ export interface WindowContextType {
   decorated: boolean | null
   maximized: boolean | null
   toggleDecorations: () => Promise<void>
-  refreshDecorated: () => Promise<boolean>
   minimize: () => Promise<void>
   close: () => Promise<void>
   toggleMaximize: () => Promise<void>
-  toggleFullscreen: () => Promise<void>
   currentWindow: ReturnType<typeof getCurrentWindow>
 }