优化排序

完善动漫特别内容分类与版本判定
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-28 11:16:37 +08:00 · 2026-09-09 22:24:45 +08:00 · 2026-09-09 22:03:52 +08:00 · 2026-09-09 20:32:03 +08:00 · 2026-09-09 19:26:22 +08:00
32 changed files with 888 additions and 148 deletions
@@ -120,8 +120,8 @@ const (
 )

 var (
-	embySeasonDirRE    = regexp.MustCompile(`(?i)^(season[\s._-]*\d+|s\d+|specials?|sp|ova|oad|extra|extras|第\s*[0-9一二三四五六七八九十百零两]+\s*季|特别篇|特別篇|番外|特典)$`)
-	embySeasonSuffixRE = regexp.MustCompile(`(?i)(?:[\s._-]+(?:season[\s._-]*\d+|s\d+|第\s*[0-9一二三四五六七八九十百零两]+\s*季|specials?|sp|ova|oad|extra|extras|特别篇|特別篇|番外|特典)|\s*第\s*[0-9一二三四五六七八九十百零两]+\s*季)\s*$`)
+	embySeasonDirRE    = regexp.MustCompile(`(?i)^(season[\s._-]*\d+|s\d+|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|第\s*[0-9一二三四五六七八九十百零两]+\s*季|特别篇|特別篇|番外|特典|画像特典)$`)
+	embySeasonSuffixRE = regexp.MustCompile(`(?i)(?:[\s._-]+(?:season[\s._-]*\d+|s\d+|第\s*[0-9一二三四五六七八九十百零两]+\s*季|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|特别篇|特別篇|番外|特典|画像特典)|\s*第\s*[0-9一二三四五六七八九十百零两]+\s*季)\s*$`)
 	embyYearSuffixRE   = regexp.MustCompile(`\s*[\(（\[]\d{4}[\)）\]]\s*$`)
 	embyEpisodeTitleRE = regexp.MustCompile(`(?i)\s*[-_ ]*s\d{1,2}e\d{1,3}.*$`)
 )
@@ -55,6 +55,17 @@ func (e *EmbyService) mediaVersionSiblings(ctx context.Context, m *model.Media)
 	if err := q.Find(&rows).Error; err != nil || len(rows) == 0 {
 		return []model.Media{*m}
 	}
+	targetKey := e.mediaVersionKey(ctx, m)
+	filtered := rows[:0]
+	for i := range rows {
+		if e.mediaVersionKey(ctx, &rows[i]) == targetKey {
+			filtered = append(filtered, rows[i])
+		}
+	}
+	rows = filtered
+	if len(rows) == 0 {
+		return []model.Media{*m}
+	}
 	rows = e.collapseExactPathRows(rows)
 	sort.SliceStable(rows, func(i, j int) bool {
 		if rows[i].ID == m.ID {
@@ -97,11 +108,28 @@ func (e *EmbyService) mediaVersionKey(ctx context.Context, m *model.Media) strin
 	if libraryGroup == "" {
 		libraryGroup = strings.TrimSpace(m.LibraryID)
 	}
+	kind := mediaSpecialKind(m.Path)
+	season, episode := m.SeasonNum, m.EpisodeNum
+	if kind != "" && kind != mediaSpecialTheatrical && episode <= 0 {
+		if parsedSeason, parsedEpisode := ParseEpisode(m.Path); parsedEpisode > 0 {
+			season, episode = parsedSeason, parsedEpisode
+		}
+	}
+	kindKey := ""
+	if kind != "" {
+		kindKey = "|kind:" + kind
+	}
+	if kind != "" && kind != mediaSpecialTheatrical && episode <= 0 {
+		if stemKey := mediaVersionStemGroupKey(*m, libraryGroup); stemKey != "" {
+			return stemKey + kindKey
+		}
+		return libraryGroup + "|special-item:" + kind + "|id:" + m.ID
+	}
 	if m.TMDbID > 0 {
-		return fmt.Sprintf("%s|tmdb:%d|s:%d|e:%d", libraryGroup, m.TMDbID, m.SeasonNum, m.EpisodeNum)
+		return fmt.Sprintf("%s|tmdb:%d|s:%d|e:%d%s", libraryGroup, m.TMDbID, season, episode, kindKey)
 	}
 	if m.BangumiID > 0 {
-		return fmt.Sprintf("%s|bangumi:%d|s:%d|e:%d", libraryGroup, m.BangumiID, m.SeasonNum, m.EpisodeNum)
+		return fmt.Sprintf("%s|bangumi:%d|s:%d|e:%d%s", libraryGroup, m.BangumiID, season, episode, kindKey)
 	}
 	title := strings.ToLower(strings.TrimSpace(m.Title))
 	if title == "" {
@@ -110,7 +138,7 @@ func (e *EmbyService) mediaVersionKey(ctx context.Context, m *model.Media) strin
 	if title == "" {
 		return ""
 	}
-	return fmt.Sprintf("%s|title:%s|y:%d|s:%d|e:%d", libraryGroup, title, m.Year, m.SeasonNum, m.EpisodeNum)
+	return fmt.Sprintf("%s|title:%s|y:%d|s:%d|e:%d%s", libraryGroup, title, m.Year, season, episode, kindKey)
 }

 func preferMediaVersion(candidate, current model.Media) bool {
@@ -220,7 +220,7 @@ func embyLikelyEpisodicPathSQL() (string, []any) {
 	patterns := []string{
 		"%/season %/%", "%/season.%/%", "%/season-%/%", "%/season_%/%",
 		"%/s0%/%", "%/s1%/%", "%/s2%/%", "%/s3%/%", "%/s4%/%", "%/s5%/%", "%/s6%/%", "%/s7%/%", "%/s8%/%", "%/s9%/%",
-		"%/special/%", "%/specials/%", "%/sp/%", "%/ova/%", "%/oad/%", "%/extra/%", "%/extras/%",
+		"%/special/%", "%/specials/%", "%/sp/%", "%/ova/%", "%/ovas/%", "%/oad/%", "%/oads/%", "%/ovd/%", "%/ovds/%", "%/ona/%", "%/onas/%", "%/extra/%", "%/extras/%", "%/bonus/%", "%/bonuses/%", "%/omake/%", "%/picture drama/%", "%/ncop/%", "%/nced/%",
 		"%/电视剧/%", "%/剧集/%", "%/连续剧/%", "%/短剧/%", "%/国产剧/%", "%/国剧/%", "%/大陆剧/%", "%/华语剧/%", "%/国产电视剧/%", "%/大陆电视剧/%", "%/华语电视剧/%", "%/欧美剧/%", "%/欧美电视剧/%", "%/美剧/%", "%/英剧/%", "%/日韩剧/%", "%/日韩电视剧/%", "%/日剧/%", "%/韩剧/%", "%/港剧/%", "%/台剧/%", "%/港台剧/%", "%/泰剧/%",
 		"%/日番/%", "%/国漫/%", "%/番剧/%", "%/动漫/%", "%/特别篇/%", "%/特別篇/%", "%/番外/%", "%/特典/%",
 	}
@@ -243,7 +243,7 @@ func embyMediaPathLooksEpisodic(path string) bool {
 		return false
 	}
 	for _, marker := range []string{
-		"/season ", "/season.", "/season-", "/season_", "/special/", "/specials/", "/sp/", "/ova/", "/oad/", "/extra/", "/extras/",
+		"/season ", "/season.", "/season-", "/season_", "/special/", "/specials/", "/sp/", "/ova/", "/ovas/", "/oad/", "/oads/", "/ovd/", "/ovds/", "/ona/", "/onas/", "/extra/", "/extras/", "/bonus/", "/bonuses/", "/omake/", "/picture drama/", "/ncop/", "/nced/",
 		"/电视剧/", "/剧集/", "/连续剧/", "/短剧/", "/国产剧/", "/国剧/", "/大陆剧/", "/华语剧/", "/国产电视剧/", "/大陆电视剧/", "/华语电视剧/", "/欧美剧/", "/欧美电视剧/", "/美剧/", "/英剧/", "/日韩剧/", "/日韩电视剧/", "/日剧/", "/韩剧/", "/港剧/", "/台剧/", "/港台剧/", "/泰剧/",
 		"/日番/", "/国漫/", "/番剧/", "/动漫/", "/特别篇/", "/特別篇/", "/番外/", "/特典/",
 	} {
@@ -19,7 +19,7 @@ const pollutedEpisodeCleanupSettingKey = "media.polluted_episode_cleanup_v2_done

 // seasonFolderTailRE 去掉路径末尾的「季文件夹 + 文件名」,得到整剧目录(show_dir)。
 // 例: /tv/国漫/遮天 (2023)/Season 01/遮天 - S01E01.mkv → /tv/国漫/遮天 (2023)
-var seasonFolderTailRE = regexp.MustCompile(`(?i)[\\/](?:season[\s._-]*\d+|s\d{1,2}|specials?|sp|ova|oad|extra|extras|第\s*[0-9一二三四五六七八九十百零两]+\s*季|特别篇|特別篇|番外|特典)[\\/][^\\/]*$`)
+var seasonFolderTailRE = regexp.MustCompile(`(?i)[\\/](?:season[\s._-]*\d+|s\d{1,2}|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|第\s*[0-9一二三四五六七八九十百零两]+\s*季|特别篇|特別篇|番外|特典|画像特典)[\\/][^\\/]*$`)

 // showDirFromEpisodePath 从单集路径推出整剧目录, 作为「同一部剧」的聚合键。
 // 若没有季文件夹, 则退而去掉文件名取其父目录。
@@ -27,13 +27,14 @@ var (
 	patDanglingSE        = regexp.MustCompile(`(?i)(?:^|[\s._-])s\d{1,2}e(?:[\s._-]|$)`)
 	patNxE               = regexp.MustCompile(`(\d{1,2})x(\d{1,3})`)
 	patEP                = regexp.MustCompile(`(?i)(?:^|[^a-z])(?:e|ep)\.?\s*(\d{1,3})(?:[^0-9]|$)`)
+	patSpecialEpisode    = regexp.MustCompile(`(?i)(?:^|[^a-z0-9])(?:ova|oad|ovd|ona|sp|special(?:[\s._-]*episode)?|extra|bonus|omake)[\s._-]*0*(\d{1,3})(?:[^0-9]|$)`)
 	patCN                = regexp.MustCompile(`第\s*([0-9一二三四五六七八九十百零两]+)\s*[集话話期]`)
 	patCNRange           = regexp.MustCompile(`第\s*([0-9一二三四五六七八九十百零两]+)\s*[-~–—]\s*([0-9一二三四五六七八九十百零两]+)\s*[集话話期]`)
 	patDashEpisode       = regexp.MustCompile(`[\s._-][-–—]\s*(\d{1,3})(?:\s*(?:v\d+)?)?(?:\s*[\[\(._-]|$)`)
 	patSeasonFolder      = regexp.MustCompile(`(?i)(?:^|[^a-z])(?:s|season)\.?\s*(\d{1,2})(?:[^0-9]|$)|第\s*([0-9一二三四五六七八九十百零两]+)\s*季`)
 	patSeasonOnly        = regexp.MustCompile(`(?i)(?:^|[\s._-])(?:s|season)\.?\s*\d{1,2}(?:[\s._-]|$)`)
 	patBareEpisode       = regexp.MustCompile(`^(?:第\s*)?0?(\d{1,3})(?:\s*(?:v\d+)?)?$`)
-	patSpecialSeason     = regexp.MustCompile(`(?i)^(?:s0+|season[\s._-]*0+|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|extras?|bonus(?:es)?|omake|番外篇?|特别篇|特別篇|特典|外传|外傳|总集篇|總集篇)$`)
+	patSpecialSeason     = regexp.MustCompile(`(?i)^(?:s0+|season[\s._-]*0+|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|番外篇?|特别篇|特別篇|特典|外传|外傳|总集篇|總集篇|画像特典)$`)
 	patSeasonEpisodeZero = regexp.MustCompile(`(?i)s0*([1-9]\d?)e0+(?:[^0-9]|$)`)
 	// patCNSeason 匹配中文季/部标记，支持阿拉伯数字与中文数字（如「第二季」「第2部」）。
 	patCNSeason = regexp.MustCompile(`第\s*[0-9一二三四五六七八九十百零两]+\s*[季部]`)
@@ -57,6 +58,9 @@ func ParseEpisode(path string) (season, episode int) {
 		episode = mustAtoi(m[2])
 		return
 	}
+	if m := patSpecialEpisode.FindStringSubmatch(name); len(m) >= 2 {
+		return 0, mustAtoi(m[1])
+	}
 	if m := patEP.FindStringSubmatch(name); len(m) >= 2 {
 		var found bool
 		season, found = seasonFromParents(path)
@@ -29,6 +29,10 @@ func TestParseEpisode(t *testing.T) {
 		{`剧集/Specials/剧集 - 02.mkv`, 0, 2},
 		{`剧集/特别篇/03.mkv`, 0, 3},
 		{`剧集/剧集 - S00E04.mkv`, 0, 4},
+		{`动漫/摇曳露营/OVA/Season 3 [OVA01 [1080p].mkv`, 0, 1},
+		{`动漫/示例/OAD/示例.OAD02.mkv`, 0, 2},
+		{`动漫/示例/OVD/示例-OVD03.mkv`, 0, 3},
+		{`动漫/示例/ONA/示例_ONA04.mkv`, 0, 4},
 		{"Movie.2020.1080p.mkv", 0, 0},
 	}
 	for _, tc := range cases {
@@ -24,6 +24,13 @@ func (s *ScraperService) ManualSearch(ctx context.Context, media *model.Media, q
 			mediaType = lib.Type
 		}
 	}
+	// Keep manual scraping consistent with automatic scraping for theatrical
+	// features stored inside anime libraries. The UI may pass the library type
+	// ("anime"), which otherwise makes TMDb stop after a TV result and hide the
+	// actual movie candidate.
+	if mediaLooksLikeTheatricalFeature(media) {
+		mediaType = "movie"
+	}
 	mediaType = normalizeMediaType(mediaType, queries[0], "")
 	providers := manualSearchProviderSet(provider)
 	year := mediaYearHint(media)
@@ -313,6 +313,80 @@ func TestManualSearchReturnsMovieFallbackForTVTypedTMDbSearch(t *testing.T) {
 	}
 }

+func TestManualSearchAnimeTheatricalPrefersTMDbMovie(t *testing.T) {
+	var paths []string
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		paths = append(paths, r.URL.Path)
+		w.Header().Set("Content-Type", "application/json")
+		switch r.URL.Path {
+		case "/search/movie":
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"results": []map[string]any{{
+					"id":             635302,
+					"title":          "鬼灭之刃 剧场版 无限列车篇",
+					"original_title": "劇場版「鬼滅の刃」無限列車編",
+					"release_date":   "2020-10-16",
+				}},
+			})
+		case "/search/tv":
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"results": []map[string]any{{
+					"id":             85937,
+					"name":           "鬼灭之刃",
+					"original_name":  "鬼滅の刃",
+					"first_air_date": "2019-04-06",
+				}},
+			})
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer upstream.Close()
+
+	db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(&model.Library{}, &model.Series{}, &model.Media{}); err != nil {
+		t.Fatal(err)
+	}
+	repos := repository.New(db)
+	cfg := &config.Config{}
+	cfg.Secrets.TMDbAPIKey = "test-key"
+	cfg.Secrets.TMDbAPIProxy = upstream.URL
+	log := zap.NewNop()
+	scraper := NewScraperService(cfg, log, repos, NewTMDbProvider(cfg, log, nil), nil, nil, nil, NewHub(log))
+
+	lib := model.Library{Name: "动漫", Path: `/media/anime`, Type: "anime", Enabled: true}
+	if err := repos.DB.Create(&lib).Error; err != nil {
+		t.Fatal(err)
+	}
+	media := model.Media{
+		LibraryID: lib.ID,
+		Title:     "鬼灭之刃 剧场版 无限列车篇",
+		Path:      `/media/anime/鬼灭之刃/鬼灭之刃 剧场版 无限列车篇.mkv`,
+	}
+	if err := repos.DB.Create(&media).Error; err != nil {
+		t.Fatal(err)
+	}
+
+	results, err := scraper.ManualSearch(t.Context(), &media, media.Title, "tmdb", "anime")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(results) == 0 || results[0].TMDbID != 635302 || results[0].MediaType != "movie" {
+		t.Fatalf("manual theatrical results=%#v, paths=%v", results, paths)
+	}
+	if len(paths) == 0 || paths[0] != "/search/movie" {
+		t.Fatalf("TMDb search paths=%v, want movie first", paths)
+	}
+	for _, path := range paths {
+		if path == "/search/tv" {
+			t.Fatalf("manual theatrical search unexpectedly queried TV after finding movie: paths=%v", paths)
+		}
+	}
+}
+
 func TestManualSearchAllProvidersTMDbNumericIDTriesMovieAndTVNamespaces(t *testing.T) {
 	var paths []string
 	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -9,7 +9,7 @@ import (
 	"github.com/truewhile/MeBox/internal/model"
 )

-var episodicPathRE = regexp.MustCompile(`(?i)[\\/](?:电视剧|剧集|连续剧|短剧|国产剧|国剧|大陆剧|华语剧|国产电视剧|大陆电视剧|华语电视剧|欧美剧|欧美电视剧|美剧|英剧|日韩剧|日韩电视剧|日剧|韩剧|港剧|台剧|港台剧|泰剧|综艺|纪录片|儿童|动漫|番剧|国漫|日番|韩漫|美漫|欧美动漫|欧美动画|其他动漫|tv|series|shows?|season[\s._-]*\d|s\d{1,2}(?:[\s._-]|[\\/])|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|extras?|bonus(?:es)?|omake|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇)[\\/]`)
+var episodicPathRE = regexp.MustCompile(`(?i)[\\/](?:电视剧|剧集|连续剧|短剧|国产剧|国剧|大陆剧|华语剧|国产电视剧|大陆电视剧|华语电视剧|欧美剧|欧美电视剧|美剧|英剧|日韩剧|日韩电视剧|日剧|韩剧|港剧|台剧|港台剧|泰剧|综艺|纪录片|儿童|动漫|番剧|国漫|日番|韩漫|美漫|欧美动漫|欧美动画|其他动漫|tv|series|shows?|season[\s._-]*\d|s\d{1,2}(?:[\s._-]|[\\/])|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇|画像特典)[\\/]`)

 var genericMovieTitleRE = regexp.MustCompile(`(?i)^(?:cd\s*\d+|part\s*\d+|disc\s*\d+|disk\s*\d+|dvd\s*\d+|movie|film|video|main|feature|track\s*\d+|preview|sample|trailer|\d{3,4}p|4k|2160p|1080p|720p)$`)

@@ -123,9 +123,9 @@ var (
 	seriesIDRE          = regexp.MustCompile(`(?i)\s*\[(?:tmdb|tmdbid)[=-]\d+\]\s*`)
 	seriesBraceRE       = regexp.MustCompile(`(?i)\s*\{(?:tmdb|tmdbid|douban|bangumi|bgm|thetvdb|tvdb)[\s:=#-]*[a-z0-9_-]+\}\s*`)
 	seriesSpacerRE      = regexp.MustCompile(`[\s._-]+`)
-	seriesSeasonDirRE   = regexp.MustCompile(`(?i)^(?:s\d{1,2}|season[\s._-]*\d{1,2}|第\s*[0-9一二三四五六七八九十百零两]+\s*季|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|extras?|bonus(?:es)?|omake|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇)$`)
-	seriesSpecialCodeRE = regexp.MustCompile(`(?i)\s*[\[(（【]?\s*(?:s0+\s*e?\s*\d+|season\s*0+(?:\s*episode)?\s*\d*|special(?:\s*episode)?s?\s*\d*|sp\s*\d*|ovas?\s*\d*|oads?\s*\d*|extras?\s*\d*|bonus(?:es)?\s*\d*|omake\s*\d*)\s*[\])）】]?$`)
-	seriesSpecialCJKRE  = regexp.MustCompile(`(?i)\s*[\[(（【]?\s*(?:特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇)(?:\s*第?\s*[0-9一二三四五六七八九十百零两]+(?:[集话話期])?)?\s*[\])）】]?$`)
+	seriesSeasonDirRE   = regexp.MustCompile(`(?i)^(?:s\d{1,2}|season[\s._-]*\d{1,2}|第\s*[0-9一二三四五六七八九十百零两]+\s*季|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇|画像特典)$`)
+	seriesSpecialCodeRE = regexp.MustCompile(`(?i)\s*[\[(（【]?\s*(?:s0+\s*e?\s*\d+|season\s*0+(?:\s*episode)?\s*\d*|special(?:\s*episode)?s?\s*\d*|sp\s*\d*|ovas?\s*\d*|oads?\s*\d*|ovds?\s*\d*|onas?\s*\d*|extras?\s*\d*|bonus(?:es)?\s*\d*|omake\s*\d*|picture[\s._-]*drama\s*\d*|ncop\s*\d*|nced\s*\d*)\s*[\])）】]?$`)
+	seriesSpecialCJKRE  = regexp.MustCompile(`(?i)\s*[\[(（【]?\s*(?:特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇|画像特典)(?:\s*第?\s*[0-9一二三四五六七八九十百零两]+(?:[集话話期])?)?\s*[\])）】]?$`)
 )

 func normalizeSeriesTitle(value string) string {
@@ -173,7 +173,7 @@ func seriesTitleFromMediaPath(path string) string {
 	if last := parts[len(parts)-1]; !seriesPathPartLooksLikeFile(last) && !seriesSeasonDirRE.MatchString(filepath.Base(last)) {
 		dirIndex = len(parts) - 1
 	}
-	for dirIndex >= 0 && seriesSeasonDirRE.MatchString(filepath.Base(parts[dirIndex])) {
+	for dirIndex >= 0 && (seriesSeasonDirRE.MatchString(filepath.Base(parts[dirIndex])) || isTheatricalFolder(parts[dirIndex])) {
 		dirIndex--
 	}
 	if dirIndex < 0 {
@@ -404,6 +404,32 @@ func TestGroupMediaSeriesCardsKeepsMovieVersionsAsOneMovie(t *testing.T) {
 	}
 }

+func TestGroupMediaSeriesCardsKeepsTheatricalMovieWithTVSeries(t *testing.T) {
+	episode := model.Media{
+		Base:       model.Base{ID: "episode"},
+		LibraryID:  "anime",
+		Title:      "摇曳露营△",
+		Path:       `/media/动漫/摇曳露营△ (2018)/Season 01/摇曳露营△.S01E01.mkv`,
+		SeasonNum:  1,
+		EpisodeNum: 1,
+	}
+	theatrical := model.Media{
+		Base:      model.Base{ID: "theatrical"},
+		LibraryID: "anime",
+		Title:     "摇曳露营△ 剧场版",
+		Path:      `/media/动漫/摇曳露营△ (2018)/摇曳露营△ 剧场版 (2022)/Eiga.Yurukyan.2022.Bluray.mkv`,
+		TMDbID:    566466,
+	}
+
+	cards := groupMediaSeriesCards([]model.Media{episode, theatrical})
+	if len(cards) != 1 {
+		t.Fatalf("cards=%#v, want theatrical movie retained with TV series", cards)
+	}
+	if cards[0].Count != 2 {
+		t.Fatalf("series card count=%d, want TV episode plus theatrical movie", cards[0].Count)
+	}
+}
+
 func TestGroupMediaSeriesCardsDoesNotCollideMovieAndTVExternalIDs(t *testing.T) {
 	movie := model.Media{
 		Base:      model.Base{ID: "movie"},
@@ -512,4 +538,3 @@ func TestListMediaEpisodesKeepsIndependentMoviesSeparate(t *testing.T) {
 		t.Fatalf("ListMediaEpisodes got %#v, want exactly m1", eps)
 	}
 }
-
@@ -0,0 +1,54 @@
+package service
+
+import (
+	"regexp"
+	"strings"
+)
+
+const (
+	mediaSpecialTheatrical = "theatrical"
+	mediaSpecialOVA        = "ova"
+	mediaSpecialOAD        = "oad"
+	mediaSpecialOVD        = "ovd"
+	mediaSpecialONA        = "ona"
+	mediaSpecialExtra      = "extra"
+	mediaSpecialBonus      = "bonus"
+	mediaSpecialOmake      = "omake"
+	mediaSpecialPicture    = "picture_drama"
+	mediaSpecialNCOP       = "ncop"
+	mediaSpecialNCED       = "nced"
+	mediaSpecialGeneric    = "special"
+)
+
+var mediaSpecialKindPatterns = []struct {
+	kind string
+	re   *regexp.Regexp
+}{
+	{mediaSpecialOVA, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])ova(?:s)?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialOAD, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])oad(?:s)?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialOVD, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])ovd(?:s)?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialONA, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])ona(?:s)?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialPicture, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])(?:picture[\s._-]*drama|画像特典)(?:[^a-z0-9]|$)`)},
+	{mediaSpecialNCOP, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])ncop(?:\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialNCED, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])nced(?:\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialExtra, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])extras?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialBonus, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])bonus(?:es)?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialOmake, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])omake(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)`)},
+	{mediaSpecialGeneric, regexp.MustCompile(`(?i)(?:^|[^a-z0-9])(?:special(?:[\s._-]*episodes?)?|specials|sps?)(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇`)},
+}
+
+func mediaSpecialKind(path string) string {
+	if pathHasTheatricalFolder(path) || patTheatricalTitle.MatchString(path) {
+		return mediaSpecialTheatrical
+	}
+	for _, part := range strings.FieldsFunc(path, func(r rune) bool {
+		return r == '/' || r == '\\'
+	}) {
+		for _, pattern := range mediaSpecialKindPatterns {
+			if pattern.re.MatchString(part) {
+				return pattern.kind
+			}
+		}
+	}
+	return ""
+}
@@ -145,16 +145,32 @@ func mediaVersionGroupKey(m model.Media) string {
 		return fmt.Sprintf("embyremote:%s", m.ID)
 	}

-	if m.SeasonNum > 0 || m.EpisodeNum > 0 {
+	libKey := strings.ToLower(strings.TrimSpace(m.LibraryID))
+	if libKey == "" {
+		libKey = strings.ToLower(strings.TrimSpace(m.DisplayLibraryID))
+	}
+	specialKind := mediaSpecialKind(m.Path)
+	season, episode := m.SeasonNum, m.EpisodeNum
+	if specialKind != "" && specialKind != mediaSpecialTheatrical && episode <= 0 {
+		if parsedSeason, parsedEpisode := ParseEpisode(m.Path); parsedEpisode > 0 {
+			season, episode = parsedSeason, parsedEpisode
+		}
+	}
+
+	if season > 0 || episode > 0 {
+		kind := specialKind
+		if kind == "" {
+			kind = "episode"
+		}
 		switch {
 		case m.TMDbID > 0:
-			return fmt.Sprintf("episode:tmdb:%d:%d:%d", m.TMDbID, m.SeasonNum, m.EpisodeNum)
+			return fmt.Sprintf("episode:%s:tmdb:%d:%d:%d", kind, m.TMDbID, season, episode)
 		case m.BangumiID > 0:
-			return fmt.Sprintf("episode:bangumi:%d:%d:%d", m.BangumiID, m.SeasonNum, m.EpisodeNum)
+			return fmt.Sprintf("episode:%s:bangumi:%d:%d:%d", kind, m.BangumiID, season, episode)
 		case strings.TrimSpace(m.DoubanID) != "":
-			return fmt.Sprintf("episode:douban:%s:%d:%d", strings.ToLower(strings.TrimSpace(m.DoubanID)), m.SeasonNum, m.EpisodeNum)
+			return fmt.Sprintf("episode:%s:douban:%s:%d:%d", kind, strings.ToLower(strings.TrimSpace(m.DoubanID)), season, episode)
 		case strings.TrimSpace(m.TheTVDBID) != "":
-			return fmt.Sprintf("episode:thetvdb:%s:%d:%d", strings.ToLower(strings.TrimSpace(m.TheTVDBID)), m.SeasonNum, m.EpisodeNum)
+			return fmt.Sprintf("episode:%s:thetvdb:%s:%d:%d", kind, strings.ToLower(strings.TrimSpace(m.TheTVDBID)), season, episode)
 		}
 		title := firstNonEmpty(m.OriginalName, m.Title)
 		if title == "" {
@@ -166,37 +182,61 @@ func mediaVersionGroupKey(m model.Media) string {
 		}
 		return strings.Join([]string{
 			"episode",
-			strings.ToLower(strings.TrimSpace(m.LibraryID)),
+			kind,
+			libKey,
 			title,
-			fmt.Sprintf("%d:%d", m.SeasonNum, m.EpisodeNum),
+			fmt.Sprintf("%d:%d", season, episode),
 		}, "|")
 	}

-	libKey := strings.ToLower(strings.TrimSpace(m.LibraryID))
-	if libKey == "" {
-		libKey = strings.ToLower(strings.TrimSpace(m.DisplayLibraryID))
+	if specialKind != "" && specialKind != mediaSpecialTheatrical {
+		return mediaVersionStemGroupKey(m, libKey)
 	}

 	switch {
 	case m.TMDbID > 0:
 		if libKey != "" {
+			if specialKind != "" {
+				return fmt.Sprintf("movie:%s:%s:tmdb:%d", specialKind, libKey, m.TMDbID)
+			}
 			return fmt.Sprintf("movie:%s:tmdb:%d", libKey, m.TMDbID)
 		}
+		if specialKind != "" {
+			return fmt.Sprintf("movie:%s:tmdb:%d", specialKind, m.TMDbID)
+		}
 		return fmt.Sprintf("tmdb:%d", m.TMDbID)
 	case m.BangumiID > 0:
 		if libKey != "" {
+			if specialKind != "" {
+				return fmt.Sprintf("movie:%s:%s:bangumi:%d", specialKind, libKey, m.BangumiID)
+			}
 			return fmt.Sprintf("movie:%s:bangumi:%d", libKey, m.BangumiID)
 		}
+		if specialKind != "" {
+			return fmt.Sprintf("movie:%s:bangumi:%d", specialKind, m.BangumiID)
+		}
 		return fmt.Sprintf("bangumi:%d", m.BangumiID)
 	case strings.TrimSpace(m.DoubanID) != "":
 		if libKey != "" {
+			if specialKind != "" {
+				return fmt.Sprintf("movie:%s:%s:douban:%s", specialKind, libKey, strings.ToLower(strings.TrimSpace(m.DoubanID)))
+			}
 			return fmt.Sprintf("movie:%s:douban:%s", libKey, strings.ToLower(strings.TrimSpace(m.DoubanID)))
 		}
+		if specialKind != "" {
+			return "movie:" + specialKind + ":douban:" + strings.ToLower(strings.TrimSpace(m.DoubanID))
+		}
 		return "douban:" + strings.ToLower(strings.TrimSpace(m.DoubanID))
 	case strings.TrimSpace(m.TheTVDBID) != "":
 		if libKey != "" {
+			if specialKind != "" {
+				return fmt.Sprintf("movie:%s:%s:thetvdb:%s", specialKind, libKey, strings.ToLower(strings.TrimSpace(m.TheTVDBID)))
+			}
 			return fmt.Sprintf("movie:%s:thetvdb:%s", libKey, strings.ToLower(strings.TrimSpace(m.TheTVDBID)))
 		}
+		if specialKind != "" {
+			return "movie:" + specialKind + ":thetvdb:" + strings.ToLower(strings.TrimSpace(m.TheTVDBID))
+		}
 		return "thetvdb:" + strings.ToLower(strings.TrimSpace(m.TheTVDBID))
 	}

@@ -71,6 +71,73 @@ func TestGroupEpisodeVersionsForDisplayMergesAndKeepsEpisodeOrder(t *testing.T)
 	}
 }

+func TestGroupMediaVersionsSeparatesAnimeSpecialKindsAndNumbers(t *testing.T) {
+	rows := []model.Media{
+		{
+			Base:      model.Base{ID: "movie"},
+			LibraryID: "anime",
+			Title:     "摇曳露营△",
+			Path:      "/media/动漫/摇曳露营△/摇曳露营△ 剧场版 (2022)/movie.strm",
+			TMDbID:    76075,
+		},
+		{
+			Base:      model.Base{ID: "ova-1"},
+			LibraryID: "anime",
+			Title:     "摇曳露营△",
+			Path:      "/media/动漫/摇曳露营△/OVA/Yuru Camp OVA01.strm",
+			TMDbID:    76075,
+		},
+		{
+			Base:      model.Base{ID: "ova-2"},
+			LibraryID: "anime",
+			Title:     "摇曳露营△",
+			Path:      "/media/动漫/摇曳露营△/OVA/Yuru Camp OVA02.strm",
+			TMDbID:    76075,
+		},
+		{
+			Base:      model.Base{ID: "oad-1"},
+			LibraryID: "anime",
+			Title:     "摇曳露营△",
+			Path:      "/media/动漫/摇曳露营△/OAD/Yuru Camp OAD01.strm",
+			TMDbID:    76075,
+		},
+	}
+
+	grouped := groupMediaVersions(rows)
+	if len(grouped) != 4 {
+		t.Fatalf("grouped len = %d, want theatrical, OVA01, OVA02 and OAD01 separate: %#v", len(grouped), grouped)
+	}
+	for _, item := range grouped {
+		if len(item.Versions) > 1 {
+			t.Fatalf("unrelated anime extras were merged as versions: %#v", item.Versions)
+		}
+	}
+}
+
+func TestGroupMediaVersionsMergesSameNumberedOVAEncodes(t *testing.T) {
+	rows := []model.Media{
+		{
+			Base:      model.Base{ID: "ova-1-hd"},
+			LibraryID: "anime",
+			Path:      "/media/动漫/示例/OVA/Show OVA01 1080p.mkv",
+			TMDbID:    123,
+			SizeBytes: 100,
+		},
+		{
+			Base:      model.Base{ID: "ova-1-uhd"},
+			LibraryID: "anime",
+			Path:      "/media/动漫/示例/OVA/Show OVA01 2160p.mkv",
+			TMDbID:    123,
+			SizeBytes: 200,
+		},
+	}
+
+	grouped := groupMediaVersions(rows)
+	if len(grouped) != 1 || len(grouped[0].Versions) != 2 {
+		t.Fatalf("same numbered OVA encodes should be versions: %#v", grouped)
+	}
+}
+
 func TestGroupMediaVersionsMergesMovieEncodingVariants(t *testing.T) {
 	hd := model.Media{
 		LibraryID:    "movies",
@@ -93,7 +93,11 @@ func (s *ScannerService) readLocalScanMetadata(lib *model.Library, root *model.L
 	if root != nil && strings.TrimSpace(root.Path) != "" {
 		rootPath = root.Path
 	}
-	localMeta, err := ReadLocalMetadata(path, rootPath, librarySupportsSeasons(lib) || parsedSeason > 0 || parsedEpisode > 0)
+	seriesLike := librarySupportsSeasons(lib) || parsedSeason > 0 || parsedEpisode > 0
+	if mediaLooksLikeTheatricalFeature(&model.Media{Path: path}) {
+		seriesLike = false
+	}
+	localMeta, err := ReadLocalMetadata(path, rootPath, seriesLike)
 	if err != nil {
 		s.log.Warn("read local metadata failed", zap.String("path", path), zap.Error(err))
 	}
@@ -69,6 +69,49 @@ func TestScanLibraryUsesLocalMetadata(t *testing.T) {
 	}
 }

+func TestScanAnimeTheatricalFolderUsesMovieNFO(t *testing.T) {
+	root := t.TempDir()
+	showDir := filepath.Join(root, "摇曳露营△ (2018)")
+	movieDir := filepath.Join(showDir, "摇曳露营△ 剧场版 (2022)")
+	if err := os.MkdirAll(movieDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(showDir, "tvshow.nfo"), []byte(
+		`<tvshow><title>错误的剧集标题</title><tmdbid>76075</tmdbid><year>2018</year></tvshow>`,
+	), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	mediaPath := filepath.Join(movieDir, "Eiga.Yurukyan.2022.Bluray.mkv")
+	if err := os.WriteFile(mediaPath, []byte("x"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(nfoPath(mediaPath), []byte(
+		`<movie><title>摇曳露营△ 剧场版</title><tmdbid>566466</tmdbid><year>2022</year></movie>`,
+	), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	db := newServiceTestDB(t, &model.Library{}, &model.Media{}, &model.Setting{})
+	repos := repository.New(db)
+	lib := model.Library{Name: "动漫", Path: root, Type: "anime", Enabled: true}
+	if err := repos.Library.Create(t.Context(), &lib); err != nil {
+		t.Fatal(err)
+	}
+
+	scanner := NewScannerService(&config.Config{}, zap.NewNop(), repos, NewHub(zap.NewNop()), nil, nil)
+	if _, err := scanner.ScanLibrary(t.Context(), lib.ID); err != nil {
+		t.Fatal(err)
+	}
+
+	var media model.Media
+	if err := db.First(&media, "path = ?", mediaPath).Error; err != nil {
+		t.Fatal(err)
+	}
+	if media.Title != "摇曳露营△ 剧场版" || media.TMDbID != 566466 || media.Year != 2022 {
+		t.Fatalf("theatrical movie metadata = title %q tmdb %d year %d", media.Title, media.TMDbID, media.Year)
+	}
+}
+
 func TestScanLibraryDoesNotMarkArtworkOnlyAsMatched(t *testing.T) {
 	root := t.TempDir()
 	mediaPath := filepath.Join(root, "SSIS-001-CD1.mp4")
@@ -66,6 +66,36 @@ func TestMetadataMatchCompatibilityForTheatricalFeatures(t *testing.T) {
 	}
 }

+func TestMediaLooksLikeTheatricalFeatureIgnoresStaleEpisodeIdentity(t *testing.T) {
+	media := &model.Media{
+		Title:      "未命名",
+		Path:       `/media/anime/超人高校生们/剧场版/超人高校生们 剧场版.mkv`,
+		SeasonNum:  1,
+		EpisodeNum: 1,
+	}
+	if !mediaLooksLikeTheatricalFeature(media) {
+		t.Fatal("theatrical path should override stale persisted season/episode fields")
+	}
+
+	namedFolder := &model.Media{
+		Title: "Eiga Yurukyan 2022 Bluray",
+		Path:  `/media/anime/摇曳露营△ (2018)/摇曳露营△ 剧场版 (2022)/Eiga.Yurukyan.2022.Bluray.mkv`,
+	}
+	if !mediaLooksLikeTheatricalFeature(namedFolder) {
+		t.Fatal("a named theatrical folder with a year should be detected from the full path")
+	}
+
+	realEpisode := &model.Media{
+		Title:      "剧场版制作幕后",
+		Path:       `/media/anime/超人高校生们/Season 01/超人高校生们.S01E01.mkv`,
+		SeasonNum:  1,
+		EpisodeNum: 1,
+	}
+	if mediaLooksLikeTheatricalFeature(realEpisode) {
+		t.Fatal("an actual episode marker in the path must remain episodic")
+	}
+}
+
 func TestScrapeQueryCandidatesForAnimeTheatricalMix(t *testing.T) {
 	lib := &model.Library{
 		Path: `/media/anime`,
@@ -16,7 +16,7 @@ var (
 	genericEpisodeWordsRE    = regexp.MustCompile(`^\s*第\s*[集期话話]\s*$`)
 	episodeReleaseTitleTagRE = regexp.MustCompile(`(?i)(?:^|[\s._-])s\d{1,2}e\d{1,3}(?:[\s._-]|$)`)
 	patTheatricalTitle       = regexp.MustCompile(`(?i)(?:剧场版|劇場版|动画电影|動畫電影|电影版|電影版|\bthe\s+movie\b|\bmovie\s*\d{1,2}\b)`)
-	patTheatricalFolder      = regexp.MustCompile(`(?i)[\\/](?:剧场版|劇場版|動畫電影|动画电影)[\\/]`)
+	patTheatricalFolder      = regexp.MustCompile(`(?i)[\\/][^\\/]*(?:剧场版|劇場版|動畫電影|动画电影|电影版|電影版)[^\\/]*[\\/]`)
 	theatricalNoiseRE        = regexp.MustCompile(`(?i)(?:剧场版|劇場版)\s*(?:第?\s*\d{1,3}\s*[部篇]?)?|电影版|電影版|动画电影|動畫電影`)
 )

@@ -40,14 +40,15 @@ func mediaLooksLikeTheatricalFeature(m *model.Media) bool {
 	if m == nil {
 		return false
 	}
-	if m.SeasonNum > 0 || m.EpisodeNum > 0 {
-		return false
-	}
+	// Trust an episode marker that is actually present in the path, but do not
+	// trust persisted season/episode fields here. Older scans could incorrectly
+	// assign those fields to a theatrical file, which would permanently prevent
+	// both manual re-scraping and separation from the TV series.
 	if season, ep := ParseEpisode(m.Path); season > 0 || ep > 0 {
 		return false
 	}
 	text := m.Title + " " + pathBaseSlash(m.Path)
-	return patTheatricalTitle.MatchString(text) || patTheatricalFolder.MatchString(m.Path)
+	return patTheatricalTitle.MatchString(text) || pathHasTheatricalFolder(m.Path)
 }

 func scrapeQueryCandidates(m *model.Media, lib *model.Library) []string {
@@ -1,6 +1,11 @@
 package service

-import "strings"
+import (
+	"regexp"
+	"strings"
+)
+
+var namedTheatricalFolderRE = regexp.MustCompile(`(?i)(?:剧场版|劇場版|动画电影|動畫電影|电影版|電影版)`)

 func mediaFolderTitle(mediaPath, libraryRoot string) string {
 	dir := parentSlashPath(mediaPath)
@@ -13,10 +18,10 @@ func mediaFolderTitle(mediaPath, libraryRoot string) string {
 		if base == "" || base == "." {
 			return ""
 		}
-			if isTechnicalMediaFolder(base) || strictSeasonFolderMatched(base) || isTheatricalFolder(base) {
-				dir = parentSlashPath(dir)
-				continue
-			}
+		if isTechnicalMediaFolder(base) || strictSeasonFolderMatched(base) || isTheatricalFolder(base) {
+			dir = parentSlashPath(dir)
+			continue
+		}
 		if isMediaCollectionFolder(base) {
 			dir = parentSlashPath(dir)
 			continue
@@ -123,14 +128,30 @@ func seriesFolderTitle(mediaPath, libraryRoot string) string {
 func isTheatricalFolder(name string) bool {
 	key := strings.ToLower(strings.TrimSpace(name))
 	key = strings.Trim(key, `\/`)
+	if namedTheatricalFolderRE.MatchString(key) {
+		return true
+	}
 	switch key {
-	case "剧场版", "劇場版", "动画电影", "動畫電影", "特别篇", "特別篇", "specials", "sp", "ova", "oad":
+	case "剧场版", "劇場版", "动画电影", "動畫電影", "特别篇", "特別篇",
+		"special", "specials", "sp", "ova", "ovas", "oad", "oads", "ovd", "ovds", "ona", "onas",
+		"extra", "extras", "bonus", "bonuses", "omake", "picture drama", "ncop", "nced", "画像特典":
 		return true
 	default:
 		return false
 	}
 }

+func pathHasTheatricalFolder(path string) bool {
+	for _, part := range strings.FieldsFunc(path, func(r rune) bool {
+		return r == '/' || r == '\\'
+	}) {
+		if isTheatricalFolder(part) && namedTheatricalFolderRE.MatchString(part) {
+			return true
+		}
+	}
+	return false
+}
+
 func libraryRootTitle(libraryRoot string) string {
 	base := ""
 	if info, ok := ParseCloudLibraryMount(libraryRoot); ok {
@@ -46,25 +46,26 @@ type strmSyncState struct {
 	rec      *model.StrmSyncRecord
 	syncType string

-	mu                  sync.Mutex
-	processed           int                         // 已处理文件计数（用于定期落库进度）
-	lastProgressFlush   time.Time                   // 上次进度落库时间
-	seenVideo           map[string]bool             // "v:"+strm 去扩展名相对路径 → 远端存在该视频（供 prune）
-	seenMeta            map[string]bool             // "m:"+相对路径 → 远端存在该元数据
-	remoteMeta          map[string][]remoteMetaItem // "m:"+相对路径 → 远端元数据副本列表（多副本聚合，支持择优比对与冗余清理）
-	seenMetaTarget      map[string]cloud.FileEntry
-	seenVideoTarget     map[string]cloud.FileEntry
+	mu                sync.Mutex
+	processed         int                         // 已处理文件计数（用于定期落库进度）
+	lastProgressFlush time.Time                   // 上次进度落库时间
+	seenVideo         map[string]bool             // "v:"+strm 去扩展名相对路径 → 远端存在该视频（供 prune）
+	seenDir           map[string]bool             // 清洗后的目录相对路径 → 远端存在该目录（供整目录 prune）
+	seenMeta          map[string]bool             // "m:"+相对路径 → 远端存在该元数据
+	remoteMeta        map[string][]remoteMetaItem // "m:"+相对路径 → 远端元数据副本列表（多副本聚合，支持择优比对与冗余清理）
+	seenMetaTarget    map[string]cloud.FileEntry
+	seenVideoTarget   map[string]cloud.FileEntry
 	// remoteVideos：prefer 模式下同名（去扩展名）视频候选列表，walk 结束后择优写盘
-	remoteVideos map[string][]remoteVideoCandidate
+	remoteVideos        map[string][]remoteVideoCandidate
 	activeDownloadPaths map[string]bool // 本地已在排队/进行的下载任务路径（内存去重）
 	activeUploadPaths   map[string]bool // 本地已在排队/进行的上传任务路径（内存去重）
 	// recentDoneUploadSizes：近期已成功上传的 local_path → size，缩短「done 但列表未到」窗口内的重复入队
 	recentDoneUploadSizes map[string]int64
 	pendingDownloads      []*model.StrmDownloadTask
 	pendingUploads        []*model.StrmUploadTask
-	dirCache            sync.Map          // dirID (string) -> relativePath (string)
-	dirPathToID         map[string]string // relativePath (string) -> dirID（115 上传父目录寻址用，walk 后构建）
-	dirCacheDirty       map[string]string // 待批量落库的目录缓存（dirID → 相对路径），避免逐目录单条 upsert
+	dirCache              sync.Map          // dirID (string) -> relativePath (string)
+	dirPathToID           map[string]string // relativePath (string) -> dirID（115 上传父目录寻址用，walk 后构建）
+	dirCacheDirty         map[string]string // 待批量落库的目录缓存（dirID → 相对路径），避免逐目录单条 upsert

 	scanIncomplete atomic.Bool // 远端目录树/文件列表本次扫描不完整 → 禁止增量 prune 误删本地文件
 }
@@ -281,6 +282,7 @@ func (s *StrmService) runSync(ctx context.Context, p *model.StrmSyncPath, rec *m
 		rec:             rec,
 		syncType:        rec.SyncType,
 		seenVideo:       map[string]bool{},
+		seenDir:         map[string]bool{"": true},
 		seenMeta:        map[string]bool{},
 		remoteMeta:      map[string][]remoteMetaItem{},
 		seenMetaTarget:  map[string]cloud.FileEntry{},
@@ -535,36 +537,38 @@ func (st *strmSyncState) walkRemote() error {
 						if task.rel != "" {
 							rel = task.rel + "/" + cleanName
 						}
-							if entry.IsDir {
-								st.dirCache.Store(entry.ID, rel)
-								st.deferDirCacheSave(entry.ID, rel)
-								push(dirTask{id: entry.ID, rel: rel})
-							} else {
-								st.processRemoteFile(entry, rel)
-							}
+						if entry.IsDir {
+							st.markSeenDir(rel)
+							st.dirCache.Store(entry.ID, rel)
+							st.deferDirCacheSave(entry.ID, rel)
+							push(dirTask{id: entry.ID, rel: rel})
+						} else {
+							st.processRemoteFile(entry, rel)
 						}
-						walkMu.Lock()
-						pending--
-						if pending == 0 {
-							walkCond.Broadcast()
-						}
-						walkMu.Unlock()
 					}
-				}); err != nil {
-					cancel()
+					walkMu.Lock()
+					pending--
+					if pending == 0 {
+						walkCond.Broadcast()
+					}
+					walkMu.Unlock()
 				}
-			}()
-		}
-		wg.Wait()
-		st.flushDirCacheSave()
-		if firstErr != nil {
-			return firstErr
-		}
+			}); err != nil {
+				cancel()
+			}
+		}()
+	}
+	wg.Wait()
+	st.flushDirCacheSave()
+	if firstErr != nil {
+		return firstErr
+	}
 	return ctx.Err()
 }

 // processRemoteFile 分类处理远端文件：视频生成 STRM，元数据入下载队列。
 func (st *strmSyncState) processRemoteFile(entry cloud.FileEntry, rel string) {
+	st.markSeenDir(filepath.ToSlash(filepath.Dir(rel)))
 	fileName := entry.Name
 	if st.isExcluded(fileName) {
 		return
@@ -698,16 +702,16 @@ func (st *strmSyncState) walk115Flat(open115 *cloud115.OpenClient) error {
 				if pathCounts[item.Path] > 1 {
 					continue
 				}
-					st.dirCache.Store(item.DirID, cleanDirRel(item.Path))
-				}
+				st.dirCache.Store(item.DirID, cleanDirRel(item.Path))
 			}
 		}
+	}

-		// 2. 自适应分治拉取文件列表（单目录超 9500 时自动对子目录并发分治扁平化）
-		allFiles, err := st.fetch115FilesAdaptive(ctx, open115, rootCID)
-		if err != nil {
-			return err
-		}
+	// 2. 自适应分治拉取文件列表（单目录超 9500 时自动对子目录并发分治扁平化）
+	allFiles, err := st.fetch115FilesAdaptive(ctx, open115, rootCID)
+	if err != nil {
+		return err
+	}

 	if ctx.Err() != nil {
 		return ctx.Err()
@@ -1031,10 +1035,10 @@ func list115DirDirect(ctx context.Context, open115 *cloud115.OpenClient, cid str

 // fetch115FilesAdaptive 采用自适应分治策略抓取 115 目录树下的全部文件：
 // 115 开放平台扁平搜索对 offset+limit 有 10000 的最大深度限制。
-// - 若子树文件总数 < 9500，直接使用全速扁平分页批量拉取；
-// - 若子树文件总数 >= 9500（大库或超大分类目录），自动分治：仅单层列出该目录的直属子项（cur=1），
-//   直属纯文件直接收集，直属子目录则派发为独立的子树任务继续递归探测与拉取；
-// - 若超大单目录下无子目录或层级过深（>10层），安全回退到 errFallbackToWalkRemote。
+//   - 若子树文件总数 < 9500，直接使用全速扁平分页批量拉取；
+//   - 若子树文件总数 >= 9500（大库或超大分类目录），自动分治：仅单层列出该目录的直属子项（cur=1），
+//     直属纯文件直接收集，直属子目录则派发为独立的子树任务继续递归探测与拉取；
+//   - 若超大单目录下无子目录或层级过深（>10层），安全回退到 errFallbackToWalkRemote。
 func (st *strmSyncState) fetch115FilesAdaptive(ctx context.Context, open115 *cloud115.OpenClient, rootCID string) ([]cloud115.RemoteFile, error) {
 	var (
 		allFiles []cloud115.RemoteFile
@@ -1637,6 +1641,10 @@ func (st *strmSyncState) walkLocalSource() error {
 		default:
 		}
 		if d.IsDir() {
+			rel, relErr := filepath.Rel(srcRoot, path)
+			if relErr == nil {
+				st.markSeenDir(filepath.ToSlash(rel))
+			}
 			return nil
 		}
 		rel, err := filepath.Rel(srcRoot, path)
@@ -1898,8 +1906,104 @@ func (st *strmSyncState) taskExists(kind, syncPathID, localPath string) bool {
 	return count > 0
 }

-// pruneLocal 清理本地多余 .strm（远端已不存在的视频），可选删除空目录。
-// 元数据文件（nfo/图片/字幕等）一律保留：本地刮削结果不因网盘端缺失而被删除。
+// markSeenDir 记录远端存在的目录及其全部祖先目录。
+func (st *strmSyncState) markSeenDir(rel string) {
+	rel = strings.Trim(filepath.ToSlash(rel), "/")
+	if rel == "." {
+		rel = ""
+	}
+	st.mu.Lock()
+	if st.seenDir == nil {
+		st.seenDir = map[string]bool{"": true}
+	}
+	for {
+		st.seenDir[rel] = true
+		if rel == "" {
+			break
+		}
+		if idx := strings.LastIndexByte(rel, '/'); idx >= 0 {
+			rel = rel[:idx]
+		} else {
+			rel = ""
+		}
+	}
+	st.mu.Unlock()
+}
+
+// refreshUnseen115Dirs 补查本地存在、但 115 扁平文件列表未覆盖的目录。
+// 扁平接口不返回空目录；逐层补查这些候选目录可以避免把远端仍存在的空目录误删。
+func (st *strmSyncState) refreshUnseen115Dirs(localRoot string, dirs []string) error {
+	if st.p.Provider != model.StrmProvider115 || st.provider == nil {
+		return nil
+	}
+	dirIDs := map[string]string{"": strings.TrimSpace(st.p.RemotePath)}
+	if dirIDs[""] == "" {
+		dirIDs[""] = "0"
+	}
+	st.dirCache.Range(func(key, value any) bool {
+		id, idOK := key.(string)
+		rel, relOK := value.(string)
+		if idOK && relOK && id != "" {
+			dirIDs[cleanDirRel(rel)] = id
+		}
+		return true
+	})
+	liveIDs := map[string]string{"": dirIDs[""]}
+	listed := map[string]bool{}
+
+	sort.Strings(dirs)
+	for _, dir := range dirs {
+		rel, err := filepath.Rel(localRoot, dir)
+		if err != nil {
+			continue
+		}
+		rel = cleanDirRel(filepath.ToSlash(rel))
+		st.mu.Lock()
+		seen := st.seenDir[rel]
+		st.mu.Unlock()
+		if seen {
+			if id := dirIDs[rel]; id != "" {
+				liveIDs[rel] = id
+			}
+			continue
+		}
+
+		parentRel := ""
+		if idx := strings.LastIndexByte(rel, '/'); idx >= 0 {
+			parentRel = rel[:idx]
+		}
+		parentID := liveIDs[parentRel]
+		if parentID == "" {
+			continue // 父目录已确认不存在，子目录也必然是本地孤儿
+		}
+		if listed[parentRel] {
+			continue
+		}
+		entries, err := st.provider.List(st.ctx, parentID)
+		if err != nil {
+			return fmt.Errorf("核对 115 远端目录 %s 失败：%w", parentRel, err)
+		}
+		listed[parentRel] = true
+		for _, entry := range entries {
+			if !entry.IsDir {
+				continue
+			}
+			childRel := cleanEntryName(entry.Name, true)
+			if parentRel != "" {
+				childRel = parentRel + "/" + childRel
+			}
+			st.markSeenDir(childRel)
+			liveIDs[childRel] = entry.ID
+			dirIDs[childRel] = entry.ID
+		}
+	}
+	return nil
+}
+
+// pruneLocal 清理本地远端已不存在的内容：
+//   - 整个目录在远端不存在时，递归删除该本地目录（包括元数据）；
+//   - 目录仍存在但视频已删除时，仅删除对应的 .strm，保留本地元数据；
+//   - DeleteDir 开启时，最后再清理其余空目录。
 func (st *strmSyncState) pruneLocal() error {
 	// 增量同步保护：本次远端扫描不完整（目录详情解析失败 / 文件父路径降级）时，
 	// seenVideo 覆盖不全，按"远端不存在"清理会误删刚下载或已存在的本地 .strm，
@@ -1911,6 +2015,7 @@ func (st *strmSyncState) pruneLocal() error {
 	}
 	localRoot := filepath.Clean(st.p.LocalPath)
 	var dirs []string
+	var strmFiles []string
 	err := filepath.WalkDir(localRoot, func(path string, d os.DirEntry, err error) error {
 		if err != nil {
 			return nil
@@ -1933,13 +2038,74 @@ func (st *strmSyncState) pruneLocal() error {
 		}
 		rel = filepath.ToSlash(rel)
 		ext := strings.ToLower(filepath.Ext(rel))
-		remove := false
 		if ext == ".strm" {
-			relSansExt := rel[:len(rel)-len(ext)]
+			strmFiles = append(strmFiles, path)
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if err := st.refreshUnseen115Dirs(localRoot, dirs); err != nil {
+		return err
+	}
+
+	// 先从浅到深找出最上层孤儿目录；父目录已判定为孤儿时无需重复处理子目录。
+	sort.Strings(dirs)
+	orphanRoots := make([]string, 0)
+	for _, dir := range dirs {
+		rel, relErr := filepath.Rel(localRoot, dir)
+		if relErr != nil {
+			continue
+		}
+		rel = filepath.ToSlash(rel)
+		st.mu.Lock()
+		existsRemotely := st.seenDir[rel]
+		st.mu.Unlock()
+		if existsRemotely {
+			continue
+		}
+		underOrphan := false
+		for _, root := range orphanRoots {
+			childRel, childErr := filepath.Rel(root, dir)
+			if childErr == nil && childRel != ".." && !strings.HasPrefix(childRel, ".."+string(filepath.Separator)) {
+				underOrphan = true
+				break
+			}
+		}
+		if !underOrphan {
+			orphanRoots = append(orphanRoots, dir)
+		}
+	}
+	for _, dir := range orphanRoots {
+		var fileCount int64
+		_ = filepath.WalkDir(dir, func(_ string, d os.DirEntry, walkErr error) error {
+			if walkErr == nil && !d.IsDir() {
+				fileCount++
+			}
+			return nil
+		})
+		if err := os.RemoveAll(dir); err == nil {
 			st.mu.Lock()
-			remove = !st.seenVideo["v:"+relSansExt]
+			st.rec.Pruned += fileCount
 			st.mu.Unlock()
 		}
+	}
+
+	// 对仍存在于远端的目录，按原规则清理失去远端视频来源的单个 .strm。
+	for _, path := range strmFiles {
+		if _, err := os.Stat(path); err != nil {
+			continue // 已随孤儿目录递归删除
+		}
+		rel, relErr := filepath.Rel(localRoot, path)
+		if relErr != nil {
+			continue
+		}
+		rel = filepath.ToSlash(rel)
+		relSansExt := strings.TrimSuffix(rel, filepath.Ext(rel))
+		st.mu.Lock()
+		remove := !st.seenVideo["v:"+relSansExt]
+		st.mu.Unlock()
 		if remove {
 			if err := os.Remove(path); err == nil {
 				st.mu.Lock()
@@ -1947,11 +2113,8 @@ func (st *strmSyncState) pruneLocal() error {
 				st.mu.Unlock()
 			}
 		}
-		return nil
-	})
-	if err != nil {
-		return err
 	}
+
 	if st.cfg.DeleteDir {
 		sort.Sort(sort.Reverse(sort.StringSlice(dirs)))
 		for _, dir := range dirs {
@@ -489,14 +489,12 @@ func taskNames(tasks []model.StrmUploadTask) []string {
 	return names
 }

-// TestPruneLocalKeepsLocalMeta 验证清理规则：远端已删除的视频 .strm 仍会被清理，
-// 但本地元数据一律保留（即使开启"下载元数据"且未开启"上传元数据"、网盘端没有
-// 该元数据，也不再删除本地刮削好的 nfo/图片/字幕）。
-func TestPruneLocalKeepsLocalMeta(t *testing.T) {
+// TestPruneLocalRemovesOrphanDirectory 验证远端目录不存在时，会递归删除整个本地
+// 目录，包括其中的 strm、NFO、图片等文件。
+func TestPruneLocalRemovesOrphanDirectory(t *testing.T) {
 	svc := testStrmService(t)
 	localDir := t.TempDir()

-	// 阿凡达.strm（对应视频已被网盘删除 → 应清理）+ 阿凡达.nfo（网盘没有 → 保留）
 	writeFile(t, filepath.Join(localDir, "电影", "阿凡达.strm"), "http://test.local:8096/x")
 	writeFile(t, filepath.Join(localDir, "电影", "阿凡达.nfo"), "<local scraped meta/>")
 	writeFile(t, filepath.Join(localDir, "电影", "poster.jpg"), "local-poster")
@@ -518,10 +516,40 @@ func TestPruneLocalKeepsLocalMeta(t *testing.T) {
 		rec:        &model.StrmSyncRecord{},
 		syncType:   model.StrmSyncTypeFull,
 		seenVideo:  map[string]bool{},
+		seenDir:    map[string]bool{"": true},
 		seenMeta:   map[string]bool{},
 		remoteMeta: map[string][]remoteMetaItem{},
 	}
-	// 本次远端扫描既没有看到视频，也没有看到任何元数据
+	if err := st.pruneLocal(); err != nil {
+		t.Fatalf("pruneLocal failed: %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(localDir, "电影")); !os.IsNotExist(err) {
+		t.Fatalf("orphan directory should be removed recursively, stat err = %v", err)
+	}
+	if st.rec.Pruned != 3 {
+		t.Fatalf("expected 3 pruned files, got %d", st.rec.Pruned)
+	}
+}
+
+// TestPruneLocalKeepsMetaInExistingDirectory 验证目录仍在远端时，只清理失去
+// 视频来源的 strm，不删除本地刮削元数据。
+func TestPruneLocalKeepsMetaInExistingDirectory(t *testing.T) {
+	svc := testStrmService(t)
+	localDir := t.TempDir()
+	writeFile(t, filepath.Join(localDir, "电影", "阿凡达.strm"), "http://test.local:8096/x")
+	writeFile(t, filepath.Join(localDir, "电影", "阿凡达.nfo"), "<local scraped meta/>")
+
+	st := &strmSyncState{
+		s:         svc,
+		ctx:       context.Background(),
+		p:         &model.StrmSyncPath{Base: model.Base{ID: "prune-existing-dir"}, LocalPath: localDir},
+		cfg:       &strmPathConfig{},
+		rec:       &model.StrmSyncRecord{},
+		syncType:  model.StrmSyncTypeFull,
+		seenVideo: map[string]bool{},
+		seenDir:   map[string]bool{"": true, "电影": true},
+	}
 	if err := st.pruneLocal(); err != nil {
 		t.Fatalf("pruneLocal failed: %v", err)
 	}
@@ -530,10 +558,7 @@ func TestPruneLocalKeepsLocalMeta(t *testing.T) {
 		t.Fatalf("orphan .strm should be pruned, stat err = %v", err)
 	}
 	if _, err := os.Stat(filepath.Join(localDir, "电影", "阿凡达.nfo")); err != nil {
-		t.Fatalf("local meta must be kept even when missing on remote: %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(localDir, "电影", "poster.jpg")); err != nil {
-		t.Fatalf("local poster must be kept even when missing on remote: %v", err)
+		t.Fatalf("local meta in an existing remote directory must be kept: %v", err)
 	}
 	if st.rec.Pruned != 1 {
 		t.Fatalf("expected 1 pruned (strm only), got %d", st.rec.Pruned)
@@ -44,8 +44,8 @@ export function ManualScrapeDialog({
  if (!open || !media) return null

  return (
-    <div className="fixed inset-0 z-50 flex items-center justify-center bg-ink-900/40 px-4 py-8 backdrop-blur-sm">
-      <div className="flex max-h-[86vh] w-full max-w-4xl flex-col overflow-hidden rounded-2xl border border-sand-200 bg-white shadow-2xl">
+    <div className="fixed inset-0 z-50 flex min-w-0 items-center justify-center overflow-hidden bg-ink-900/40 px-4 py-8 backdrop-blur-sm">
+      <div className="flex min-w-0 max-h-[86vh] w-full max-w-4xl flex-col overflow-hidden rounded-2xl border border-sand-200 bg-white shadow-2xl">
        <ManualScrapeDialogHeader title={scopeLabel || media.title} targetCount={dialog.targetIds.length} onClose={onClose} />

        <ManualScrapeSearchControls
@@ -60,7 +60,7 @@ export function ManualScrapeDialog({
          onEpisodeArtworkChange={dialog.setIncludeEpisodeArtwork}
        />

-        <div className="flex-1 overflow-y-auto p-5">
+        <div className="min-w-0 flex-1 overflow-x-hidden overflow-y-auto p-5">
          <ManualScrapeCandidateList items={dialog.items} applyingKey={dialog.applyingKey} onApply={dialog.apply} />
        </div>
      </div>
@@ -20,14 +20,14 @@ export function ManualScrapeDialogHeader({
  onClose: () => void
 }) {
  return (
-    <div className="flex items-start justify-between gap-4 border-b border-sand-200 px-5 py-4">
-      <div>
+    <div className="flex min-w-0 items-start justify-between gap-4 border-b border-sand-200 px-5 py-4">
+      <div className="min-w-0">
        <h2 className="font-display text-xl font-bold text-ink-600">手动搜索刮削</h2>
-        <p className="mt-1 text-xs text-sand-500">
+        <p className="mt-1 truncate text-xs text-sand-500">
          {title} · {targetCount > 1 ? `将应用到 ${targetCount} 个媒体` : '单个媒体'}
        </p>
      </div>
-      <button onClick={onClose} className="btn-ghost h-9 w-9 p-0" aria-label="关闭">
+      <button onClick={onClose} className="btn-ghost h-9 w-9 shrink-0 p-0" aria-label="关闭">
        <X size={16} />
      </button>
    </div>
@@ -58,7 +58,7 @@ export function ManualScrapeSearchControls({
  onEpisodeArtworkChange,
 }: ManualScrapeSearchControlsProps) {
  return (
-    <div className="grid gap-4 border-b border-sand-200 bg-sand-50/40 p-5">
+    <div className="grid min-w-0 gap-4 border-b border-sand-200 bg-sand-50/40 p-5">
      <ManualScrapeQueryBar
        query={query}
        searching={searching}
@@ -170,7 +170,7 @@ export function ManualScrapeCandidateList({
  }

  return (
-    <div className="grid gap-3">
+    <div className="grid min-w-0 gap-3">
      {items.map((item) => {
        const key = candidateKey(item)
        return (
@@ -199,7 +199,7 @@ function ManualScrapeCandidateRow({
  onApply: (item: ManualScrapeCandidate) => void
 }) {
  return (
-    <div className="flex flex-col gap-4 rounded-xl border border-sand-200 bg-white p-3 shadow-sm sm:flex-row">
+    <div className="flex min-w-0 max-w-full flex-col gap-4 overflow-hidden rounded-xl border border-sand-200 bg-white p-3 shadow-sm sm:flex-row">
      <div className="h-28 w-20 shrink-0 overflow-hidden rounded-lg bg-sand-100">
        {item.poster_url ? (
          <img src={imageURL(item.poster_url)} alt={item.title} loading="lazy" decoding="async" className="h-full w-full object-cover" referrerPolicy="no-referrer" />
@@ -208,14 +208,14 @@ function ManualScrapeCandidateRow({
        )}
      </div>
      <div className="min-w-0 flex-1">
-        <div className="flex flex-wrap items-center gap-2">
-          <h3 className="truncate font-semibold text-ink-600">{item.title}</h3>
-          <span className="rounded-full bg-brand-50 px-2 py-0.5 text-[11px] font-bold uppercase text-brand-700">{item.source}</span>
-          {item.nsfw ? <span className="rounded-full bg-rose-50 px-2 py-0.5 text-[11px] font-bold text-rose-600">成人</span> : null}
-          {item.year ? <span className="text-xs text-sand-500">{item.year}</span> : null}
+        <div className="flex min-w-0 flex-wrap items-center gap-2">
+          <h3 className="min-w-0 max-w-full flex-1 truncate font-semibold text-ink-600">{item.title}</h3>
+          <span className="shrink-0 rounded-full bg-brand-50 px-2 py-0.5 text-[11px] font-bold uppercase text-brand-700">{item.source}</span>
+          {item.nsfw ? <span className="shrink-0 rounded-full bg-rose-50 px-2 py-0.5 text-[11px] font-bold text-rose-600">成人</span> : null}
+          {item.year ? <span className="shrink-0 text-xs text-sand-500">{item.year}</span> : null}
        </div>
        <p className="mt-1 line-clamp-2 text-xs leading-relaxed text-ink-50">{item.overview || '暂无简介'}</p>
-        <p className="mt-2 text-[11px] font-semibold text-sand-500">{candidateIDText(item)}</p>
+        <p className="mt-2 break-words text-[11px] font-semibold text-sand-500">{candidateIDText(item)}</p>
      </div>
      <button onClick={() => onApply(item)} disabled={disabled} className="btn-outline h-10 w-full shrink-0 justify-center px-3 text-xs sm:w-auto sm:self-center">
        {applying ? <LoaderCircle size={14} className="animate-spin" /> : <Check size={14} />}
@@ -3,7 +3,7 @@ import { Check, Film, ListVideo, Play, Search, X } from 'lucide-react'

 import { imageURL } from '../api/client'
 import type { Media } from '../types'
-import { seriesTitleFromPath } from '../utils/groupSeries'
+import { seasonLabel, seasonSortOrder, seriesTitleFromPath } from '../utils/groupSeries'

 export type SeasonGroup = {
  season: number
@@ -42,7 +42,7 @@ export function PlayerPlaylistPanel({
      list.sort((a, b) => (a.episode_num || 0) - (b.episode_num || 0))
    }
    return Array.from(seasonsMap.entries())
-      .sort(([a], [b]) => a - b)
+      .sort(([a], [b]) => seasonSortOrder(a) - seasonSortOrder(b))
      .map(([season, list]) => ({ season, episodes: list }))
  }, [episodes])

@@ -128,7 +128,7 @@ export function PlayerPlaylistPanel({
                    : 'bg-white/5 text-white/70 hover:bg-white/10 hover:text-white'
                }`}
              >
-                <span>{season === 0 ? '特别篇' : `第 ${season} 季`}</span>
+                <span>{seasonLabel(season)}</span>
                <span className="text-[10px] opacity-75">({sesEps.length})</span>
                {isPlayingThisSeason && !isSelected && (
                  <span className="h-1.5 w-1.5 rounded-full bg-rose-400" />
@@ -5,7 +5,7 @@ import { motion } from 'framer-motion'
 import { historyAPI } from '../api/history'
 import type { Media } from '../types'
 import { useAuthStore } from '../stores/auth'
-import type { SeriesCard } from '../utils/groupSeries'
+import { isTheatricalFeature, type SeriesCard } from '../utils/groupSeries'
 import {
  sortMediaList,
  sortSeriesList,
@@ -150,6 +150,9 @@ export function LibraryPage() {
    setSelectedSeason,
    onClearSeriesState: () => setSeriesMetadataEditOpen(false),
  })
+  const selectedSeriesScrapeMedia = selectedSeriesEpisodes.find((media) => !isTheatricalFeature(media))
+    ?? selectedSeries?.rep
+    ?? null

  const {
    scraping,
@@ -287,6 +290,7 @@ export function LibraryPage() {
        onOrganize={handleSeriesOrganize}
        onDelete={handleSeriesDelete}
        onSeasonChange={setSelectedSeason}
+        onManualScrapeMedia={setManualMovie}
      />

      <LibraryPageDialogs
@@ -296,6 +300,7 @@ export function LibraryPage() {
        seriesMetadataEditOpen={seriesMetadataEditOpen}
        manualMovie={manualMovie}
        selectedSeries={selectedSeries}
+        selectedSeriesScrapeMedia={selectedSeriesScrapeMedia}
        selectedSeriesMediaIDs={selectedSeriesMediaIDs}
        libraryType={library?.type}
        scrapeEpisodeArtwork={scrapeEpisodeArtwork}
@@ -2,7 +2,7 @@ import { ManualScrapeDialog } from '../components/ManualScrapeDialog'
 import { MetadataEditDialog } from '../components/MetadataEditDialog'
 import { ScrapeMetadataDialog } from '../components/ScrapeMetadataDialog'
 import type { Library, Media } from '../types'
-import { seriesTitle, type SeriesCard } from '../utils/groupSeries'
+import { isTheatricalFeature, seriesTitle, type SeriesCard } from '../utils/groupSeries'

 type LibraryPageDialogsProps = {
  scrapeDialogOpen: boolean
@@ -11,6 +11,7 @@ type LibraryPageDialogsProps = {
  seriesMetadataEditOpen: boolean
  manualMovie: Media | null
  selectedSeries: SeriesCard | null
+  selectedSeriesScrapeMedia: Media | null
  selectedSeriesMediaIDs: string[]
  libraryType?: string
  scrapeEpisodeArtwork: boolean
@@ -29,6 +30,7 @@ export function LibraryPageDialogs({
  seriesMetadataEditOpen,
  manualMovie,
  selectedSeries,
+  selectedSeriesScrapeMedia,
  selectedSeriesMediaIDs,
  libraryType,
  scrapeEpisodeArtwork,
@@ -53,10 +55,10 @@ export function LibraryPageDialogs({
      />
      <ManualScrapeDialog
        open={manualSeriesScrapeOpen}
-        media={selectedSeries?.rep ?? null}
+        media={selectedSeriesScrapeMedia}
        mediaIds={selectedSeriesMediaIDs}
        defaultQuery={selectedSeriesTitle}
-        mediaType={selectedSeries ? scrapeMediaType(libraryType, selectedSeries.rep) : 'tv'}
+        mediaType="tv"
        scopeLabel={selectedSeriesTitle || '当前剧集'}
        episodeArtwork={scrapeEpisodeArtwork}
        onClose={onCloseManualSeriesScrape}
@@ -86,6 +88,9 @@ export function LibraryPageDialogs({
 }

 function scrapeMediaType(libraryType: string | undefined, media: Media): string {
+  if (isTheatricalFeature(media)) {
+    return 'movie'
+  }
  if ((media.season_num ?? 0) > 0 || (media.episode_num ?? 0) > 0) {
    return 'tv'
  }
@@ -6,11 +6,10 @@ import { imageURL } from '../api/client'
 import { ExternalPlayerButton } from '../components/ExternalPlayerButton'
 import { MediaFavouriteButton } from '../components/MediaFavouriteButton'
 import type { Media } from '../types'
-import { seriesTitle, type SeriesCard } from '../utils/groupSeries'
+import { isTheatricalFeature, seriesTitle, type SeriesCard } from '../utils/groupSeries'

 type LibrarySeriesDetailHeaderProps = {
  series: SeriesCard
-  visibleEpisodes: Media[]
  allEpisodes: Media[]
  playbackFrom: string
  isAdmin: boolean
@@ -31,7 +30,6 @@ type LibrarySeriesDetailHeaderProps = {

 export function LibrarySeriesDetailHeader({
  series,
-  visibleEpisodes,
  allEpisodes,
  playbackFrom,
  isAdmin,
@@ -49,7 +47,9 @@ export function LibrarySeriesDetailHeader({
  onOrganize,
  onDelete,
 }: LibrarySeriesDetailHeaderProps) {
-  const firstEpisode = firstPlayableEpisode(visibleEpisodes.length > 0 ? visibleEpisodes : allEpisodes)
+  const tvEpisodes = allEpisodes.filter((media) => !isTheatricalFeature(media))
+  const theatricalCount = allEpisodes.length - tvEpisodes.length
+  const firstEpisode = firstPlayableEpisode(tvEpisodes)

  return (
    <>
@@ -61,7 +61,9 @@ export function LibrarySeriesDetailHeader({
        <h2 className="truncate font-display text-2xl font-bold text-ink-600">
          {seriesTitle(series.rep)}
        </h2>
-        <span className="text-sm text-sand-500">共 {series.count} 集</span>
+        <span className="text-sm text-sand-500">
+          共 {tvEpisodes.length} 集{theatricalCount > 0 ? ` · ${theatricalCount} 部剧场版` : ''}
+        </span>
      </div>

      <div className="flex flex-col gap-6 sm:flex-row">
@@ -115,7 +117,7 @@ export function LibrarySeriesDetailHeader({
                </button>
                <button onClick={onManualScrape} disabled={!!seriesToolBusy} className="btn-outline px-3.5 py-2 text-xs gap-1.5">
                  <Search size={13} className="text-[#c9954a]" />
-                  <span>手动匹配整剧</span>
+                  <span>{theatricalCount > 0 ? '手动匹配 TV 版' : '手动匹配整剧'}</span>
                </button>
                <button onClick={onMetadataEdit} disabled={!!seriesToolBusy} className="btn-outline px-3.5 py-2 text-xs gap-1.5">
                  <Pencil size={13} />
@@ -33,6 +33,7 @@ type LibrarySeriesDetailSectionProps = {
  onOrganize: () => void
  onDelete: () => void
  onSeasonChange: (season: number) => void
+  onManualScrapeMedia: (media: Media) => void
 }

 export function LibrarySeriesDetailSection({
@@ -58,6 +59,7 @@ export function LibrarySeriesDetailSection({
  onOrganize,
  onDelete,
  onSeasonChange,
+  onManualScrapeMedia,
 }: LibrarySeriesDetailSectionProps) {
  return (
    <AnimatePresence mode="wait">
@@ -70,7 +72,6 @@ export function LibrarySeriesDetailSection({
        >
          <LibrarySeriesDetailHeader
            series={selectedSeries}
-            visibleEpisodes={visibleEpisodes}
            allEpisodes={allEpisodes}
            playbackFrom={playbackFrom}
            isAdmin={isAdmin}
@@ -95,7 +96,9 @@ export function LibrarySeriesDetailSection({
            selectedSeason={selectedSeason}
            visibleEpisodes={visibleEpisodes}
            playbackFrom={playbackFrom}
+            isAdmin={isAdmin}
            onSeasonChange={onSeasonChange}
+            onManualScrape={onManualScrapeMedia}
          />
        </motion.div>
      )}
@@ -109,7 +112,9 @@ type LibrarySeriesEpisodesPanelProps = {
  selectedSeason: number | null
  visibleEpisodes: Media[]
  playbackFrom: string
+  isAdmin: boolean
  onSeasonChange: (season: number) => void
+  onManualScrape: (media: Media) => void
 }

 function LibrarySeriesEpisodesPanel({
@@ -118,7 +123,9 @@ function LibrarySeriesEpisodesPanel({
  selectedSeason,
  visibleEpisodes,
  playbackFrom,
+  isAdmin,
  onSeasonChange,
+  onManualScrape,
 }: LibrarySeriesEpisodesPanelProps) {
  return (
    <div className="space-y-6">
@@ -128,7 +135,9 @@ function LibrarySeriesEpisodesPanel({
        selectedSeason={selectedSeason}
        visibleEpisodes={visibleEpisodes}
        playbackFrom={playbackFrom}
+        isAdmin={isAdmin}
        onSeasonChange={onSeasonChange}
+        onManualScrape={onManualScrape}
      />
    </div>
  )
@@ -1,10 +1,15 @@
 import { Link } from 'react-router-dom'
-import { Play } from 'lucide-react'
+import { Play, Search } from 'lucide-react'

 import { imageURL } from '../api/client'
 import { ExternalPlayerButton } from '../components/ExternalPlayerButton'
 import type { Media } from '../types'
-import { seriesTitleFromPath } from '../utils/groupSeries'
+import {
+  isTheatricalFeature,
+  seasonLabel,
+  seriesTitleFromPath,
+  THEATRICAL_SEASON,
+} from '../utils/groupSeries'
 import { formatSize } from './libraryPageModel'

 type SeasonGroup = {
@@ -18,7 +23,9 @@ type LibrarySeriesEpisodesProps = {
  selectedSeason: number | null
  visibleEpisodes: Media[]
  playbackFrom: string
+  isAdmin?: boolean
  onSeasonChange: (season: number) => void
+  onManualScrape?: (media: Media) => void
 }

 export function LibrarySeriesEpisodes({
@@ -27,7 +34,9 @@ export function LibrarySeriesEpisodes({
  selectedSeason,
  visibleEpisodes,
  playbackFrom,
+  isAdmin = false,
  onSeasonChange,
+  onManualScrape,
 }: LibrarySeriesEpisodesProps) {
  if (loading) {
    return (
@@ -53,14 +62,14 @@ export function LibrarySeriesEpisodes({
                : 'border-sand-200 bg-white text-ink-100 hover:border-brand-200 hover:text-brand-600')
            }
          >
-            {season === 0 ? '特别篇' : `第 ${season} 季`} · {episodes.length} 集
+            {seasonLabel(season)} · {episodes.length} {season === THEATRICAL_SEASON ? '部' : '集'}
          </button>
        ))}
      </div>

      <div>
        <h3 className="mb-3 font-display text-lg font-semibold text-ink-600">
-          {displaySeason === 0 ? '特别篇' : `第 ${displaySeason} 季`}
+          {seasonLabel(displaySeason)}
        </h3>
        <div className="grid grid-cols-1 gap-2.5 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-5">
          {visibleEpisodes.map((ep) => {
@@ -107,7 +116,20 @@ export function LibrarySeriesEpisodes({
                    </p>
                  </div>
                </Link>
-                <ExternalPlayerButton mediaId={ep.id} label="外部" compact />
+                <div className="flex shrink-0 items-center gap-1">
+                  {isAdmin && onManualScrape && isTheatricalFeature(ep) && (
+                    <button
+                      type="button"
+                      onClick={() => onManualScrape(ep)}
+                      className="btn-outline !px-2 !py-1.5 text-[11px]"
+                      title="手动匹配剧场版"
+                    >
+                      <Search size={12} />
+                      匹配
+                    </button>
+                  )}
+                  <ExternalPlayerButton mediaId={ep.id} label="外部" compact />
+                </div>
              </div>
            )
          })}
@@ -15,7 +15,7 @@ export function seriesSourceRoot(episodes: Media[]): string {
  if (!firstPath) return ''
  const dir = dirname(firstPath)
  const base = basename(dir)
-  if (/^(?:s\d{1,2}|season[\s._-]*\d{1,2}|第\s*\d{1,2}\s*季|specials?|sp|ova|oad|extra|extras|特别篇|特別篇|番外|特典)$/i.test(base)) {
+  if (/^(?:s\d{1,2}|season[\s._-]*\d{1,2}|第\s*\d{1,2}\s*季|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|特别篇|特別篇|番外|特典|画像特典)$/i.test(base)) {
    return dirname(dir)
  }
  return dir
@@ -1,7 +1,13 @@
 import { useEffect, useMemo } from 'react'

 import type { Media } from '../types'
-import { getSeriesKey, type SeriesCard } from '../utils/groupSeries'
+import {
+  getSeriesKey,
+  isTheatricalFeature,
+  seasonSortOrder,
+  specialSectionForMedia,
+  type SeriesCard,
+} from '../utils/groupSeries'

 type SeasonEpisodes = {
  season: number
@@ -47,7 +53,9 @@ export function useLibrarySeriesSelection({
      : sourceItems.filter((m) => getSeriesKey(m) === selectedSeries.key)
    const seasons = new Map<number, Media[]>()
    for (const ep of eps) {
-      const s = ep.episode_num > 0 ? (ep.season_num ?? 0) : (ep.season_num || 1)
+      const specialSection = specialSectionForMedia(ep)
+      const s = specialSection ??
+        (ep.episode_num > 0 ? (ep.season_num ?? 0) : (ep.season_num || 1))
      if (!seasons.has(s)) seasons.set(s, [])
      seasons.get(s)!.push(ep)
    }
@@ -55,7 +63,7 @@ export function useLibrarySeriesSelection({
      list.sort((a, b) => (a.episode_num || 0) - (b.episode_num || 0))
    }
    return Array.from(seasons.entries())
-      .sort(([a], [b]) => a - b)
+      .sort(([a], [b]) => seasonSortOrder(a) - seasonSortOrder(b))
      .map(([season, episodes]) => ({ season, episodes }))
  }, [isSeriesLibrary, selectedSeries, items, seriesEpisodeItems])

@@ -70,7 +78,7 @@ export function useLibrarySeriesSelection({
  )

  const selectedSeriesMediaIDs = useMemo(
-    () => selectedSeriesEpisodes.map((ep) => ep.id),
+    () => selectedSeriesEpisodes.filter((ep) => !isTheatricalFeature(ep)).map((ep) => ep.id),
    [selectedSeriesEpisodes],
  )

@@ -8,6 +8,7 @@ import { playbackAPI } from '../api/playback'
 import { confirmActionResult } from '../components/confirmAction'
 import { useEpisodeArtworkPreference } from '../hooks/useEpisodeArtworkPreference'
 import type { Media } from '../types'
+import { seasonSortOrder } from '../utils/groupSeries'
 import { mediaLibraryBackTarget } from './MediaDetailPageModel'

 interface MediaDetailPageStateParams {
@@ -77,7 +78,7 @@ export function useMediaDetailPageState({ id, navigate }: MediaDetailPageStatePa
      list.sort((a, b) => (a.episode_num || 0) - (b.episode_num || 0))
    }
    return Array.from(seasons.entries())
-      .sort(([a], [b]) => a - b)
+      .sort(([a], [b]) => seasonSortOrder(a) - seasonSortOrder(b))
      .map(([season, list]) => ({ season, episodes: list }))
  }, [episodes])

@@ -38,6 +38,18 @@ export type SeriesCard = {
  last_added_at?: string
 }

+export const THEATRICAL_SEASON = -1
+export const OVA_SEASON = -2
+export const OAD_SEASON = -3
+export const OVD_SEASON = -4
+export const ONA_SEASON = -5
+export const EXTRA_SEASON = -6
+export const BONUS_SEASON = -7
+export const OMAKE_SEASON = -8
+export const PICTURE_DRAMA_SEASON = -9
+export const NCOP_SEASON = -10
+export const NCED_SEASON = -11
+
 export function getSeriesKey(media: Media): string {
  return compactSeriesKey(getSeriesRawKey(media))
 }
@@ -90,16 +102,98 @@ export function isEpisodeLike(media: Media): boolean {
 // 剧集类目录名(电视剧/动漫及其二级分类)。媒体路径落在这些目录下时, 即便
 // 季集号未识别出来, 也应按剧集对待, 跳转到 /library 分类视图而非 /media 单页。
 const EPISODIC_PATH_RE =
-  /[\\/](?:电视剧|剧集|连续剧|短剧|国产剧|国剧|大陆剧|华语剧|国产电视剧|大陆电视剧|华语电视剧|欧美剧|欧美电视剧|美剧|英剧|日韩剧|日韩电视剧|日剧|韩剧|港剧|台剧|港台剧|泰剧|综艺|纪录片|儿童|动漫|番剧|国漫|日番|韩漫|美漫|欧美动漫|欧美动画|其他动漫|anime|tv|series|shows?|season[\s._-]*\d|s\d{1,2}(?:[\s._-]|[\\/])|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|extras?|bonus(?:es)?|omake|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇)[\\/]/i
+  /[\\/](?:电视剧|剧集|连续剧|短剧|国产剧|国剧|大陆剧|华语剧|国产电视剧|大陆电视剧|华语电视剧|欧美剧|欧美电视剧|美剧|英剧|日韩剧|日韩电视剧|日剧|韩剧|港剧|台剧|港台剧|泰剧|综艺|纪录片|儿童|动漫|番剧|国漫|日番|韩漫|美漫|欧美动漫|欧美动画|其他动漫|anime|tv|series|shows?|season[\s._-]*\d|s\d{1,2}(?:[\s._-]|[\\/])|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇|画像特典)[\\/]/i
+
+const THEATRICAL_TITLE_RE =
+  /(?:剧场版|劇場版|动画电影|動畫電影|电影版|電影版|\bthe\s+movie\b|\bmovie\s*\d{1,2}\b)/i
+
+const THEATRICAL_FOLDER_NAME_RE =
+  /(?:剧场版|劇場版|动画电影|動畫電影|电影版|電影版)/i
+
+const THEATRICAL_FOLDER_RE =
+  /[\\/][^\\/]*(?:剧场版|劇場版|动画电影|動畫電影|电影版|電影版)[^\\/]*[\\/]/

 const SEASON_FOLDER_RE =
-  /^(?:s\d{1,2}|season[\s._-]*\d{1,2}|第\s*[0-9一二三四五六七八九十百零两]+\s*季|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|extras?|bonus(?:es)?|omake|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇)$/i
+  /^(?:s\d{1,2}|season[\s._-]*\d{1,2}|第\s*[0-9一二三四五六七八九十百零两]+\s*季|special[\s._-]*episodes?|specials?|sp|ovas?|oads?|ovds?|onas?|extras?|bonus(?:es)?|omake|picture[\s._-]*drama|ncop|nced|特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇|画像特典|剧场版|劇場版|动画电影|動畫電影)$/i

 export function pathLooksEpisodic(media: Media): boolean {
  const path = (media.path || media.display_library_path || media.library_path || '')
  return EPISODIC_PATH_RE.test(path)
 }

+export function isTheatricalFeature(media: Media): boolean {
+  const path = media.path || ''
+  if (SERIES_FILE_EPISODE_RE.test(path)) return false
+  return THEATRICAL_TITLE_RE.test(`${media.title || ''} ${path}`) || THEATRICAL_FOLDER_RE.test(path)
+}
+
+const SPECIAL_SECTION_PATTERNS: Array<[number, RegExp]> = [
+  [OVA_SEASON, /(?:^|[^a-z0-9])ovas?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)/i],
+  [OAD_SEASON, /(?:^|[^a-z0-9])oads?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)/i],
+  [OVD_SEASON, /(?:^|[^a-z0-9])ovds?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)/i],
+  [ONA_SEASON, /(?:^|[^a-z0-9])onas?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)/i],
+  [PICTURE_DRAMA_SEASON, /(?:^|[^a-z0-9])(?:picture[\s._-]*drama|画像特典)(?:[^a-z0-9]|$)/i],
+  [NCOP_SEASON, /(?:^|[^a-z0-9])ncop(?:\d+)?(?:[^a-z0-9]|$)/i],
+  [NCED_SEASON, /(?:^|[^a-z0-9])nced(?:\d+)?(?:[^a-z0-9]|$)/i],
+  [EXTRA_SEASON, /(?:^|[^a-z0-9])extras?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)/i],
+  [BONUS_SEASON, /(?:^|[^a-z0-9])bonus(?:es)?(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)/i],
+  [OMAKE_SEASON, /(?:^|[^a-z0-9])omake(?:[\s._-]*\d+)?(?:[^a-z0-9]|$)/i],
+]
+
+export function specialSectionForMedia(media: Media): number | null {
+  if (isTheatricalFeature(media)) return THEATRICAL_SEASON
+  const parts = (media.path || '').split(/[\\/]+/).filter(Boolean)
+  for (const part of parts) {
+    for (const [section, pattern] of SPECIAL_SECTION_PATTERNS) {
+      if (pattern.test(part)) return section
+    }
+  }
+  return null
+}
+
+/**
+ * 季按钮显示顺序:第一季、第二季 … 第 XX 季 → 特别篇 → 剧场版 → OVA → OAD → 其余特典。
+ *
+ * 正片季(季号 > 0)按季号升序排最前;特殊分区(0 / 负数季)按固定优先级排在后面。
+ * 各季分组页(剧集库 / 详情页 / 播放器选集)共用这一顺序,避免三处各排各的。
+ */
+export function seasonSortOrder(season: number): number {
+  if (season > 0) return season
+  switch (season) {
+    case 0: return 1000 // 特别篇紧随正片
+    case THEATRICAL_SEASON: return 1001 // 剧场版
+    case OVA_SEASON: return 1002
+    case OAD_SEASON: return 1003
+    case OVD_SEASON: return 1004
+    case ONA_SEASON: return 1005
+    case EXTRA_SEASON: return 1006
+    case BONUS_SEASON: return 1007
+    case OMAKE_SEASON: return 1008
+    case PICTURE_DRAMA_SEASON: return 1009
+    case NCOP_SEASON: return 1010
+    case NCED_SEASON: return 1011
+    default: return 2000 // 未知季兜底,排最后
+  }
+}
+
+export function seasonLabel(season: number): string {
+  switch (season) {
+    case 0: return '特别篇'
+    case THEATRICAL_SEASON: return '剧场版'
+    case OVA_SEASON: return 'OVA'
+    case OAD_SEASON: return 'OAD'
+    case OVD_SEASON: return 'OVD'
+    case ONA_SEASON: return 'ONA'
+    case EXTRA_SEASON: return 'Extra'
+    case BONUS_SEASON: return 'Bonus'
+    case OMAKE_SEASON: return 'Omake'
+    case PICTURE_DRAMA_SEASON: return 'Picture Drama'
+    case NCOP_SEASON: return 'NCOP'
+    case NCED_SEASON: return 'NCED'
+    default: return `第 ${season} 季`
+  }
+}
+
 export function isSeriesCard(card: SeriesCard): boolean {
  return (
    card.count > 1 ||
@@ -156,10 +250,10 @@ function normalizeTitle(value?: string): string {
 }

 const SERIES_SPECIAL_CODE_RE =
-  /\s*[[(（【]?\s*(?:s0+\s*e?\s*\d+|season\s*0+(?:\s*episode)?\s*\d*|special(?:\s*episode)?s?\s*\d*|sp\s*\d*|ovas?\s*\d*|oads?\s*\d*|extras?\s*\d*|bonus(?:es)?\s*\d*|omake\s*\d*)\s*[\])）】]?$/i
+  /\s*[[(（【]?\s*(?:s0+\s*e?\s*\d+|season\s*0+(?:\s*episode)?\s*\d*|special(?:\s*episode)?s?\s*\d*|sp\s*\d*|ovas?\s*\d*|oads?\s*\d*|ovds?\s*\d*|onas?\s*\d*|extras?\s*\d*|bonus(?:es)?\s*\d*|omake\s*\d*|picture[\s._-]*drama\s*\d*|ncop\s*\d*|nced\s*\d*)\s*[\])）】]?$/i

 const SERIES_SPECIAL_CJK_RE =
-  /\s*[[(（【]?\s*(?:特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇)(?:\s*第?\s*[0-9一二三四五六七八九十百零两]+(?:[集话話期])?)?\s*[\])）】]?$/i
+  /\s*[[(（【]?\s*(?:特别篇|特別篇|番外篇?|特典|外传|外傳|总集篇|總集篇|画像特典)(?:\s*第?\s*[0-9一二三四五六七八九十百零两]+(?:[集话話期])?)?\s*[\])）】]?$/i

 function normalizePathSeriesTitle(value?: string): string {
  const title = normalizeTitle(value)
@@ -257,16 +351,20 @@ function seriesDirectoryNameFromPath(path?: string): string {
  if (parts.length < 2) return ''
  let dirIndex = parts.length - 2
  const lastPart = parts[parts.length - 1]
-  if (!seriesPathPartLooksLikeFile(lastPart) && !SEASON_FOLDER_RE.test(lastPart)) {
+  if (!seriesPathPartLooksLikeFile(lastPart) && !isSeriesContainerFolder(lastPart)) {
    dirIndex = parts.length - 1
  }
-  while (dirIndex >= 0 && SEASON_FOLDER_RE.test(parts[dirIndex])) {
+  while (dirIndex >= 0 && isSeriesContainerFolder(parts[dirIndex])) {
    dirIndex -= 1
  }
  if (dirIndex < 0) return ''
  return parts[dirIndex]
 }

+function isSeriesContainerFolder(name: string): boolean {
+  return SEASON_FOLDER_RE.test(name) || THEATRICAL_FOLDER_NAME_RE.test(name)
+}
+
 function seriesExternalIDFromPath(path?: string): string {
  const part = seriesDirectoryNameFromPath(path)
  if (!part) return ''
Author	SHA1	Message	Date
truewhile	8f2551a1b6	优化排序	2026-09-09 22:24:45 +08:00
truewhile	18e6cb40fd	完善动漫特别内容分类与版本判定 Co-authored-by: Cursor <cursoragent@cursor.com>	2026-09-09 22:03:52 +08:00
truewhile	92e693ccac	优化	2026-09-09 20:32:03 +08:00
truewhile	62206aa05a	优化	2026-09-09 19:26:22 +08:00