* fix(connections): stabilize table memory usage
Render the connections table and list from stable row view models, and replace the TanStack row/cell instantiation path with a lightweight virtualized table body.
The leak was isolated to the frontend table render path: websocket data without the table stayed flat, while the normal table path kept producing large per-snapshot object graphs under active/closed churn.
Introduced-by: bf06cbc87d (introduced the TanStack table path)
Related-hot-path: 068678135 (made default ordering/filtering hot enough for long-running /connections sessions to amplify retained heap/RSS)
Related-retention-path: 7fc238c27b (moved Home stats to the full connection websocket subscription, so Home could keep connection snapshots alive for totals/count)
Keep UI behavior intact: column visibility, column order, resizing, sorting, connection details, the closed-connection cap, and the 500ms refresh cadence remain.
* fix(connections): lazily release connection snapshots
Keep the full active/closed connection snapshot scoped to /connections by using a short React Query gcTime for the full subscription.
Home now subscribes to a lightweight connection summary for totals and active count, so leaving /connections no longer keeps the full active/closed arrays and closed history alive for the dashboard.
Only the selected Active or Closed mode feeds filtering, sorting, row-view derivation, and table/list rendering. Switching modes remounts the row subtree and closes detail/column-manager state without changing the capped closed-history behavior.
* fix(connections): decouple collection from rendering
Move the high-frequency connection websocket path out of React Query and into a module-level external store consumed with useSyncExternalStore.
The store keeps one normalized active snapshot plus the capped closed history, continues collecting across route changes, and only notifies mounted subscribers. Home reads the same store through a lightweight summary snapshot, so leaving /connections no longer renders the table/list while connection history is still preserved.
This replaces the short-gc release behavior that made Active/Closed history disappear after navigating away, and bounds retained data to current active connections plus the closed cap instead of React Query cache objects.
* fix(connections): keep collection store authoritative
Remove the temporary per-subscription gcTime override added for /connections. The connection monitor now owns active/closed retention outside React Query, so route changes should stop rendering without clearing collected history.
This leaves the shared Mihomo websocket hook on its original 30s cache behavior for logs, traffic, and memory while /connections uses the external store introduced in the previous commit.
* perf(connections): coalesce snapshots before parsing
Keep only the latest raw websocket message during the 500ms throttle window and parse it when the store flushes. High-churn connection bursts no longer allocate parsed object graphs for snapshots that will be overwritten before React can observe them.
Also compare incoming metadata through the same normalization used for retained records, so optional undefined fields do not prevent metadata reference reuse.
* perf(connections): trim render allocations
Reuse existing row view objects before formatting derived strings when the retained connection object reference is unchanged. Stable closed-history rows no longer allocate throwaway display strings on every snapshot.
Measure the table scroll viewport on mount and resize instead of assuming a 1200px body, so virtual rendering starts from the real visible row count. Keep table state across Active/Closed switches and share the relative-time cell between table and list rows.
* perf(connections): tighten shared time updates
Refresh the shared relative-time clock before the first subscriber render and switch the listener registry back to a Set, avoiding stale labels after returning to /connections and keeping subscriber churn O(1).
Also sort table time rows by the existing numeric startTime field, drop the redundant row-view startTime equality check, and remove one unnecessary table prop guard.
* perf(connections): skip table-wide row projection
Stop materializing ConnectionRowView objects for the whole filtered dataset in table layout. The page now keeps raw connection records for the table path and only formats visible cells inside the virtualized table body, while list layout keeps the cached row-view path.
This removes the steady 500ms allocation pass that was still walking every filtered connection before table rendering. Detail lookup now reads the current filtered raw record directly, and the table clamps scroll state when switching between datasets of different lengths.
* perf(connections): skip unnecessary filter clone when table not searching
In table mode, avoid creating a filtered copy when search is empty: only apply search/sort work for non-empty query while retaining the same default order behavior. Also replace parsing in order comparators with numeric startTime to avoid per-tick Date object churn and use SearchBox state to detect an empty search.
In table layout without search input, use upstream connection snapshot directly for rendering instead of cloning/sorting every interval tick. This removes a persistent per-update array allocation path while keeping list-mode sort/search behavior unchanged.
* perf(connections): bound closed merge without full transient arrays
Cap closed-history promotion while iterating previous active set without building a temporary large closed array. This preserves the 500-item limit while avoiding 100k-scale transient allocations when many connections close between snapshots.
* fix(changelog): address memory leak caused by frontend
* perf(connections): cache visible table cell snapshots
Add a bounded row snapshot cache for the virtualized table so repeated paints and optional column sorting reuse stable formatted strings instead of rebuilding host/source/rule/chains/traffic text on every refresh. The cache is capped to avoid retaining large active sets.
Also skip full connection-data snapshot merging when only summary listeners are mounted, keeping Home on the summary-only path without changing Connections history while the page is subscribed.
* chore: update Changelog
* chore: update Changelog
- Replace boolean/string validation results with structured ValidationOutcome values across config validation, profile switching, DNS validation, and script validation. Callers can now distinguish valid, invalid, skipped, and busy states, with invalid results carrying an error kind and message.
- Route core config updates through structured outcomes and checked forced updates. Generation and validation failures now discard runtime drafts and surface validation failures instead of relying on empty success messages.
- Preserve existing frontend ergonomics by keeping boolean service wrappers where callers only need success, while direct DNS and script validation consumers receive ValidationOutcome. Failed profile editor saves reload the backend-restored file content and synchronize Monaco models so reopened editors show the restored state.
WebSocket hooks (use-connection-data, use-log-data)
- Single-pass merge for connection snapshots; reuse previous row reference
when upload/download are unchanged so downstream memos can bail out
- Single-allocation cap on closedConnections (no double concat+slice)
- Single-allocation clamp in appendLogs
- Cache dayjs().format result within each 50ms log flush window
Connection table (connection-table.tsx)
- Decouple 5s relative-time tick from columnDefs via shared module-level
tickStore + memoised RelativeTimeCell so the tick no longer rebuilds
the table
- RowComponent memo with custom comparator (relies on stable row reference)
- Lift sx objects to module scope
- Stable onShowDetail via ref
App data provider (app-data-provider, app-data-context)
- Split monolithic context into six sub-contexts (Proxies/Rules/ClashConfig/
System/Uptime/Refreshers); 3s uptime ticks no longer invalidate unrelated
consumers
- useAppData adapter aggregates sub-contexts; consumer files unchanged
- useStableFn helper stabilises all refresh* callback identities
- Extract useCtx helper to remove repeated null-check boilerplate
Canvas traffic graph (enhanced-canvas-traffic-graph, use-traffic-monitor)
- Lift Y-axis scale (max/min) to drawGraph layer; calculateY allocations
per frame: ~600 -> 1
- Document visibility gate stops RAF and the setNow interval when the
window is hidden; appendData unaffected
- Reuse the existing visibilitychange listener instead of adding a second
one; isDocumentVisibleRef guards animate() inside the frame
- Convert forEach arrow shorthands to block bodies
- Drop unnecessary state-setter deps from a useCallback
Proxy groups (proxy-groups, proxy-render, use-render-list)
- Narrow proxyColItemsMemo dep: headState -> headState.showType
- Per-group fingerprint cache + prevListRef in use-render-list; steady-state
refetch ticks become O(0) and the list reference stays stable when nothing
changed
- useStableCallback wraps handleCheckAll / handleLocation
- Extract shared delay state logic from ProxyItem and ProxyItemMini
into `useProxyDelayState` hook (src/hooks/use-proxy-delay-state.ts);
JSX display thresholds preserved per-component.
- Deduplicate rAF/setTimeout/Promise scheduling in DelayManager via
a private `scheduleOnNextFrame` helper.
- Drop no-op `useMemo(() => MODES, [])` in proxies page.
- Replace `any` on `setClashLog` prev params and layout-traffic sx
objects with proper types (`pre!`, `Pick<BoxProps|...>`).
- Dispose Monaco editor instances on dialog close to prevent cycle leak
- Replace gcTime: Infinity with finite TTLs and evict orphaned subscription queryKeys
- Add missing useEffect cleanup for timers, move setTimeout out of useMemo
- Add 10s startup grace period before TUN auto-disable logic activates;
service IPC may not be ready when the frontend first queries, causing
a transient isServiceOk=false that incorrectly persists
- Replace placeholderData (which set isLoading=false with stale data)
with a proper isStartingUp guard; query now polls every 2s during
startup to catch service readiness quickly
- Add 'getSystemState' to refresh-verge-config invalidation keys to
fix key mismatch that prevented event-driven refetches from working
Replace swr with @tanstack/react-query v5 across all hooks, providers,
and components. Introduce singleton QueryClient, WS subscription pattern
via useQuery+useEffect, and enforce component-layer cache access contract.
Preserve SWR cache in onConnected to avoid replacing accumulated logs
with kernel buffer on reconnect. Add KeepAlive for the logs page so
its DOM stays mounted across route changes, removing the visible blank
window when navigating back.
Add leading-edge throttle to useMihomoWsSubscription, reduce SWR retry
aggressiveness, and increase WebSocket reconnect delay to prevent event
storms when switching profiles under poor network conditions.
- use-system-state: convert module-level `disablingTunMode` to useRef
to isolate state per hook instance, fix no-op clearTimeout, add
proper effect cleanup
- use-profiles: convert forEach to for..of so selectNodeForGroup is
properly awaited, remove fire-and-forget setTimeout around mutate
- use-clash: add useLockFn to patchInfo for concurrency safety
- Remove unused `dns_settings_enabled` localStorage writes in
setting-clash.tsx — state is sourced from verge config, these
writes were never read anywhere.
- Replace hardcoded `'last_check_update'` localStorage read in
system-info-card.tsx with exported `readLastCheckTime()` from
the useUpdate hook, keeping the key in a single source of truth.
The settings page "Check for updates" did not update the homepage
"last check update time" because each page managed the timestamp
independently. Centralizes the timestamp in the useUpdate hook
via SWR + localStorage so both pages share a single data source.
Closes https://github.com/clash-verge-rev/clash-verge-rev/issues/6605#issuecomment-4147144987
* refactor: replace handle::Handle::get_window() with WindowManager::get_main_window() in multiple files
* refactor: enhance WindowManager to return window state alongside the main window instance
* refactor: update useProfiles and ProfilePage to support profile overrides and improve patchProfilesConfig return type
* refactor: enhance handle_success to check main window existence before notifying profile changes
* refactor: simplify get_main_window_with_state by using pattern matching and improve window state handling
* refactor: fix window activation by removing unnecessary reference in activate_existing_main_window
* refactor: remove redundant macOS conditional for window_manager import
* refactor(traffic-monitor): Move traffic sampling/compression to a dedicated Web Worker
* refactor(traffic-monitor): introduce shared sampler, safe fallback, and decoupled range handling
* refactor(traffic-monitor): add optional subscribe flag and fix range handling
* fix(traffic-monitor): age out idle samples and prevent ref-count updates after unmount
Fixed race condition where button state and background color would desync
during rapid toggles or slow backend responses.
Root causes:
- Button used actualState while background used configState
- toggleSystemProxy returned immediately via setTimeout(0), releasing lock
before backend operation completed
- 100ms delay in updateProxyStatus caused visual flash
Changes:
- Unified state source: both button and background now use actualState
- Made toggleSystemProxy truly async with proper await chain
- Wrapped toggle function with useLockFn to serialize operations
- Reduced state refresh delay from 100ms to 50ms
- Fixed GuardState lock release timing for async operations
- Added proper error rollback with state refresh on failure
Resolves issue where proxy toggle button would show as off while
background remained green, or vice versa.
Tunglies