Release 3.8.1.1: lighter idle UI poll, core cache, multicore ping.

Reduce idle CPU (cheap PollUI, binary cache, logbuf cap, DOM fingerprint),
speed ping/AWG HostPort, CopyBuffer pool; ship arm64 build and update notes.

Co-authored-by: Cursor <cursoragent@cursor.com>

internal/corebin/cache.go

@@ -0,0 +1,73 @@
+package corebin
+
+import (
+	"os"
+	"sync"
+)
+
+var (
+	mu    sync.Mutex
+	cache = map[string]string{}
+)
+
+// CacheKey identifies a resolved core binary for a binDir + protocol.
+func CacheKey(binDir, proto string) string {
+	return binDir + "\x00" + proto
+}
+
+// Get returns a cached absolute path if present.
+func Get(key string) (string, bool) {
+	mu.Lock()
+	defer mu.Unlock()
+	p, ok := cache[key]
+	return p, ok
+}
+
+// Set stores a resolved path.
+func Set(key, path string) {
+	if key == "" || path == "" {
+		return
+	}
+	mu.Lock()
+	cache[key] = path
+	mu.Unlock()
+}
+
+// Invalidate clears all cached paths (call after EnsureCore / binDir change).
+func Invalidate() {
+	mu.Lock()
+	cache = map[string]string{}
+	mu.Unlock()
+}
+
+// Resolve caches the result of fn under key. Stale paths (missing on disk) are refreshed.
+func Resolve(key string, fn func() (string, error)) (string, error) {
+	if path, ok := Get(key); ok {
+		if _, err := os.Stat(path); err == nil {
+			return path, nil
+		}
+		mu.Lock()
+		delete(cache, key)
+		mu.Unlock()
+	}
+	path, err := fn()
+	if err != nil {
+		return "", err
+	}
+	Set(key, path)
+	return path, nil
+}
+
+// ProtoKey normalizes protocol to the shared binary cache key (xray covers vless/vmess/trojan).
+func ProtoKey(proto string) string {
+	switch proto {
+	case "hysteria2":
+		return "hysteria2"
+	case "awg":
+		return "awg"
+	case "vless", "vmess", "trojan", "xray":
+		return "xray"
+	default:
+		return "naive"
+	}
+}

internal/corebin/cache_test.go

@@ -0,0 +1,45 @@
+package corebin
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestResolveCacheAndStale(t *testing.T) {
+	Invalidate()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "core")
+	if err := os.WriteFile(path, []byte("x"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	key := CacheKey(dir, "naive")
+	calls := 0
+	fn := func() (string, error) {
+		calls++
+		return path, nil
+	}
+	if p, err := Resolve(key, fn); err != nil || p != path || calls != 1 {
+		t.Fatalf("first: path=%q calls=%d err=%v", p, calls, err)
+	}
+	if p, err := Resolve(key, fn); err != nil || p != path || calls != 1 {
+		t.Fatalf("cached: path=%q calls=%d err=%v", p, calls, err)
+	}
+	_ = os.Remove(path)
+	if _, err := Resolve(key, fn); err != nil {
+		// fn returns removed path; Resolve still succeeds but next Stat misses
+		t.Fatalf("unexpected err after delete before recreate: %v", err)
+	}
+	if calls != 2 {
+		t.Fatalf("expected refresh call, got %d", calls)
+	}
+	if err := os.WriteFile(path, []byte("y"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if p, err := Resolve(key, fn); err != nil || p != path {
+		t.Fatalf("after recreate: %q %v", p, err)
+	}
+	if ProtoKey("vless") != "xray" || ProtoKey("naive") != "naive" {
+		t.Fatal("ProtoKey")
+	}
+}