分集图片设置落库

internal/service/cloud115/client.go

@@ -150,6 +150,7 @@ func (c *OpenClient) doJSON(ctx context.Context, method, rawURL string, form map
 		if err != nil {
 			return nil, err
 		}
+		attemptedAccess := strings.TrimPrefix(req.Header.Get("Authorization"), "Bearer ")
 
 		resp, err := c.HTTP.Do(req)
 		if err != nil {
@@ -218,7 +219,7 @@ func (c *OpenClient) doJSON(ctx context.Context, method, rawURL string, form map
 		// refresh_token 刷新后重试一次。刷新失败或重试后仍失败才返回，
 		// 避免长时间同步因 token 过期而整体失败。
 		if isTokenCode(base.Code) {
-			if access && c.tryRefreshTokenLocked(ctx) {
+			if access && c.tryRefreshTokenLocked(ctx, attemptedAccess) {
 				continue
 			}
 			if access {
@@ -305,21 +306,23 @@ func (c *OpenClient) doAuthJSONWithUA(ctx context.Context, method, rawURL string
 // tryRefreshTokenLocked 并发安全地刷新 access_token；成功返回 true（调用方
 // 应使用内存中的新 token 重试原请求）。
 //
-// 拿到写锁后在锁内读取 oldAccess，与持锁期间的当前值对比：若已被其他
-// goroutine 刷新过则直接复用新 token，避免并发请求连环轮转消耗 115 的
-// 一次性 refresh_token。全程持写锁读写 token 字段，无 TOCTOU 窗口。
+// failedAccess 是失败请求实际携带的 token。拿到写锁后与当前 token 对比：
+// 若已被其他 goroutine 刷新过则直接复用，避免并发请求连环轮转消耗 115
+// 的一次性 refresh_token。全程持写锁读写 token 字段，无 TOCTOU 窗口。
 //
 // 对"refresh_token 本身已失效/被吊销"（IsRefreshTokenDead，如 40140114/116/119/120）
 // 这类不可恢复的错误直接放弃并清空内存 token（提示需重新授权）。
 // 对其它失败（网络瞬时抖动、刷新接口可重试错误码等）做指数退避重试几次再放弃，
 // 避免同步长任务中途 token 到期时恰好撞上一个短暂的刷新失败就整体失败。
-func (c *OpenClient) tryRefreshTokenLocked(ctx context.Context) bool {
+func (c *OpenClient) tryRefreshTokenLocked(ctx context.Context, failedAccess string) bool {
 	c.tokenMu.Lock()
-	// 在已持有写锁内读取当前 token 作为"刷新前快照"，消除双重加锁窗口：
-	// 若在拿锁期间已有其他 goroutine 完成刷新，refreshTokenWhileLocked
-	// 内的 c.AccessToken != oldAccess 判断会立即命中并返回复用。
-	oldAccess := c.AccessToken
-	newToken, ok := c.refreshTokenWhileLocked(ctx, oldAccess)
+	// 请求发出后若其他 goroutine 已经刷新完成，直接复用新 token 重试；
+	// 不能再次轮换一次性的 refresh_token。
+	if failedAccess != "" && c.AccessToken != failedAccess {
+		c.tokenMu.Unlock()
+		return true
+	}
+	newToken, ok := c.refreshTokenWhileLocked(ctx, failedAccess)
 	c.tokenMu.Unlock()
 	// 回调必须在 tokenMu 释放后调用，避免上层在回调内访问客户端时死锁
 	if ok && newToken != nil && c.OnTokenRefreshed != nil {

internal/service/cloud115/cloud115_test.go

@@ -140,6 +140,47 @@ func TestRefreshTokenDead(t *testing.T) {
 	}
 }
 
+func TestConcurrentTokenFailuresShareOneRefresh(t *testing.T) {
+	var mu sync.Mutex
+	refreshCalls := 0
+	mockAPI(t, func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/open/refreshToken" {
+			t.Errorf("unexpected path %s", r.URL.Path)
+		}
+		mu.Lock()
+		refreshCalls++
+		mu.Unlock()
+		time.Sleep(50 * time.Millisecond)
+		_, _ = w.Write([]byte(`{"state":true,"data":{"access_token":"at-new","refresh_token":"rt-new","expires_in":7200}}`))
+	})
+
+	client := NewOpenClient("100195129", "at-old", "rt-old")
+	var wg sync.WaitGroup
+	results := make(chan bool, 2)
+	for range 2 {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			results <- client.tryRefreshTokenLocked(context.Background(), "at-old")
+		}()
+	}
+	wg.Wait()
+	close(results)
+	for ok := range results {
+		if !ok {
+			t.Fatal("concurrent refresh should reuse the refreshed token")
+		}
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if refreshCalls != 1 {
+		t.Fatalf("refresh calls = %d, want 1", refreshCalls)
+	}
+	if client.CurrentAccessToken() != "at-new" {
+		t.Fatalf("access token = %q, want at-new", client.CurrentAccessToken())
+	}
+}
+
 func TestFsListAndDownload(t *testing.T) {
 	mockAPI(t, func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {

internal/service/cloud115/open.go

@@ -477,24 +477,32 @@ func (c *OpenClient) GetToken(qrCode *QrCodeDataReturn) (*TokenData, error) {
 
 // RefreshToken 刷新访问令牌。
 func (c *OpenClient) RefreshToken(refreshToken string) (*TokenData, error) {
+	c.tokenMu.Lock()
 	if refreshToken == "" {
-		refreshToken = c.currentRefreshToken()
+		refreshToken = c.RefreshTokenStr
 	}
 	if refreshToken == "" {
+		c.tokenMu.Unlock()
 		return nil, fmt.Errorf("没有可用的 refresh_token")
 	}
 	token, err := c.doRefreshToken(refreshToken)
 	if err != nil {
 		// refresh_token 已失效时清空内存令牌（提示需重新授权）
 		if IsRefreshTokenDead(err) {
-			c.SetAuthToken("", "")
+			c.setAuthTokenLocked("", "")
 		}
+		c.tokenMu.Unlock()
 		return nil, err
 	}
 	if token.AccessToken == "" || token.RefreshToken == "" {
+		c.tokenMu.Unlock()
 		return nil, fmt.Errorf("115: 刷新返回空凭证（access_token/refresh_token 缺失）")
 	}
-	c.SetAuthToken(token.AccessToken, token.RefreshToken)
+	c.setAuthTokenLocked(token.AccessToken, token.RefreshToken)
+	c.tokenMu.Unlock()
+	if c.OnTokenRefreshed != nil {
+		c.OnTokenRefreshed(token.AccessToken, token.RefreshToken)
+	}
 	return token, nil
 }
 

internal/service/strm_115_oauth.go

@@ -293,7 +293,11 @@ func (s *StrmService) save115OAuthToken(ctx context.Context, session *strm115Aut
 	acct.LastTestAt = &now
 	acct.LastTestResult = "授权成功"
 	acct.LastTestOK = true
-	return s.repo.StrmAccount.Update(ctx, acct)
+	if err := s.repo.StrmAccount.Update(ctx, acct); err != nil {
+		return err
+	}
+	s.invalidate115Provider(acct.ID)
+	return nil
 }
 
 func (s *StrmService) drop115AuthSession(sessionID string) {
@@ -382,8 +386,15 @@ func (s *StrmService) refresh115TokensOnce(ctx context.Context) {
 				}
 			}
 		}
-		client := cloud115.NewOpenClient(cfg["app_id"], cfg["access_token"], cfg["refresh_token"])
-		token, err := client.RefreshToken(cfg["refresh_token"])
+		provider, err := s.providerFor(ctx, acct)
+		if err != nil {
+			continue
+		}
+		openProvider, ok := provider.(interface{ OpenClient() *cloud115.OpenClient })
+		if !ok || openProvider.OpenClient() == nil {
+			continue
+		}
+		token, err := openProvider.OpenClient().RefreshToken("")
 		if err != nil {
 			msg := "令牌刷新失败：" + err.Error()
 			if cloud115.IsRefreshTokenDead(err) {

internal/service/strm_account_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/truewhile/MeBox/internal/config"
 	"github.com/truewhile/MeBox/internal/model"
 	"github.com/truewhile/MeBox/internal/repository"
+	"github.com/truewhile/MeBox/internal/service/cloud115"
 )
 
 func TestStrmAccountConfigPreviewOf(t *testing.T) {
@@ -71,6 +72,90 @@ func TestUpdateStrmAccountMergesConfigWithoutClearingSecrets(t *testing.T) {
 	}
 }
 
+func TestProviderForReuses115ClientUntilCredentialsChange(t *testing.T) {
+	svc := testStrmService(t)
+	ctx := context.Background()
+	acct, err := svc.CreateStrmAccount(ctx, "115", model.StrmProvider115, map[string]string{
+		"app_id":        "100195129",
+		"access_token":  "at-1",
+		"refresh_token": "rt-1",
+	})
+	if err != nil {
+		t.Fatalf("create account: %v", err)
+	}
+
+	first, err := svc.providerFor(ctx, acct)
+	if err != nil {
+		t.Fatalf("first provider: %v", err)
+	}
+	second, err := svc.providerFor(ctx, acct)
+	if err != nil {
+		t.Fatalf("second provider: %v", err)
+	}
+	if first != second {
+		t.Fatal("115 provider should be shared per account")
+	}
+
+	updated, err := svc.UpdateStrmAccount(ctx, acct.ID, "", nil, map[string]string{
+		"access_token":  "at-2",
+		"refresh_token": "rt-2",
+	})
+	if err != nil {
+		t.Fatalf("update account: %v", err)
+	}
+	third, err := svc.providerFor(ctx, updated)
+	if err != nil {
+		t.Fatalf("provider after credential update: %v", err)
+	}
+	if first == third {
+		t.Fatal("credential update must invalidate the shared provider")
+	}
+
+	oldClient := first.(interface{ OpenClient() *cloud115.OpenClient }).OpenClient()
+	oldClient.OnTokenRefreshed("at-stale", "rt-stale")
+	fresh, err := svc.repo.StrmAccount.FindByID(ctx, acct.ID)
+	if err != nil || fresh == nil {
+		t.Fatalf("reload account: %v", err)
+	}
+	freshCfg, err := svc.strmAccountConfig(fresh)
+	if err != nil {
+		t.Fatalf("decode refreshed account: %v", err)
+	}
+	if freshCfg["access_token"] != "at-2" || freshCfg["refresh_token"] != "rt-2" {
+		t.Fatalf("stale client overwrote new credentials: %#v", freshCfg)
+	}
+}
+
+func TestPersist115TokensKeepsSharedClient(t *testing.T) {
+	svc := testStrmService(t)
+	ctx := context.Background()
+	acct, err := svc.CreateStrmAccount(ctx, "115", model.StrmProvider115, map[string]string{
+		"app_id":        "100195129",
+		"access_token":  "at-1",
+		"refresh_token": "rt-1",
+	})
+	if err != nil {
+		t.Fatalf("create account: %v", err)
+	}
+	first, err := svc.providerFor(ctx, acct)
+	if err != nil {
+		t.Fatalf("first provider: %v", err)
+	}
+
+	svc.persist115Tokens(acct.ID, "at-2", "rt-2")
+	fresh, err := svc.repo.StrmAccount.FindByID(ctx, acct.ID)
+	if err != nil || fresh == nil {
+		t.Fatalf("reload account: %v", err)
+	}
+	second, err := svc.providerFor(ctx, fresh)
+	if err != nil {
+		t.Fatalf("second provider: %v", err)
+	}
+	if first != second {
+		t.Fatal("automatic token persistence must keep the in-memory shared client")
+	}
+}
+
 func TestDeleteStrmAccountCascadesEmbyMounts(t *testing.T) {
 	ctx := context.Background()
 	db := newServiceTestDB(t, &model.StrmAccount{}, &model.EmbyMount{}, &model.StrmSyncPath{})

internal/service/strm_service.go

@@ -95,6 +95,9 @@ type StrmService struct {
 	oauthSessions map[string]*strm115AuthSession
 	wafUntil      time.Time // 115 风控/限流熔断截止时间（由 mu 保护）
 
+	providerMu       sync.Mutex
+	provider115Cache map[string]cloud.Provider // account ID -> shared provider/OpenClient
+
 	downloadSem115  chan struct{} // 115 换直链+下载并发上限（风控兜底）
 	downloadSemDAV  chan struct{} // WebDAV/OpenList/CloudDrive2 元数据下载并发上限
 	downloadSemOnce sync.Once
@@ -158,15 +161,16 @@ func (s *StrmService) releaseDownloadSlot(provider string) {
 // NewStrmService constructs the STRM service.
 func NewStrmService(cfg *config.Config, log *zap.Logger, repos *repository.Container, crypto *CryptoService) *StrmService {
 	return &StrmService{
-		log:           log,
-		repo:          repos,
-		cfg:           cfg,
-		crypto:        crypto,
-		http:          &http.Client{Timeout: 90 * time.Second},
-		stopCh:        make(chan struct{}),
-		baseCtx:       context.Background(),
-		running:       map[string]context.CancelFunc{},
-		oauthSessions: map[string]*strm115AuthSession{},
+		log:              log,
+		repo:             repos,
+		cfg:              cfg,
+		crypto:           crypto,
+		http:             &http.Client{Timeout: 90 * time.Second},
+		stopCh:           make(chan struct{}),
+		baseCtx:          context.Background(),
+		running:          map[string]context.CancelFunc{},
+		oauthSessions:    map[string]*strm115AuthSession{},
+		provider115Cache: map[string]cloud.Provider{},
 	}
 }
 
@@ -409,6 +413,9 @@ func (s *StrmService) UpdateStrmAccount(ctx context.Context, id, name string, en
 	if err := s.repo.StrmAccount.Update(ctx, acct); err != nil {
 		return nil, err
 	}
+	if acct.Provider == model.StrmProvider115 && len(config) > 0 {
+		s.invalidate115Provider(acct.ID)
+	}
 	return acct, nil
 }
 
@@ -426,6 +433,7 @@ func (s *StrmService) DeleteStrmAccount(ctx context.Context, id string) error {
 	if err := s.repo.StrmAccount.Delete(ctx, id); err != nil {
 		return err
 	}
+	s.invalidate115Provider(id)
 	// 级联清理远程 Emby 挂载：否则留下孤儿挂载，挂载计数/列表仍会显示。
 	// 账号已删，挂载清理失败只记日志，不让删除请求报错。
 	if _, err := s.repo.EmbyMount.DeleteByAccountID(ctx, id); err != nil && s.log != nil {
@@ -464,6 +472,23 @@ func (s *StrmService) ListAccounts(ctx context.Context) ([]model.StrmAccount, er
 
 // providerFor 依据账号配置构建网盘驱动。
 func (s *StrmService) providerFor(ctx context.Context, acct *model.StrmAccount) (cloud.Provider, error) {
+	if acct != nil && acct.Provider == model.StrmProvider115 {
+		s.providerMu.Lock()
+		defer s.providerMu.Unlock()
+		if provider := s.provider115Cache[acct.ID]; provider != nil {
+			return provider, nil
+		}
+		provider, err := s.newProvider(ctx, acct)
+		if err != nil {
+			return nil, err
+		}
+		s.provider115Cache[acct.ID] = provider
+		return provider, nil
+	}
+	return s.newProvider(ctx, acct)
+}
+
+func (s *StrmService) newProvider(ctx context.Context, acct *model.StrmAccount) (cloud.Provider, error) {
 	cfg, err := s.strmAccountConfig(acct)
 	if err != nil {
 		return nil, err
@@ -482,13 +507,33 @@ func (s *StrmService) providerFor(ctx context.Context, acct *model.StrmAccount)
 	// refresh_token 再刷（一次性轮转），两者互相作废，最终把有效账号
 	// 标成“授权已失效”。
 	if oc, ok := provider.(interface{ OpenClient() *cloud115.OpenClient }); ok {
-		oc.OpenClient().OnTokenRefreshed = func(accessToken, refreshToken string) {
+		client := oc.OpenClient()
+		client.OnTokenRefreshed = func(accessToken, refreshToken string) {
+			// 账号重新授权/修改凭据后，旧客户端可能仍有在途请求。旧请求
+			// 刷新的令牌不能覆盖新授权写入的凭据。
+			if !s.isCurrent115Client(acct.ID, client) {
+				return
+			}
 			s.persist115Tokens(acct.ID, accessToken, refreshToken)
 		}
 	}
 	return provider, nil
 }
 
+func (s *StrmService) invalidate115Provider(accountID string) {
+	s.providerMu.Lock()
+	delete(s.provider115Cache, accountID)
+	s.providerMu.Unlock()
+}
+
+func (s *StrmService) isCurrent115Client(accountID string, client *cloud115.OpenClient) bool {
+	s.providerMu.Lock()
+	defer s.providerMu.Unlock()
+	provider := s.provider115Cache[accountID]
+	openProvider, ok := provider.(interface{ OpenClient() *cloud115.OpenClient })
+	return ok && openProvider.OpenClient() == client
+}
+
 // ─── 全局设置 ──────────────────────────────────────────────────────────────────
 
 // GetStrmSettings 返回全局 strm 设置（含默认值）。

internal/service/subtitle_convert.go

@@ -27,6 +27,7 @@ func srtToVTT(body string) string {
 func assToVTT(body string) string {
 	out := strings.Builder{}
 	out.WriteString("WEBVTT\n\n")
+	seen := make(map[string]struct{})
 	for i, line := range strings.Split(body, "\n") {
 		line = strings.TrimSpace(line)
 		if !strings.HasPrefix(line, "Dialogue:") {
@@ -36,11 +37,22 @@ func assToVTT(body string) string {
 		if len(parts) < 10 {
 			continue
 		}
+		start := normaliseTimecode(parts[1])
+		end := normaliseTimecode(parts[2])
+		text := stripASSTags(parts[9])
+		if text == "" {
+			continue
+		}
+		key := start + "\x00" + end + "\x00" + text
+		if _, duplicate := seen[key]; duplicate {
+			continue
+		}
+		seen[key] = struct{}{}
 		fmt.Fprintf(&out, "%d\n%s --> %s\n%s\n\n",
 			i,
-			normaliseTimecode(parts[1]),
-			normaliseTimecode(parts[2]),
-			stripASSTags(parts[9]),
+			start,
+			end,
+			text,
 		)
 	}
 	return out.String()
@@ -86,5 +98,9 @@ func normaliseTimecode(t string) string {
 var assTag = regexp.MustCompile(`\{[^}]*\}`)
 
 func stripASSTags(s string) string {
-	return assTag.ReplaceAllString(s, "")
+	s = assTag.ReplaceAllString(s, "")
+	s = strings.ReplaceAll(s, `\N`, "\n")
+	s = strings.ReplaceAll(s, `\n`, "\n")
+	s = strings.ReplaceAll(s, `\h`, "\u00a0")
+	return strings.TrimSpace(s)
 }

internal/service/subtitle_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/glebarez/sqlite"
@@ -84,6 +85,25 @@ func TestNormaliseTimecode(t *testing.T) {
 	}
 }
 
+func TestAssToVTTDeduplicatesDialogueAndNormalisesLineBreaks(t *testing.T) {
+	body := strings.Join([]string{
+		`Dialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,{\an2}第一行\N第二行`,
+		`Dialogue: 1,0:00:01.00,0:00:02.00,Copy,,0,0,0,,{\bord2}第一行\N第二行`,
+		`Dialogue: 0,0:00:03.00,0:00:04.00,Default,,0,0,0,,{\i1}`,
+	}, "\n")
+
+	got := assToVTT(body)
+	if strings.Count(got, "第一行\n第二行") != 1 {
+		t.Fatalf("duplicate ASS dialogue was not collapsed:\n%s", got)
+	}
+	if strings.Contains(got, `\N`) || strings.Contains(got, `\an2`) {
+		t.Fatalf("ASS control sequences leaked into WebVTT:\n%s", got)
+	}
+	if strings.Contains(got, "00:00:03.000 --> 00:00:04.000") {
+		t.Fatalf("empty styled dialogue should be omitted:\n%s", got)
+	}
+}
+
 func TestSubtitleServeRawWritesSourceBytes(t *testing.T) {
 	db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{})
 	if err != nil {

web/src/components/useManualScrapeDialogState.ts

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useMemo, useState, type Dispatch, type SetState
 import toast from 'react-hot-toast'
 
 import { mediaAPI, type ManualScrapeCandidate } from '../api/library'
+import { useEpisodeArtworkPreference } from '../hooks/useEpisodeArtworkPreference'
 import type { Media } from '../types'
 import {
   candidateKey,
@@ -103,7 +104,7 @@ export function useManualScrapeDialogState({
 function useManualScrapeFormState() {
   const [query, setQuery] = useState('')
   const [selectedProviders, setSelectedProviders] = useState<string[]>([])
-  const [includeEpisodeArtwork, setIncludeEpisodeArtwork] = useState(false)
+  const [includeEpisodeArtwork, setIncludeEpisodeArtwork] = useEpisodeArtworkPreference()
   const [searching, setSearching] = useState(false)
   const [applyingKey, setApplyingKey] = useState('')
   const [items, setItems] = useState<ManualScrapeCandidate[]>([])

web/src/hooks/useEpisodeArtworkPreference.ts

@@ -0,0 +1,53 @@
+import { useCallback, useEffect, useRef, useState, type Dispatch, type SetStateAction } from 'react'
+import toast from 'react-hot-toast'
+
+import { adminAPI } from '../api/admin'
+
+const SETTING_KEY = 'scrape.episode_images'
+
+// This is an instance-wide scraper preference. The existing admin settings
+// endpoint stores it in the Setting table, so it follows the server instead
+// of a particular browser.
+export function useEpisodeArtworkPreference(): [boolean, Dispatch<SetStateAction<boolean>>] {
+  const [enabled, setEnabledState] = useState(false)
+  const enabledRef = useRef(false)
+  const changedLocally = useRef(false)
+  const saveQueue = useRef(Promise.resolve())
+
+  useEffect(() => {
+    let active = true
+    adminAPI.listSettings()
+      .then((settings) => {
+        if (!active || changedLocally.current) return
+        const value = settings.find((setting) => setting.key === SETTING_KEY)?.value
+        const next = value === 'true' || value === '1'
+        enabledRef.current = next
+        setEnabledState(next)
+      })
+      .catch(() => {
+        if (active) {
+          toast.error('读取每集图片设置失败')
+        }
+      })
+    return () => {
+      active = false
+    }
+  }, [])
+
+  const setEnabled = useCallback((nextValue: SetStateAction<boolean>) => {
+    const next = typeof nextValue === 'function' ? nextValue(enabledRef.current) : nextValue
+    if (enabledRef.current === next) return
+    changedLocally.current = true
+    enabledRef.current = next
+    setEnabledState(next)
+
+    saveQueue.current = saveQueue.current
+      .catch(() => undefined)
+      .then(() => adminAPI.updateSetting(SETTING_KEY, String(next)))
+      .catch(() => {
+        toast.error('保存每集图片设置失败')
+      })
+  }, [])
+
+  return [enabled, setEnabled]
+}

web/src/pages/LibrariesPage.tsx

@@ -3,6 +3,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { libraryAPI } from '../api/library'
 import { toolsAPI } from '../api/tools'
 import { openManageLibrariesDialog } from '../components/manageLibrariesDialog'
+import { useEpisodeArtworkPreference } from '../hooks/useEpisodeArtworkPreference'
 import { usePinnedLibraries } from '../hooks/usePinnedLibraries'
 import {
   LibrariesContent,
@@ -21,7 +22,7 @@ export function LibrariesPage() {
   const { pinnedIds, loading: pinnedLoading, togglePin } = usePinnedLibraries()
   const [loading, setLoading] = useState(true)
   const [repairing, setRepairing] = useState(false)
-  const [repairEpisodeArtwork, setRepairEpisodeArtwork] = useState(false)
+  const [repairEpisodeArtwork, setRepairEpisodeArtwork] = useEpisodeArtworkPreference()
   const [repairMsg, setRepairMsg] = useState('')
 
   const fetchedLibIdsRef = useRef<Set<string>>(new Set())

web/src/pages/PlayerPage.tsx

@@ -13,6 +13,7 @@ import type { Media } from '../types'
 import { getSeriesKey, seriesTitleFromPath } from '../utils/groupSeries'
 import { isRemoteEmbyID } from '../utils/remoteEmby'
 import { pickPlayerMode, needsTranscodeForBrowser, isDirectStreamMedia, type PlayerMode } from './playerPageModel'
+import { classifyDirectPlayError } from './directPlayError'
 import { apiErrorMessage } from './StrmManagePage'
 import { PlayerTopBar } from './PlayerTopBar'
 import { PlayerVideoStage } from './PlayerVideoStage'
@@ -42,6 +43,9 @@ export function PlayerPage() {
   const ref = useRef<HTMLVideoElement>(null)
   const hlsRef = useRef<Hls | null>(null)
   const lastSentRef = useRef(0)
+  const directRetryRef = useRef(false)
+  const retryingDirectRef = useRef(false)
+  const fallbackTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const [media, setMedia] = useState<Media | null>(null)
   const [mode, setMode] = useState<PlayerMode>('direct')
@@ -178,11 +182,40 @@ export function PlayerPage() {
     setDanmakuSelectedSource('')
     setDanmakuInfo(null)
     setDanmakuSearching(true)
+    directRetryRef.current = false
+    retryingDirectRef.current = false
+    if (fallbackTimerRef.current) {
+      clearTimeout(fallbackTimerRef.current)
+      fallbackTimerRef.current = null
+    }
+    return () => {
+      if (fallbackTimerRef.current) {
+        clearTimeout(fallbackTimerRef.current)
+        fallbackTimerRef.current = null
+      }
+    }
   }, [id])
 
   // 依赖收敛为 mode 参数的字符串值：避免 params 对象引用每次变化都重复拉取元数据
   const modeParam = params.get('mode') as PlayerMode | null
 
+  const setPlaybackMode = useCallback(
+    (next: PlayerMode) => {
+      setMode(next)
+      const nextParams = new URLSearchParams(window.location.search)
+      nextParams.set('mode', next)
+      setParams(nextParams, { replace: true })
+    },
+    [setParams],
+  )
+
+  const clearFallbackTimer = useCallback(() => {
+    if (fallbackTimerRef.current) {
+      clearTimeout(fallbackTimerRef.current)
+      fallbackTimerRef.current = null
+    }
+  }, [])
+
   // Load metadata and pick a default mode.
   useEffect(() => {
     if (!id) return
@@ -229,6 +262,10 @@ export function PlayerPage() {
   const selectedSubtitle = subtitleIndex >= 0 ? subs[subtitleIndex] : undefined
   const burnedSubtitleStream =
     selectedSubtitle?.delivery === 'burn' ? selectedSubtitle.stream_index : undefined
+  // 直连不使用烧录字幕参数。字幕列表通常比媒体信息晚返回，若把该参数直接
+  // 作为播放 effect 的依赖，会在 STRM 的 302 直链仍在建立时重复设置 src，
+  // Chromium 会把被中断的首次加载报告成播放错误并误触发 HLS 回退。
+  const activeBurnedSubtitleStream = mode === 'hls' ? burnedSubtitleStream : undefined
   const mediaRef = useRef(media)
   mediaRef.current = media
   useEffect(() => {
@@ -241,11 +278,19 @@ export function PlayerPage() {
     const video = ref.current
     const durationSec = currentMedia.duration_sec || 0
     if (mode === 'hls') {
-      const url = hlsURL(mediaId, hlsStartSec, burnedSubtitleStream)
+      const url = hlsURL(mediaId, hlsStartSec, activeBurnedSubtitleStream)
       void import('hls.js').then(({ default: HlsCtor }) => {
         if (cancelled || !ref.current) return
         if (HlsCtor.isSupported()) {
-          const hls = new HlsCtor({ enableWorker: true, lowLatencyMode: false })
+          const hls = new HlsCtor({
+            enableWorker: true,
+            lowLatencyMode: false,
+            // The server waits up to 45s for the first segment. Slow two-core
+            // hosts and remote STRM sources regularly need more than hls.js's
+            // 10s default, which otherwise aborts a healthy transcode.
+            manifestLoadingTimeOut: 60_000,
+            manifestLoadingMaxRetry: 1,
+          })
           try {
             video.currentTime = 0
           } catch {
@@ -260,6 +305,7 @@ export function PlayerPage() {
             mediaAPI
               .get(mediaId)
               .then((fresh) => {
+                if (cancelled || fresh.id !== mediaId) return
                 if ((fresh.duration_sec || 0) > 0) setMedia(fresh)
               })
               .catch(() => undefined)
@@ -269,9 +315,7 @@ export function PlayerPage() {
               setHlsUnavailable(true)
               setPlayerError('HLS 转码不可用，正在尝试直接播放原始文件。若出现有画面无声音，通常是 MKV/AC3/EAC3 音轨需要配置本机 ffmpeg 转码为 AAC。')
               toast.error('HLS 转码失败，尝试切换到直接播放')
-              setMode('direct')
-              params.set('mode', 'direct')
-              setParams(params, { replace: true })
+              setPlaybackMode('direct')
             }
           })
           if (cancelled) {
@@ -291,26 +335,46 @@ export function PlayerPage() {
           setHlsUnavailable(true)
           setPlayerError('当前浏览器不支持 HLS，正在尝试直接播放。')
           toast.error('当前浏览器不支持 HLS，降级到直接播放')
-          setMode('direct')
+          setPlaybackMode('direct')
         }
       }).catch(() => {
         if (cancelled) return
         setHlsUnavailable(true)
         setPlayerError('HLS 播放组件加载失败，正在尝试直接播放。')
-        setMode('direct')
+        setPlaybackMode('direct')
       })
     } else {
-      video.src = streamURL(mediaId)
+      const url = streamURL(mediaId)
+      const absoluteURL = new URL(url, window.location.href).href
+      // 其它异步播放器状态更新不应重启同一个直连请求；STRM 的重定向/换链
+      // 比本地文件慢，重启请求可能产生一个短暂但会触发 onError 的中断。
+      if (video.src !== absoluteURL) {
+        directRetryRef.current = false
+        clearFallbackTimer()
+        video.src = url
+        void video.play().catch(() => undefined)
+      }
       if (hlsUnavailable && needsTranscodeForBrowser(currentMedia)) {
         setPlayerError('当前正在直连播放原始文件；此封装或音轨浏览器兼容性有限，可能只有画面没有声音。请配置本机 ffmpeg 后切回 HLS 转码播放。')
       }
-      void video.play().catch(() => undefined)
     }
+    const onPlaying = () => clearFallbackTimer()
+    video.addEventListener('playing', onPlaying)
     return () => {
       cancelled = true
+      video.removeEventListener('playing', onPlaying)
       teardownHls()
     }
-  }, [burnedSubtitleStream, hlsUnavailable, hlsStartSec, mediaId, mode, params, setParams, teardownHls])
+  }, [
+    activeBurnedSubtitleStream,
+    clearFallbackTimer,
+    hlsUnavailable,
+    hlsStartSec,
+    mediaId,
+    mode,
+    setPlaybackMode,
+    teardownHls,
+  ])
 
   // Stop host ffmpeg when leaving this HLS player. The keepalive request also
   // survives route navigation while the component is being torn down.
@@ -361,21 +425,30 @@ export function PlayerPage() {
     }
     const video = ref.current
     if (!video) return
+    let onSeeked: (() => void) | undefined
     const applyResume = () => {
       if (resumePosition > 0 && Math.abs(video.currentTime - resumePosition) > 2) {
+        onSeeked = () => {
+          setInitialSeekDone(true)
+          const m = Math.floor(resumePosition / 60)
+          const s = Math.floor(resumePosition % 60)
+          const timeStr = `${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`
+          toast.success(`已恢复上次播放进度至 ${timeStr}`, { duration: 2500 })
+        }
+        video.addEventListener('seeked', onSeeked, { once: true })
         video.currentTime = resumePosition
-        setInitialSeekDone(true)
-        const m = Math.floor(resumePosition / 60)
-        const s = Math.floor(resumePosition % 60)
-        const timeStr = `${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`
-        toast.success(`已恢复上次播放进度至 ${timeStr}`, { duration: 2500 })
+        return
       }
+      setInitialSeekDone(true)
     }
-    if (video.readyState >= 1) {
+    if (video.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
       applyResume()
     } else {
-      video.addEventListener('loadedmetadata', applyResume, { once: true })
-      return () => video.removeEventListener('loadedmetadata', applyResume)
+      video.addEventListener('canplay', applyResume, { once: true })
+    }
+    return () => {
+      video.removeEventListener('canplay', applyResume)
+      if (onSeeked) video.removeEventListener('seeked', onSeeked)
     }
   }, [resumePosition, initialSeekDone, mode, hlsStartSec])
 
@@ -495,7 +568,11 @@ export function PlayerPage() {
     [navigate, location.search, location.state],
   )
 
-  const versionList = useMemo(() => mediaVersionsOf(media), [media])
+  // URL 已切换但新媒体尚未返回时，不渲染上一条媒体遗留的版本入口。
+  const versionList = useMemo(
+    () => (media?.id === id ? mediaVersionsOf(media) : []),
+    [id, media],
+  )
   const switchVersion = useCallback(
     (version: Media) => {
       if (!version?.id || version.id === media?.id) return
@@ -599,17 +676,14 @@ export function PlayerPage() {
       return
     }
     setHlsStartSec(ref.current?.currentTime || 0)
-    setMode('hls')
-    params.set('mode', 'hls')
-    setParams(params, { replace: true })
+    setPlaybackMode('hls')
   }, [
     directOnly,
     directOnlyKnown,
     isDirectStream,
     mode,
-    params,
     selectedSubtitle?.delivery,
-    setParams,
+    setPlaybackMode,
   ])
 
   const toggleMode = useCallback(() => {
@@ -621,10 +695,8 @@ export function PlayerPage() {
     if (next === 'hls') {
       setHlsStartSec(0)
     }
-    setMode(next)
-    params.set('mode', next)
-    setParams(params, { replace: true })
-  }, [isDirectStream, mode, params, setParams])
+    setPlaybackMode(next)
+  }, [isDirectStream, mode, setPlaybackMode])
 
   const handleSeekAbsolute = useCallback(
     (absoluteSec: number) => {
@@ -674,17 +746,47 @@ export function PlayerPage() {
     setSubtitleIndex(index)
     if (nextTrack?.delivery === 'burn' && mode !== 'hls' && !directOnly && !isDirectStream) {
       setHlsStartSec(ref.current?.currentTime || 0)
-      setMode('hls')
-      params.set('mode', 'hls')
-      setParams(params, { replace: true })
+      setPlaybackMode('hls')
     }
-  }, [directOnly, hlsStartSec, isDirectStream, mode, params, setParams, subs, subtitleIndex])
+  }, [directOnly, hlsStartSec, isDirectStream, mode, setPlaybackMode, subs, subtitleIndex])
 
   const handleVideoError = useCallback(() => {
-    // 浏览器对 <video src> 的错误描述非常有限，把详细原因
-    // 转给开发者控制台 + 一条 toast；常见原因是 codec 不支持。
-    if (mode === 'direct') {
-      if (isRemoteEmbyID(media?.id) || isDirectStreamMedia(media)) {
+    const video = ref.current
+    if (mode !== 'direct') {
+      setPlayerError('视频播放失败，请检查文件是否存在，或确认 ffmpeg 已正确配置。')
+      toast.error('视频播放失败，请检查文件是否存在')
+      return
+    }
+
+    if (retryingDirectRef.current) return
+
+    const expectedSrc = mediaId ? new URL(streamURL(mediaId), window.location.href).href : ''
+    const action = classifyDirectPlayError({
+      errorCode: video?.error?.code,
+      readyState: video?.readyState ?? 0,
+      elementSrc: video?.src ?? '',
+      expectedSrc,
+      alreadyRetried: directRetryRef.current,
+    })
+    if (action === 'ignore') return
+
+    if (action === 'retry' && video && mediaId) {
+      directRetryRef.current = true
+      retryingDirectRef.current = true
+      try {
+        video.load()
+        void video.play().catch(() => undefined)
+      } finally {
+        retryingDirectRef.current = false
+      }
+      return
+    }
+
+    const fallbackDirectPlay = () => {
+      if (modeRef.current !== 'direct') return
+      const current = ref.current
+      if (current && current.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) return
+      if (isRemoteEmbyID(mediaRef.current?.id) || isDirectStreamMedia(mediaRef.current)) {
         setPlayerError('直接播放失败。该媒体为远程 Emby 挂载直连播放（不进行转码）；当前浏览器可能不支持该视频编码或音频格式，建议使用外部播放器（如 PotPlayer / VLC / IINA）播放。')
         toast.error('直接播放失败，建议使用外部播放器')
       } else if (directOnly) {
@@ -695,16 +797,13 @@ export function PlayerPage() {
         toast.error('直接播放失败，HLS 转码不可用')
       } else {
         toast.error('直接播放失败，切换到 HLS 转码')
-        setMode('hls')
-        params.set('mode', 'hls')
-        setParams(params, { replace: true })
+        setPlaybackMode('hls')
       }
-      return
     }
 
-    setPlayerError('视频播放失败，请检查文件是否存在，或确认 ffmpeg 已正确配置。')
-    toast.error('视频播放失败，请检查文件是否存在')
-  }, [directOnly, hlsUnavailable, media, mode, params, setParams])
+    clearFallbackTimer()
+    fallbackTimerRef.current = setTimeout(fallbackDirectPlay, 1500)
+  }, [clearFallbackTimer, directOnly, hlsUnavailable, mediaId, mode, setPlaybackMode])
 
   const danmakuAutoTitle =
     danmakuInfo?.animeTitle ||

web/src/pages/PlayerVideoStage.tsx

@@ -7,6 +7,54 @@ import type { Media } from '../types'
 import { DanmakuStage } from '../components/DanmakuStage'
 import { PlayerControls } from '../components/PlayerControls'
 
+type SubtitleCue = {
+  startTime: number
+  endTime: number
+  text: string
+}
+
+function parseVTTTimestamp(value: string): number {
+  const parts = value.trim().replace(',', '.').split(':')
+  if (parts.length !== 2 && parts.length !== 3) return Number.NaN
+  const seconds = Number(parts.pop())
+  const minutes = Number(parts.pop())
+  const hours = parts.length > 0 ? Number(parts.pop()) : 0
+  if (![hours, minutes, seconds].every(Number.isFinite)) return Number.NaN
+  return hours * 3600 + minutes * 60 + seconds
+}
+
+function parseWebVTTCues(body: string): SubtitleCue[] {
+  const blocks = body
+    .replace(/^\uFEFF/, '')
+    .replace(/\r\n?/g, '\n')
+    .split(/\n{2,}/)
+  const cues: SubtitleCue[] = []
+
+  for (const block of blocks) {
+    const lines = block.split('\n')
+    const timingIndex = lines.findIndex((line) => line.includes('-->'))
+    if (timingIndex < 0) continue
+
+    const [rawStart, rawEnd] = lines[timingIndex].split('-->', 2)
+    const startTime = parseVTTTimestamp(rawStart)
+    const endTime = parseVTTTimestamp(rawEnd.trim().split(/\s+/, 1)[0])
+    const text = lines.slice(timingIndex + 1).join('\n').trim()
+    if (Number.isFinite(startTime) && Number.isFinite(endTime) && endTime >= startTime && text) {
+      cues.push({ startTime, endTime, text })
+    }
+  }
+
+  return cues
+}
+
+function uniqueSubtitleTexts(texts: string[]): string[] {
+  const unique = [...new Set(texts.map((text) => text.trim()).filter(Boolean))]
+  // ponytail: WebVTT cannot preserve ASS layers/positions. Keep at most two
+  // simultaneous blocks for bilingual subtitles; use libass if full ASS
+  // typesetting support is added later.
+  return unique.slice(-2)
+}
+
 type PlayerVideoStageProps = {
   media: Media | null
   /** 媒体元数据加载失败提示（非空时替代「加载中」展示）。 */
@@ -89,6 +137,61 @@ export function PlayerVideoStage({
   const revealControlsOnlyRef = useRef(false)
   // 当前展示的字幕文本（由自定义字幕层渲染，100% 透明无黑框）
   const [activeCueText, setActiveCueText] = useState<string>('')
+  // 独立保存完整 WebVTT 时间轴。HLS seek 会替换媒体源，Chromium 此时可能清空
+  // <track>.track.cues；独立时间轴不受 MediaSource 重挂载和轨道 mode 切换影响。
+  const [subtitleTimeline, setSubtitleTimeline] = useState<{
+    path: string
+    cues: SubtitleCue[]
+  } | null>(null)
+  // 直连 302 尚未完成时插入 <track> 会中断加载并误报播放失败；等 canplay 再挂。
+  const [tracksArmed, setTracksArmed] = useState(false)
+
+  useEffect(() => {
+    setTracksArmed(false)
+    const video = videoRef.current
+    if (!video || !media?.id) return
+    const arm = () => setTracksArmed(true)
+    if (video.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
+      arm()
+      return
+    }
+    video.addEventListener('canplay', arm)
+    video.addEventListener('playing', arm)
+    return () => {
+      video.removeEventListener('canplay', arm)
+      video.removeEventListener('playing', arm)
+    }
+  }, [media?.id, videoRef])
+
+  useEffect(() => {
+    const selectedTrack = subs[subtitleIndex]
+    if (!media || subtitleIndex < 0 || !selectedTrack || selectedTrack.delivery !== 'webvtt') {
+      setSubtitleTimeline(null)
+      return
+    }
+
+    const controller = new AbortController()
+    setSubtitleTimeline(null)
+    fetch(subtitlesAPI.url(media.id, selectedTrack.path), { signal: controller.signal })
+      .then((response) => {
+        if (!response.ok) throw new Error(`subtitle request failed: ${response.status}`)
+        return response.text()
+      })
+      .then((body) => {
+        setSubtitleTimeline({
+          path: selectedTrack.path,
+          cues: parseWebVTTCues(body),
+        })
+      })
+      .catch((error: unknown) => {
+        if (!(error instanceof DOMException && error.name === 'AbortError')) {
+          // 保留原生 TextTrack 作为请求失败时的降级路径。
+          setSubtitleTimeline(null)
+        }
+      })
+
+    return () => controller.abort()
+  }, [media, subs, subtitleIndex])
 
   // 监听舞台容器的真实尺寸（响应窗口大小调整和全屏切换）
   useEffect(() => {
@@ -160,6 +263,7 @@ export function PlayerVideoStage({
     const selectedTrack = subs[subtitleIndex]
     if (
       !video ||
+      !tracksArmed ||
       subs.length === 0 ||
       subtitleIndex < 0 ||
       !selectedTrack ||
@@ -170,6 +274,17 @@ export function PlayerVideoStage({
     }
 
     const updateCue = () => {
+      const absoluteTime = video.currentTime + (streamOffset ?? 0)
+      if (subtitleTimeline?.path === selectedTrack.path) {
+        const texts = uniqueSubtitleTexts(
+          subtitleTimeline.cues
+            .filter((cue) => absoluteTime >= cue.startTime && absoluteTime <= cue.endTime)
+            .map((cue) => cue.text),
+        )
+        setActiveCueText(texts.join('\n'))
+        return
+      }
+
       const selectedEl = video.querySelector<HTMLTrackElement>(
         `track[data-subtitle-index="${subtitleIndex}"]`,
       )
@@ -188,15 +303,19 @@ export function PlayerVideoStage({
           if (cue && cue.text) texts.push(cue.text)
         }
       } else if (tt.cues && tt.cues.length > 0) {
-        const cur = video.currentTime + (streamOffset ?? 0)
         for (let i = 0; i < tt.cues.length; i++) {
           const cue = tt.cues[i] as VTTCue
-          if (cue && cur >= cue.startTime && cur <= cue.endTime && cue.text) {
+          if (
+            cue &&
+            absoluteTime >= cue.startTime &&
+            absoluteTime <= cue.endTime &&
+            cue.text
+          ) {
             texts.push(cue.text)
           }
         }
       }
-      setActiveCueText(texts.join('\n'))
+      setActiveCueText(uniqueSubtitleTexts(texts).join('\n'))
     }
 
     const apply = () => {
@@ -251,7 +370,7 @@ export function PlayerVideoStage({
         }
       }
     }
-  }, [subtitleIndex, subs, videoRef, media, streamOffset])
+  }, [subtitleIndex, subs, videoRef, media, streamOffset, subtitleTimeline, tracksArmed])
 
   // 根据视频画面宽高比与舞台宽高比，确定视频在哪个轴向撑满 100%
   const isWiderThanStage =
@@ -294,19 +413,19 @@ export function PlayerVideoStage({
               className="h-full w-full object-contain bg-black"
               onError={onVideoError}
             >
-              {subs.map((track, index) =>
-                track.delivery === 'burn' ? null : (
-                <track
-                  key={track.path}
-                  data-subtitle-index={index}
-                  kind="subtitles"
-                  src={subtitlesAPI.url(media.id, track.path)}
-                  srcLang={track.lang}
-                  label={track.label || track.lang}
-                  default={subtitleIndex === index}
-                />
-                ),
-              )}
+              {tracksArmed &&
+                subs.map((track, index) =>
+                  track.delivery === 'burn' ? null : (
+                    <track
+                      key={track.path}
+                      data-subtitle-index={index}
+                      kind="subtitles"
+                      src={subtitlesAPI.url(media.id, track.path)}
+                      srcLang={track.lang}
+                      label={track.label || track.lang}
+                    />
+                  ),
+                )}
             </video>
             <DanmakuStage
               key={media.id}

web/src/pages/directPlayError.ts

@@ -0,0 +1,24 @@
+export type DirectPlayErrorAction = 'ignore' | 'retry' | 'fallback'
+
+const MEDIA_ERR_ABORTED = 1
+const HAVE_CURRENT_DATA = 2
+
+/**
+ * Chromium 常把被中断的直连（换 src、插入 track、302 未完成就 seek）
+ * 报成 error。真正不兼容应 fallback；瞬时中断应忽略或静默重试一次。
+ */
+export function classifyDirectPlayError(input: {
+  errorCode: number | undefined | null
+  readyState: number
+  elementSrc: string
+  expectedSrc: string
+  alreadyRetried: boolean
+}): DirectPlayErrorAction {
+  const code = input.errorCode ?? 0
+  if (code === MEDIA_ERR_ABORTED) return 'ignore'
+  if (input.readyState >= HAVE_CURRENT_DATA) return 'ignore'
+  if (!input.elementSrc) return 'ignore'
+  if (input.expectedSrc && input.elementSrc !== input.expectedSrc) return 'ignore'
+  if (!input.alreadyRetried) return 'retry'
+  return 'fallback'
+}

web/src/pages/playerPageModel.test.ts

@@ -0,0 +1,75 @@
+import { classifyDirectPlayError } from './directPlayError.ts'
+
+function check(name: string, cond: boolean) {
+  if (!cond) throw new Error(`classifyDirectPlayError: ${name}`)
+}
+
+const src = 'http://nas.local/api/stream/m1?token=abc'
+
+check(
+  'aborted load is ignored',
+  classifyDirectPlayError({
+    errorCode: 1,
+    readyState: 0,
+    elementSrc: src,
+    expectedSrc: src,
+    alreadyRetried: false,
+  }) === 'ignore',
+)
+
+check(
+  'already-playing error is ignored',
+  classifyDirectPlayError({
+    errorCode: 4,
+    readyState: 3,
+    elementSrc: src,
+    expectedSrc: src,
+    alreadyRetried: false,
+  }) === 'ignore',
+)
+
+check(
+  'stale src error is ignored',
+  classifyDirectPlayError({
+    errorCode: 4,
+    readyState: 0,
+    elementSrc: 'http://nas.local/old',
+    expectedSrc: src,
+    alreadyRetried: false,
+  }) === 'ignore',
+)
+
+check(
+  'empty src during reload is ignored',
+  classifyDirectPlayError({
+    errorCode: 4,
+    readyState: 0,
+    elementSrc: '',
+    expectedSrc: src,
+    alreadyRetried: false,
+  }) === 'ignore',
+)
+
+check(
+  'first decode/network miss retries',
+  classifyDirectPlayError({
+    errorCode: 4,
+    readyState: 0,
+    elementSrc: src,
+    expectedSrc: src,
+    alreadyRetried: false,
+  }) === 'retry',
+)
+
+check(
+  'second failure falls back to HLS',
+  classifyDirectPlayError({
+    errorCode: 4,
+    readyState: 0,
+    elementSrc: src,
+    expectedSrc: src,
+    alreadyRetried: true,
+  }) === 'fallback',
+)
+
+console.log('playerPageModel.test.ts ok')

web/src/pages/useLibraryAdminActions.tsx

@@ -6,6 +6,7 @@ import { libraryAPI } from '../api/library'
 import { mediaAPI } from '../api/library'
 import { toolsAPI } from '../api/tools'
 import { confirmAction, confirmActionResult } from '../components/confirmAction'
+import { useEpisodeArtworkPreference } from '../hooks/useEpisodeArtworkPreference'
 import type { Library, Media } from '../types'
 import { seriesTitle, type SeriesCard } from '../utils/groupSeries'
 import { LibraryMovieActions } from './LibraryMovieActions'
@@ -33,7 +34,7 @@ export function useLibraryAdminActions({
   setManualMovie,
 }: UseLibraryAdminActionsOptions) {
   const [scraping, setScraping] = useState(false)
-  const [scrapeEpisodeArtwork, setScrapeEpisodeArtwork] = useState(false)
+  const [scrapeEpisodeArtwork, setScrapeEpisodeArtwork] = useEpisodeArtworkPreference()
   const [repairing, setRepairing] = useState(false)
   const [seriesToolBusy, setSeriesToolBusy] = useState('')
   const [movieToolBusy, setMovieToolBusy] = useState('')

web/src/pages/useMediaDetailPageState.ts

@@ -6,6 +6,7 @@ import { api } from '../api/client'
 import { mediaAPI } from '../api/library'
 import { playbackAPI } from '../api/playback'
 import { confirmActionResult } from '../components/confirmAction'
+import { useEpisodeArtworkPreference } from '../hooks/useEpisodeArtworkPreference'
 import type { Media } from '../types'
 import { mediaLibraryBackTarget } from './MediaDetailPageModel'
 
@@ -42,7 +43,7 @@ export function useMediaDetailPageState({ id, navigate }: MediaDetailPageStatePa
   const [manualScrapeOpen, setManualScrapeOpen] = useState(false)
   const [metadataEditOpen, setMetadataEditOpen] = useState(false)
   const [organizeOpen, setOrganizeOpen] = useState(false)
-  const [scrapeEpisodeArtwork, setScrapeEpisodeArtwork] = useState(false)
+  const [scrapeEpisodeArtwork, setScrapeEpisodeArtwork] = useEpisodeArtworkPreference()
 
   const refresh = useMediaDetailRefresh({
     id,

web/tsconfig.json

@@ -20,5 +20,6 @@
       "@/*": ["src/*"]
     }
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
 }