docs: add FindByPaths comment

Signed-off-by: Deluan <deluan@navidrome.org>

cmd/scan.go

@@ -4,10 +4,12 @@ import (
 	"context"
 	"encoding/gob"
 	"os"
+	"strings"
 
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
 	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/utils/pl"
@@ -17,11 +19,13 @@ import (
 var (
 	fullScan   bool
 	subprocess bool
+	targets    string
 )
 
 func init() {
 	scanCmd.Flags().BoolVarP(&fullScan, "full", "f", false, "check all subfolders, ignoring timestamps")
 	scanCmd.Flags().BoolVarP(&subprocess, "subprocess", "", false, "run as subprocess (internal use)")
+	scanCmd.Flags().StringVarP(&targets, "targets", "t", "", "comma-separated list of libraryID:folderPath pairs (e.g., \"1:Music/Rock,1:Music/Jazz,2:Classical\")")
 	rootCmd.AddCommand(scanCmd)
 }
 
@@ -68,7 +72,18 @@ func runScanner(ctx context.Context) {
 	ds := persistence.New(sqlDB)
 	pls := core.NewPlaylists(ds)
 
-	progress, err := scanner.CallScan(ctx, ds, pls, fullScan)
+	// Parse targets if provided
+	var scanTargets []model.ScanTarget
+	if targets != "" {
+		var err error
+		scanTargets, err = model.ParseTargets(strings.Split(targets, ","))
+		if err != nil {
+			log.Fatal(ctx, "Failed to parse targets", err)
+		}
+		log.Info(ctx, "Scanning specific folders", "numTargets", len(scanTargets))
+	}
+
+	progress, err := scanner.CallScan(ctx, ds, pls, fullScan, scanTargets)
 	if err != nil {
 		log.Fatal(ctx, "Failed to scan", err)
 	}

cmd/wire_gen.go

@@ -69,10 +69,11 @@ func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	broker := events.GetBroker()
-	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	watcher := scanner.GetWatcher(dataStore, scannerScanner)
-	library := core.NewLibrary(dataStore, scannerScanner, watcher, broker)
-	router := nativeapi.New(dataStore, share, playlists, insights, library)
+	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	watcher := scanner.GetWatcher(dataStore, modelScanner)
+	library := core.NewLibrary(dataStore, modelScanner, watcher, broker)
+	maintenance := core.NewMaintenance(dataStore)
+	router := nativeapi.New(dataStore, share, playlists, insights, library, maintenance)
 	return router
 }
 
@@ -94,10 +95,10 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
 	playbackServer := playback.GetInstance(dataStore)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, scannerScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
 	return router
 }
 
@@ -149,7 +150,7 @@ func CreatePrometheus() metrics.Metrics {
 	return metricsMetrics
 }
 
-func CreateScanner(ctx context.Context) scanner.Scanner {
+func CreateScanner(ctx context.Context) model.Scanner {
 	sqlDB := db.Db()
 	dataStore := persistence.New(sqlDB)
 	fileCache := artwork.GetImageCache()
@@ -162,8 +163,8 @@ func CreateScanner(ctx context.Context) scanner.Scanner {
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	return scannerScanner
+	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	return modelScanner
 }
 
 func CreateScanWatcher(ctx context.Context) scanner.Watcher {
@@ -179,8 +180,8 @@ func CreateScanWatcher(ctx context.Context) scanner.Watcher {
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	broker := events.GetBroker()
 	playlists := core.NewPlaylists(dataStore)
-	scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
-	watcher := scanner.GetWatcher(dataStore, scannerScanner)
+	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+	watcher := scanner.GetWatcher(dataStore, modelScanner)
 	return watcher
 }
 
@@ -201,7 +202,7 @@ func getPluginManager() plugins.Manager {
 
 // wire_injectors.go:
 
-var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, plugins.GetManager, metrics.GetPrometheusInstance, db.Db, wire.Bind(new(agents.PluginLoader), new(plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)), wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)), wire.Bind(new(core.Scanner), new(scanner.Scanner)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
+var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, plugins.GetManager, metrics.GetPrometheusInstance, db.Db, wire.Bind(new(agents.PluginLoader), new(plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)), wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
 
 func GetPluginManager(ctx context.Context) plugins.Manager {
 	manager := getPluginManager()

cmd/wire_injectors.go

@@ -45,7 +45,6 @@ var allProviders = wire.NewSet(
 	wire.Bind(new(agents.PluginLoader), new(plugins.Manager)),
 	wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)),
 	wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)),
-	wire.Bind(new(core.Scanner), new(scanner.Scanner)),
 	wire.Bind(new(core.Watcher), new(scanner.Watcher)),
 )
 
@@ -103,7 +102,7 @@ func CreatePrometheus() metrics.Metrics {
 	))
 }
 
-func CreateScanner(ctx context.Context) scanner.Scanner {
+func CreateScanner(ctx context.Context) model.Scanner {
 	panic(wire.Build(
 		allProviders,
 	))

conf/configuration.go

@@ -125,6 +125,7 @@ type configOptions struct {
 	DevAlbumInfoTimeToLive           time.Duration
 	DevExternalScanner               bool
 	DevScannerThreads                uint
+	DevSelectiveWatcher              bool
 	DevInsightsInitialDelay          time.Duration
 	DevEnablePlayerInsights          bool
 	DevEnablePluginsInsights         bool
@@ -600,6 +601,7 @@ func setViperDefaults() {
 	viper.SetDefault("devalbuminfotimetolive", consts.AlbumInfoTimeToLive)
 	viper.SetDefault("devexternalscanner", true)
 	viper.SetDefault("devscannerthreads", 5)
+	viper.SetDefault("devselectivewatcher", true)
 	viper.SetDefault("devinsightsinitialdelay", consts.InsightsInitialDelay)
 	viper.SetDefault("devenableplayerinsights", true)
 	viper.SetDefault("devenablepluginsinsights", true)

core/artwork/cache_warmer_test.go

@@ -90,6 +90,7 @@ var _ = Describe("CacheWarmer", func() {
 		})
 
 		It("deduplicates items in buffer", func() {
+			fc.SetReady(false) // Make cache unavailable so items stay in buffer
 			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
 			cw.PreCache(model.MustParseArtworkID("al-1"))
 			cw.PreCache(model.MustParseArtworkID("al-1"))

core/artwork/reader_album.go

@@ -1,6 +1,7 @@
 package artwork
 
 import (
+	"cmp"
 	"context"
 	"crypto/md5"
 	"fmt"
@@ -11,6 +12,7 @@ import (
 	"time"
 
 	"github.com/Masterminds/squirrel"
+	"github.com/maruel/natural"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/core/external"
@@ -116,8 +118,30 @@ func loadAlbumFoldersPaths(ctx context.Context, ds model.DataStore, albums ...mo
 	}
 
 	// Sort image files to ensure consistent selection of cover art
-	// This prioritizes files from lower-numbered disc folders by sorting the paths
-	slices.Sort(imgFiles)
+	// This prioritizes files without numeric suffixes (e.g., cover.jpg over cover.1.jpg)
+	// by comparing base filenames without extensions
+	slices.SortFunc(imgFiles, compareImageFiles)
 
 	return paths, imgFiles, &updatedAt, nil
 }
+
+// compareImageFiles compares two image file paths for sorting.
+// It extracts the base filename (without extension) and compares case-insensitively.
+// This ensures that "cover.jpg" sorts before "cover.1.jpg" since "cover" < "cover.1".
+// Note: This function is called O(n log n) times during sorting, but in practice albums
+// typically have only 1-20 image files, making the repeated string operations negligible.
+func compareImageFiles(a, b string) int {
+	// Case-insensitive comparison
+	a = strings.ToLower(a)
+	b = strings.ToLower(b)
+
+	// Extract base filenames without extensions
+	baseA := strings.TrimSuffix(filepath.Base(a), filepath.Ext(a))
+	baseB := strings.TrimSuffix(filepath.Base(b), filepath.Ext(b))
+
+	// Compare base names first, then full paths if equal
+	return cmp.Or(
+		natural.Compare(baseA, baseB),
+		natural.Compare(a, b),
+	)
+}

core/artwork/reader_album_test.go

@@ -27,26 +27,7 @@ var _ = Describe("Album Artwork Reader", func() {
 			expectedAt = now.Add(5 * time.Minute)
 
 			// Set up the test folders with image files
-			repo = &fakeFolderRepo{
-				result: []model.Folder{
-					{
-						Path:            "Artist/Album/Disc1",
-						ImagesUpdatedAt: expectedAt,
-						ImageFiles:      []string{"cover.jpg", "back.jpg"},
-					},
-					{
-						Path:            "Artist/Album/Disc2",
-						ImagesUpdatedAt: now,
-						ImageFiles:      []string{"cover.jpg"},
-					},
-					{
-						Path:            "Artist/Album/Disc10",
-						ImagesUpdatedAt: now,
-						ImageFiles:      []string{"cover.jpg"},
-					},
-				},
-				err: nil,
-			}
+			repo = &fakeFolderRepo{}
 			ds = &fakeDataStore{
 				folderRepo: repo,
 			}
@@ -58,19 +39,82 @@ var _ = Describe("Album Artwork Reader", func() {
 		})
 
 		It("returns sorted image files", func() {
+			repo.result = []model.Folder{
+				{
+					Path:            "Artist/Album/Disc1",
+					ImagesUpdatedAt: expectedAt,
+					ImageFiles:      []string{"cover.jpg", "back.jpg", "cover.1.jpg"},
+				},
+				{
+					Path:            "Artist/Album/Disc2",
+					ImagesUpdatedAt: now,
+					ImageFiles:      []string{"cover.jpg"},
+				},
+				{
+					Path:            "Artist/Album/Disc10",
+					ImagesUpdatedAt: now,
+					ImageFiles:      []string{"cover.jpg"},
+				},
+			}
+
 			_, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)
 
 			Expect(err).ToNot(HaveOccurred())
 			Expect(*imagesUpdatedAt).To(Equal(expectedAt))
 
-			// Check that image files are sorted alphabetically
-			Expect(imgFiles).To(HaveLen(4))
+			// Check that image files are sorted by base name (without extension)
+			Expect(imgFiles).To(HaveLen(5))
 
-			// The files should be sorted by full path
+			// Files should be sorted by base filename without extension, then by full path
+			// "back" < "cover", so back.jpg comes first
+			// Then all cover.jpg files, sorted by path
 			Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/back.jpg")))
 			Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/cover.jpg")))
-			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/cover.jpg")))
-			Expect(imgFiles[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc2/cover.jpg")))
+			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Disc2/cover.jpg")))
+			Expect(imgFiles[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/cover.jpg")))
+			Expect(imgFiles[4]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/cover.1.jpg")))
+		})
+
+		It("prioritizes files without numeric suffixes", func() {
+			// Test case for issue #4683: cover.jpg should come before cover.1.jpg
+			repo.result = []model.Folder{
+				{
+					Path:            "Artist/Album",
+					ImagesUpdatedAt: now,
+					ImageFiles:      []string{"cover.1.jpg", "cover.jpg", "cover.2.jpg"},
+				},
+			}
+
+			_, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(imgFiles).To(HaveLen(3))
+
+			// cover.jpg should come first because "cover" < "cover.1" < "cover.2"
+			Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/cover.jpg")))
+			Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/cover.1.jpg")))
+			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/cover.2.jpg")))
+		})
+
+		It("handles case-insensitive sorting", func() {
+			// Test that Cover.jpg and cover.jpg are treated as equivalent
+			repo.result = []model.Folder{
+				{
+					Path:            "Artist/Album",
+					ImagesUpdatedAt: now,
+					ImageFiles:      []string{"Folder.jpg", "cover.jpg", "BACK.jpg"},
+				},
+			}
+
+			_, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(imgFiles).To(HaveLen(3))
+
+			// Files should be sorted case-insensitively: BACK, cover, Folder
+			Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/BACK.jpg")))
+			Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/cover.jpg")))
+			Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Folder.jpg")))
 		})
 	})
 })

core/artwork/reader_artist.go

@@ -8,6 +8,7 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"time"
 
@@ -139,11 +140,22 @@ func findImageInFolder(ctx context.Context, folder, pattern string) (io.ReadClos
 		return nil, "", err
 	}
 
+	// Filter to valid image files
+	var imagePaths []string
 	for _, m := range matches {
 		if !model.IsImageFile(m) {
 			continue
 		}
-		filePath := filepath.Join(folder, m)
+		imagePaths = append(imagePaths, m)
+	}
+
+	// Sort image files by prioritizing base filenames without numeric
+	// suffixes (e.g., artist.jpg before artist.1.jpg)
+	slices.SortFunc(imagePaths, compareImageFiles)
+
+	// Try to open files in sorted order
+	for _, p := range imagePaths {
+		filePath := filepath.Join(folder, p)
 		f, err := os.Open(filePath)
 		if err != nil {
 			log.Warn(ctx, "Could not open cover art file", "file", filePath, err)

core/artwork/reader_artist_test.go

@@ -240,24 +240,79 @@ var _ = Describe("artistArtworkReader", func() {
 				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
 
 				// Create multiple matching files
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("jpg image"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.abc"), []byte("text file"), 0600)).To(Succeed())
 				Expect(os.WriteFile(filepath.Join(artistDir, "artist.png"), []byte("png image"), 0600)).To(Succeed())
-				Expect(os.WriteFile(filepath.Join(artistDir, "artist.txt"), []byte("text file"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("jpg image"), 0600)).To(Succeed())
 
 				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
 			})
 
-			It("returns the first valid image file", func() {
+			It("returns the first valid image file in sorted order", func() {
 				reader, path, err := testFunc()
 				Expect(err).ToNot(HaveOccurred())
 				Expect(reader).ToNot(BeNil())
 
-				// Should return an image file, not the text file
-				Expect(path).To(SatisfyAny(
-					ContainSubstring("artist.jpg"),
-					ContainSubstring("artist.png"),
-				))
-				Expect(path).ToNot(ContainSubstring("artist.txt"))
+				// Should return an image file,
+				// Files are sorted: jpg comes before png alphabetically.
+				// .abc comes first, but it's not an image.
+				Expect(path).To(ContainSubstring("artist.jpg"))
+				reader.Close()
+			})
+		})
+
+		When("prioritizing files without numeric suffixes", func() {
+			BeforeEach(func() {
+				// Test case for issue #4683: artist.jpg should come before artist.1.jpg
+				artistDir := filepath.Join(tempDir, "artist")
+				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
+
+				// Create multiple matches with and without numeric suffixes
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.1.jpg"), []byte("artist 1"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist main"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.2.jpg"), []byte("artist 2"), 0600)).To(Succeed())
+
+				testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
+			})
+
+			It("returns artist.jpg before artist.1.jpg and artist.2.jpg", func() {
+				reader, path, err := testFunc()
+				Expect(err).ToNot(HaveOccurred())
+				Expect(reader).ToNot(BeNil())
+				Expect(path).To(ContainSubstring("artist.jpg"))
+
+				// Verify it's the main file, not a numbered variant
+				data, err := io.ReadAll(reader)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(string(data)).To(Equal("artist main"))
+				reader.Close()
+			})
+		})
+
+		When("handling case-insensitive sorting", func() {
+			BeforeEach(func() {
+				// Test case to ensure case-insensitive natural sorting
+				artistDir := filepath.Join(tempDir, "artist")
+				Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
+
+				// Create files with mixed case names
+				Expect(os.WriteFile(filepath.Join(artistDir, "Folder.jpg"), []byte("folder"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist"), 0600)).To(Succeed())
+				Expect(os.WriteFile(filepath.Join(artistDir, "BACK.jpg"), []byte("back"), 0600)).To(Succeed())
+
+				testFunc = fromArtistFolder(ctx, artistDir, "*.*")
+			})
+
+			It("sorts case-insensitively", func() {
+				reader, path, err := testFunc()
+				Expect(err).ToNot(HaveOccurred())
+				Expect(reader).ToNot(BeNil())
+
+				// Should return artist.jpg first (case-insensitive: "artist" < "back" < "folder")
+				Expect(path).To(ContainSubstring("artist.jpg"))
+
+				data, err := io.ReadAll(reader)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(string(data)).To(Equal("artist"))
 				reader.Close()
 			})
 		})

core/library.go

@@ -21,11 +21,6 @@ import (
 	"github.com/navidrome/navidrome/utils/slice"
 )
 
-// Scanner interface for triggering scans
-type Scanner interface {
-	ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
-}
-
 // Watcher interface for managing file system watchers
 type Watcher interface {
 	Watch(ctx context.Context, lib *model.Library) error
@@ -43,13 +38,13 @@ type Library interface {
 
 type libraryService struct {
 	ds      model.DataStore
-	scanner Scanner
+	scanner model.Scanner
 	watcher Watcher
 	broker  events.Broker
 }
 
 // NewLibrary creates a new Library service
-func NewLibrary(ds model.DataStore, scanner Scanner, watcher Watcher, broker events.Broker) Library {
+func NewLibrary(ds model.DataStore, scanner model.Scanner, watcher Watcher, broker events.Broker) Library {
 	return &libraryService{
 		ds:      ds,
 		scanner: scanner,
@@ -155,7 +150,7 @@ type libraryRepositoryWrapper struct {
 	model.LibraryRepository
 	ctx     context.Context
 	ds      model.DataStore
-	scanner Scanner
+	scanner model.Scanner
 	watcher Watcher
 	broker  events.Broker
 }
@@ -192,7 +187,7 @@ func (r *libraryRepositoryWrapper) Save(entity interface{}) (string, error) {
 	return strconv.Itoa(lib.ID), nil
 }
 
-func (r *libraryRepositoryWrapper) Update(id string, entity interface{}, cols ...string) error {
+func (r *libraryRepositoryWrapper) Update(id string, entity interface{}, _ ...string) error {
 	lib := entity.(*model.Library)
 	libID, err := strconv.Atoi(id)
 	if err != nil {

core/library_test.go

@@ -29,7 +29,7 @@ var _ = Describe("Library Service", func() {
 	var userRepo *tests.MockedUserRepo
 	var ctx context.Context
 	var tempDir string
-	var scanner *mockScanner
+	var scanner *tests.MockScanner
 	var watcherManager *mockWatcherManager
 	var broker *mockEventBroker
 
@@ -43,7 +43,7 @@ var _ = Describe("Library Service", func() {
 		ds.MockedUser = userRepo
 
 		// Create a mock scanner that tracks calls
-		scanner = &mockScanner{}
+		scanner = tests.NewMockScanner()
 		// Create a mock watcher manager
 		watcherManager = &mockWatcherManager{
 			libraryStates: make(map[int]model.Library),
@@ -616,11 +616,12 @@ var _ = Describe("Library Service", func() {
 
 			// Wait briefly for the goroutine to complete
 			Eventually(func() int {
-				return scanner.len()
+				return scanner.GetScanAllCallCount()
 			}, "1s", "10ms").Should(Equal(1))
 
 			// Verify scan was called with correct parameters
-			Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
+			calls := scanner.GetScanAllCalls()
+			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
 		})
 
 		It("triggers scan when updating library path", func() {
@@ -641,11 +642,12 @@ var _ = Describe("Library Service", func() {
 
 			// Wait briefly for the goroutine to complete
 			Eventually(func() int {
-				return scanner.len()
+				return scanner.GetScanAllCallCount()
 			}, "1s", "10ms").Should(Equal(1))
 
 			// Verify scan was called with correct parameters
-			Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
+			calls := scanner.GetScanAllCalls()
+			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
 		})
 
 		It("does not trigger scan when updating library without path change", func() {
@@ -661,7 +663,7 @@ var _ = Describe("Library Service", func() {
 
 			// Wait a bit to ensure no scan was triggered
 			Consistently(func() int {
-				return scanner.len()
+				return scanner.GetScanAllCallCount()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -674,7 +676,7 @@ var _ = Describe("Library Service", func() {
 
 			// Ensure no scan was triggered since creation failed
 			Consistently(func() int {
-				return scanner.len()
+				return scanner.GetScanAllCallCount()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -691,7 +693,7 @@ var _ = Describe("Library Service", func() {
 
 			// Ensure no scan was triggered since update failed
 			Consistently(func() int {
-				return scanner.len()
+				return scanner.GetScanAllCallCount()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -707,11 +709,12 @@ var _ = Describe("Library Service", func() {
 
 			// Wait briefly for the goroutine to complete
 			Eventually(func() int {
-				return scanner.len()
+				return scanner.GetScanAllCallCount()
 			}, "1s", "10ms").Should(Equal(1))
 
 			// Verify scan was called with correct parameters
-			Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
+			calls := scanner.GetScanAllCalls()
+			Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
 		})
 
 		It("does not trigger scan when library deletion fails", func() {
@@ -721,7 +724,7 @@ var _ = Describe("Library Service", func() {
 
 			// Ensure no scan was triggered since deletion failed
 			Consistently(func() int {
-				return scanner.len()
+				return scanner.GetScanAllCallCount()
 			}, "100ms", "10ms").Should(Equal(0))
 		})
 
@@ -868,31 +871,6 @@ var _ = Describe("Library Service", func() {
 	})
 })
 
-// mockScanner provides a simple mock implementation of core.Scanner for testing
-type mockScanner struct {
-	ScanCalls []ScanCall
-	mu        sync.RWMutex
-}
-
-type ScanCall struct {
-	FullScan bool
-}
-
-func (m *mockScanner) ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.ScanCalls = append(m.ScanCalls, ScanCall{
-		FullScan: fullScan,
-	})
-	return []string{}, nil
-}
-
-func (m *mockScanner) len() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.ScanCalls)
-}
-
 // mockWatcherManager provides a simple mock implementation of core.Watcher for testing
 type mockWatcherManager struct {
 	StartedWatchers   []model.Library

core/maintenance.go

@@ -0,0 +1,226 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"sync"
+	"time"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/utils/slice"
+)
+
+type Maintenance interface {
+	// DeleteMissingFiles deletes specific missing files by their IDs
+	DeleteMissingFiles(ctx context.Context, ids []string) error
+	// DeleteAllMissingFiles deletes all files marked as missing
+	DeleteAllMissingFiles(ctx context.Context) error
+}
+
+type maintenanceService struct {
+	ds model.DataStore
+	wg sync.WaitGroup
+}
+
+func NewMaintenance(ds model.DataStore) Maintenance {
+	return &maintenanceService{
+		ds: ds,
+	}
+}
+
+func (s *maintenanceService) DeleteMissingFiles(ctx context.Context, ids []string) error {
+	return s.deleteMissing(ctx, ids)
+}
+
+func (s *maintenanceService) DeleteAllMissingFiles(ctx context.Context) error {
+	return s.deleteMissing(ctx, nil)
+}
+
+// deleteMissing handles the deletion of missing files and triggers necessary cleanup operations
+func (s *maintenanceService) deleteMissing(ctx context.Context, ids []string) error {
+	// Track affected album IDs before deletion for refresh
+	affectedAlbumIDs, err := s.getAffectedAlbumIDs(ctx, ids)
+	if err != nil {
+		log.Warn(ctx, "Error tracking affected albums for refresh", err)
+		// Don't fail the operation, just log the warning
+	}
+
+	// Delete missing files within a transaction
+	err = s.ds.WithTx(func(tx model.DataStore) error {
+		if len(ids) == 0 {
+			_, err := tx.MediaFile(ctx).DeleteAllMissing()
+			return err
+		}
+		return tx.MediaFile(ctx).DeleteMissing(ids)
+	})
+	if err != nil {
+		log.Error(ctx, "Error deleting missing tracks from DB", "ids", ids, err)
+		return err
+	}
+
+	// Run garbage collection to clean up orphaned records
+	if err := s.ds.GC(ctx); err != nil {
+		log.Error(ctx, "Error running GC after deleting missing tracks", err)
+		return err
+	}
+
+	// Refresh statistics in background
+	s.refreshStatsAsync(ctx, affectedAlbumIDs)
+
+	return nil
+}
+
+// refreshAlbums recalculates album attributes (size, duration, song count, etc.) from media files.
+// It uses batch queries to minimize database round-trips for efficiency.
+func (s *maintenanceService) refreshAlbums(ctx context.Context, albumIDs []string) error {
+	if len(albumIDs) == 0 {
+		return nil
+	}
+
+	log.Debug(ctx, "Refreshing albums", "count", len(albumIDs))
+
+	// Process in chunks to avoid query size limits
+	const chunkSize = 100
+	for chunk := range slice.CollectChunks(slices.Values(albumIDs), chunkSize) {
+		if err := s.refreshAlbumChunk(ctx, chunk); err != nil {
+			return fmt.Errorf("refreshing album chunk: %w", err)
+		}
+	}
+
+	log.Debug(ctx, "Successfully refreshed albums", "count", len(albumIDs))
+	return nil
+}
+
+// refreshAlbumChunk processes a single chunk of album IDs
+func (s *maintenanceService) refreshAlbumChunk(ctx context.Context, albumIDs []string) error {
+	albumRepo := s.ds.Album(ctx)
+	mfRepo := s.ds.MediaFile(ctx)
+
+	// Batch load existing albums
+	albums, err := albumRepo.GetAll(model.QueryOptions{
+		Filters: squirrel.Eq{"album.id": albumIDs},
+	})
+	if err != nil {
+		return fmt.Errorf("loading albums: %w", err)
+	}
+
+	// Create a map for quick lookup
+	albumMap := make(map[string]*model.Album, len(albums))
+	for i := range albums {
+		albumMap[albums[i].ID] = &albums[i]
+	}
+
+	// Batch load all media files for these albums
+	mediaFiles, err := mfRepo.GetAll(model.QueryOptions{
+		Filters: squirrel.Eq{"album_id": albumIDs},
+		Sort:    "album_id, path",
+	})
+	if err != nil {
+		return fmt.Errorf("loading media files: %w", err)
+	}
+
+	// Group media files by album ID
+	filesByAlbum := make(map[string]model.MediaFiles)
+	for i := range mediaFiles {
+		albumID := mediaFiles[i].AlbumID
+		filesByAlbum[albumID] = append(filesByAlbum[albumID], mediaFiles[i])
+	}
+
+	// Recalculate each album from its media files
+	for albumID, oldAlbum := range albumMap {
+		mfs, hasTracks := filesByAlbum[albumID]
+		if !hasTracks {
+			// Album has no tracks anymore, skip (will be cleaned up by GC)
+			log.Debug(ctx, "Skipping album with no tracks", "albumID", albumID)
+			continue
+		}
+
+		// Recalculate album from media files
+		newAlbum := mfs.ToAlbum()
+
+		// Only update if something changed (avoid unnecessary writes)
+		if !oldAlbum.Equals(newAlbum) {
+			// Preserve original timestamps
+			newAlbum.UpdatedAt = time.Now()
+			newAlbum.CreatedAt = oldAlbum.CreatedAt
+
+			if err := albumRepo.Put(&newAlbum); err != nil {
+				log.Error(ctx, "Error updating album during refresh", "albumID", albumID, err)
+				// Continue with other albums instead of failing entirely
+				continue
+			}
+			log.Trace(ctx, "Refreshed album", "albumID", albumID, "name", newAlbum.Name)
+		}
+	}
+
+	return nil
+}
+
+// getAffectedAlbumIDs returns distinct album IDs from missing media files
+func (s *maintenanceService) getAffectedAlbumIDs(ctx context.Context, ids []string) ([]string, error) {
+	var filters squirrel.Sqlizer = squirrel.Eq{"missing": true}
+	if len(ids) > 0 {
+		filters = squirrel.And{
+			squirrel.Eq{"missing": true},
+			squirrel.Eq{"id": ids},
+		}
+	}
+
+	mfs, err := s.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: filters,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Extract unique album IDs
+	albumIDMap := make(map[string]struct{}, len(mfs))
+	for _, mf := range mfs {
+		if mf.AlbumID != "" {
+			albumIDMap[mf.AlbumID] = struct{}{}
+		}
+	}
+
+	albumIDs := make([]string, 0, len(albumIDMap))
+	for id := range albumIDMap {
+		albumIDs = append(albumIDs, id)
+	}
+
+	return albumIDs, nil
+}
+
+// refreshStatsAsync refreshes artist and album statistics in background goroutines
+func (s *maintenanceService) refreshStatsAsync(ctx context.Context, affectedAlbumIDs []string) {
+	// Refresh artist stats in background
+	s.wg.Add(1)
+	go func() {
+		defer s.wg.Done()
+		bgCtx := request.AddValues(context.Background(), ctx)
+		if _, err := s.ds.Artist(bgCtx).RefreshStats(true); err != nil {
+			log.Error(bgCtx, "Error refreshing artist stats after deleting missing files", err)
+		} else {
+			log.Debug(bgCtx, "Successfully refreshed artist stats after deleting missing files")
+		}
+
+		// Refresh album stats in background if we have affected albums
+		if len(affectedAlbumIDs) > 0 {
+			if err := s.refreshAlbums(bgCtx, affectedAlbumIDs); err != nil {
+				log.Error(bgCtx, "Error refreshing album stats after deleting missing files", err)
+			} else {
+				log.Debug(bgCtx, "Successfully refreshed album stats after deleting missing files", "count", len(affectedAlbumIDs))
+			}
+		}
+	}()
+}
+
+// Wait waits for all background goroutines to complete.
+// WARNING: This method is ONLY for testing. Never call this in production code.
+// Calling Wait() in production will block until ALL background operations complete
+// and may cause race conditions with new operations starting.
+func (s *maintenanceService) wait() {
+	s.wg.Wait()
+}

core/maintenance_test.go

@@ -0,0 +1,364 @@
+package core
+
+import (
+	"context"
+	"errors"
+	"sync"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+var _ = Describe("Maintenance", func() {
+	var ds *tests.MockDataStore
+	var mfRepo *extendedMediaFileRepo
+	var service Maintenance
+	var ctx context.Context
+
+	BeforeEach(func() {
+		ctx = context.Background()
+		ctx = request.WithUser(ctx, model.User{ID: "user1", IsAdmin: true})
+
+		ds = createTestDataStore()
+		mfRepo = ds.MockedMediaFile.(*extendedMediaFileRepo)
+		service = NewMaintenance(ds)
+	})
+
+	Describe("DeleteMissingFiles", func() {
+		Context("with specific IDs", func() {
+			It("deletes specific missing files and runs GC", func() {
+				// Setup: mock missing files with album IDs
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "album1", Missing: true},
+					{ID: "mf2", AlbumID: "album2", Missing: true},
+				})
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2"})
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(mfRepo.deleteMissingCalled).To(BeTrue())
+				Expect(mfRepo.deletedIDs).To(Equal([]string{"mf1", "mf2"}))
+				Expect(ds.GCCalled).To(BeTrue(), "GC should be called after deletion")
+			})
+
+			It("triggers artist stats refresh and album refresh after deletion", func() {
+				artistRepo := ds.MockedArtist.(*extendedArtistRepo)
+				// Setup: mock missing files with albums
+				albumRepo := ds.MockedAlbum.(*extendedAlbumRepo)
+				albumRepo.SetData(model.Albums{
+					{ID: "album1", Name: "Test Album", SongCount: 5},
+				})
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "album1", Missing: true},
+					{ID: "mf2", AlbumID: "album1", Missing: false, Size: 1000, Duration: 180},
+					{ID: "mf3", AlbumID: "album1", Missing: false, Size: 2000, Duration: 200},
+				})
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+				Expect(err).ToNot(HaveOccurred())
+
+				// Wait for background goroutines to complete
+				service.(*maintenanceService).wait()
+
+				// RefreshStats should be called
+				Expect(artistRepo.IsRefreshStatsCalled()).To(BeTrue(), "Artist stats should be refreshed")
+
+				// Album should be updated with new calculated values
+				Expect(albumRepo.GetPutCallCount()).To(BeNumerically(">", 0), "Album.Put() should be called to refresh album data")
+			})
+
+			It("returns error if deletion fails", func() {
+				mfRepo.deleteMissingError = errors.New("delete failed")
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("delete failed"))
+			})
+
+			It("continues even if album tracking fails", func() {
+				mfRepo.SetError(true)
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+				// Should not fail, just log warning
+				Expect(err).ToNot(HaveOccurred())
+				Expect(mfRepo.deleteMissingCalled).To(BeTrue())
+			})
+
+			It("returns error if GC fails", func() {
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "album1", Missing: true},
+				})
+
+				// Set GC to return error
+				ds.GCError = errors.New("gc failed")
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("gc failed"))
+			})
+		})
+
+		Context("album ID extraction", func() {
+			It("extracts unique album IDs from missing files", func() {
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "album1", Missing: true},
+					{ID: "mf2", AlbumID: "album1", Missing: true},
+					{ID: "mf3", AlbumID: "album2", Missing: true},
+				})
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2", "mf3"})
+
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("skips files without album IDs", func() {
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "", Missing: true},
+					{ID: "mf2", AlbumID: "album1", Missing: true},
+				})
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2"})
+
+				Expect(err).ToNot(HaveOccurred())
+			})
+		})
+	})
+
+	Describe("DeleteAllMissingFiles", func() {
+		It("deletes all missing files and runs GC", func() {
+			mfRepo.SetData(model.MediaFiles{
+				{ID: "mf1", AlbumID: "album1", Missing: true},
+				{ID: "mf2", AlbumID: "album2", Missing: true},
+				{ID: "mf3", AlbumID: "album3", Missing: true},
+			})
+
+			err := service.DeleteAllMissingFiles(ctx)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(ds.GCCalled).To(BeTrue(), "GC should be called after deletion")
+		})
+
+		It("returns error if deletion fails", func() {
+			mfRepo.SetError(true)
+
+			err := service.DeleteAllMissingFiles(ctx)
+
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("handles empty result gracefully", func() {
+			mfRepo.SetData(model.MediaFiles{})
+
+			err := service.DeleteAllMissingFiles(ctx)
+
+			Expect(err).ToNot(HaveOccurred())
+		})
+	})
+
+	Describe("Album refresh logic", func() {
+		var albumRepo *extendedAlbumRepo
+
+		BeforeEach(func() {
+			albumRepo = ds.MockedAlbum.(*extendedAlbumRepo)
+		})
+
+		Context("when album has no tracks after deletion", func() {
+			It("skips the album without updating it", func() {
+				// Setup album with no remaining tracks
+				albumRepo.SetData(model.Albums{
+					{ID: "album1", Name: "Empty Album", SongCount: 1},
+				})
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "album1", Missing: true},
+				})
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+				Expect(err).ToNot(HaveOccurred())
+
+				// Wait for background goroutines to complete
+				service.(*maintenanceService).wait()
+
+				// Album should NOT be updated because it has no tracks left
+				Expect(albumRepo.GetPutCallCount()).To(Equal(0), "Album with no tracks should not be updated")
+			})
+		})
+
+		Context("when Put fails for one album", func() {
+			It("continues processing other albums", func() {
+				albumRepo.SetData(model.Albums{
+					{ID: "album1", Name: "Album 1"},
+					{ID: "album2", Name: "Album 2"},
+				})
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "album1", Missing: true},
+					{ID: "mf2", AlbumID: "album1", Missing: false, Size: 1000, Duration: 180},
+					{ID: "mf3", AlbumID: "album2", Missing: true},
+					{ID: "mf4", AlbumID: "album2", Missing: false, Size: 2000, Duration: 200},
+				})
+
+				// Make Put fail on first call but succeed on subsequent calls
+				albumRepo.putError = errors.New("put failed")
+				albumRepo.failOnce = true
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf3"})
+
+				// Should not fail even if one album's Put fails
+				Expect(err).ToNot(HaveOccurred())
+
+				// Wait for background goroutines to complete
+				service.(*maintenanceService).wait()
+
+				// Put should have been called multiple times
+				Expect(albumRepo.GetPutCallCount()).To(BeNumerically(">", 0), "Put should be attempted")
+			})
+		})
+
+		Context("when media file loading fails", func() {
+			It("logs warning but continues when tracking affected albums fails", func() {
+				// Set up log capturing
+				hook, cleanup := tests.LogHook()
+				defer cleanup()
+
+				albumRepo.SetData(model.Albums{
+					{ID: "album1", Name: "Album 1"},
+				})
+				mfRepo.SetData(model.MediaFiles{
+					{ID: "mf1", AlbumID: "album1", Missing: true},
+				})
+				// Make GetAll fail when loading media files
+				mfRepo.SetError(true)
+
+				err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+				// Deletion should succeed despite the tracking error
+				Expect(err).ToNot(HaveOccurred())
+				Expect(mfRepo.deleteMissingCalled).To(BeTrue())
+
+				// Verify the warning was logged
+				Expect(hook.LastEntry()).ToNot(BeNil())
+				Expect(hook.LastEntry().Level).To(Equal(logrus.WarnLevel))
+				Expect(hook.LastEntry().Message).To(Equal("Error tracking affected albums for refresh"))
+			})
+		})
+	})
+})
+
+// Test helper to create a mock DataStore with controllable behavior
+func createTestDataStore() *tests.MockDataStore {
+	ds := &tests.MockDataStore{}
+
+	// Create extended album repo with Put tracking
+	albumRepo := &extendedAlbumRepo{
+		MockAlbumRepo: tests.CreateMockAlbumRepo(),
+	}
+	ds.MockedAlbum = albumRepo
+
+	// Create extended artist repo with RefreshStats tracking
+	artistRepo := &extendedArtistRepo{
+		MockArtistRepo: tests.CreateMockArtistRepo(),
+	}
+	ds.MockedArtist = artistRepo
+
+	// Create extended media file repo with DeleteMissing support
+	mfRepo := &extendedMediaFileRepo{
+		MockMediaFileRepo: tests.CreateMockMediaFileRepo(),
+	}
+	ds.MockedMediaFile = mfRepo
+
+	return ds
+}
+
+// Extension of MockMediaFileRepo to add DeleteMissing method
+type extendedMediaFileRepo struct {
+	*tests.MockMediaFileRepo
+	deleteMissingCalled bool
+	deletedIDs          []string
+	deleteMissingError  error
+}
+
+func (m *extendedMediaFileRepo) DeleteMissing(ids []string) error {
+	m.deleteMissingCalled = true
+	m.deletedIDs = ids
+	if m.deleteMissingError != nil {
+		return m.deleteMissingError
+	}
+	// Actually delete from the mock data
+	for _, id := range ids {
+		delete(m.Data, id)
+	}
+	return nil
+}
+
+// Extension of MockAlbumRepo to track Put calls
+type extendedAlbumRepo struct {
+	*tests.MockAlbumRepo
+	mu           sync.RWMutex
+	putCallCount int
+	lastPutData  *model.Album
+	putError     error
+	failOnce     bool
+}
+
+func (m *extendedAlbumRepo) Put(album *model.Album) error {
+	m.mu.Lock()
+	m.putCallCount++
+	m.lastPutData = album
+
+	// Handle failOnce behavior
+	var err error
+	if m.putError != nil {
+		if m.failOnce {
+			err = m.putError
+			m.putError = nil // Clear error after first failure
+			m.mu.Unlock()
+			return err
+		}
+		err = m.putError
+		m.mu.Unlock()
+		return err
+	}
+	m.mu.Unlock()
+
+	return m.MockAlbumRepo.Put(album)
+}
+
+func (m *extendedAlbumRepo) GetPutCallCount() int {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.putCallCount
+}
+
+// Extension of MockArtistRepo to track RefreshStats calls
+type extendedArtistRepo struct {
+	*tests.MockArtistRepo
+	mu                 sync.RWMutex
+	refreshStatsCalled bool
+	refreshStatsError  error
+}
+
+func (m *extendedArtistRepo) RefreshStats(allArtists bool) (int64, error) {
+	m.mu.Lock()
+	m.refreshStatsCalled = true
+	err := m.refreshStatsError
+	m.mu.Unlock()
+
+	if err != nil {
+		return 0, err
+	}
+	return m.MockArtistRepo.RefreshStats(allArtists)
+}
+
+func (m *extendedArtistRepo) IsRefreshStatsCalled() bool {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.refreshStatsCalled
+}

core/metrics/insights.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"math"
 	"net/http"
+	"os"
 	"path/filepath"
 	"runtime"
 	"runtime/debug"
@@ -160,6 +161,13 @@ var staticData = sync.OnceValue(func() insights.Data {
 	data.Build.Settings, data.Build.GoVersion = buildInfo()
 	data.OS.Containerized = consts.InContainer
 
+	// Install info
+	packageFilename := filepath.Join(conf.Server.DataFolder, ".package")
+	packageFileData, err := os.ReadFile(packageFilename)
+	if err == nil {
+		data.OS.Package = string(packageFileData)
+	}
+
 	// OS info
 	data.OS.Type = runtime.GOOS
 	data.OS.Arch = runtime.GOARCH

core/metrics/insights/data.go

@@ -16,6 +16,7 @@ type Data struct {
 		Containerized bool   `json:"containerized"`
 		Arch          string `json:"arch"`
 		NumCPU        int    `json:"numCPU"`
+		Package       string `json:"package,omitempty"`
 	} `json:"os"`
 	Mem struct {
 		Alloc      uint64 `json:"alloc"`

core/playlists.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"cmp"
 	"context"
 	"encoding/json"
 	"errors"
@@ -9,7 +10,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"regexp"
+	"slices"
 	"strings"
 	"time"
 
@@ -194,22 +195,31 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 			}
 			filteredLines = append(filteredLines, line)
 		}
-		paths, err := s.normalizePaths(ctx, pls, folder, filteredLines)
+		resolvedPaths, err := s.resolvePaths(ctx, folder, filteredLines)
 		if err != nil {
-			log.Warn(ctx, "Error normalizing paths in playlist", "playlist", pls.Name, err)
+			log.Warn(ctx, "Error resolving paths in playlist", "playlist", pls.Name, err)
 			continue
 		}
-		found, err := mediaFileRepository.FindByPaths(paths)
+
+		found, err := mediaFileRepository.FindByPaths(resolvedPaths)
 		if err != nil {
 			log.Warn(ctx, "Error reading files from DB", "playlist", pls.Name, err)
 			continue
 		}
+		// Build lookup map with library-qualified keys
 		existing := make(map[string]int, len(found))
 		for idx := range found {
-			existing[normalizePathForComparison(found[idx].Path)] = idx
+			// Key format: "libraryID:path" (normalized)
+			key := fmt.Sprintf("%d:%s", found[idx].LibraryID, normalizePathForComparison(found[idx].Path))
+			existing[key] = idx
 		}
-		for _, path := range paths {
-			idx, ok := existing[normalizePathForComparison(path)]
+		for _, path := range resolvedPaths {
+			// Parse the library-qualified path
+			parts := strings.SplitN(path, ":", 2)
+			// Path is already qualified: "libraryID:path"
+			normalizedPath := parts[0] + ":" + normalizePathForComparison(parts[1])
+
+			idx, ok := existing[normalizedPath]
 			if ok {
 				mfs = append(mfs, found[idx])
 			} else {
@@ -233,62 +243,150 @@ func normalizePathForComparison(path string) string {
 	return strings.ToLower(norm.NFC.String(path))
 }
 
-// TODO This won't work for multiple libraries
-func (s *playlists) normalizePaths(ctx context.Context, pls *model.Playlist, folder *model.Folder, lines []string) ([]string, error) {
-	libRegex, err := s.compileLibraryPaths(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	res := make([]string, 0, len(lines))
-	for idx, line := range lines {
-		var libPath string
-		var filePath string
-
-		if folder != nil && !filepath.IsAbs(line) {
-			libPath = folder.LibraryPath
-			filePath = filepath.Join(folder.AbsolutePath(), line)
-		} else {
-			cleanLine := filepath.Clean(line)
-			if libPath = libRegex.FindString(cleanLine); libPath != "" {
-				filePath = cleanLine
-			}
-		}
-
-		if libPath != "" {
-			if rel, err := filepath.Rel(libPath, filePath); err == nil {
-				res = append(res, rel)
-			} else {
-				log.Debug(ctx, "Error getting relative path", "playlist", pls.Name, "path", line, "libPath", libPath,
-					"filePath", filePath, err)
-			}
-		} else {
-			log.Warn(ctx, "Path in playlist not found in any library", "path", line, "line", idx)
-		}
-	}
-	return slice.Map(res, filepath.ToSlash), nil
+// pathResolution holds the result of resolving a playlist path to a library-relative path.
+type pathResolution struct {
+	absolutePath string
+	libraryPath  string
+	libraryID    int
+	valid        bool
 }
 
-func (s *playlists) compileLibraryPaths(ctx context.Context) (*regexp.Regexp, error) {
-	libs, err := s.ds.Library(ctx).GetAll()
+// ToQualifiedString converts the path resolution to a library-qualified string with forward slashes.
+// Format: "libraryID:relativePath" with forward slashes for path separators.
+func (r pathResolution) ToQualifiedString() (string, error) {
+	if !r.valid {
+		return "", fmt.Errorf("invalid path resolution")
+	}
+	relativePath, err := filepath.Rel(r.libraryPath, r.absolutePath)
+	if err != nil {
+		return "", err
+	}
+	// Convert path separators to forward slashes
+	return fmt.Sprintf("%d:%s", r.libraryID, filepath.ToSlash(relativePath)), nil
+}
+
+// libraryMatcher holds sorted libraries with cleaned paths for efficient path matching.
+type libraryMatcher struct {
+	libraries    model.Libraries
+	cleanedPaths []string
+}
+
+// findLibraryForPath finds which library contains the given absolute path.
+// Returns library ID and path, or 0 and empty string if not found.
+func (lm *libraryMatcher) findLibraryForPath(absolutePath string) (int, string) {
+	// Check sorted libraries (longest path first) to find the best match
+	for i, cleanLibPath := range lm.cleanedPaths {
+		// Check if absolutePath is under this library path
+		if strings.HasPrefix(absolutePath, cleanLibPath) {
+			// Ensure it's a proper path boundary (not just a prefix)
+			if len(absolutePath) == len(cleanLibPath) || absolutePath[len(cleanLibPath)] == filepath.Separator {
+				return lm.libraries[i].ID, cleanLibPath
+			}
+		}
+	}
+	return 0, ""
+}
+
+// newLibraryMatcher creates a libraryMatcher with libraries sorted by path length (longest first).
+// This ensures correct matching when library paths are prefixes of each other.
+// Example: /music-classical must be checked before /music
+// Otherwise, /music-classical/track.mp3 would match /music instead of /music-classical
+func newLibraryMatcher(libs model.Libraries) *libraryMatcher {
+	// Sort libraries by path length (descending) to ensure longest paths match first.
+	slices.SortFunc(libs, func(i, j model.Library) int {
+		return cmp.Compare(len(j.Path), len(i.Path)) // Reverse order for descending
+	})
+
+	// Pre-clean all library paths once for efficient matching
+	cleanedPaths := make([]string, len(libs))
+	for i, lib := range libs {
+		cleanedPaths[i] = filepath.Clean(lib.Path)
+	}
+	return &libraryMatcher{
+		libraries:    libs,
+		cleanedPaths: cleanedPaths,
+	}
+}
+
+// pathResolver handles path resolution logic for playlist imports.
+type pathResolver struct {
+	matcher *libraryMatcher
+}
+
+// newPathResolver creates a pathResolver with libraries loaded from the datastore.
+func newPathResolver(ctx context.Context, ds model.DataStore) (*pathResolver, error) {
+	libs, err := ds.Library(ctx).GetAll()
+	if err != nil {
+		return nil, err
+	}
+	matcher := newLibraryMatcher(libs)
+	return &pathResolver{matcher: matcher}, nil
+}
+
+// resolvePath determines the absolute path and library path for a playlist entry.
+// For absolute paths, it uses them directly.
+// For relative paths, it resolves them relative to the playlist's folder location.
+// Example: playlist at /music/playlists/test.m3u with line "../songs/abc.mp3"
+//
+//	resolves to /music/songs/abc.mp3
+func (r *pathResolver) resolvePath(line string, folder *model.Folder) pathResolution {
+	var absolutePath string
+	if folder != nil && !filepath.IsAbs(line) {
+		// Resolve relative path to absolute path based on playlist location
+		absolutePath = filepath.Clean(filepath.Join(folder.AbsolutePath(), line))
+	} else {
+		// Use absolute path directly after cleaning
+		absolutePath = filepath.Clean(line)
+	}
+
+	return r.findInLibraries(absolutePath)
+}
+
+// findInLibraries matches an absolute path against all known libraries and returns
+// a pathResolution with the library information. Returns an invalid resolution if
+// the path is not found in any library.
+func (r *pathResolver) findInLibraries(absolutePath string) pathResolution {
+	libID, libPath := r.matcher.findLibraryForPath(absolutePath)
+	if libID == 0 {
+		return pathResolution{valid: false}
+	}
+	return pathResolution{
+		absolutePath: absolutePath,
+		libraryPath:  libPath,
+		libraryID:    libID,
+		valid:        true,
+	}
+}
+
+// resolvePaths converts playlist file paths to library-qualified paths (format: "libraryID:relativePath").
+// For relative paths, it resolves them to absolute paths first, then determines which
+// library they belong to. This allows playlists to reference files across library boundaries.
+func (s *playlists) resolvePaths(ctx context.Context, folder *model.Folder, lines []string) ([]string, error) {
+	resolver, err := newPathResolver(ctx, s.ds)
 	if err != nil {
 		return nil, err
 	}
 
-	// Create regex patterns for each library path
-	patterns := make([]string, len(libs))
-	for i, lib := range libs {
-		cleanPath := filepath.Clean(lib.Path)
-		escapedPath := regexp.QuoteMeta(cleanPath)
-		patterns[i] = fmt.Sprintf("^%s(?:/|$)", escapedPath)
+	results := make([]string, 0, len(lines))
+	for idx, line := range lines {
+		resolution := resolver.resolvePath(line, folder)
+
+		if !resolution.valid {
+			log.Warn(ctx, "Path in playlist not found in any library", "path", line, "line", idx)
+			continue
+		}
+
+		qualifiedPath, err := resolution.ToQualifiedString()
+		if err != nil {
+			log.Debug(ctx, "Error getting library-qualified path", "path", line,
+				"libPath", resolution.libraryPath, "filePath", resolution.absolutePath, err)
+			continue
+		}
+
+		results = append(results, qualifiedPath)
 	}
-	// Combine all patterns into a single regex
-	combinedPattern := strings.Join(patterns, "|")
-	re, err := regexp.Compile(combinedPattern)
-	if err != nil {
-		return nil, fmt.Errorf("compiling library paths `%s`: %w", combinedPattern, err)
-	}
-	return re, nil
+
+	return results, nil
 }
 
 func (s *playlists) updatePlaylist(ctx context.Context, newPls *model.Playlist) error {

core/playlists_internal_test.go

@@ -0,0 +1,432 @@
+package core
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"golang.org/x/text/unicode/norm"
+)
+
+var _ = Describe("libraryMatcher", func() {
+	var ds *tests.MockDataStore
+	var mockLibRepo *tests.MockLibraryRepo
+	ctx := context.Background()
+
+	BeforeEach(func() {
+		mockLibRepo = &tests.MockLibraryRepo{}
+		ds = &tests.MockDataStore{
+			MockedLibrary: mockLibRepo,
+		}
+	})
+
+	// Helper function to create a libraryMatcher from the mock datastore
+	createMatcher := func(ds model.DataStore) *libraryMatcher {
+		libs, err := ds.Library(ctx).GetAll()
+		Expect(err).ToNot(HaveOccurred())
+		return newLibraryMatcher(libs)
+	}
+
+	Describe("Longest library path matching", func() {
+		It("matches the longest library path when multiple libraries share a prefix", func() {
+			// Setup libraries with prefix conflicts
+			mockLibRepo.SetData([]model.Library{
+				{ID: 1, Path: "/music"},
+				{ID: 2, Path: "/music-classical"},
+				{ID: 3, Path: "/music-classical/opera"},
+			})
+
+			matcher := createMatcher(ds)
+
+			// Test that longest path matches first and returns correct library ID
+			testCases := []struct {
+				path            string
+				expectedLibID   int
+				expectedLibPath string
+			}{
+				{"/music-classical/opera/track.mp3", 3, "/music-classical/opera"},
+				{"/music-classical/track.mp3", 2, "/music-classical"},
+				{"/music/track.mp3", 1, "/music"},
+				{"/music-classical/opera/subdir/file.mp3", 3, "/music-classical/opera"},
+			}
+
+			for _, tc := range testCases {
+				libID, libPath := matcher.findLibraryForPath(tc.path)
+				Expect(libID).To(Equal(tc.expectedLibID), "Path %s should match library ID %d, but got %d", tc.path, tc.expectedLibID, libID)
+				Expect(libPath).To(Equal(tc.expectedLibPath), "Path %s should match library path %s, but got %s", tc.path, tc.expectedLibPath, libPath)
+			}
+		})
+
+		It("handles libraries with similar prefixes but different structures", func() {
+			mockLibRepo.SetData([]model.Library{
+				{ID: 1, Path: "/home/user/music"},
+				{ID: 2, Path: "/home/user/music-backup"},
+			})
+
+			matcher := createMatcher(ds)
+
+			// Test that music-backup library is matched correctly
+			libID, libPath := matcher.findLibraryForPath("/home/user/music-backup/track.mp3")
+			Expect(libID).To(Equal(2))
+			Expect(libPath).To(Equal("/home/user/music-backup"))
+
+			// Test that music library is still matched correctly
+			libID, libPath = matcher.findLibraryForPath("/home/user/music/track.mp3")
+			Expect(libID).To(Equal(1))
+			Expect(libPath).To(Equal("/home/user/music"))
+		})
+
+		It("matches path that is exactly the library root", func() {
+			mockLibRepo.SetData([]model.Library{
+				{ID: 1, Path: "/music"},
+				{ID: 2, Path: "/music-classical"},
+			})
+
+			matcher := createMatcher(ds)
+
+			// Exact library path should match
+			libID, libPath := matcher.findLibraryForPath("/music-classical")
+			Expect(libID).To(Equal(2))
+			Expect(libPath).To(Equal("/music-classical"))
+		})
+
+		It("handles complex nested library structures", func() {
+			mockLibRepo.SetData([]model.Library{
+				{ID: 1, Path: "/media"},
+				{ID: 2, Path: "/media/audio"},
+				{ID: 3, Path: "/media/audio/classical"},
+				{ID: 4, Path: "/media/audio/classical/baroque"},
+			})
+
+			matcher := createMatcher(ds)
+
+			testCases := []struct {
+				path            string
+				expectedLibID   int
+				expectedLibPath string
+			}{
+				{"/media/audio/classical/baroque/bach/track.mp3", 4, "/media/audio/classical/baroque"},
+				{"/media/audio/classical/mozart/track.mp3", 3, "/media/audio/classical"},
+				{"/media/audio/rock/track.mp3", 2, "/media/audio"},
+				{"/media/video/movie.mp4", 1, "/media"},
+			}
+
+			for _, tc := range testCases {
+				libID, libPath := matcher.findLibraryForPath(tc.path)
+				Expect(libID).To(Equal(tc.expectedLibID), "Path %s should match library ID %d", tc.path, tc.expectedLibID)
+				Expect(libPath).To(Equal(tc.expectedLibPath), "Path %s should match library path %s", tc.path, tc.expectedLibPath)
+			}
+		})
+	})
+
+	Describe("Edge cases", func() {
+		It("handles empty library list", func() {
+			mockLibRepo.SetData([]model.Library{})
+
+			matcher := createMatcher(ds)
+			Expect(matcher).ToNot(BeNil())
+
+			// Should not match anything
+			libID, libPath := matcher.findLibraryForPath("/music/track.mp3")
+			Expect(libID).To(Equal(0))
+			Expect(libPath).To(BeEmpty())
+		})
+
+		It("handles single library", func() {
+			mockLibRepo.SetData([]model.Library{
+				{ID: 1, Path: "/music"},
+			})
+
+			matcher := createMatcher(ds)
+
+			libID, libPath := matcher.findLibraryForPath("/music/track.mp3")
+			Expect(libID).To(Equal(1))
+			Expect(libPath).To(Equal("/music"))
+		})
+
+		It("handles libraries with special characters in paths", func() {
+			mockLibRepo.SetData([]model.Library{
+				{ID: 1, Path: "/music[test]"},
+				{ID: 2, Path: "/music(backup)"},
+			})
+
+			matcher := createMatcher(ds)
+			Expect(matcher).ToNot(BeNil())
+
+			// Special characters should match literally
+			libID, libPath := matcher.findLibraryForPath("/music[test]/track.mp3")
+			Expect(libID).To(Equal(1))
+			Expect(libPath).To(Equal("/music[test]"))
+		})
+	})
+
+	Describe("Path matching order", func() {
+		It("ensures longest paths match first", func() {
+			mockLibRepo.SetData([]model.Library{
+				{ID: 1, Path: "/a"},
+				{ID: 2, Path: "/ab"},
+				{ID: 3, Path: "/abc"},
+			})
+
+			matcher := createMatcher(ds)
+
+			// Verify that longer paths match correctly (not cut off by shorter prefix)
+			testCases := []struct {
+				path          string
+				expectedLibID int
+			}{
+				{"/abc/file.mp3", 3},
+				{"/ab/file.mp3", 2},
+				{"/a/file.mp3", 1},
+			}
+
+			for _, tc := range testCases {
+				libID, _ := matcher.findLibraryForPath(tc.path)
+				Expect(libID).To(Equal(tc.expectedLibID), "Path %s should match library ID %d", tc.path, tc.expectedLibID)
+			}
+		})
+	})
+})
+
+var _ = Describe("pathResolver", func() {
+	var ds *tests.MockDataStore
+	var mockLibRepo *tests.MockLibraryRepo
+	var resolver *pathResolver
+	ctx := context.Background()
+
+	BeforeEach(func() {
+		mockLibRepo = &tests.MockLibraryRepo{}
+		ds = &tests.MockDataStore{
+			MockedLibrary: mockLibRepo,
+		}
+
+		// Setup test libraries
+		mockLibRepo.SetData([]model.Library{
+			{ID: 1, Path: "/music"},
+			{ID: 2, Path: "/music-classical"},
+			{ID: 3, Path: "/podcasts"},
+		})
+
+		var err error
+		resolver, err = newPathResolver(ctx, ds)
+		Expect(err).ToNot(HaveOccurred())
+	})
+
+	Describe("resolvePath", func() {
+		It("resolves absolute paths", func() {
+			resolution := resolver.resolvePath("/music/artist/album/track.mp3", nil)
+
+			Expect(resolution.valid).To(BeTrue())
+			Expect(resolution.libraryID).To(Equal(1))
+			Expect(resolution.libraryPath).To(Equal("/music"))
+			Expect(resolution.absolutePath).To(Equal("/music/artist/album/track.mp3"))
+		})
+
+		It("resolves relative paths when folder is provided", func() {
+			folder := &model.Folder{
+				Path:        "playlists",
+				LibraryPath: "/music",
+				LibraryID:   1,
+			}
+
+			resolution := resolver.resolvePath("../artist/album/track.mp3", folder)
+
+			Expect(resolution.valid).To(BeTrue())
+			Expect(resolution.libraryID).To(Equal(1))
+			Expect(resolution.absolutePath).To(Equal("/music/artist/album/track.mp3"))
+		})
+
+		It("returns invalid resolution for paths outside any library", func() {
+			resolution := resolver.resolvePath("/outside/library/track.mp3", nil)
+
+			Expect(resolution.valid).To(BeFalse())
+		})
+	})
+
+	Describe("resolvePath", func() {
+		Context("With absolute paths", func() {
+			It("resolves path within a library", func() {
+				resolution := resolver.resolvePath("/music/track.mp3", nil)
+
+				Expect(resolution.valid).To(BeTrue())
+				Expect(resolution.libraryID).To(Equal(1))
+				Expect(resolution.libraryPath).To(Equal("/music"))
+				Expect(resolution.absolutePath).To(Equal("/music/track.mp3"))
+			})
+
+			It("resolves path to the longest matching library", func() {
+				resolution := resolver.resolvePath("/music-classical/track.mp3", nil)
+
+				Expect(resolution.valid).To(BeTrue())
+				Expect(resolution.libraryID).To(Equal(2))
+				Expect(resolution.libraryPath).To(Equal("/music-classical"))
+			})
+
+			It("returns invalid resolution for path outside libraries", func() {
+				resolution := resolver.resolvePath("/videos/movie.mp4", nil)
+
+				Expect(resolution.valid).To(BeFalse())
+			})
+
+			It("cleans the path before matching", func() {
+				resolution := resolver.resolvePath("/music//artist/../artist/track.mp3", nil)
+
+				Expect(resolution.valid).To(BeTrue())
+				Expect(resolution.absolutePath).To(Equal("/music/artist/track.mp3"))
+			})
+		})
+
+		Context("With relative paths", func() {
+			It("resolves relative path within same library", func() {
+				folder := &model.Folder{
+					Path:        "playlists",
+					LibraryPath: "/music",
+					LibraryID:   1,
+				}
+
+				resolution := resolver.resolvePath("../songs/track.mp3", folder)
+
+				Expect(resolution.valid).To(BeTrue())
+				Expect(resolution.libraryID).To(Equal(1))
+				Expect(resolution.absolutePath).To(Equal("/music/songs/track.mp3"))
+			})
+
+			It("resolves relative path to different library", func() {
+				folder := &model.Folder{
+					Path:        "playlists",
+					LibraryPath: "/music",
+					LibraryID:   1,
+				}
+
+				// Path goes up and into a different library
+				resolution := resolver.resolvePath("../../podcasts/episode.mp3", folder)
+
+				Expect(resolution.valid).To(BeTrue())
+				Expect(resolution.libraryID).To(Equal(3))
+				Expect(resolution.libraryPath).To(Equal("/podcasts"))
+			})
+
+			It("uses matcher to find correct library for resolved path", func() {
+				folder := &model.Folder{
+					Path:        "playlists",
+					LibraryPath: "/music",
+					LibraryID:   1,
+				}
+
+				// This relative path resolves to music-classical library
+				resolution := resolver.resolvePath("../../music-classical/track.mp3", folder)
+
+				Expect(resolution.valid).To(BeTrue())
+				Expect(resolution.libraryID).To(Equal(2))
+				Expect(resolution.libraryPath).To(Equal("/music-classical"))
+			})
+
+			It("returns invalid for relative paths escaping all libraries", func() {
+				folder := &model.Folder{
+					Path:        "playlists",
+					LibraryPath: "/music",
+					LibraryID:   1,
+				}
+
+				resolution := resolver.resolvePath("../../../../etc/passwd", folder)
+
+				Expect(resolution.valid).To(BeFalse())
+			})
+		})
+	})
+
+	Describe("Cross-library resolution scenarios", func() {
+		It("handles playlist in library A referencing file in library B", func() {
+			// Playlist is in /music/playlists
+			folder := &model.Folder{
+				Path:        "playlists",
+				LibraryPath: "/music",
+				LibraryID:   1,
+			}
+
+			// Relative path that goes to /podcasts library
+			resolution := resolver.resolvePath("../../podcasts/show/episode.mp3", folder)
+
+			Expect(resolution.valid).To(BeTrue())
+			Expect(resolution.libraryID).To(Equal(3), "Should resolve to podcasts library")
+			Expect(resolution.libraryPath).To(Equal("/podcasts"))
+		})
+
+		It("prefers longer library paths when resolving", func() {
+			// Ensure /music-classical is matched instead of /music
+			resolution := resolver.resolvePath("/music-classical/baroque/track.mp3", nil)
+
+			Expect(resolution.valid).To(BeTrue())
+			Expect(resolution.libraryID).To(Equal(2), "Should match /music-classical, not /music")
+		})
+	})
+})
+
+var _ = Describe("pathResolution", func() {
+	Describe("ToQualifiedString", func() {
+		It("converts valid resolution to qualified string with forward slashes", func() {
+			resolution := pathResolution{
+				absolutePath: "/music/artist/album/track.mp3",
+				libraryPath:  "/music",
+				libraryID:    1,
+				valid:        true,
+			}
+
+			qualifiedStr, err := resolution.ToQualifiedString()
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(qualifiedStr).To(Equal("1:artist/album/track.mp3"))
+		})
+
+		It("handles Windows-style paths by converting to forward slashes", func() {
+			resolution := pathResolution{
+				absolutePath: "/music/artist/album/track.mp3",
+				libraryPath:  "/music",
+				libraryID:    2,
+				valid:        true,
+			}
+
+			qualifiedStr, err := resolution.ToQualifiedString()
+
+			Expect(err).ToNot(HaveOccurred())
+			// Should always use forward slashes regardless of OS
+			Expect(qualifiedStr).To(ContainSubstring("2:"))
+			Expect(qualifiedStr).ToNot(ContainSubstring("\\"))
+		})
+
+		It("returns error for invalid resolution", func() {
+			resolution := pathResolution{valid: false}
+
+			_, err := resolution.ToQualifiedString()
+
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})
+
+var _ = Describe("normalizePathForComparison", func() {
+	It("normalizes Unicode characters to NFC form and converts to lowercase", func() {
+		// Test with NFD (decomposed) input - as would come from macOS filesystem
+		nfdPath := norm.NFD.String("Michèle") // Explicitly convert to NFD form
+		normalized := normalizePathForComparison(nfdPath)
+		Expect(normalized).To(Equal("michèle"))
+
+		// Test with NFC (composed) input - as would come from Apple Music M3U
+		nfcPath := "Michèle" // This might be in NFC form
+		normalizedNfc := normalizePathForComparison(nfcPath)
+
+		// Ensure the two paths are not equal in their original forms
+		Expect(nfdPath).ToNot(Equal(nfcPath))
+
+		// Both should normalize to the same result
+		Expect(normalized).To(Equal(normalizedNfc))
+	})
+
+	It("handles paths with mixed case and Unicode characters", func() {
+		path := "Artist/Noël Coward/Album/Song.mp3"
+		normalized := normalizePathForComparison(path)
+		Expect(normalized).To(Equal("artist/noël coward/album/song.mp3"))
+	})
+})

core/playlists_test.go

@@ -1,4 +1,4 @@
-package core
+package core_test
 
 import (
 	"context"
@@ -9,18 +9,18 @@ import (
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/criteria"
 	"github.com/navidrome/navidrome/model/request"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"golang.org/x/text/unicode/norm"
 )
 
 var _ = Describe("Playlists", func() {
 	var ds *tests.MockDataStore
-	var ps Playlists
+	var ps core.Playlists
 	var mockPlsRepo mockedPlaylistRepo
 	var mockLibRepo *tests.MockLibraryRepo
 	ctx := context.Background()
@@ -33,16 +33,16 @@ var _ = Describe("Playlists", func() {
 			MockedLibrary:  mockLibRepo,
 		}
 		ctx = request.WithUser(ctx, model.User{ID: "123"})
-		// Path should be libPath, but we want to match the root folder referenced in the m3u, which is `/`
-		mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/"}})
 	})
 
 	Describe("ImportFile", func() {
 		var folder *model.Folder
 		BeforeEach(func() {
-			ps = NewPlaylists(ds)
+			ps = core.NewPlaylists(ds)
 			ds.MockedMediaFile = &mockedMediaFileRepo{}
 			libPath, _ := os.Getwd()
+			// Set up library with the actual library path that matches the folder
+			mockLibRepo.SetData([]model.Library{{ID: 1, Path: libPath}})
 			folder = &model.Folder{
 				ID:          "1",
 				LibraryID:   1,
@@ -112,6 +112,224 @@ var _ = Describe("Playlists", func() {
 				Expect(err.Error()).To(ContainSubstring("line 19, column 1: invalid character '\\n'"))
 			})
 		})
+
+		Describe("Cross-library relative paths", func() {
+			var tmpDir, plsDir, songsDir string
+
+			BeforeEach(func() {
+				// Create temp directory structure
+				tmpDir = GinkgoT().TempDir()
+				plsDir = tmpDir + "/playlists"
+				songsDir = tmpDir + "/songs"
+				Expect(os.Mkdir(plsDir, 0755)).To(Succeed())
+				Expect(os.Mkdir(songsDir, 0755)).To(Succeed())
+
+				// Setup two different libraries with paths matching our temp structure
+				mockLibRepo.SetData([]model.Library{
+					{ID: 1, Path: songsDir},
+					{ID: 2, Path: plsDir},
+				})
+
+				// Create a mock media file repository that returns files for both libraries
+				// Note: The paths are relative to their respective library roots
+				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
+					data: []string{
+						"abc.mp3", // This is songs/abc.mp3 relative to songsDir
+						"def.mp3", // This is playlists/def.mp3 relative to plsDir
+					},
+				}
+				ps = core.NewPlaylists(ds)
+			})
+
+			It("handles relative paths that reference files in other libraries", func() {
+				// Create a temporary playlist file with relative path
+				plsContent := "#PLAYLIST:Cross Library Test\n../songs/abc.mp3\ndef.mp3"
+				plsFile := plsDir + "/test.m3u"
+				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
+
+				// Playlist is in the Playlists library folder
+				// Important: Path should be relative to LibraryPath, and Name is the folder name
+				plsFolder := &model.Folder{
+					ID:          "2",
+					LibraryID:   2,
+					LibraryPath: plsDir,
+					Path:        "",
+					Name:        "",
+				}
+
+				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(pls.Tracks).To(HaveLen(2))
+				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3")) // From songsDir library
+				Expect(pls.Tracks[1].Path).To(Equal("def.mp3")) // From plsDir library
+			})
+
+			It("ignores paths that point outside all libraries", func() {
+				// Create a temporary playlist file with path outside libraries
+				plsContent := "#PLAYLIST:Outside Test\n../../outside.mp3\nabc.mp3"
+				plsFile := plsDir + "/test.m3u"
+				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
+
+				plsFolder := &model.Folder{
+					ID:          "2",
+					LibraryID:   2,
+					LibraryPath: plsDir,
+					Path:        "",
+					Name:        "",
+				}
+
+				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
+				Expect(err).ToNot(HaveOccurred())
+				// Should only find abc.mp3, not outside.mp3
+				Expect(pls.Tracks).To(HaveLen(1))
+				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3"))
+			})
+
+			It("handles relative paths with multiple '../' components", func() {
+				// Create a nested structure: tmpDir/playlists/subfolder/test.m3u
+				subFolder := plsDir + "/subfolder"
+				Expect(os.Mkdir(subFolder, 0755)).To(Succeed())
+
+				// Create the media file in the subfolder directory
+				// The mock will return it as "def.mp3" relative to plsDir
+				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
+					data: []string{
+						"abc.mp3", // From songsDir library
+						"def.mp3", // From plsDir library root
+					},
+				}
+
+				// From subfolder, ../../songs/abc.mp3 should resolve to songs library
+				// ../def.mp3 should resolve to plsDir/def.mp3
+				plsContent := "#PLAYLIST:Nested Test\n../../songs/abc.mp3\n../def.mp3"
+				plsFile := subFolder + "/test.m3u"
+				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
+
+				// The folder: AbsolutePath = LibraryPath + Path + Name
+				// So for /playlists/subfolder: LibraryPath=/playlists, Path="", Name="subfolder"
+				plsFolder := &model.Folder{
+					ID:          "2",
+					LibraryID:   2,
+					LibraryPath: plsDir,
+					Path:        "",          // Empty because subfolder is directly under library root
+					Name:        "subfolder", // The folder name
+				}
+
+				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(pls.Tracks).To(HaveLen(2))
+				Expect(pls.Tracks[0].Path).To(Equal("abc.mp3")) // From songsDir library
+				Expect(pls.Tracks[1].Path).To(Equal("def.mp3")) // From plsDir library root
+			})
+
+			It("correctly resolves libraries when one path is a prefix of another", func() {
+				// This tests the bug where /music would match before /music-classical
+				// Create temp directory structure with prefix conflict
+				tmpDir := GinkgoT().TempDir()
+				musicDir := tmpDir + "/music"
+				musicClassicalDir := tmpDir + "/music-classical"
+				Expect(os.Mkdir(musicDir, 0755)).To(Succeed())
+				Expect(os.Mkdir(musicClassicalDir, 0755)).To(Succeed())
+
+				// Setup two libraries where one is a prefix of the other
+				mockLibRepo.SetData([]model.Library{
+					{ID: 1, Path: musicDir},          // /tmp/xxx/music
+					{ID: 2, Path: musicClassicalDir}, // /tmp/xxx/music-classical
+				})
+
+				// Mock will return tracks from both libraries
+				ds.MockedMediaFile = &mockedMediaFileFromListRepo{
+					data: []string{
+						"rock.mp3", // From music library
+						"bach.mp3", // From music-classical library
+					},
+				}
+
+				// Create playlist in music library that references music-classical
+				plsContent := "#PLAYLIST:Cross Prefix Test\nrock.mp3\n../music-classical/bach.mp3"
+				plsFile := musicDir + "/test.m3u"
+				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
+
+				plsFolder := &model.Folder{
+					ID:          "1",
+					LibraryID:   1,
+					LibraryPath: musicDir,
+					Path:        "",
+					Name:        "",
+				}
+
+				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(pls.Tracks).To(HaveLen(2))
+				Expect(pls.Tracks[0].Path).To(Equal("rock.mp3")) // From music library
+				Expect(pls.Tracks[1].Path).To(Equal("bach.mp3")) // From music-classical library (not music!)
+			})
+
+			It("correctly handles identical relative paths from different libraries", func() {
+				// This tests the bug where two libraries have files at the same relative path
+				// and only one appears in the playlist
+				tmpDir := GinkgoT().TempDir()
+				musicDir := tmpDir + "/music"
+				classicalDir := tmpDir + "/classical"
+				Expect(os.Mkdir(musicDir, 0755)).To(Succeed())
+				Expect(os.Mkdir(classicalDir, 0755)).To(Succeed())
+				Expect(os.MkdirAll(musicDir+"/album", 0755)).To(Succeed())
+				Expect(os.MkdirAll(classicalDir+"/album", 0755)).To(Succeed())
+				// Create placeholder files so paths resolve correctly
+				Expect(os.WriteFile(musicDir+"/album/track.mp3", []byte{}, 0600)).To(Succeed())
+				Expect(os.WriteFile(classicalDir+"/album/track.mp3", []byte{}, 0600)).To(Succeed())
+
+				// Both libraries have a file at "album/track.mp3"
+				mockLibRepo.SetData([]model.Library{
+					{ID: 1, Path: musicDir},
+					{ID: 2, Path: classicalDir},
+				})
+
+				// Mock returns files with same relative path but different IDs and library IDs
+				// Keys use the library-qualified format: "libraryID:path"
+				ds.MockedMediaFile = &mockedMediaFileRepo{
+					data: map[string]model.MediaFile{
+						"1:album/track.mp3": {ID: "music-track", Path: "album/track.mp3", LibraryID: 1, Title: "Rock Song"},
+						"2:album/track.mp3": {ID: "classical-track", Path: "album/track.mp3", LibraryID: 2, Title: "Classical Piece"},
+					},
+				}
+				// Recreate playlists service to pick up new mock
+				ps = core.NewPlaylists(ds)
+
+				// Create playlist in music library that references both tracks
+				plsContent := "#PLAYLIST:Same Path Test\nalbum/track.mp3\n../classical/album/track.mp3"
+				plsFile := musicDir + "/test.m3u"
+				Expect(os.WriteFile(plsFile, []byte(plsContent), 0600)).To(Succeed())
+
+				plsFolder := &model.Folder{
+					ID:          "1",
+					LibraryID:   1,
+					LibraryPath: musicDir,
+					Path:        "",
+					Name:        "",
+				}
+
+				pls, err := ps.ImportFile(ctx, plsFolder, "test.m3u")
+				Expect(err).ToNot(HaveOccurred())
+
+				// Should have BOTH tracks, not just one
+				Expect(pls.Tracks).To(HaveLen(2), "Playlist should contain both tracks with same relative path")
+
+				// Verify we got tracks from DIFFERENT libraries (the key fix!)
+				// Collect the library IDs
+				libIDs := make(map[int]bool)
+				for _, track := range pls.Tracks {
+					libIDs[track.LibraryID] = true
+				}
+				Expect(libIDs).To(HaveLen(2), "Tracks should come from two different libraries")
+				Expect(libIDs[1]).To(BeTrue(), "Should have track from library 1")
+				Expect(libIDs[2]).To(BeTrue(), "Should have track from library 2")
+
+				// Both tracks should have the same relative path
+				Expect(pls.Tracks[0].Path).To(Equal("album/track.mp3"))
+				Expect(pls.Tracks[1].Path).To(Equal("album/track.mp3"))
+			})
+		})
 	})
 
 	Describe("ImportM3U", func() {
@@ -119,7 +337,7 @@ var _ = Describe("Playlists", func() {
 		BeforeEach(func() {
 			repo = &mockedMediaFileFromListRepo{}
 			ds.MockedMediaFile = repo
-			ps = NewPlaylists(ds)
+			ps = core.NewPlaylists(ds)
 			mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/music"}, {ID: 2, Path: "/new"}})
 			ctx = request.WithUser(ctx, model.User{ID: "123"})
 		})
@@ -206,53 +424,6 @@ var _ = Describe("Playlists", func() {
 			Expect(pls.Tracks[0].Path).To(Equal("abc/tEsT1.Mp3"))
 		})
 
-		It("handles Unicode normalization when comparing paths", func() {
-			// Test case for Apple Music playlists that use NFC encoding vs macOS filesystem NFD
-			// The character "è" can be represented as NFC (single codepoint) or NFD (e + combining accent)
-
-			const pathWithAccents = "artist/Michèle Desrosiers/album/Noël.m4a"
-
-			// Simulate a database entry with NFD encoding (as stored by macOS filesystem)
-			nfdPath := norm.NFD.String(pathWithAccents)
-			repo.data = []string{nfdPath}
-
-			// Simulate an Apple Music M3U playlist entry with NFC encoding
-			nfcPath := norm.NFC.String("/music/" + pathWithAccents)
-			m3u := strings.Join([]string{
-				nfcPath,
-			}, "\n")
-			f := strings.NewReader(m3u)
-
-			pls, err := ps.ImportM3U(ctx, f)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(pls.Tracks).To(HaveLen(1), "Should find the track despite Unicode normalization differences")
-			Expect(pls.Tracks[0].Path).To(Equal(nfdPath))
-		})
-	})
-
-	Describe("normalizePathForComparison", func() {
-		It("normalizes Unicode characters to NFC form and converts to lowercase", func() {
-			// Test with NFD (decomposed) input - as would come from macOS filesystem
-			nfdPath := norm.NFD.String("Michèle") // Explicitly convert to NFD form
-			normalized := normalizePathForComparison(nfdPath)
-			Expect(normalized).To(Equal("michèle"))
-
-			// Test with NFC (composed) input - as would come from Apple Music M3U
-			nfcPath := "Michèle" // This might be in NFC form
-			normalizedNfc := normalizePathForComparison(nfcPath)
-
-			// Ensure the two paths are not equal in their original forms
-			Expect(nfdPath).ToNot(Equal(nfcPath))
-
-			// Both should normalize to the same result
-			Expect(normalized).To(Equal(normalizedNfc))
-		})
-
-		It("handles paths with mixed case and Unicode characters", func() {
-			path := "Artist/Noël Coward/Album/Song.mp3"
-			normalized := normalizePathForComparison(path)
-			Expect(normalized).To(Equal("artist/noël coward/album/song.mp3"))
-		})
 	})
 
 	Describe("InPlaylistsPath", func() {
@@ -269,27 +440,27 @@ var _ = Describe("Playlists", func() {
 
 		It("returns true if PlaylistsPath is empty", func() {
 			conf.Server.PlaylistsPath = ""
-			Expect(InPlaylistsPath(folder)).To(BeTrue())
+			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns true if PlaylistsPath is any (**/**)", func() {
 			conf.Server.PlaylistsPath = "**/**"
-			Expect(InPlaylistsPath(folder)).To(BeTrue())
+			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns true if folder is in PlaylistsPath", func() {
 			conf.Server.PlaylistsPath = "other/**:playlists/**"
-			Expect(InPlaylistsPath(folder)).To(BeTrue())
+			Expect(core.InPlaylistsPath(folder)).To(BeTrue())
 		})
 
 		It("returns false if folder is not in PlaylistsPath", func() {
 			conf.Server.PlaylistsPath = "other"
-			Expect(InPlaylistsPath(folder)).To(BeFalse())
+			Expect(core.InPlaylistsPath(folder)).To(BeFalse())
 		})
 
 		It("returns true if for a playlist in root of MusicFolder if PlaylistsPath is '.'", func() {
 			conf.Server.PlaylistsPath = "."
-			Expect(InPlaylistsPath(folder)).To(BeFalse())
+			Expect(core.InPlaylistsPath(folder)).To(BeFalse())
 
 			folder2 := model.Folder{
 				LibraryPath: "/music",
@@ -297,22 +468,47 @@ var _ = Describe("Playlists", func() {
 				Name:        ".",
 			}
 
-			Expect(InPlaylistsPath(folder2)).To(BeTrue())
+			Expect(core.InPlaylistsPath(folder2)).To(BeTrue())
 		})
 	})
 })
 
-// mockedMediaFileRepo's FindByPaths method returns a list of MediaFiles with the same paths as the input
+// mockedMediaFileRepo's FindByPaths method returns MediaFiles for the given paths.
+// If data map is provided, looks up files by key; otherwise creates them from paths.
 type mockedMediaFileRepo struct {
 	model.MediaFileRepository
+	data map[string]model.MediaFile
 }
 
 func (r *mockedMediaFileRepo) FindByPaths(paths []string) (model.MediaFiles, error) {
 	var mfs model.MediaFiles
+
+	// If data map provided, look up files
+	if r.data != nil {
+		for _, path := range paths {
+			if mf, ok := r.data[path]; ok {
+				mfs = append(mfs, mf)
+			}
+		}
+		return mfs, nil
+	}
+
+	// Otherwise, create MediaFiles from paths
 	for idx, path := range paths {
+		// Strip library qualifier if present (format: "libraryID:path")
+		actualPath := path
+		libraryID := 1
+		if parts := strings.SplitN(path, ":", 2); len(parts) == 2 {
+			if id, err := strconv.Atoi(parts[0]); err == nil {
+				libraryID = id
+				actualPath = parts[1]
+			}
+		}
+
 		mfs = append(mfs, model.MediaFile{
-			ID:   strconv.Itoa(idx),
-			Path: path,
+			ID:        strconv.Itoa(idx),
+			Path:      actualPath,
+			LibraryID: libraryID,
 		})
 	}
 	return mfs, nil
@@ -324,13 +520,31 @@ type mockedMediaFileFromListRepo struct {
 	data []string
 }
 
-func (r *mockedMediaFileFromListRepo) FindByPaths([]string) (model.MediaFiles, error) {
+func (r *mockedMediaFileFromListRepo) FindByPaths(paths []string) (model.MediaFiles, error) {
 	var mfs model.MediaFiles
-	for idx, path := range r.data {
-		mfs = append(mfs, model.MediaFile{
-			ID:   strconv.Itoa(idx),
-			Path: path,
-		})
+
+	for idx, dataPath := range r.data {
+		for _, requestPath := range paths {
+			// Strip library qualifier if present (format: "libraryID:path")
+			actualPath := requestPath
+			libraryID := 1
+			if parts := strings.SplitN(requestPath, ":", 2); len(parts) == 2 {
+				if id, err := strconv.Atoi(parts[0]); err == nil {
+					libraryID = id
+					actualPath = parts[1]
+				}
+			}
+
+			// Case-insensitive comparison (like SQL's "collate nocase")
+			if strings.EqualFold(actualPath, dataPath) {
+				mfs = append(mfs, model.MediaFile{
+					ID:        strconv.Itoa(idx),
+					Path:      dataPath,
+					LibraryID: libraryID,
+				})
+				break
+			}
+		}
 	}
 	return mfs, nil
 }

core/wire_providers.go

@@ -18,6 +18,7 @@ var Set = wire.NewSet(
 	NewShare,
 	NewPlaylists,
 	NewLibrary,
+	NewMaintenance,
 	agents.GetAgents,
 	external.NewProvider,
 	wire.Bind(new(external.Agents), new(*agents.Agents)),

go.mod

@@ -2,12 +2,8 @@ module github.com/navidrome/navidrome
 
 go 1.25.4
 
-replace (
-	// Fork to fix https://github.com/navidrome/navidrome/issues/3254
-	github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8 => github.com/deluan/tag v0.0.0-20241002021117-dfe5e6ea396d
-	// Using version from main that fixes https://github.com/navidrome/navidrome/issues/4396
-	github.com/tetratelabs/wazero v1.9.0 => github.com/tetratelabs/wazero v0.0.0-20251106165119-514cdb337684
-)
+// Fork to fix https://github.com/navidrome/navidrome/issues/3254
+replace github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8 => github.com/deluan/tag v0.0.0-20241002021117-dfe5e6ea396d
 
 require (
 	github.com/Masterminds/squirrel v1.5.4
@@ -43,6 +39,7 @@ require (
 	github.com/knqyf263/go-plugin v0.9.0
 	github.com/kr/pretty v0.3.1
 	github.com/lestrrat-go/jwx/v2 v2.1.6
+	github.com/maruel/natural v1.2.1
 	github.com/matoous/go-nanoid/v2 v2.1.0
 	github.com/mattn/go-sqlite3 v1.14.32
 	github.com/microcosm-cc/bluemonday v1.0.27
@@ -60,15 +57,15 @@ require (
 	github.com/spf13/cobra v1.10.1
 	github.com/spf13/viper v1.21.0
 	github.com/stretchr/testify v1.11.1
-	github.com/tetratelabs/wazero v1.9.0
+	github.com/tetratelabs/wazero v1.10.0
 	github.com/unrolled/secure v1.17.0
 	github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342
 	go.uber.org/goleak v1.3.0
 	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546
 	golang.org/x/image v0.32.0
 	golang.org/x/net v0.46.0
-	golang.org/x/sync v0.17.0
-	golang.org/x/sys v0.37.0
+	golang.org/x/sync v0.18.0
+	golang.org/x/sys v0.38.0
 	golang.org/x/text v0.30.0
 	golang.org/x/time v0.14.0
 	google.golang.org/protobuf v1.36.10

go.sum

@@ -162,8 +162,8 @@ github.com/lestrrat-go/jwx/v2 v2.1.6 h1:hxM1gfDILk/l5ylers6BX/Eq1m/pnxe9NBwW6lVf
 github.com/lestrrat-go/jwx/v2 v2.1.6/go.mod h1:Y722kU5r/8mV7fYDifjug0r8FK8mZdw0K0GpJw/l8pU=
 github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=
 github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
-github.com/maruel/natural v1.1.1 h1:Hja7XhhmvEFhcByqDoHz9QZbkWey+COd9xWfCfn1ioo=
-github.com/maruel/natural v1.1.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
+github.com/maruel/natural v1.2.1 h1:G/y4pwtTA07lbQsMefvsmEO0VN0NfqpxprxXDM4R/4o=
+github.com/maruel/natural v1.2.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
 github.com/matoous/go-nanoid/v2 v2.1.0 h1:P64+dmq21hhWdtvZfEAofnvJULaRR1Yib0+PnU669bE=
 github.com/matoous/go-nanoid/v2 v2.1.0/go.mod h1:KlbGNQ+FhrUNIHUxZdL63t7tl4LaPkZNpUULS8H4uVM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -265,8 +265,8 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-github.com/tetratelabs/wazero v0.0.0-20251106165119-514cdb337684 h1:ugT1JTRsK1Jhn95BWilCugyZ1Svsyxm9xSiflOa2e7E=
-github.com/tetratelabs/wazero v0.0.0-20251106165119-514cdb337684/go.mod h1:DRm5twOQ5Gr1AoEdSi0CLjDQF1J9ZAuyqFIjl1KKfQU=
+github.com/tetratelabs/wazero v1.10.0 h1:CXP3zneLDl6J4Zy8N/J+d5JsWKfrjE6GtvVK1fpnDlk=
+github.com/tetratelabs/wazero v1.10.0/go.mod h1:DRm5twOQ5Gr1AoEdSi0CLjDQF1J9ZAuyqFIjl1KKfQU=
 github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
 github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
 github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
@@ -332,8 +332,8 @@ golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
-golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180926160741-c2ed4eda69e7/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -350,8 +350,8 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
-golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8 h1:LvzTn0GQhWuvKH/kVRS3R3bVAsdQWI7hvfLHGgh9+lU=
 golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8/go.mod h1:Pi4ztBfryZoJEkyFTI5/Ocsu2jXyDr6iSdgJiYE/uwE=

log/log.go

@@ -11,6 +11,7 @@ import (
 	"runtime"
 	"sort"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/sirupsen/logrus"
@@ -70,6 +71,7 @@ type levelPath struct {
 
 var (
 	currentLevel  Level
+	loggerMu      sync.RWMutex
 	defaultLogger = logrus.New()
 	logSourceLine = false
 	rootPath      string
@@ -78,8 +80,10 @@ var (
 
 // SetLevel sets the global log level used by the simple logger.
 func SetLevel(l Level) {
+	loggerMu.Lock()
 	currentLevel = l
 	defaultLogger.Level = logrus.TraceLevel
+	loggerMu.Unlock()
 	logrus.SetLevel(logrus.Level(l))
 }
 
@@ -110,6 +114,8 @@ func levelFromString(l string) Level {
 
 // SetLogLevels sets the log levels for specific paths in the codebase.
 func SetLogLevels(levels map[string]string) {
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
 	logLevels = nil
 	for k, v := range levels {
 		logLevels = append(logLevels, levelPath{path: k, level: levelFromString(v)})
@@ -125,6 +131,8 @@ func SetLogSourceLine(enabled bool) {
 
 func SetRedacting(enabled bool) {
 	if enabled {
+		loggerMu.Lock()
+		defer loggerMu.Unlock()
 		defaultLogger.AddHook(redacted)
 	}
 }
@@ -133,6 +141,8 @@ func SetOutput(w io.Writer) {
 	if runtime.GOOS == "windows" {
 		w = CRLFWriter(w)
 	}
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
 	defaultLogger.SetOutput(w)
 }
 
@@ -158,10 +168,14 @@ func NewContext(ctx context.Context, keyValuePairs ...interface{}) context.Conte
 }
 
 func SetDefaultLogger(l *logrus.Logger) {
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
 	defaultLogger = l
 }
 
 func CurrentLevel() Level {
+	loggerMu.RLock()
+	defer loggerMu.RUnlock()
 	return currentLevel
 }
 
@@ -204,14 +218,21 @@ func log(level Level, args ...interface{}) {
 }
 
 func Writer() io.Writer {
+	loggerMu.RLock()
+	defer loggerMu.RUnlock()
 	return defaultLogger.Writer()
 }
 
 func shouldLog(requiredLevel Level, skip int) bool {
-	if currentLevel >= requiredLevel {
+	loggerMu.RLock()
+	level := currentLevel
+	levels := logLevels
+	loggerMu.RUnlock()
+
+	if level >= requiredLevel {
 		return true
 	}
-	if len(logLevels) == 0 {
+	if len(levels) == 0 {
 		return false
 	}
 
@@ -221,7 +242,7 @@ func shouldLog(requiredLevel Level, skip int) bool {
 	}
 
 	file = strings.TrimPrefix(file, rootPath)
-	for _, lp := range logLevels {
+	for _, lp := range levels {
 		if strings.HasPrefix(file, lp.path) {
 			return lp.level >= requiredLevel
 		}
@@ -314,6 +335,8 @@ func extractLogger(ctx interface{}) (*logrus.Entry, error) {
 func createNewLogger() *logrus.Entry {
 	//logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true, DisableTimestamp: false, FullTimestamp: true})
 	//l.Formatter = &logrus.TextFormatter{ForceColors: true, DisableTimestamp: false, FullTimestamp: true}
+	loggerMu.RLock()
+	defer loggerMu.RUnlock()
 	logger := logrus.NewEntry(defaultLogger)
 	return logger
 }

model/datastore.go

@@ -43,5 +43,5 @@ type DataStore interface {
 
 	WithTx(block func(tx DataStore) error, scope ...string) error
 	WithTxImmediate(block func(tx DataStore) error, scope ...string) error
-	GC(ctx context.Context) error
+	GC(ctx context.Context, libraryIDs ...int) error
 }

model/folder.go

@@ -85,7 +85,7 @@ type FolderRepository interface {
 	GetByPath(lib Library, path string) (*Folder, error)
 	GetAll(...QueryOptions) ([]Folder, error)
 	CountAll(...QueryOptions) (int64, error)
-	GetLastUpdates(lib Library) (map[string]FolderUpdateInfo, error)
+	GetFolderUpdateInfo(lib Library, targetPaths ...string) (map[string]FolderUpdateInfo, error)
 	Put(*Folder) error
 	MarkMissing(missing bool, ids ...string) error
 	GetTouchedWithPlaylists() (FolderCursor, error)

model/metadata/legacy_ids.go

@@ -23,7 +23,7 @@ func legacyTrackID(mf model.MediaFile, prependLibId bool) string {
 }
 
 func legacyAlbumID(mf model.MediaFile, md Metadata, prependLibId bool) string {
-	releaseDate := legacyReleaseDate(md)
+	_, _, releaseDate := md.mapDates()
 	albumPath := strings.ToLower(fmt.Sprintf("%s\\%s", legacyMapAlbumArtistName(md), legacyMapAlbumName(md)))
 	if !conf.Server.Scanner.GroupAlbumReleases {
 		if len(releaseDate) != 0 {
@@ -55,9 +55,3 @@ func legacyMapAlbumName(md Metadata) string {
 		consts.UnknownAlbum,
 	)
 }
-
-// Keep the TaggedLikePicard logic for backwards compatibility
-func legacyReleaseDate(md Metadata) string {
-	_, _, releaseDate := md.mapDates()
-	return string(releaseDate)
-}

model/metadata/legacy_ids_test.go

@@ -1,30 +0,0 @@
-package metadata
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("legacyReleaseDate", func() {
-
-	DescribeTable("legacyReleaseDate",
-		func(recordingDate, originalDate, releaseDate, expected string) {
-			md := New("", Info{
-				Tags: map[string][]string{
-					"DATE":         {recordingDate},
-					"ORIGINALDATE": {originalDate},
-					"RELEASEDATE":  {releaseDate},
-				},
-			})
-
-			result := legacyReleaseDate(md)
-			Expect(result).To(Equal(expected))
-		},
-		Entry("regular mapping", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
-		Entry("legacy mapping", "2020-05-15", "2019-02-10", "", "2020-05-15"),
-		Entry("legacy mapping, originalYear < year", "2018-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
-		Entry("legacy mapping, originalYear empty", "2020-05-15", "", "2021-01-01", "2021-01-01"),
-		Entry("legacy mapping, releaseYear", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
-		Entry("legacy mapping, same dates", "2020-05-15", "2020-05-15", "", "2020-05-15"),
-	)
-})

model/metadata/map_mediafile_test.go

@@ -75,6 +75,23 @@ var _ = Describe("ToMediaFile", func() {
 			Expect(mf.OriginalYear).To(Equal(1966))
 			Expect(mf.ReleaseYear).To(Equal(2014))
 		})
+		DescribeTable("legacyReleaseDate (TaggedLikePicard old behavior)",
+			func(recordingDate, originalDate, releaseDate, expected string) {
+				mf := toMediaFile(model.RawTags{
+					"DATE":         {recordingDate},
+					"ORIGINALDATE": {originalDate},
+					"RELEASEDATE":  {releaseDate},
+				})
+
+				Expect(mf.ReleaseDate).To(Equal(expected))
+			},
+			Entry("regular mapping", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
+			Entry("legacy mapping", "2020-05-15", "2019-02-10", "", "2020-05-15"),
+			Entry("legacy mapping, originalYear < year", "2018-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
+			Entry("legacy mapping, originalYear empty", "2020-05-15", "", "2021-01-01", "2021-01-01"),
+			Entry("legacy mapping, releaseYear", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
+			Entry("legacy mapping, same dates", "2020-05-15", "2020-05-15", "", "2020-05-15"),
+		)
 	})
 
 	Describe("Lyrics", func() {

model/scanner.go

@@ -0,0 +1,81 @@
+package model
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// ScanTarget represents a specific folder within a library to be scanned.
+// NOTE: This struct is used as a map key, so it should only contain comparable types.
+type ScanTarget struct {
+	LibraryID  int
+	FolderPath string // Relative path within the library, or "" for entire library
+}
+
+func (st ScanTarget) String() string {
+	return fmt.Sprintf("%d:%s", st.LibraryID, st.FolderPath)
+}
+
+// ScannerStatus holds information about the current scan status
+type ScannerStatus struct {
+	Scanning    bool
+	LastScan    time.Time
+	Count       uint32
+	FolderCount uint32
+	LastError   string
+	ScanType    string
+	ElapsedTime time.Duration
+}
+
+type Scanner interface {
+	// ScanAll starts a scan of all libraries. This is a blocking operation.
+	ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
+	// ScanFolders scans specific library/folder pairs, recursing into subdirectories.
+	// If targets is nil, it scans all libraries. This is a blocking operation.
+	ScanFolders(ctx context.Context, fullScan bool, targets []ScanTarget) (warnings []string, err error)
+	Status(context.Context) (*ScannerStatus, error)
+}
+
+// ParseTargets parses scan targets strings into ScanTarget structs.
+// Example: []string{"1:Music/Rock", "2:Classical"}
+func ParseTargets(libFolders []string) ([]ScanTarget, error) {
+	targets := make([]ScanTarget, 0, len(libFolders))
+
+	for _, part := range libFolders {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+
+		// Split by the first colon
+		colonIdx := strings.Index(part, ":")
+		if colonIdx == -1 {
+			return nil, fmt.Errorf("invalid target format: %q (expected libraryID:folderPath)", part)
+		}
+
+		libIDStr := part[:colonIdx]
+		folderPath := part[colonIdx+1:]
+
+		libID, err := strconv.Atoi(libIDStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid library ID %q: %w", libIDStr, err)
+		}
+		if libID <= 0 {
+			return nil, fmt.Errorf("invalid library ID %q", libIDStr)
+		}
+
+		targets = append(targets, ScanTarget{
+			LibraryID:  libID,
+			FolderPath: folderPath,
+		})
+	}
+
+	if len(targets) == 0 {
+		return nil, fmt.Errorf("no valid targets found")
+	}
+
+	return targets, nil
+}

model/scanner_test.go

@@ -0,0 +1,89 @@
+package model_test
+
+import (
+	"github.com/navidrome/navidrome/model"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ParseTargets", func() {
+	It("parses multiple entries in slice", func() {
+		targets, err := model.ParseTargets([]string{"1:Music/Rock", "1:Music/Jazz", "2:Classical"})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(targets).To(HaveLen(3))
+		Expect(targets[0].LibraryID).To(Equal(1))
+		Expect(targets[0].FolderPath).To(Equal("Music/Rock"))
+		Expect(targets[1].LibraryID).To(Equal(1))
+		Expect(targets[1].FolderPath).To(Equal("Music/Jazz"))
+		Expect(targets[2].LibraryID).To(Equal(2))
+		Expect(targets[2].FolderPath).To(Equal("Classical"))
+	})
+
+	It("handles empty folder paths", func() {
+		targets, err := model.ParseTargets([]string{"1:", "2:"})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(targets).To(HaveLen(2))
+		Expect(targets[0].FolderPath).To(Equal(""))
+		Expect(targets[1].FolderPath).To(Equal(""))
+	})
+
+	It("trims whitespace from entries", func() {
+		targets, err := model.ParseTargets([]string{"  1:Music/Rock", " 2:Classical "})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(targets).To(HaveLen(2))
+		Expect(targets[0].LibraryID).To(Equal(1))
+		Expect(targets[0].FolderPath).To(Equal("Music/Rock"))
+		Expect(targets[1].LibraryID).To(Equal(2))
+		Expect(targets[1].FolderPath).To(Equal("Classical"))
+	})
+
+	It("skips empty strings", func() {
+		targets, err := model.ParseTargets([]string{"1:Music/Rock", "", "2:Classical"})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(targets).To(HaveLen(2))
+	})
+
+	It("handles paths with colons", func() {
+		targets, err := model.ParseTargets([]string{"1:C:/Music/Rock", "2:/path:with:colons"})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(targets).To(HaveLen(2))
+		Expect(targets[0].FolderPath).To(Equal("C:/Music/Rock"))
+		Expect(targets[1].FolderPath).To(Equal("/path:with:colons"))
+	})
+
+	It("returns error for invalid format without colon", func() {
+		_, err := model.ParseTargets([]string{"1Music/Rock"})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("invalid target format"))
+	})
+
+	It("returns error for non-numeric library ID", func() {
+		_, err := model.ParseTargets([]string{"abc:Music/Rock"})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("invalid library ID"))
+	})
+
+	It("returns error for negative library ID", func() {
+		_, err := model.ParseTargets([]string{"-1:Music/Rock"})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("invalid library ID"))
+	})
+
+	It("returns error for zero library ID", func() {
+		_, err := model.ParseTargets([]string{"0:Music/Rock"})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("invalid library ID"))
+	})
+
+	It("returns error for empty input", func() {
+		_, err := model.ParseTargets([]string{})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("no valid targets found"))
+	})
+
+	It("returns error for all empty strings", func() {
+		_, err := model.ParseTargets([]string{"", "  ", ""})
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("no valid targets found"))
+	})
+})

persistence/album_repository.go

@@ -337,8 +337,12 @@ on conflict (user_id, item_id, item_type) do update
 	return r.executeSQL(query)
 }
 
-func (r *albumRepository) purgeEmpty() error {
+func (r *albumRepository) purgeEmpty(libraryIDs ...int) error {
 	del := Delete(r.tableName).Where("id not in (select distinct(album_id) from media_file)")
+	// If libraryIDs are specified, only purge albums from those libraries
+	if len(libraryIDs) > 0 {
+		del = del.Where(Eq{"library_id": libraryIDs})
+	}
 	c, err := r.executeSQL(del)
 	if err != nil {
 		return fmt.Errorf("purging empty albums: %w", err)

persistence/folder_repository.go

@@ -4,7 +4,10 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
+	"path/filepath"
 	"slices"
+	"strings"
 	"time"
 
 	. "github.com/Masterminds/squirrel"
@@ -91,8 +94,47 @@ func (r folderRepository) CountAll(opt ...model.QueryOptions) (int64, error) {
 	return r.count(query)
 }
 
-func (r folderRepository) GetLastUpdates(lib model.Library) (map[string]model.FolderUpdateInfo, error) {
-	sq := r.newSelect().Columns("id", "updated_at", "hash").Where(Eq{"library_id": lib.ID, "missing": false})
+func (r folderRepository) GetFolderUpdateInfo(lib model.Library, targetPaths ...string) (map[string]model.FolderUpdateInfo, error) {
+	where := And{
+		Eq{"library_id": lib.ID},
+		Eq{"missing": false},
+	}
+
+	// If specific paths are requested, include those folders and all their descendants
+	if len(targetPaths) > 0 {
+		// Collect folder IDs for exact target folders and path conditions for descendants
+		folderIDs := make([]string, 0, len(targetPaths))
+		pathConditions := make(Or, 0, len(targetPaths)*2)
+
+		for _, targetPath := range targetPaths {
+			if targetPath == "" || targetPath == "." {
+				// Root path - include everything in this library
+				pathConditions = Or{}
+				folderIDs = nil
+				break
+			}
+			// Clean the path to normalize it. Paths stored in the folder table do not have leading/trailing slashes.
+			cleanPath := strings.TrimPrefix(targetPath, string(os.PathSeparator))
+			cleanPath = filepath.Clean(cleanPath)
+
+			// Include the target folder itself by ID
+			folderIDs = append(folderIDs, model.FolderID(lib, cleanPath))
+
+			// Include all descendants: folders whose path field equals or starts with the target path
+			// Note: Folder.Path is the directory path, so children have path = targetPath
+			pathConditions = append(pathConditions, Eq{"path": cleanPath})
+			pathConditions = append(pathConditions, Like{"path": cleanPath + "/%"})
+		}
+
+		// Combine conditions: exact folder IDs OR descendant path patterns
+		if len(folderIDs) > 0 {
+			where = append(where, Or{Eq{"id": folderIDs}, pathConditions})
+		} else if len(pathConditions) > 0 {
+			where = append(where, pathConditions)
+		}
+	}
+
+	sq := r.newSelect().Columns("id", "updated_at", "hash").Where(where)
 	var res []struct {
 		ID        string
 		UpdatedAt time.Time
@@ -149,7 +191,7 @@ func (r folderRepository) GetTouchedWithPlaylists() (model.FolderCursor, error)
 	}, nil
 }
 
-func (r folderRepository) purgeEmpty() error {
+func (r folderRepository) purgeEmpty(libraryIDs ...int) error {
 	sq := Delete(r.tableName).Where(And{
 		Eq{"num_audio_files": 0},
 		Eq{"num_playlists": 0},
@@ -157,6 +199,10 @@ func (r folderRepository) purgeEmpty() error {
 		ConcatExpr("id not in (select parent_id from folder)"),
 		ConcatExpr("id not in (select folder_id from media_file)"),
 	})
+	// If libraryIDs are specified, only purge folders from those libraries
+	if len(libraryIDs) > 0 {
+		sq = sq.Where(Eq{"library_id": libraryIDs})
+	}
 	c, err := r.executeSQL(sq)
 	if err != nil {
 		return fmt.Errorf("purging empty folders: %w", err)

persistence/folder_repository_test.go

@@ -0,0 +1,213 @@
+package persistence
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/pocketbase/dbx"
+)
+
+var _ = Describe("FolderRepository", func() {
+	var repo model.FolderRepository
+	var ctx context.Context
+	var conn *dbx.DB
+	var testLib, otherLib model.Library
+
+	BeforeEach(func() {
+		ctx = request.WithUser(log.NewContext(context.TODO()), model.User{ID: "userid"})
+		conn = GetDBXBuilder()
+		repo = newFolderRepository(ctx, conn)
+
+		// Use existing library ID 1 from test fixtures
+		libRepo := NewLibraryRepository(ctx, conn)
+		lib, err := libRepo.Get(1)
+		Expect(err).ToNot(HaveOccurred())
+		testLib = *lib
+
+		// Create a second library with its own folder to verify isolation
+		otherLib = model.Library{Name: "Other Library", Path: "/other/path"}
+		Expect(libRepo.Put(&otherLib)).To(Succeed())
+	})
+
+	AfterEach(func() {
+		// Clean up only test folders created by our tests (paths starting with "Test")
+		// This prevents interference with fixture data needed by other tests
+		_, _ = conn.NewQuery("DELETE FROM folder WHERE library_id = 1 AND path LIKE 'Test%'").Execute()
+		_, _ = conn.NewQuery(fmt.Sprintf("DELETE FROM library WHERE id = %d", otherLib.ID)).Execute()
+	})
+
+	Describe("GetFolderUpdateInfo", func() {
+		Context("with no target paths", func() {
+			It("returns all folders in the library", func() {
+				// Create test folders with unique names to avoid conflicts
+				folder1 := model.NewFolder(testLib, "TestGetLastUpdates/Folder1")
+				folder2 := model.NewFolder(testLib, "TestGetLastUpdates/Folder2")
+
+				err := repo.Put(folder1)
+				Expect(err).ToNot(HaveOccurred())
+				err = repo.Put(folder2)
+				Expect(err).ToNot(HaveOccurred())
+
+				otherFolder := model.NewFolder(otherLib, "TestOtherLib/Folder")
+				err = repo.Put(otherFolder)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Query all folders (no target paths) - should only return folders from testLib
+				results, err := repo.GetFolderUpdateInfo(testLib)
+				Expect(err).ToNot(HaveOccurred())
+				// Should include folders from testLib
+				Expect(results).To(HaveKey(folder1.ID))
+				Expect(results).To(HaveKey(folder2.ID))
+				// Should NOT include folders from other library
+				Expect(results).ToNot(HaveKey(otherFolder.ID))
+			})
+		})
+
+		Context("with specific target paths", func() {
+			It("returns folder info for existing folders", func() {
+				// Create test folders with unique names
+				folder1 := model.NewFolder(testLib, "TestSpecific/Rock")
+				folder2 := model.NewFolder(testLib, "TestSpecific/Jazz")
+				folder3 := model.NewFolder(testLib, "TestSpecific/Classical")
+
+				err := repo.Put(folder1)
+				Expect(err).ToNot(HaveOccurred())
+				err = repo.Put(folder2)
+				Expect(err).ToNot(HaveOccurred())
+				err = repo.Put(folder3)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Query specific paths
+				results, err := repo.GetFolderUpdateInfo(testLib, "TestSpecific/Rock", "TestSpecific/Classical")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(results).To(HaveLen(2))
+
+				// Verify folder IDs are in results
+				Expect(results).To(HaveKey(folder1.ID))
+				Expect(results).To(HaveKey(folder3.ID))
+				Expect(results).ToNot(HaveKey(folder2.ID))
+
+				// Verify update info is populated
+				Expect(results[folder1.ID].UpdatedAt).ToNot(BeZero())
+				Expect(results[folder1.ID].Hash).To(Equal(folder1.Hash))
+			})
+
+			It("includes all child folders when querying parent", func() {
+				// Create a parent folder with multiple children
+				parent := model.NewFolder(testLib, "TestParent/Music")
+				child1 := model.NewFolder(testLib, "TestParent/Music/Rock/Queen")
+				child2 := model.NewFolder(testLib, "TestParent/Music/Jazz")
+				otherParent := model.NewFolder(testLib, "TestParent2/Music/Jazz")
+
+				Expect(repo.Put(parent)).To(Succeed())
+				Expect(repo.Put(child1)).To(Succeed())
+				Expect(repo.Put(child2)).To(Succeed())
+
+				// Query the parent folder - should return parent and all children
+				results, err := repo.GetFolderUpdateInfo(testLib, "TestParent/Music")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(results).To(HaveLen(3))
+				Expect(results).To(HaveKey(parent.ID))
+				Expect(results).To(HaveKey(child1.ID))
+				Expect(results).To(HaveKey(child2.ID))
+				Expect(results).ToNot(HaveKey(otherParent.ID))
+			})
+
+			It("excludes children from other libraries", func() {
+				// Create parent in testLib
+				parent := model.NewFolder(testLib, "TestIsolation/Parent")
+				child := model.NewFolder(testLib, "TestIsolation/Parent/Child")
+
+				Expect(repo.Put(parent)).To(Succeed())
+				Expect(repo.Put(child)).To(Succeed())
+
+				// Create similar path in other library
+				otherParent := model.NewFolder(otherLib, "TestIsolation/Parent")
+				otherChild := model.NewFolder(otherLib, "TestIsolation/Parent/Child")
+
+				Expect(repo.Put(otherParent)).To(Succeed())
+				Expect(repo.Put(otherChild)).To(Succeed())
+
+				// Query should only return folders from testLib
+				results, err := repo.GetFolderUpdateInfo(testLib, "TestIsolation/Parent")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(results).To(HaveLen(2))
+				Expect(results).To(HaveKey(parent.ID))
+				Expect(results).To(HaveKey(child.ID))
+				Expect(results).ToNot(HaveKey(otherParent.ID))
+				Expect(results).ToNot(HaveKey(otherChild.ID))
+			})
+
+			It("excludes missing children when querying parent", func() {
+				// Create parent and children, mark one as missing
+				parent := model.NewFolder(testLib, "TestMissingChild/Parent")
+				child1 := model.NewFolder(testLib, "TestMissingChild/Parent/Child1")
+				child2 := model.NewFolder(testLib, "TestMissingChild/Parent/Child2")
+				child2.Missing = true
+
+				Expect(repo.Put(parent)).To(Succeed())
+				Expect(repo.Put(child1)).To(Succeed())
+				Expect(repo.Put(child2)).To(Succeed())
+
+				// Query parent - should only return parent and non-missing child
+				results, err := repo.GetFolderUpdateInfo(testLib, "TestMissingChild/Parent")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(results).To(HaveLen(2))
+				Expect(results).To(HaveKey(parent.ID))
+				Expect(results).To(HaveKey(child1.ID))
+				Expect(results).ToNot(HaveKey(child2.ID))
+			})
+
+			It("handles mix of existing and non-existing target paths", func() {
+				// Create folders for one path but not the other
+				existingParent := model.NewFolder(testLib, "TestMixed/Exists")
+				existingChild := model.NewFolder(testLib, "TestMixed/Exists/Child")
+
+				Expect(repo.Put(existingParent)).To(Succeed())
+				Expect(repo.Put(existingChild)).To(Succeed())
+
+				// Query both existing and non-existing paths
+				results, err := repo.GetFolderUpdateInfo(testLib, "TestMixed/Exists", "TestMixed/DoesNotExist")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(results).To(HaveLen(2))
+				Expect(results).To(HaveKey(existingParent.ID))
+				Expect(results).To(HaveKey(existingChild.ID))
+			})
+
+			It("handles empty folder path as root", func() {
+				// Test querying for root folder without creating it (fixtures should have one)
+				rootFolderID := model.FolderID(testLib, ".")
+
+				results, err := repo.GetFolderUpdateInfo(testLib, "")
+				Expect(err).ToNot(HaveOccurred())
+				// Should return the root folder if it exists
+				if len(results) > 0 {
+					Expect(results).To(HaveKey(rootFolderID))
+				}
+			})
+
+			It("returns empty map for non-existent folders", func() {
+				results, err := repo.GetFolderUpdateInfo(testLib, "NonExistent/Path")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(results).To(BeEmpty())
+			})
+
+			It("skips missing folders", func() {
+				// Create a folder and mark it as missing
+				folder := model.NewFolder(testLib, "TestMissing/Folder")
+				folder.Missing = true
+				err := repo.Put(folder)
+				Expect(err).ToNot(HaveOccurred())
+
+				results, err := repo.GetFolderUpdateInfo(testLib, "TestMissing/Folder")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(results).To(BeEmpty())
+			})
+		})
+	})
+})

persistence/library_repository.go

@@ -177,7 +177,9 @@ func (r *libraryRepository) ScanEnd(id int) error {
 		return err
 	}
 	// https://www.sqlite.org/pragma.html#pragma_optimize
-	_, err = r.executeSQL(Expr("PRAGMA optimize=0x10012;"))
+	// Use mask 0x10000 to check table sizes without running ANALYZE
+	// Running ANALYZE can cause query planner issues with expression-based collation indexes
+	_, err = r.executeSQL(Expr("PRAGMA optimize=0x10000;"))
 	return err
 }
 

persistence/library_repository_test.go

@@ -142,4 +142,62 @@ var _ = Describe("LibraryRepository", func() {
 		Expect(libAfter.TotalSize).To(Equal(sizeRes.Sum))
 		Expect(libAfter.TotalDuration).To(Equal(durationRes.Sum))
 	})
+
+	Describe("ScanBegin and ScanEnd", func() {
+		var lib *model.Library
+
+		BeforeEach(func() {
+			lib = &model.Library{
+				ID:   0,
+				Name: "Test Scan Library",
+				Path: "/music/test-scan",
+			}
+			err := repo.Put(lib)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		DescribeTable("ScanBegin",
+			func(fullScan bool, expectedFullScanInProgress bool) {
+				err := repo.ScanBegin(lib.ID, fullScan)
+				Expect(err).ToNot(HaveOccurred())
+
+				updatedLib, err := repo.Get(lib.ID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(updatedLib.LastScanStartedAt).ToNot(BeZero())
+				Expect(updatedLib.FullScanInProgress).To(Equal(expectedFullScanInProgress))
+			},
+			Entry("sets FullScanInProgress to true for full scan", true, true),
+			Entry("sets FullScanInProgress to false for quick scan", false, false),
+		)
+
+		Context("ScanEnd", func() {
+			BeforeEach(func() {
+				err := repo.ScanBegin(lib.ID, true)
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("sets LastScanAt and clears FullScanInProgress and LastScanStartedAt", func() {
+				err := repo.ScanEnd(lib.ID)
+				Expect(err).ToNot(HaveOccurred())
+
+				updatedLib, err := repo.Get(lib.ID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(updatedLib.LastScanAt).ToNot(BeZero())
+				Expect(updatedLib.FullScanInProgress).To(BeFalse())
+				Expect(updatedLib.LastScanStartedAt).To(BeZero())
+			})
+
+			It("sets LastScanAt to be after LastScanStartedAt", func() {
+				libBefore, err := repo.Get(lib.ID)
+				Expect(err).ToNot(HaveOccurred())
+
+				err = repo.ScanEnd(lib.ID)
+				Expect(err).ToNot(HaveOccurred())
+
+				libAfter, err := repo.Get(lib.ID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(libAfter.LastScanAt).To(BeTemporally(">=", libBefore.LastScanStartedAt))
+			})
+		})
+	})
 })

persistence/mediafile_repository.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"slices"
+	"strconv"
+	"strings"
 	"sync"
 	"time"
 
@@ -192,12 +194,43 @@ func (r *mediaFileRepository) GetCursor(options ...model.QueryOptions) (model.Me
 	}, nil
 }
 
+// FindByPaths finds media files by their paths.
+// The paths can be library-qualified (format: "libraryID:path") or unqualified ("path").
+// Library-qualified paths search within the specified library, while unqualified paths
+// search across all libraries for backward compatibility.
 func (r *mediaFileRepository) FindByPaths(paths []string) (model.MediaFiles, error) {
-	sel := r.newSelect().Columns("*").Where(Eq{"path collate nocase": paths})
+	query := Or{}
+
+	for _, path := range paths {
+		parts := strings.SplitN(path, ":", 2)
+		if len(parts) == 2 {
+			// Library-qualified path: "libraryID:path"
+			libraryID, err := strconv.Atoi(parts[0])
+			if err != nil {
+				// Invalid format, skip
+				continue
+			}
+			relativePath := parts[1]
+			query = append(query, And{
+				Eq{"path collate nocase": relativePath},
+				Eq{"library_id": libraryID},
+			})
+		} else {
+			// Unqualified path: search across all libraries
+			query = append(query, Eq{"path collate nocase": path})
+		}
+	}
+
+	if len(query) == 0 {
+		return model.MediaFiles{}, nil
+	}
+
+	sel := r.newSelect().Columns("*").Where(query)
 	var res dbMediaFiles
 	if err := r.queryAll(sel, &res); err != nil {
 		return nil, err
 	}
+
 	return res.toModels(), nil
 }
 

persistence/persistence.go

@@ -157,7 +157,7 @@ func (s *SQLStore) WithTxImmediate(block func(tx model.DataStore) error, scope .
 	}, scope...)
 }
 
-func (s *SQLStore) GC(ctx context.Context) error {
+func (s *SQLStore) GC(ctx context.Context, libraryIDs ...int) error {
 	trace := func(ctx context.Context, msg string, f func() error) func() error {
 		return func() error {
 			start := time.Now()
@@ -167,11 +167,17 @@ func (s *SQLStore) GC(ctx context.Context) error {
 		}
 	}
 
+	// If libraryIDs are provided, scope operations to those libraries where possible
+	scoped := len(libraryIDs) > 0
+	if scoped {
+		log.Debug(ctx, "GC: Running selective garbage collection", "libraryIDs", libraryIDs)
+	}
+
 	err := run.Sequentially(
-		trace(ctx, "purge empty albums", func() error { return s.Album(ctx).(*albumRepository).purgeEmpty() }),
+		trace(ctx, "purge empty albums", func() error { return s.Album(ctx).(*albumRepository).purgeEmpty(libraryIDs...) }),
 		trace(ctx, "purge empty artists", func() error { return s.Artist(ctx).(*artistRepository).purgeEmpty() }),
 		trace(ctx, "mark missing artists", func() error { return s.Artist(ctx).(*artistRepository).markMissing() }),
-		trace(ctx, "purge empty folders", func() error { return s.Folder(ctx).(*folderRepository).purgeEmpty() }),
+		trace(ctx, "purge empty folders", func() error { return s.Folder(ctx).(*folderRepository).purgeEmpty(libraryIDs...) }),
 		trace(ctx, "clean album annotations", func() error { return s.Album(ctx).(*albumRepository).cleanAnnotations() }),
 		trace(ctx, "clean artist annotations", func() error { return s.Artist(ctx).(*artistRepository).cleanAnnotations() }),
 		trace(ctx, "clean media file annotations", func() error { return s.MediaFile(ctx).(*mediaFileRepository).cleanAnnotations() }),

release/goreleaser.yml

@@ -83,6 +83,15 @@ nfpms:
           owner: navidrome
           group: navidrome
 
+      - src: release/linux/.package.rpm  # contents: "rpm"
+        dst: /var/lib/navidrome/.package
+        type: "config|noreplace"
+        packager: rpm
+      - src: release/linux/.package.deb  # contents: "deb"
+        dst: /var/lib/navidrome/.package
+        type: "config|noreplace"
+        packager: deb
+
     scripts:
       preinstall: "release/linux/preinstall.sh"
       postinstall: "release/linux/postinstall.sh"

release/linux/.package.deb

@@ -0,0 +1 @@
+deb

release/linux/.package.rpm

@@ -0,0 +1 @@
+rpm

release/wix/build_msi.sh

@@ -49,6 +49,9 @@ cp "${DOWNLOAD_FOLDER}"/extracted_ffmpeg/${FFMPEG_FILE}/bin/ffmpeg.exe "$MSI_OUT
 cp "$WORKSPACE"/LICENSE "$WORKSPACE"/README.md "$MSI_OUTPUT_DIR"
 cp "$BINARY" "$MSI_OUTPUT_DIR"
 
+# package type indicator file
+echo "msi" > "$MSI_OUTPUT_DIR/.package"
+
 # workaround for wixl WixVariable not working to override bmp locations
 cp "$WORKSPACE"/release/wix/bmp/banner.bmp /usr/share/wixl-*/ext/ui/bitmaps/bannrbmp.bmp
 cp "$WORKSPACE"/release/wix/bmp/dialogue.bmp /usr/share/wixl-*/ext/ui/bitmaps/dlgbmp.bmp

release/wix/navidrome.wxs

@@ -69,6 +69,12 @@
 
 				</Directory>
 			</Directory>
+
+			<Directory Id="ND_DATAFOLDER" name="[ND_DATAFOLDER]">
+				<Component Id='PackageFile' Guid='9eec0697-803c-4629-858f-20dc376c960b' Win64="$(var.Win64)">
+					<File Id='package' Name='.package' DiskId='1' Source='.package' KeyPath='no' />
+				</Component>
+			</Directory>
 		</Directory>
 
 		<InstallUISequence>
@@ -81,6 +87,7 @@
 			<ComponentRef Id='Configuration'/>
 			<ComponentRef Id='MainExecutable' />
 			<ComponentRef Id='FFMpegExecutable' />
+			<ComponentRef Id='PackageFile' />
 		</Feature>
 	</Product>
 </Wix>

resources/i18n/gl.json

@@ -31,8 +31,12 @@
         "mood": "Estado",
         "participants": "Participantes adicionais",
         "tags": "Etiquetas adicionais",
-        "mappedTags": "",
-        "rawTags": "Etiquetas en cru"
+        "mappedTags": "Etiquetas mapeadas",
+        "rawTags": "Etiquetas en cru",
+        "bitDepth": "Calidade de Bit",
+        "sampleRate": "Taxa de mostra",
+        "missing": "Falta",
+        "libraryName": "Biblioteca"
       },
       "actions": {
         "addToQueue": "Ao final da cola",
@@ -41,7 +45,8 @@
         "shuffleAll": "Remexer todo",
         "download": "Descargar",
         "playNext": "A continuación",
-        "info": "Obter info"
+        "info": "Obter info",
+        "showInPlaylist": "Mostrar en Lista de reprodución"
       }
     },
     "album": {
@@ -70,7 +75,10 @@
         "releaseType": "Tipo",
         "grouping": "Grupos",
         "media": "Multimedia",
-        "mood": "Estado"
+        "mood": "Estado",
+        "date": "Data de gravación",
+        "missing": "Falta",
+        "libraryName": "Biblioteca"
       },
       "actions": {
         "playAll": "Reproducir",
@@ -102,7 +110,8 @@
         "rating": "Valoración",
         "genre": "Xénero",
         "size": "Tamaño",
-        "role": "Rol"
+        "role": "Rol",
+        "missing": "Falta"
       },
       "roles": {
         "albumartist": "Artista do álbum |||| Artistas do álbum",
@@ -117,7 +126,13 @@
         "mixer": "Mistura |||| Mistura",
         "remixer": "Remezcla |||| Remezcla",
         "djmixer": "Mezcla DJs |||| Mezcla DJs",
-        "performer": "Intérprete |||| Intérpretes"
+        "performer": "Intérprete |||| Intérpretes",
+        "maincredit": "Artista do álbum ou Artista |||| Artistas do álbum ou Artistas"
+      },
+      "actions": {
+        "shuffle": "Barallar",
+        "radio": "Radio",
+        "topSongs": "Cancións destacadas"
       }
     },
     "user": {
@@ -134,10 +149,12 @@
         "currentPassword": "Contrasinal actual",
         "newPassword": "Novo contrasinal",
         "token": "Token",
-        "lastAccessAt": "Último acceso"
+        "lastAccessAt": "Último acceso",
+        "libraries": "Bibliotecas"
       },
       "helperTexts": {
-        "name": "Os cambios no nome aplicaranse a próxima vez que accedas"
+        "name": "Os cambios no nome aplicaranse a próxima vez que accedas",
+        "libraries": "Selecciona bibliotecas específicas para esta usuaria, ou deixa baleiro para usar as bibliotecas por defecto"
       },
       "notifications": {
         "created": "Creouse a usuaria",
@@ -146,7 +163,12 @@
       },
       "message": {
         "listenBrainzToken": "Escribe o token de usuaria de ListenBrainz",
-        "clickHereForToken": "Preme aquí para obter o token"
+        "clickHereForToken": "Preme aquí para obter o token",
+        "selectAllLibraries": "Seleccionar todas as bibliotecas",
+        "adminAutoLibraries": "As usuarias Admin teñen acceso por defecto a todas as bibliotecas"
+      },
+      "validation": {
+        "librariesRequired": "Debes seleccionar polo menos unha biblioteca para usuarias non admins"
       }
     },
     "player": {
@@ -190,11 +212,17 @@
         "addNewPlaylist": "Crear \"%{name}\"",
         "export": "Exportar",
         "makePublic": "Facela Pública",
-        "makePrivate": "Facela Privada"
+        "makePrivate": "Facela Privada",
+        "saveQueue": "Salvar a Cola como Lista de reprodución",
+        "searchOrCreate": "Buscar listas ou escribe para crear nova…",
+        "pressEnterToCreate": "Preme Enter para crear nova lista",
+        "removeFromSelection": "Retirar da selección"
       },
       "message": {
         "duplicate_song": "Engadir cancións duplicadas",
-        "song_exist": "Hai duplicadas que serán engadidas á lista de reprodución. Desexas engadir as duplicadas ou omitilas?"
+        "song_exist": "Hai duplicadas que serán engadidas á lista de reprodución. Desexas engadir as duplicadas ou omitilas?",
+        "noPlaylistsFound": "Sen listas de reprodución",
+        "noPlaylists": "Sen listas dispoñibles"
       }
     },
     "radio": {
@@ -232,13 +260,68 @@
       "fields": {
         "path": "Ruta",
         "size": "Tamaño",
-        "updatedAt": "Desapareceu o"
+        "updatedAt": "Desapareceu o",
+        "libraryName": "Biblioteca"
       },
       "actions": {
-        "remove": "Retirar"
+        "remove": "Retirar",
+        "remove_all": "Retirar todo"
       },
       "notifications": {
         "removed": "Ficheiro(s) faltantes retirados"
+      },
+      "empty": "Sen ficheiros faltantes"
+    },
+    "library": {
+      "name": "Biblioteca |||| Bibliotecas",
+      "fields": {
+        "name": "Nome",
+        "path": "Ruta",
+        "remotePath": "Ruta remota",
+        "lastScanAt": "Último escaneado",
+        "songCount": "Cancións",
+        "albumCount": "Álbums",
+        "artistCount": "Artistas",
+        "totalSongs": "Cancións",
+        "totalAlbums": "Álbums",
+        "totalArtists": "Artistas",
+        "totalFolders": "Cartafoles",
+        "totalFiles": "Ficheiros",
+        "totalMissingFiles": "Ficheiros que faltan",
+        "totalSize": "Tamaño total",
+        "totalDuration": "Duración",
+        "defaultNewUsers": "Por defecto para novas usuarias",
+        "createdAt": "Creada",
+        "updatedAt": "Actualizada"
+      },
+      "sections": {
+        "basic": "Información básica",
+        "statistics": "Estatísticas"
+      },
+      "actions": {
+        "scan": "Escanear Biblioteca",
+        "manageUsers": "Xestionar acceso das usuarias",
+        "viewDetails": "Ver detalles"
+      },
+      "notifications": {
+        "created": "Biblioteca creada correctamente",
+        "updated": "Biblioteca actualizada correctamente",
+        "deleted": "Biblioteca eliminada correctamente",
+        "scanStarted": "Comezou o escaneo da biblioteca",
+        "scanCompleted": "Completouse o escaneado da biblioteca"
+      },
+      "validation": {
+        "nameRequired": "Requírese un nome para a biblioteca",
+        "pathRequired": "Requírese unha ruta para a biblioteca",
+        "pathNotDirectory": "A ruta á biblioteca ten que ser un directorio",
+        "pathNotFound": "Non se atopa a ruta á biblioteca",
+        "pathNotAccessible": "A ruta á biblioteca non é accesible",
+        "pathInvalid": "Ruta non válida á biblioteca"
+      },
+      "messages": {
+        "deleteConfirm": "Tes certeza de querer eliminar esta biblioteca? Isto eliminará todos os datos asociados e accesos de usuarias.",
+        "scanInProgress": "Escaneo en progreso…",
+        "noLibrariesAssigned": "Sen bibliotecas asignadas a esta usuaria"
       }
     }
   },
@@ -419,7 +502,11 @@
     "downloadDialogTitle": "Descargar %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Copiar ao portapapeis: Ctrl+C, Enter",
     "remove_missing_title": "Retirar ficheiros que faltan",
-    "remove_missing_content": "Tes certeza de querer retirar da base de datos os ficheiros que faltan? Isto retirará de xeito permanente todas a referencias a eles, incluíndo a conta de reproducións e valoracións."
+    "remove_missing_content": "Tes certeza de querer retirar da base de datos os ficheiros que faltan? Isto retirará de xeito permanente todas a referencias a eles, incluíndo a conta de reproducións e valoracións.",
+    "remove_all_missing_title": "Retirar todos os ficheiros que faltan",
+    "remove_all_missing_content": "Tes certeza de querer retirar da base de datos todos os ficheiros que faltan? Isto eliminará todas as referencias a eles, incluíndo o número de reproducións e valoracións.",
+    "noSimilarSongsFound": "Sen cancións parecidas",
+    "noTopSongsFound": "Sen cancións destacadas"
   },
   "menu": {
     "library": "Biblioteca",
@@ -448,7 +535,13 @@
     "albumList": "Álbums",
     "about": "Acerca de",
     "playlists": "Listas de reprodución",
-    "sharedPlaylists": "Listas compartidas"
+    "sharedPlaylists": "Listas compartidas",
+    "librarySelector": {
+      "allLibraries": "Todas as bibliotecas (%{count})",
+      "multipleLibraries": "%{selected} de %{total} Bibliotecas",
+      "selectLibraries": "Seleccionar Bibliotecas",
+      "none": "Ningunha"
+    }
   },
   "player": {
     "playListsText": "Reproducir cola",
@@ -485,6 +578,21 @@
         "disabled": "Desactivado",
         "waiting": "Agardando"
       }
+    },
+    "tabs": {
+      "about": "Sobre",
+      "config": "Configuración"
+    },
+    "config": {
+      "configName": "Nome",
+      "environmentVariable": "Variable de entorno",
+      "currentValue": "Valor actual",
+      "configurationFile": "Ficheiro de configuración",
+      "exportToml": "Exportar configuración (TOML)",
+      "exportSuccess": "Configuración exportada ao portapapeis no formato TOML",
+      "exportFailed": "Fallou a copia da configuración",
+      "devFlagsHeader": "Configuracións de Desenvolvemento (suxeitas a cambio/retirada)",
+      "devFlagsComment": "Son axustes experimentais e poden retirarse en futuras versións"
     }
   },
   "activity": {
@@ -493,7 +601,10 @@
     "quickScan": "Escaneo rápido",
     "fullScan": "Escaneo completo",
     "serverUptime": "Servidor a funcionar",
-    "serverDown": "SEN CONEXIÓN"
+    "serverDown": "SEN CONEXIÓN",
+    "scanType": "Tipo",
+    "status": "Erro de escaneado",
+    "elapsedTime": "Tempo transcurrido"
   },
   "help": {
     "title": "Atallos de Navidrome",
@@ -508,5 +619,10 @@
       "toggle_love": "Engadir canción a favoritas",
       "current_song": "Ir á Canción actual "
     }
+  },
+  "nowPlaying": {
+    "title": "En reprodución",
+    "empty": "Sen reprodución",
+    "minutesAgo": "hai %{smart_count} minuto |||| hai %{smart_count} minutos"
   }
 }

resources/i18n/it.json

@@ -400,8 +400,8 @@
         },
         "albumList": "Album",
         "about": "Info",
-        "playlists": "Scalette",
-        "sharedPlaylists": "Scalette Condivise"
+        "playlists": "Playlist",
+        "sharedPlaylists": "Playlist Condivise"
     },
     "player": {
         "playListsText": "Coda",
@@ -457,4 +457,4 @@
             "current_song": ""
         }
     }
-}
+}

resources/i18n/ko.json

@@ -12,6 +12,7 @@
         "artist": "아티스트",
         "album": "앨범",
         "path": "파일 경로",
+		"libraryName": "라이브러리",
         "genre": "장르",
         "compilation": "컴필레이션",
         "year": "년",
@@ -34,7 +35,8 @@
         "participants": "추가 참가자",
         "tags": "추가 태그",
         "mappedTags": "매핑된 태그",
-        "rawTags": "원시 태그"
+        "rawTags": "원시 태그",
+        "missing": "누락"
       },
       "actions": {
         "addToQueue": "나중에 재생",
@@ -56,6 +58,7 @@
         "playCount": "재생 횟수",
         "size": "크기",
         "name": "이름",
+        "libraryName": "라이브러리",
         "genre": "장르",
         "compilation": "컴필레이션",
         "year": "년",
@@ -73,7 +76,8 @@
         "releaseType": "유형",
         "grouping": "그룹",
         "media": "미디어",
-        "mood": "분위기"
+        "mood": "분위기",
+        "missing": "누락"
       },
       "actions": {
         "playAll": "재생",
@@ -105,7 +109,8 @@
         "playCount": "재생 횟수",
         "rating": "평가",
         "genre": "장르",
-        "role": "역할"
+        "role": "역할",
+        "missing": "누락"
       },
       "roles": {
         "albumartist": "앨범 아티스트 |||| 앨범 아티스트들",
@@ -120,7 +125,13 @@
         "mixer": "믹서 |||| 믹서들",
         "remixer": "리믹서 |||| 리믹서들",
         "djmixer": "DJ 믹서 |||| DJ 믹서들",
-        "performer": "공연자 |||| 공연자들"
+        "performer": "공연자 |||| 공연자들",
+        "maincredit": "앨범 아티스트 또는 아티스트 |||| 앨범 아티스트들 또는 아티스트들"
+      },
+      "actions": {
+        "topSongs": "인기곡",
+        "shuffle": "셔플",
+        "radio": "라디오"
       }
     },
     "user": {
@@ -137,19 +148,26 @@
         "changePassword": "비밀번호를 변경할까요?",
         "currentPassword": "현재 비밀번호",
         "newPassword": "새 비밀번호",
-        "token": "토큰"
+        "token": "토큰",
+        "libraries": "라이브러리"
       },
       "helperTexts": {
-        "name": "이름 변경 사항은 다음 로그인 시에만 반영됨"
+        "name": "이름 변경 사항은 다음 로그인 시에만 반영됨",
+        "libraries": "이 사용자에 대한 특정 라이브러리를 선택하거나 기본 라이브러리를 사용하려면 비움"
       },
       "notifications": {
         "created": "사용자 생성됨",
         "updated": "사용자 업데이트됨",
         "deleted": "사용자 삭제됨"
       },
+      "validation": {
+        "librariesRequired": "관리자가 아닌 사용자의 경우 최소한 하나의 라이브러리를 선택해야 함"
+      },
       "message": {
         "listenBrainzToken": "ListenBrainz 사용자 토큰을 입력하세요.",
-        "clickHereForToken": "여기를 클릭하여 토큰을 얻으세요"
+        "clickHereForToken": "여기를 클릭하여 토큰을 얻으세요",
+        "selectAllLibraries": "모든 라이브러리 선택",
+        "adminAutoLibraries": "관리자 사용자는 자동으로 모든 라이브러리에 접속할 수 있음"
       }
     },
     "player": {
@@ -192,12 +210,18 @@
         "selectPlaylist": "재생목록 선택:",
         "addNewPlaylist": "\"%{name}\" 만들기",
         "export": "내보내기",
+        "saveQueue": "재생목록에 대기열 저장",
         "makePublic": "공개 만들기",
-        "makePrivate": "비공개 만들기"
+        "makePrivate": "비공개 만들기",
+        "searchOrCreate": "재생목록을 검색하거나 입력하여 새 재생목록을 만드세요...",
+        "pressEnterToCreate": "새 재생목록을 만드려면 Enter 키를 누름",
+        "removeFromSelection": "선택에서 제거"
       },
       "message": {
         "duplicate_song": "중복된 노래 추가",
-        "song_exist": "이미 재생목록에 존재하는 노래입니다. 중복을 추가할까요 아니면 건너뛸까요?"
+        "song_exist": "이미 재생목록에 존재하는 노래입니다. 중복을 추가할까요 아니면 건너뛸까요?",
+        "noPlaylistsFound": "재생목록을 찾을 수 없음",
+        "noPlaylists": "사용 가능한 재생 목록이 없음"
       }
     },
     "radio": {
@@ -238,14 +262,68 @@
       "fields": {
         "path": "경로",
         "size": "크기",
+        "libraryName": "라이브러리",
         "updatedAt": "사라짐"
       },
       "actions": {
-        "remove": "제거"
+        "remove": "제거",
+        "remove_all": "모두 제거"
       },
       "notifications": {
         "removed": "누락된 파일이 제거되었음"
       }
+    },
+    "library": {
+      "name": "라이브러리 |||| 라이브러리들",
+      "fields": {
+        "name": "이름",
+        "path": "경로",
+        "remotePath": "원격 경로",
+        "lastScanAt": "최근 스캔",
+        "songCount": "노래",
+        "albumCount": "앨범",
+        "artistCount": "아티스트",
+        "totalSongs": "노래",
+        "totalAlbums": "앨범",
+        "totalArtists": "아티스트",
+        "totalFolders": "폴더",
+        "totalFiles": "파일",
+        "totalMissingFiles": "누락된 파일",
+        "totalSize": "총 크기",
+        "totalDuration": "기간",
+        "defaultNewUsers": "신규 사용자 기본값",
+        "createdAt": "생성됨",
+        "updatedAt": "업데이트됨"
+      },
+      "sections": {
+        "basic": "기본 정보",
+        "statistics": "통계"
+      },
+      "actions": {
+        "scan": "라이브러리 스캔",
+        "manageUsers": "자용자 접속 관리",
+        "viewDetails": "상세 보기"
+      },
+      "notifications": {
+        "created": "라이브러리가 성공적으로 생성됨",
+        "updated": "라이브러리가 성공적으로 업데이트됨",
+        "deleted": "라이브러리가 성공적으로 삭제됨",
+        "scanStarted": "라이브러리 스캔 스작됨",
+        "scanCompleted": "라이브러리 스캔 완료됨"
+      },
+      "validation": {
+        "nameRequired": "라이브러리 이름이 필요함",
+        "pathRequired": "라이브러리 경로가 필요함",
+        "pathNotDirectory": "라이브러리 경로는 디렉터리여야 함",
+        "pathNotFound": "라이브러리 경로를 찾을 수 없음",
+        "pathNotAccessible": "라이브러리 경로에 접근할 수 없음",
+        "pathInvalid": "잘못된 라이브러리 경로"
+      },
+      "messages": {
+        "deleteConfirm": "이 라이브러리를 삭제할까요? 삭제하면 연결된 모든 데이터와 사용자 접속 권한이 제거됩니다.",
+        "scanInProgress": "스캔 진행 중...",
+        "noLibrariesAssigned": "이 사용자에게 할당된 라이브러리가 없음"
+      }
     }
   },
   "ra": {
@@ -398,11 +476,15 @@
     "transcodingDisabled": "웹 인터페이스를 통한 트랜스코딩 구성 변경은 보안상의 이유로 비활성화되어 있습니다. 트랜스코딩 옵션을 변경(편집 또는 추가)하려면, %{config} 구성 옵션으로 서버를 다시 시작하세요.",
     "transcodingEnabled": "Navidrome은 현재 %{config}로 실행 중이므로 웹 인터페이스를 사용하여 트랜스코딩 설정에서 시스템 명령을 실행할 수 있습니다. 보안상의 이유로 비활성화하고 트랜스코딩 옵션을 구성할 때만 활성화하는 것이 좋습니다.",
     "songsAddedToPlaylist": "1 개의 노래를 재생목록에 추가하였음 |||| %{smart_count} 개의 노래를 재생 목록에 추가하였음",
+    "noSimilarSongsFound": "비슷한 노래를 찾을 수 없음",
+    "noTopSongsFound": "인기곡을 찾을 수 없음",
     "noPlaylistsAvailable": "사용 가능한 노래 없음",
     "delete_user_title": "사용자 '%{name}' 삭제",
     "delete_user_content": "이 사용자와 해당 사용자의 모든 데이터(재생 목록 및 환경 설정 포함)를 삭제할까요?",
     "remove_missing_title": "누락된 파일들 제거",
     "remove_missing_content": "선택한 누락된 파일을 데이터베이스에서 삭제할까요? 삭제하면 재생 횟수 및 평점을 포함하여 해당 파일에 대한 모든 참조가 영구적으로 삭제됩니다.",
+    "remove_all_missing_title": "누락된 모든 파일 제거",
+    "remove_all_missing_content": "데이터베이스에서 누락된 모든 파일을 제거할까요? 이렇게 하면 해당 게임의 플레이 횟수와 평점을 포함한 모든 참조 내용이 영구적으로 삭제됩니다.",
     "notifications_blocked": "브라우저 설정에서 이 사이트의 알림을 차단하였음",
     "notifications_not_available": "이 브라우저는 데스크톱 알림을 지원하지 않거나 https를 통해 Navidrome에 접속하고 있지 않음",
     "lastfmLinkSuccess": "Last.fm이 성공적으로 연결되었고 스크로블링이 활성화되었음",
@@ -429,6 +511,12 @@
   },
   "menu": {
     "library": "라이브러리",
+    "librarySelector": {
+      "allLibraries": "모든 라이브러리 (%{count})",
+      "multipleLibraries": "%{selected} / %{total} 라이브러리",
+      "selectLibraries": "라이브러리 선택",
+      "none": "없음"
+    },
     "settings": "설정",
     "version": "버전",
     "theme": "테마",
@@ -491,6 +579,21 @@
         "disabled": "비활성화",
         "waiting": "대기중"
       }
+    },
+    "tabs": {
+      "about": "정보",
+      "config": "구성"
+    },
+    "config": {
+      "configName": "구성 이름",
+      "environmentVariable": "환경 변수",
+      "currentValue": "현재 값",
+      "configurationFile": "구성 파일",
+      "exportToml": "구성 내보내기 (TOML)",
+      "exportSuccess": "TOML 형식으로 클립보드로 내보낸 구성",
+      "exportFailed": "구성 복사 실패",
+      "devFlagsHeader": "개발 플래그 (변경/삭제 가능)",
+      "devFlagsComment": "이는 실험적 설정이므로 향후 버전에서 제거될 수 있음"
     }
   },
   "activity": {
@@ -499,7 +602,15 @@
     "quickScan": "빠른 스캔",
     "fullScan": "전체 스캔",
     "serverUptime": "서버 가동 시간",
-    "serverDown": "오프라인"
+    "serverDown": "오프라인",
+    "scanType": "유형",
+    "status": "스캔 오류",
+    "elapsedTime": "경과 시간"
+  },
+  "nowPlaying": {
+    "title": "현재 재생 중",
+    "empty": "재생 중인 콘텐츠 없음",
+    "minutesAgo": "%{smart_count} 분 전"
   },
   "help": {
     "title": "Navidrome 단축키",

resources/i18n/nl.json

@@ -5,7 +5,7 @@
       "name": "Nummer |||| Nummers",
       "fields": {
         "albumArtist": "Album Artiest",
-        "duration": "Lengte",
+        "duration": "Afspeelduur",
         "trackNumber": "Nummer #",
         "playCount": "Aantal keren afgespeeld",
         "title": "Titel",
@@ -35,7 +35,8 @@
         "rawTags": "Onbewerkte tags",
         "bitDepth": "Bit diepte",
         "sampleRate": "Sample waarde",
-        "missing": "Ontbrekend"
+        "missing": "Ontbrekend",
+        "libraryName": "Bibliotheek"
       },
       "actions": {
         "addToQueue": "Voeg toe aan wachtrij",
@@ -44,7 +45,8 @@
         "shuffleAll": "Shuffle alles",
         "download": "Downloaden",
         "playNext": "Volgende",
-        "info": "Meer info"
+        "info": "Meer info",
+        "showInPlaylist": "Toon in afspeellijst"
       }
     },
     "album": {
@@ -55,7 +57,7 @@
         "duration": "Afspeelduur",
         "songCount": "Nummers",
         "playCount": "Aantal keren afgespeeld",
-        "name": "Naam",
+        "name": "Titel",
         "genre": "Genre",
         "compilation": "Compilatie",
         "year": "Jaar",
@@ -65,9 +67,9 @@
         "createdAt": "Datum toegevoegd",
         "size": "Grootte",
         "originalDate": "Origineel",
-        "releaseDate": "Uitgegeven",
+        "releaseDate": "Uitgave",
         "releases": "Uitgave |||| Uitgaven",
-        "released": "Uitgegeven",
+        "released": "Uitgave",
         "recordLabel": "Label",
         "catalogNum": "Catalogus nummer",
         "releaseType": "Type",
@@ -75,7 +77,8 @@
         "media": "Media",
         "mood": "Sfeer",
         "date": "Opnamedatum",
-        "missing": "Ontbrekend"
+        "missing": "Ontbrekend",
+        "libraryName": "Bibliotheek"
       },
       "actions": {
         "playAll": "Afspelen",
@@ -123,7 +126,13 @@
         "mixer": "Mixer |||| Mixers",
         "remixer": "Remixer |||| Remixers",
         "djmixer": "DJ Mixer |||| DJ Mixers",
-        "performer": "Performer |||| Performers"
+        "performer": "Performer |||| Performers",
+        "maincredit": "Album Artiest of Artiest |||| Album Artiesten or Artiesten"
+      },
+      "actions": {
+        "shuffle": "Shuffle",
+        "radio": "Radio",
+        "topSongs": "Beste nummers"
       }
     },
     "user": {
@@ -132,7 +141,7 @@
         "userName": "Gebruikersnaam",
         "isAdmin": "Is beheerder",
         "lastLoginAt": "Laatst ingelogd op",
-        "updatedAt": "Laatst gewijzigd op",
+        "updatedAt": "Laatst bijgewerkt op",
         "name": "Naam",
         "password": "Wachtwoord",
         "createdAt": "Aangemaakt op",
@@ -140,19 +149,26 @@
         "currentPassword": "Huidig wachtwoord",
         "newPassword": "Nieuw wachtwoord",
         "token": "Token",
-        "lastAccessAt": "Meest recente toegang"
+        "lastAccessAt": "Meest recente toegang",
+        "libraries": "Bibliotheken"
       },
       "helperTexts": {
-        "name": "Naamswijziging wordt pas zichtbaar bij de volgende login"
+        "name": "Naamswijziging wordt pas zichtbaar bij de volgende login",
+        "libraries": "Selecteer specifieke bibliotheken voor deze gebruiker, of laat leeg om de standaardbiblliotheken te gebruiken"
       },
       "notifications": {
         "created": "Aangemaakt door gebruiker",
-        "updated": "Gewijzigd door gebruiker",
-        "deleted": "Gewist door gebruiker"
+        "updated": "Bijgewerkt door gebruiker",
+        "deleted": "Gebruiker verwijderd"
       },
       "message": {
         "listenBrainzToken": "Vul je ListenBrainz gebruikers-token in.",
-        "clickHereForToken": "Klik hier voor je token"
+        "clickHereForToken": "Klik hier voor je token",
+        "selectAllLibraries": "Selecteer alle bibliotheken",
+        "adminAutoLibraries": "Admin gebruikers hebben automatisch toegang tot alle bibliotheken"
+      },
+      "validation": {
+        "librariesRequired": "Minstens één bibliotheek moet geselecteerd worden voor niet-admin gebruikers"
       }
     },
     "player": {
@@ -181,10 +197,10 @@
       "name": "Afspeellijst |||| Afspeellijsten",
       "fields": {
         "name": "Titel",
-        "duration": "Lengte",
+        "duration": "Afspeelduur",
         "ownerName": "Eigenaar",
         "public": "Publiek",
-        "updatedAt": "Laatst gewijzigd op",
+        "updatedAt": "Laatst bijgewerkt op",
         "createdAt": "Aangemaakt op",
         "songCount": "Nummers",
         "comment": "Commentaar",
@@ -197,11 +213,16 @@
         "export": "Exporteer",
         "makePublic": "Openbaar maken",
         "makePrivate": "Privé maken",
-        "saveQueue": "Bewaar wachtrij als playlist"
+        "saveQueue": "Bewaar wachtrij als playlist",
+        "searchOrCreate": "Zoek afspeellijsten of typ om een nieuwe te starten...",
+        "pressEnterToCreate": "Druk Enter om nieuwe afspeellijst te maken",
+        "removeFromSelection": "Verwijder van selectie"
       },
       "message": {
         "duplicate_song": "Dubbele nummers toevoegen",
-        "song_exist": "Er komen nummers dubbel in de afspeellijst. Wil je de dubbele nummers toevoegen of overslaan?"
+        "song_exist": "Er komen nummers dubbel in de afspeellijst. Wil je de dubbele nummers toevoegen of overslaan?",
+        "noPlaylistsFound": "Geen playlists gevonden",
+        "noPlaylists": "Geen playlists beschikbaar"
       }
     },
     "radio": {
@@ -210,8 +231,8 @@
         "name": "Naam",
         "streamUrl": "Stream URL",
         "homePageUrl": "Hoofdpagina URL",
-        "updatedAt": "Geüpdate op",
-        "createdAt": "Gecreëerd op"
+        "updatedAt": "Bijgewerkt op",
+        "createdAt": "Aangemaakt op"
       },
       "actions": {
         "playNow": "Speel nu"
@@ -229,8 +250,8 @@
         "visitCount": "Bezocht",
         "format": "Formaat",
         "maxBitRate": "Max. bitrate",
-        "updatedAt": "Geüpdatet op",
-        "createdAt": "Gecreëerd op",
+        "updatedAt": "Bijgewerkt op",
+        "createdAt": "Aangemaakt op",
         "downloadable": "Downloads toestaan?"
       }
     },
@@ -239,7 +260,8 @@
       "fields": {
         "path": "Pad",
         "size": "Grootte",
-        "updatedAt": "Verdwenen op"
+        "updatedAt": "Verdwenen op",
+        "libraryName": "Bibliotheek"
       },
       "actions": {
         "remove": "Verwijder",
@@ -249,6 +271,58 @@
         "removed": "Ontbrekende bestanden verwijderd"
       },
       "empty": "Geen ontbrekende bestanden"
+    },
+    "library": {
+      "name": "Bibliotheek |||| Bibliotheken",
+      "fields": {
+        "name": "Naam",
+        "path": "Pad",
+        "remotePath": "Extern pad",
+        "lastScanAt": "Laatste scan",
+        "songCount": "Nummers",
+        "albumCount": "Albums",
+        "artistCount": "Artiesten",
+        "totalSongs": "Nummers",
+        "totalAlbums": "Albums",
+        "totalArtists": "Artiesten",
+        "totalFolders": "Mappen",
+        "totalFiles": "Bestanden",
+        "totalMissingFiles": "Ontbrekende bestanden",
+        "totalSize": "Totale bestandsgrootte",
+        "totalDuration": "Afspeelduur",
+        "defaultNewUsers": "Standaard voor nieuwe gebruikers",
+        "createdAt": "Aangemaakt",
+        "updatedAt": "Bijgewerkt"
+      },
+      "sections": {
+        "basic": "Basisinformatie",
+        "statistics": "Statistieken"
+      },
+      "actions": {
+        "scan": "Scan bibliotheek",
+        "manageUsers": "Beheer gebruikerstoegang",
+        "viewDetails": "Bekijk details"
+      },
+      "notifications": {
+        "created": "Bibliotheek succesvol aangemaakt",
+        "updated": "Bibliotheek succesvol bijgewerkt",
+        "deleted": "Bibliotheek succesvol verwijderd",
+        "scanStarted": "Bibliotheekscan is gestart",
+        "scanCompleted": "Bibliotheekscan is voltooid"
+      },
+      "validation": {
+        "nameRequired": "Bibliotheek naam is vereist",
+        "pathRequired": "Pad naar bibliotheek is vereist",
+        "pathNotDirectory": "Pad naar bibliotheek moet een map zijn",
+        "pathNotFound": "Pad naar bibliotheek niet gevonden",
+        "pathNotAccessible": "Pad naar bibliotheek is niet toegankelijk",
+        "pathInvalid": "Ongeldig pad naar bibliotheek"
+      },
+      "messages": {
+        "deleteConfirm": "Weet je zeker dat je deze bibliotheek wil verwijderen? Dit verwijdert ook alle gerelateerde data en gebruikerstoegang.",
+        "scanInProgress": "Scan is bezig...",
+        "noLibrariesAssigned": "Geen bibliotheken aan deze gebruiker toegewezen"
+      }
     }
   },
   "ra": {
@@ -430,7 +504,9 @@
     "remove_missing_title": "Verwijder ontbrekende bestanden",
     "remove_missing_content": "Weet je zeker dat je alle ontbrekende bestanden van de database wil verwijderen? Dit wist permanent al hun referenties inclusief afspeel tellers en beoordelingen.",
     "remove_all_missing_title": "Verwijder alle ontbrekende bestanden",
-    "remove_all_missing_content": "Weet je zeker dat je alle ontbrekende bestanden van de database wil verwijderen? Dit wist permanent al hun referenties inclusief afspeel tellers en beoordelingen."
+    "remove_all_missing_content": "Weet je zeker dat je alle ontbrekende bestanden van de database wil verwijderen? Dit wist permanent al hun referenties inclusief afspeel tellers en beoordelingen.",
+    "noSimilarSongsFound": "Geen vergelijkbare nummers gevonden",
+    "noTopSongsFound": "Geen beste nummers gevonden"
   },
   "menu": {
     "library": "Bibliotheek",
@@ -459,7 +535,13 @@
     "albumList": "Albums",
     "about": "Over",
     "playlists": "Afspeellijsten",
-    "sharedPlaylists": "Gedeelde afspeellijsten"
+    "sharedPlaylists": "Gedeelde afspeellijsten",
+    "librarySelector": {
+      "allLibraries": "Alle bibliotheken (%{count})",
+      "multipleLibraries": "%{selected} van %{total} bibliotheken",
+      "selectLibraries": "Selecteer bibliotheken",
+      "none": "Geen"
+    }
   },
   "player": {
     "playListsText": "Wachtrij",
@@ -468,7 +550,7 @@
     "notContentText": "Geen muziek",
     "clickToPlayText": "Klik om af te spelen",
     "clickToPauseText": "Klik om te pauzeren",
-    "nextTrackText": "Volgende",
+    "nextTrackText": "Volgend nummer",
     "previousTrackText": "Vorige",
     "reloadText": "Herladen",
     "volumeText": "Volume",
@@ -496,11 +578,26 @@
         "disabled": "Uitgeschakeld",
         "waiting": "Wachten"
       }
+    },
+    "tabs": {
+      "about": "Over",
+      "config": "Configuratie"
+    },
+    "config": {
+      "configName": "Config Naam",
+      "environmentVariable": "Omgevingsvariabele",
+      "currentValue": "Huidige waarde",
+      "configurationFile": "Configuratiebestand",
+      "exportToml": "Exporteer configuratie (TOML)",
+      "exportSuccess": "Configuratie geëxporteerd naar klembord in TOML formaat",
+      "exportFailed": "Kopiëren van configuratie mislukt",
+      "devFlagsHeader": "Ontwikkelaarsinstellingen (onder voorbehoud)",
+      "devFlagsComment": "Dit zijn experimentele instellingen en worden mogelijk in latere versies verwijderd"
     }
   },
   "activity": {
     "title": "Activiteit",
-    "totalScanned": "Totaal gescande folders",
+    "totalScanned": "Totaal gescande mappen",
     "quickScan": "Snelle scan",
     "fullScan": "Volledige scan",
     "serverUptime": "Server uptime",
@@ -522,5 +619,10 @@
       "toggle_love": "Voeg toe aan favorieten",
       "current_song": "Ga naar huidig nummer"
     }
+  },
+  "nowPlaying": {
+    "title": "Speelt nu",
+    "empty": "Er wordt niets afgespeed",
+    "minutesAgo": "%{smart_count} minuut geleden |||| %{smart_count} minuten geleden"
   }
 }

resources/i18n/pt-br.json

@@ -300,6 +300,8 @@
       },
       "actions": {
         "scan": "Scanear Biblioteca",
+        "quickScan": "Scan Rápido",
+        "fullScan": "Scan Completo",
         "manageUsers": "Gerenciar Acesso do Usuário",
         "viewDetails": "Ver Detalhes"
       },
@@ -308,6 +310,9 @@
         "updated": "Biblioteca atualizada com sucesso",
         "deleted": "Biblioteca excluída com sucesso",
         "scanStarted": "Scan da biblioteca iniciada",
+        "quickScanStarted": "Scan rápido iniciado",
+        "fullScanStarted": "Scan completo iniciado",
+        "scanError": "Erro ao iniciar o scan. Verifique os logs",
         "scanCompleted": "Scan da biblioteca concluída"
       },
       "validation": {
@@ -598,11 +603,12 @@
   "activity": {
     "title": "Atividade",
     "totalScanned": "Total de pastas scaneadas",
-    "quickScan": "Scan rápido",
-    "fullScan": "Scan completo",
+    "quickScan": "Rápido",
+    "fullScan": "Completo",
+    "selectiveScan": "Seletivo",
     "serverUptime": "Uptime do servidor",
     "serverDown": "DESCONECTADO",
-    "scanType": "Tipo",
+    "scanType": "Último Scan",
     "status": "Erro",
     "elapsedTime": "Duração"
   },

resources/i18n/th.json

@@ -26,7 +26,17 @@
         "bpm": "BPM",
         "playDate": "เล่นล่าสุด",
         "channels": "ช่อง",
-        "createdAt": "เพิ่มเมื่อ"
+        "createdAt": "เพิ่มเมื่อ",
+        "grouping": "จัดกลุ่ม",
+        "mood": "อารมณ์",
+        "participants": "ผู้มีส่วนร่วม",
+        "tags": "แทกเพิ่มเติม",
+        "mappedTags": "แมพแทก",
+        "rawTags": "แทกเริ่มต้น",
+        "bitDepth": "Bit depth",
+        "sampleRate": "แซมเปิ้ลเรต",
+        "missing": "หายไป",
+        "libraryName": "ห้องสมุด"
       },
       "actions": {
         "addToQueue": "เพิ่มในคิว",
@@ -35,7 +45,8 @@
         "shuffleAll": "สุ่มทั้งหมด",
         "download": "ดาวน์โหลด",
         "playNext": "เล่นถัดไป",
-        "info": "ดูรายละเอียด"
+        "info": "ดูรายละเอียด",
+        "showInPlaylist": "แสดงในเพลย์ลิสต์"
       }
     },
     "album": {
@@ -58,7 +69,16 @@
         "originalDate": "วันที่เริ่ม",
         "releaseDate": "เผยแพร่เมื่อ",
         "releases": "เผยแพร่ |||| เผยแพร่",
-        "released": "เผยแพร่เมื่อ"
+        "released": "เผยแพร่เมื่อ",
+        "recordLabel": "ป้าย",
+        "catalogNum": "หมายเลขแคตาล็อก",
+        "releaseType": "ประเภท",
+        "grouping": "จัดกลุ่ม",
+        "media": "มีเดีย",
+        "mood": "อารมณ์",
+        "date": "บันทึกเมื่อ",
+        "missing": "หายไป",
+        "libraryName": "ห้องสมุด"
       },
       "actions": {
         "playAll": "เล่นทั้งหมด",
@@ -89,7 +109,30 @@
         "playCount": "เล่นแล้ว",
         "rating": "ความนิยม",
         "genre": "ประเภท",
-        "size": "ขนาด"
+        "size": "ขนาด",
+        "role": "Role",
+        "missing": "หายไป"
+      },
+      "roles": {
+        "albumartist": "ศิลปินอัลบั้ม |||| ศิลปินอัลบั้ม",
+        "artist": "ศิลปิน |||| ศิลปิน",
+        "composer": "ผู้แต่ง |||| ผู้แต่ง",
+        "conductor": "คอนดักเตอร์ |||| คอนดักเตอร์",
+        "lyricist": "เนื้อเพลง |||| เนื้อเพลง",
+        "arranger": "ผู้ดำเนินการ |||| ผู้ดำเนินการ",
+        "producer": "ผู้จัด |||| ผู้จัด",
+        "director": "ไดเรกเตอร์ |||| ไดเรกเตอร์",
+        "engineer": "วิศวกร |||| วิศวกร",
+        "mixer": "มิกเซอร์ |||| มิกเซอร์",
+        "remixer": "รีมิกเซอร์ |||| รีมิกเซอร์",
+        "djmixer": "ดีเจมิกเซอร์ |||| ดีเจมิกเซอร์",
+        "performer": "ผู้เล่น |||| ผู้เล่น",
+        "maincredit": "ศิลปิน |||| ศิลปิน"
+      },
+      "actions": {
+        "shuffle": "เล่นสุ่ม",
+        "radio": "วิทยุ",
+        "topSongs": "เพลงยอดนิยม"
       }
     },
     "user": {
@@ -106,10 +149,12 @@
         "currentPassword": "รหัสผ่านปัจจุบัน",
         "newPassword": "รหัสผ่านใหม่",
         "token": "โทเคน",
-        "lastAccessAt": "เข้าใช้ล่าสุด"
+        "lastAccessAt": "เข้าใช้ล่าสุด",
+        "libraries": "ห้องสมุด"
       },
       "helperTexts": {
-        "name": "การเปลี่ยนชื่อจะมีผลในการล็อกอินครั้งถัดไป"
+        "name": "การเปลี่ยนชื่อจะมีผลในการล็อกอินครั้งถัดไป",
+        "libraries": "เลือกห้องสมุดสำหรับผู้ใช้นี้หรือปล่อยว่างเพื่อใช้ห้องสมุดเริ่มต้น"
       },
       "notifications": {
         "created": "สร้างชื่อผู้ใช้",
@@ -118,7 +163,12 @@
       },
       "message": {
         "listenBrainzToken": "ใส่โทเคน ListenBrainz ของคุณ",
-        "clickHereForToken": "กดที่นี่เพื่อรับโทเคนของคุณ"
+        "clickHereForToken": "กดที่นี่เพื่อรับโทเคนของคุณ",
+        "selectAllLibraries": "เลือกห้องสมุดทั้งหมด",
+        "adminAutoLibraries": "ผู้ดูแลเข้าถึงห้องสมุดทั้งหมดโดยอัตโนมัติ"
+      },
+      "validation": {
+        "librariesRequired": "ต้องเลือกห้องสมุด 1 ห้อง สำหรับผู้ใช้ที่ไม่ใช่ผู้ดูแล"
       }
     },
     "player": {
@@ -162,11 +212,17 @@
         "addNewPlaylist": "สร้าง \"%{name}\"",
         "export": "ส่งออก",
         "makePublic": "ทำเป็นสาธารณะ",
-        "makePrivate": "ทำเป็นส่วนตัว"
+        "makePrivate": "ทำเป็นส่วนตัว",
+        "saveQueue": "บันทึกคิวลงเพลย์ลิสต์",
+        "searchOrCreate": "ค้นหาเพลย์ลิสต์หรือพิมพ์เพื่อสร้างใหม่",
+        "pressEnterToCreate": "กด Enter เพื่อสร้างเพลย์ลิสต์",
+        "removeFromSelection": "เอาออกจากที่เลือกไว้"
       },
       "message": {
         "duplicate_song": "เพิ่มเพลงซ้ำ",
-        "song_exist": "เพิ่มเพลงซ้ำกันในเพลย์ลิสต์ คุณจะเพิ่มเพลงต่อหรือข้าม"
+        "song_exist": "เพิ่มเพลงซ้ำกันในเพลย์ลิสต์ คุณจะเพิ่มเพลงต่อหรือข้าม",
+        "noPlaylistsFound": "ไม่พบเพลย์ลิสต์",
+        "noPlaylists": "ไม่มีเพลย์ลิสต์อยู่"
       }
     },
     "radio": {
@@ -198,6 +254,75 @@
         "createdAt": "สร้างเมื่อ",
         "downloadable": "อนุญาตให้ดาวโหลด?"
       }
+    },
+    "missing": {
+      "name": "ไฟล์ที่หายไป |||| ไฟล์ที่หายไป",
+      "fields": {
+        "path": "พาร์ท",
+        "size": "ขนาด",
+        "updatedAt": "หายไปจาก",
+        "libraryName": "ห้องสมุด"
+      },
+      "actions": {
+        "remove": "เอาออก",
+        "remove_all": "เอาออกทั้งหมด"
+      },
+      "notifications": {
+        "removed": "เอาไฟล์ที่หายไปออกแล้ว"
+      },
+      "empty": "ไม่มีไฟล์หาย"
+    },
+    "library": {
+      "name": "ห้องสมุด |||| ห้องสมุด",
+      "fields": {
+        "name": "ชื่อ",
+        "path": "พาร์ท",
+        "remotePath": "รีโมทพาร์ท",
+        "lastScanAt": "สแกนล่าสุด",
+        "songCount": "เพลง",
+        "albumCount": "อัลบัม",
+        "artistCount": "ศิลปิน",
+        "totalSongs": "เพลง",
+        "totalAlbums": "อัลบัม",
+        "totalArtists": "ศิลปิน",
+        "totalFolders": "แฟ้ม",
+        "totalFiles": "ไฟล์",
+        "totalMissingFiles": "ไฟล์ที่หายไป",
+        "totalSize": "ขนาดทั้งหมด",
+        "totalDuration": "ความยาว",
+        "defaultNewUsers": "ค่าเริ่มต้นผู้ใช้ใหม่",
+        "createdAt": "สร้าง",
+        "updatedAt": "อัพเดท"
+      },
+      "sections": {
+        "basic": "ข้อมูลเบื้องต้น",
+        "statistics": "สถิติ"
+      },
+      "actions": {
+        "scan": "สแกนห้องสมุด",
+        "manageUsers": "ตั้งค่าการเข้าถึง",
+        "viewDetails": "ดูรายละเอียด"
+      },
+      "notifications": {
+        "created": "สร้างห้องสมุดเรียบร้อย",
+        "updated": "อัพเดทห้องสมุดเรียบร้อย",
+        "deleted": "ลบห้องสมุดเพลงเรียบร้อยแล้ว",
+        "scanStarted": "เริ่มสแกนห้องสมุด",
+        "scanCompleted": "สแกนห้องสมุดเสร็จแล้ว"
+      },
+      "validation": {
+        "nameRequired": "ต้องใส่ชื่อห้องสมุดเพลง",
+        "pathRequired": "ต้องใส่พาร์ทของห้องสมุด",
+        "pathNotDirectory": "พาร์ทของห้องสมุดต้องเป็นแฟ้ม",
+        "pathNotFound": "ไม่เจอพาร์ทของห้องสมุด",
+        "pathNotAccessible": "ไม่สามารถเข้าพาร์ทของห้องสมุด",
+        "pathInvalid": "พาร์ทห้องสมุดไม่ถูก"
+      },
+      "messages": {
+        "deleteConfirm": "คุณแน่ใจว่าจะลบห้องสมุดนี้? นี่จะลบข้อมูลและการเข้าถึงของผู้ใช้ที่เกี่ยวข้องทั้งหมด",
+        "scanInProgress": "กำลังสแกน...",
+        "noLibrariesAssigned": "ไม่มีห้องสมุดสำหรับผู้ใช้นี้"
+      }
     }
   },
   "ra": {
@@ -375,7 +500,13 @@
     "shareSuccess": "คัดลอก URL ไปคลิปบอร์ด: %{url}",
     "shareFailure": "คัดลอก URL %{url} ไปคลิปบอร์ดผิดพลาด",
     "downloadDialogTitle": "ดาวโหลด %{resource} '%{name}' (%{size})",
-    "shareCopyToClipboard": "คัดลอกไปคลิปบอร์ด: Ctrl+C, Enter"
+    "shareCopyToClipboard": "คัดลอกไปคลิปบอร์ด: Ctrl+C, Enter",
+    "remove_missing_title": "ลบรายการไฟล์ที่หายไป",
+    "remove_missing_content": "คุณแน่ใจว่าจะเอารายการไฟล์ที่หายไปออกจากดาต้าเบส นี่จะเป็นการลบข้อมูลอ้างอิงทั้งหมดของไฟล์ออกอย่างถาวร",
+    "remove_all_missing_title": "เอารายการไฟล์ที่หายไปออกทั้งหมด",
+    "remove_all_missing_content": "คุณแน่ใจว่าจะเอารายการไฟล์ที่หายไปออกจากดาต้าเบส นี่จะเป็นการลบข้อมูลอ้างอิงทั้งหมดของไฟล์ออกอย่างถาวร",
+    "noSimilarSongsFound": "ไม่มีเพลงคล้ายกัน",
+    "noTopSongsFound": "ไม่พบเพลงยอดนิยม"
   },
   "menu": {
     "library": "ห้องสมุดเพลง",
@@ -404,7 +535,13 @@
     "albumList": "อัลบั้ม",
     "about": "เกี่ยวกับ",
     "playlists": "เพลย์ลิสต์",
-    "sharedPlaylists": "เพลย์ลิสต์ที่แบ่งปัน"
+    "sharedPlaylists": "เพลย์ลิสต์ที่แบ่งปัน",
+    "librarySelector": {
+      "allLibraries": "ห้องสมุด (%{count}) ห้อง",
+      "multipleLibraries": "%{selected} ของ %{total} ห้องสมุด",
+      "selectLibraries": "เลือกห้องสมุด",
+      "none": "ไม่มี"
+    }
   },
   "player": {
     "playListsText": "คิวเล่น",
@@ -441,6 +578,21 @@
         "disabled": "ปิดการทำงาน",
         "waiting": "รอ"
       }
+    },
+    "tabs": {
+      "about": "เกี่ยวกับ",
+      "config": "การตั้งค่า"
+    },
+    "config": {
+      "configName": "ชื่อการตั้งค่า",
+      "environmentVariable": "ค่าทั่วไป",
+      "currentValue": "ค่าปัจจุบัน",
+      "configurationFile": "ไฟล์การตั้งค่า",
+      "exportToml": "นำออกการตั้งค่า (TOML)",
+      "exportSuccess": "นำออกการตั้งค่าไปยังคลิปบอร์ดในรูปแบบ TOML แล้ว",
+      "exportFailed": "คัดลอกการตั้งค่าล้มเหลว",
+      "devFlagsHeader": "ปักธงการพัฒนา (อาจมีการเปลี่ยน/เอาออก)",
+      "devFlagsComment": "การตั้งค่านี้อยู่ในช่วงทดลองและอาจจะมีการเอาออกในเวอร์ชั่นหลัง"
     }
   },
   "activity": {
@@ -449,7 +601,10 @@
     "quickScan": "สแกนแบบเร็ว",
     "fullScan": "สแกนทั้งหมด",
     "serverUptime": "เซิร์ฟเวอร์ออนไลน์นาน",
-    "serverDown": "ออฟไลน์"
+    "serverDown": "ออฟไลน์",
+    "scanType": "ประเภท",
+    "status": "สแกนผิดพลาด",
+    "elapsedTime": "เวลาที่ใช้"
   },
   "help": {
     "title": "คีย์ลัด Navidrome",
@@ -464,5 +619,10 @@
       "toggle_love": "เพิ่มเพลงนี้ไปยังรายการโปรด",
       "current_song": "ไปยังเพลงปัจจุบัน"
     }
+  },
+  "nowPlaying": {
+    "title": "กำลังเล่น",
+    "empty": "ไม่มีเพลงเล่น",
+    "minutesAgo": "%{smart_count} นาทีที่แล้ว |||| %{smart_count} นาทีที่แล้ว"
   }
 }

scanner/controller.go

@@ -26,24 +26,8 @@ var (
 	ErrAlreadyScanning = errors.New("already scanning")
 )
 
-type Scanner interface {
-	// ScanAll starts a full scan of the music library. This is a blocking operation.
-	ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
-	Status(context.Context) (*StatusInfo, error)
-}
-
-type StatusInfo struct {
-	Scanning    bool
-	LastScan    time.Time
-	Count       uint32
-	FolderCount uint32
-	LastError   string
-	ScanType    string
-	ElapsedTime time.Duration
-}
-
 func New(rootCtx context.Context, ds model.DataStore, cw artwork.CacheWarmer, broker events.Broker,
-	pls core.Playlists, m metrics.Metrics) Scanner {
+	pls core.Playlists, m metrics.Metrics) model.Scanner {
 	c := &controller{
 		rootCtx: rootCtx,
 		ds:      ds,
@@ -65,9 +49,10 @@ func (s *controller) getScanner() scanner {
 	return &scannerImpl{ds: s.ds, cw: s.cw, pls: s.pls}
 }
 
-// CallScan starts an in-process scan of the music library.
+// CallScan starts an in-process scan of specific library/folder pairs.
+// If targets is empty, it scans all libraries.
 // This is meant to be called from the command line (see cmd/scan.go).
-func CallScan(ctx context.Context, ds model.DataStore, pls core.Playlists, fullScan bool) (<-chan *ProgressInfo, error) {
+func CallScan(ctx context.Context, ds model.DataStore, pls core.Playlists, fullScan bool, targets []model.ScanTarget) (<-chan *ProgressInfo, error) {
 	release, err := lockScan(ctx)
 	if err != nil {
 		return nil, err
@@ -79,7 +64,7 @@ func CallScan(ctx context.Context, ds model.DataStore, pls core.Playlists, fullS
 	go func() {
 		defer close(progress)
 		scanner := &scannerImpl{ds: ds, cw: artwork.NoopCacheWarmer(), pls: pls}
-		scanner.scanAll(ctx, fullScan, progress)
+		scanner.scanFolders(ctx, fullScan, targets, progress)
 	}()
 	return progress, nil
 }
@@ -99,8 +84,11 @@ type ProgressInfo struct {
 	ForceUpdate     bool
 }
 
+// scanner defines the interface for different scanner implementations.
+// This allows for swapping between in-process and external scanners.
 type scanner interface {
-	scanAll(ctx context.Context, fullScan bool, progress chan<- *ProgressInfo)
+	// scanFolders performs the actual scanning of folders. If targets is nil, it scans all libraries.
+	scanFolders(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo)
 }
 
 type controller struct {
@@ -158,7 +146,7 @@ func (s *controller) getScanInfo(ctx context.Context) (scanType string, elapsed
 	return scanType, elapsed, lastErr
 }
 
-func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
+func (s *controller) Status(ctx context.Context) (*model.ScannerStatus, error) {
 	lastScanTime, err := s.getLastScanTime(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("getting last scan time: %w", err)
@@ -167,7 +155,7 @@ func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
 	scanType, elapsed, lastErr := s.getScanInfo(ctx)
 
 	if running.Load() {
-		status := &StatusInfo{
+		status := &model.ScannerStatus{
 			Scanning:    true,
 			LastScan:    lastScanTime,
 			Count:       s.count.Load(),
@@ -183,7 +171,7 @@ func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
 	if err != nil {
 		return nil, fmt.Errorf("getting library stats: %w", err)
 	}
-	return &StatusInfo{
+	return &model.ScannerStatus{
 		Scanning:    false,
 		LastScan:    lastScanTime,
 		Count:       uint32(count),
@@ -208,6 +196,10 @@ func (s *controller) getCounters(ctx context.Context) (int64, int64, error) {
 }
 
 func (s *controller) ScanAll(requestCtx context.Context, fullScan bool) ([]string, error) {
+	return s.ScanFolders(requestCtx, fullScan, nil)
+}
+
+func (s *controller) ScanFolders(requestCtx context.Context, fullScan bool, targets []model.ScanTarget) ([]string, error) {
 	release, err := lockScan(requestCtx)
 	if err != nil {
 		return nil, err
@@ -224,7 +216,7 @@ func (s *controller) ScanAll(requestCtx context.Context, fullScan bool) ([]strin
 	go func() {
 		defer close(progress)
 		scanner := s.getScanner()
-		scanner.scanAll(ctx, fullScan, progress)
+		scanner.scanFolders(ctx, fullScan, targets, progress)
 	}()
 
 	// Wait for the scan to finish, sending progress events to all connected clients

scanner/controller_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/navidrome/navidrome/core/artwork"
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
 	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/server/events"
@@ -20,7 +21,7 @@ import (
 var _ = Describe("Controller", func() {
 	var ctx context.Context
 	var ds *tests.MockDataStore
-	var ctrl scanner.Scanner
+	var ctrl model.Scanner
 
 	Describe("Status", func() {
 		BeforeEach(func() {

scanner/external.go

@@ -8,10 +8,12 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"strings"
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
-	. "github.com/navidrome/navidrome/utils/gg"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/slice"
 )
 
 // scannerExternal is a scanner that runs an external process to do the scanning. It is used to avoid
@@ -23,19 +25,41 @@ import (
 // process will forward them to the caller.
 type scannerExternal struct{}
 
-func (s *scannerExternal) scanAll(ctx context.Context, fullScan bool, progress chan<- *ProgressInfo) {
+func (s *scannerExternal) scanFolders(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo) {
+	s.scan(ctx, fullScan, targets, progress)
+}
+
+func (s *scannerExternal) scan(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo) {
 	exe, err := os.Executable()
 	if err != nil {
 		progress <- &ProgressInfo{Error: fmt.Sprintf("failed to get executable path: %s", err)}
 		return
 	}
-	log.Debug(ctx, "Spawning external scanner process", "fullScan", fullScan, "path", exe)
-	cmd := exec.CommandContext(ctx, exe, "scan",
+
+	// Build command arguments
+	args := []string{
+		"scan",
 		"--nobanner", "--subprocess",
 		"--configfile", conf.Server.ConfigFile,
 		"--datafolder", conf.Server.DataFolder,
 		"--cachefolder", conf.Server.CacheFolder,
-		If(fullScan, "--full", ""))
+	}
+
+	// Add targets if provided
+	if len(targets) > 0 {
+		targetsStr := strings.Join(slice.Map(targets, func(t model.ScanTarget) string { return t.String() }), ",")
+		args = append(args, "--targets", targetsStr)
+		log.Debug(ctx, "Spawning external scanner process with targets", "fullScan", fullScan, "path", exe, "targets", targetsStr)
+	} else {
+		log.Debug(ctx, "Spawning external scanner process", "fullScan", fullScan, "path", exe)
+	}
+
+	// Add full scan flag if needed
+	if fullScan {
+		args = append(args, "--full")
+	}
+
+	cmd := exec.CommandContext(ctx, exe, args...)
 
 	in, out := io.Pipe()
 	defer in.Close()

scanner/folder_entry.go

@@ -15,9 +15,7 @@ import (
 	"github.com/navidrome/navidrome/utils/chrono"
 )
 
-func newFolderEntry(job *scanJob, path string) *folderEntry {
-	id := model.FolderID(job.lib, path)
-	info := job.popLastUpdate(id)
+func newFolderEntry(job *scanJob, id, path string, updTime time.Time, hash string) *folderEntry {
 	f := &folderEntry{
 		id:         id,
 		job:        job,
@@ -25,8 +23,8 @@ func newFolderEntry(job *scanJob, path string) *folderEntry {
 		audioFiles: make(map[string]fs.DirEntry),
 		imageFiles: make(map[string]fs.DirEntry),
 		albumIDMap: make(map[string]string),
-		updTime:    info.UpdatedAt,
-		prevHash:   info.Hash,
+		updTime:    updTime,
+		prevHash:   hash,
 	}
 	return f
 }

scanner/folder_entry_test.go

@@ -40,9 +40,8 @@ var _ = Describe("folder_entry", func() {
 				UpdatedAt: time.Now().Add(-30 * time.Minute),
 				Hash:      "previous-hash",
 			}
-			job.lastUpdates[folderID] = updateInfo
 
-			entry := newFolderEntry(job, path)
+			entry := newFolderEntry(job, folderID, path, updateInfo.UpdatedAt, updateInfo.Hash)
 
 			Expect(entry.id).To(Equal(folderID))
 			Expect(entry.job).To(Equal(job))
@@ -53,15 +52,10 @@ var _ = Describe("folder_entry", func() {
 			Expect(entry.updTime).To(Equal(updateInfo.UpdatedAt))
 			Expect(entry.prevHash).To(Equal(updateInfo.Hash))
 		})
+	})
 
-		It("creates a new folder entry with zero time when no previous update exists", func() {
-			entry := newFolderEntry(job, path)
-
-			Expect(entry.updTime).To(BeZero())
-			Expect(entry.prevHash).To(BeEmpty())
-		})
-
-		It("removes the lastUpdate from the job after popping", func() {
+	Describe("createFolderEntry", func() {
+		It("removes the lastUpdate from the job after creation", func() {
 			folderID := model.FolderID(lib, path)
 			updateInfo := model.FolderUpdateInfo{
 				UpdatedAt: time.Now().Add(-30 * time.Minute),
@@ -69,8 +63,10 @@ var _ = Describe("folder_entry", func() {
 			}
 			job.lastUpdates[folderID] = updateInfo
 
-			newFolderEntry(job, path)
+			entry := job.createFolderEntry(path)
 
+			Expect(entry.updTime).To(Equal(updateInfo.UpdatedAt))
+			Expect(entry.prevHash).To(Equal(updateInfo.Hash))
 			Expect(job.lastUpdates).ToNot(HaveKey(folderID))
 		})
 	})
@@ -79,7 +75,8 @@ var _ = Describe("folder_entry", func() {
 		var entry *folderEntry
 
 		BeforeEach(func() {
-			entry = newFolderEntry(job, path)
+			folderID := model.FolderID(lib, path)
+			entry = newFolderEntry(job, folderID, path, time.Time{}, "")
 		})
 
 		Describe("hasNoFiles", func() {
@@ -458,7 +455,9 @@ var _ = Describe("folder_entry", func() {
 	Describe("integration scenarios", func() {
 		It("handles complete folder lifecycle", func() {
 			// Create new folder entry
-			entry := newFolderEntry(job, "music/rock/album")
+			folderPath := "music/rock/album"
+			folderID := model.FolderID(lib, folderPath)
+			entry := newFolderEntry(job, folderID, folderPath, time.Time{}, "")
 
 			// Initially new and has no files
 			Expect(entry.isNew()).To(BeTrue())

scanner/ignore_checker.go

@@ -0,0 +1,163 @@
+package scanner
+
+import (
+	"bufio"
+	"context"
+	"io/fs"
+	"path"
+	"strings"
+
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	ignore "github.com/sabhiram/go-gitignore"
+)
+
+// IgnoreChecker manages .ndignore patterns using a stack-based approach.
+// Use Push() to add patterns when entering a folder, Pop() when leaving,
+// and ShouldIgnore() to check if a path should be ignored.
+type IgnoreChecker struct {
+	fsys            fs.FS
+	patternStack    [][]string        // Stack of patterns for each folder level
+	currentPatterns []string          // Flattened current patterns
+	matcher         *ignore.GitIgnore // Compiled matcher for current patterns
+}
+
+// newIgnoreChecker creates a new IgnoreChecker for the given filesystem.
+func newIgnoreChecker(fsys fs.FS) *IgnoreChecker {
+	return &IgnoreChecker{
+		fsys:         fsys,
+		patternStack: make([][]string, 0),
+	}
+}
+
+// Push loads .ndignore patterns from the specified folder and adds them to the pattern stack.
+// Use this when entering a folder during directory tree traversal.
+func (ic *IgnoreChecker) Push(ctx context.Context, folder string) error {
+	patterns := ic.loadPatternsFromFolder(ctx, folder)
+	ic.patternStack = append(ic.patternStack, patterns)
+	ic.rebuildCurrentPatterns()
+	return nil
+}
+
+// Pop removes the most recent patterns from the stack.
+// Use this when leaving a folder during directory tree traversal.
+func (ic *IgnoreChecker) Pop() {
+	if len(ic.patternStack) > 0 {
+		ic.patternStack = ic.patternStack[:len(ic.patternStack)-1]
+		ic.rebuildCurrentPatterns()
+	}
+}
+
+// PushAllParents pushes patterns from root down to the target path.
+// This is a convenience method for when you need to check a specific path
+// without recursively walking the tree. It handles the common pattern of
+// pushing all parent directories from root to the target.
+// This method is optimized to compile patterns only once at the end.
+func (ic *IgnoreChecker) PushAllParents(ctx context.Context, targetPath string) error {
+	if targetPath == "." || targetPath == "" {
+		// Simple case: just push root
+		return ic.Push(ctx, ".")
+	}
+
+	// Load patterns for root
+	patterns := ic.loadPatternsFromFolder(ctx, ".")
+	ic.patternStack = append(ic.patternStack, patterns)
+
+	// Load patterns for each parent directory
+	currentPath := "."
+	parts := strings.Split(path.Clean(targetPath), "/")
+	for _, part := range parts {
+		if part == "." || part == "" {
+			continue
+		}
+		currentPath = path.Join(currentPath, part)
+		patterns = ic.loadPatternsFromFolder(ctx, currentPath)
+		ic.patternStack = append(ic.patternStack, patterns)
+	}
+
+	// Rebuild and compile patterns only once at the end
+	ic.rebuildCurrentPatterns()
+	return nil
+}
+
+// ShouldIgnore checks if the given path should be ignored based on the current patterns.
+// Returns true if the path matches any ignore pattern, false otherwise.
+func (ic *IgnoreChecker) ShouldIgnore(ctx context.Context, relPath string) bool {
+	// Handle root/empty path - never ignore
+	if relPath == "" || relPath == "." {
+		return false
+	}
+
+	// If no patterns loaded, nothing to ignore
+	if ic.matcher == nil {
+		return false
+	}
+
+	matches := ic.matcher.MatchesPath(relPath)
+	if matches {
+		log.Trace(ctx, "Scanner: Ignoring entry matching .ndignore", "path", relPath)
+	}
+	return matches
+}
+
+// loadPatternsFromFolder reads the .ndignore file in the specified folder and returns the patterns.
+// If the file doesn't exist, returns an empty slice.
+// If the file exists but is empty, returns a pattern to ignore everything ("**/*").
+func (ic *IgnoreChecker) loadPatternsFromFolder(ctx context.Context, folder string) []string {
+	ignoreFilePath := path.Join(folder, consts.ScanIgnoreFile)
+	var patterns []string
+
+	// Check if .ndignore file exists
+	if _, err := fs.Stat(ic.fsys, ignoreFilePath); err != nil {
+		// No .ndignore file in this folder
+		return patterns
+	}
+
+	// Read and parse the .ndignore file
+	ignoreFile, err := ic.fsys.Open(ignoreFilePath)
+	if err != nil {
+		log.Warn(ctx, "Scanner: Error opening .ndignore file", "path", ignoreFilePath, err)
+		return patterns
+	}
+	defer ignoreFile.Close()
+
+	lineScanner := bufio.NewScanner(ignoreFile)
+	for lineScanner.Scan() {
+		line := strings.TrimSpace(lineScanner.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue // Skip empty lines, whitespace-only lines, and comments
+		}
+		patterns = append(patterns, line)
+	}
+
+	if err := lineScanner.Err(); err != nil {
+		log.Warn(ctx, "Scanner: Error reading .ndignore file", "path", ignoreFilePath, err)
+		return patterns
+	}
+
+	// If the .ndignore file is empty, ignore everything
+	if len(patterns) == 0 {
+		log.Trace(ctx, "Scanner: .ndignore file is empty, ignoring everything", "path", folder)
+		patterns = []string{"**/*"}
+	}
+
+	return patterns
+}
+
+// rebuildCurrentPatterns flattens the pattern stack into currentPatterns and recompiles the matcher.
+func (ic *IgnoreChecker) rebuildCurrentPatterns() {
+	ic.currentPatterns = make([]string, 0)
+	for _, patterns := range ic.patternStack {
+		ic.currentPatterns = append(ic.currentPatterns, patterns...)
+	}
+	ic.compilePatterns()
+}
+
+// compilePatterns compiles the current patterns into a GitIgnore matcher.
+func (ic *IgnoreChecker) compilePatterns() {
+	if len(ic.currentPatterns) == 0 {
+		ic.matcher = nil
+		return
+	}
+	ic.matcher = ignore.CompileIgnoreLines(ic.currentPatterns...)
+}

scanner/ignore_checker_test.go

@@ -0,0 +1,313 @@
+package scanner
+
+import (
+	"context"
+	"testing/fstest"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("IgnoreChecker", func() {
+	Describe("loadPatternsFromFolder", func() {
+		var ic *IgnoreChecker
+		var ctx context.Context
+
+		BeforeEach(func() {
+			ctx = context.Background()
+		})
+
+		Context("when .ndignore file does not exist", func() {
+			It("should return empty patterns", func() {
+				fsys := fstest.MapFS{}
+				ic = newIgnoreChecker(fsys)
+				patterns := ic.loadPatternsFromFolder(ctx, ".")
+				Expect(patterns).To(BeEmpty())
+			})
+		})
+
+		Context("when .ndignore file is empty", func() {
+			It("should return wildcard to ignore everything", func() {
+				fsys := fstest.MapFS{
+					".ndignore": &fstest.MapFile{Data: []byte("")},
+				}
+				ic = newIgnoreChecker(fsys)
+				patterns := ic.loadPatternsFromFolder(ctx, ".")
+				Expect(patterns).To(Equal([]string{"**/*"}))
+			})
+		})
+
+		DescribeTable("parsing .ndignore content",
+			func(content string, expectedPatterns []string) {
+				fsys := fstest.MapFS{
+					".ndignore": &fstest.MapFile{Data: []byte(content)},
+				}
+				ic = newIgnoreChecker(fsys)
+				patterns := ic.loadPatternsFromFolder(ctx, ".")
+				Expect(patterns).To(Equal(expectedPatterns))
+			},
+			Entry("single pattern", "*.txt", []string{"*.txt"}),
+			Entry("multiple patterns", "*.txt\n*.log", []string{"*.txt", "*.log"}),
+			Entry("with comments", "# comment\n*.txt\n# another\n*.log", []string{"*.txt", "*.log"}),
+			Entry("with empty lines", "*.txt\n\n*.log\n\n", []string{"*.txt", "*.log"}),
+			Entry("mixed content", "# header\n\n*.txt\n# middle\n*.log\n\n", []string{"*.txt", "*.log"}),
+			Entry("only comments and empty lines", "# comment\n\n# another\n", []string{"**/*"}),
+			Entry("trailing newline", "*.txt\n*.log\n", []string{"*.txt", "*.log"}),
+			Entry("directory pattern", "temp/", []string{"temp/"}),
+			Entry("wildcard pattern", "**/*.mp3", []string{"**/*.mp3"}),
+			Entry("multiple wildcards", "**/*.mp3\n**/*.flac\n*.log", []string{"**/*.mp3", "**/*.flac", "*.log"}),
+			Entry("negation pattern", "!important.txt", []string{"!important.txt"}),
+			Entry("comment with hash not at start is pattern", "not#comment", []string{"not#comment"}),
+			Entry("whitespace-only lines skipped", "*.txt\n   \n*.log\n\t\n", []string{"*.txt", "*.log"}),
+			Entry("patterns with whitespace trimmed", "  *.txt  \n\t*.log\t", []string{"*.txt", "*.log"}),
+		)
+	})
+
+	Describe("Push and Pop", func() {
+		var ic *IgnoreChecker
+		var fsys fstest.MapFS
+		var ctx context.Context
+
+		BeforeEach(func() {
+			ctx = context.Background()
+			fsys = fstest.MapFS{
+				".ndignore":         &fstest.MapFile{Data: []byte("*.txt")},
+				"folder1/.ndignore": &fstest.MapFile{Data: []byte("*.mp3")},
+				"folder2/.ndignore": &fstest.MapFile{Data: []byte("*.flac")},
+			}
+			ic = newIgnoreChecker(fsys)
+		})
+
+		Context("Push", func() {
+			It("should add patterns to stack", func() {
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(ic.patternStack)).To(Equal(1))
+				Expect(ic.currentPatterns).To(ContainElement("*.txt"))
+			})
+
+			It("should compile matcher after push", func() {
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(ic.matcher).ToNot(BeNil())
+			})
+
+			It("should accumulate patterns from multiple levels", func() {
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				err = ic.Push(ctx, "folder1")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(ic.patternStack)).To(Equal(2))
+				Expect(ic.currentPatterns).To(ConsistOf("*.txt", "*.mp3"))
+			})
+
+			It("should handle push when no .ndignore exists", func() {
+				err := ic.Push(ctx, "nonexistent")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(ic.patternStack)).To(Equal(1))
+				Expect(ic.currentPatterns).To(BeEmpty())
+			})
+		})
+
+		Context("Pop", func() {
+			It("should remove most recent patterns", func() {
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				err = ic.Push(ctx, "folder1")
+				Expect(err).ToNot(HaveOccurred())
+				ic.Pop()
+				Expect(len(ic.patternStack)).To(Equal(1))
+				Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+			})
+
+			It("should handle Pop on empty stack gracefully", func() {
+				Expect(func() { ic.Pop() }).ToNot(Panic())
+				Expect(ic.patternStack).To(BeEmpty())
+			})
+
+			It("should set matcher to nil when all patterns popped", func() {
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(ic.matcher).ToNot(BeNil())
+				ic.Pop()
+				Expect(ic.matcher).To(BeNil())
+			})
+
+			It("should update matcher after pop", func() {
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				err = ic.Push(ctx, "folder1")
+				Expect(err).ToNot(HaveOccurred())
+				matcher1 := ic.matcher
+				ic.Pop()
+				matcher2 := ic.matcher
+				Expect(matcher1).ToNot(Equal(matcher2))
+			})
+		})
+
+		Context("multiple Push/Pop cycles", func() {
+			It("should maintain correct state through cycles", func() {
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+
+				err = ic.Push(ctx, "folder1")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(ic.currentPatterns).To(ConsistOf("*.txt", "*.mp3"))
+
+				ic.Pop()
+				Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+
+				err = ic.Push(ctx, "folder2")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(ic.currentPatterns).To(ConsistOf("*.txt", "*.flac"))
+
+				ic.Pop()
+				Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+
+				ic.Pop()
+				Expect(ic.currentPatterns).To(BeEmpty())
+			})
+		})
+	})
+
+	Describe("PushAllParents", func() {
+		var ic *IgnoreChecker
+		var ctx context.Context
+
+		BeforeEach(func() {
+			ctx = context.Background()
+			fsys := fstest.MapFS{
+				".ndignore":                         &fstest.MapFile{Data: []byte("root.txt")},
+				"folder1/.ndignore":                 &fstest.MapFile{Data: []byte("level1.txt")},
+				"folder1/folder2/.ndignore":         &fstest.MapFile{Data: []byte("level2.txt")},
+				"folder1/folder2/folder3/.ndignore": &fstest.MapFile{Data: []byte("level3.txt")},
+			}
+			ic = newIgnoreChecker(fsys)
+		})
+
+		DescribeTable("loading parent patterns",
+			func(targetPath string, expectedStackDepth int, expectedPatterns []string) {
+				err := ic.PushAllParents(ctx, targetPath)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(ic.patternStack)).To(Equal(expectedStackDepth))
+				Expect(ic.currentPatterns).To(ConsistOf(expectedPatterns))
+			},
+			Entry("root path", ".", 1, []string{"root.txt"}),
+			Entry("empty path", "", 1, []string{"root.txt"}),
+			Entry("single level", "folder1", 2, []string{"root.txt", "level1.txt"}),
+			Entry("two levels", "folder1/folder2", 3, []string{"root.txt", "level1.txt", "level2.txt"}),
+			Entry("three levels", "folder1/folder2/folder3", 4, []string{"root.txt", "level1.txt", "level2.txt", "level3.txt"}),
+		)
+
+		It("should only compile patterns once at the end", func() {
+			// This is more of a behavioral test - we verify the matcher is not nil after PushAllParents
+			err := ic.PushAllParents(ctx, "folder1/folder2")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(ic.matcher).ToNot(BeNil())
+		})
+
+		It("should handle paths with dot", func() {
+			err := ic.PushAllParents(ctx, "./folder1")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(ic.patternStack)).To(Equal(2))
+		})
+
+		Context("when some parent folders have no .ndignore", func() {
+			BeforeEach(func() {
+				fsys := fstest.MapFS{
+					".ndignore":                 &fstest.MapFile{Data: []byte("root.txt")},
+					"folder1/folder2/.ndignore": &fstest.MapFile{Data: []byte("level2.txt")},
+				}
+				ic = newIgnoreChecker(fsys)
+			})
+
+			It("should still push all parent levels", func() {
+				err := ic.PushAllParents(ctx, "folder1/folder2")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(ic.patternStack)).To(Equal(3)) // root, folder1 (empty), folder2
+				Expect(ic.currentPatterns).To(ConsistOf("root.txt", "level2.txt"))
+			})
+		})
+	})
+
+	Describe("ShouldIgnore", func() {
+		var ic *IgnoreChecker
+		var ctx context.Context
+
+		BeforeEach(func() {
+			ctx = context.Background()
+		})
+
+		Context("with no patterns loaded", func() {
+			It("should not ignore any path", func() {
+				fsys := fstest.MapFS{}
+				ic = newIgnoreChecker(fsys)
+				Expect(ic.ShouldIgnore(ctx, "anything.txt")).To(BeFalse())
+				Expect(ic.ShouldIgnore(ctx, "folder/file.mp3")).To(BeFalse())
+			})
+		})
+
+		Context("special paths", func() {
+			BeforeEach(func() {
+				fsys := fstest.MapFS{
+					".ndignore": &fstest.MapFile{Data: []byte("**/*")},
+				}
+				ic = newIgnoreChecker(fsys)
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("should never ignore root or empty paths", func() {
+				Expect(ic.ShouldIgnore(ctx, "")).To(BeFalse())
+				Expect(ic.ShouldIgnore(ctx, ".")).To(BeFalse())
+			})
+
+			It("should ignore all other paths with wildcard", func() {
+				Expect(ic.ShouldIgnore(ctx, "file.txt")).To(BeTrue())
+				Expect(ic.ShouldIgnore(ctx, "folder/file.mp3")).To(BeTrue())
+			})
+		})
+
+		DescribeTable("pattern matching",
+			func(pattern string, path string, shouldMatch bool) {
+				fsys := fstest.MapFS{
+					".ndignore": &fstest.MapFile{Data: []byte(pattern)},
+				}
+				ic = newIgnoreChecker(fsys)
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(ic.ShouldIgnore(ctx, path)).To(Equal(shouldMatch))
+			},
+			Entry("glob match", "*.txt", "file.txt", true),
+			Entry("glob no match", "*.txt", "file.mp3", false),
+			Entry("directory pattern match", "tmp/", "tmp/file.txt", true),
+			Entry("directory pattern no match", "tmp/", "temporary/file.txt", false),
+			Entry("nested glob match", "**/*.log", "deep/nested/file.log", true),
+			Entry("nested glob no match", "**/*.log", "deep/nested/file.txt", false),
+			Entry("specific file match", "ignore.me", "ignore.me", true),
+			Entry("specific file no match", "ignore.me", "keep.me", false),
+			Entry("wildcard all", "**/*", "any/path/file.txt", true),
+			Entry("nested specific match", "temp/*", "temp/cache.db", true),
+			Entry("nested specific no match", "temp/*", "temporary/cache.db", false),
+		)
+
+		Context("with multiple patterns", func() {
+			BeforeEach(func() {
+				fsys := fstest.MapFS{
+					".ndignore": &fstest.MapFile{Data: []byte("*.txt\n*.log\ntemp/")},
+				}
+				ic = newIgnoreChecker(fsys)
+				err := ic.Push(ctx, ".")
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("should match any of the patterns", func() {
+				Expect(ic.ShouldIgnore(ctx, "file.txt")).To(BeTrue())
+				Expect(ic.ShouldIgnore(ctx, "debug.log")).To(BeTrue())
+				Expect(ic.ShouldIgnore(ctx, "temp/cache")).To(BeTrue())
+				Expect(ic.ShouldIgnore(ctx, "music.mp3")).To(BeFalse())
+			})
+		})
+	})
+})

scanner/phase_1_folders.go

@@ -26,58 +26,46 @@ import (
 	"github.com/navidrome/navidrome/utils/slice"
 )
 
-func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore, cw artwork.CacheWarmer, libs []model.Library) *phaseFolders {
+func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore, cw artwork.CacheWarmer) *phaseFolders {
 	var jobs []*scanJob
-	var updatedLibs []model.Library
-	for _, lib := range libs {
-		if lib.LastScanStartedAt.IsZero() {
-			err := ds.Library(ctx).ScanBegin(lib.ID, state.fullScan)
-			if err != nil {
-				log.Error(ctx, "Scanner: Error updating last scan started at", "lib", lib.Name, err)
-				state.sendWarning(err.Error())
-				continue
-			}
-			// Reload library to get updated state
-			l, err := ds.Library(ctx).Get(lib.ID)
-			if err != nil {
-				log.Error(ctx, "Scanner: Error reloading library", "lib", lib.Name, err)
-				state.sendWarning(err.Error())
-				continue
-			}
-			lib = *l
-		} else {
-			log.Debug(ctx, "Scanner: Resuming previous scan", "lib", lib.Name, "lastScanStartedAt", lib.LastScanStartedAt, "fullScan", lib.FullScanInProgress)
+
+	// Create scan jobs for all libraries
+	for _, lib := range state.libraries {
+		// Get target folders for this library if selective scan
+		var targetFolders []string
+		if state.isSelectiveScan() {
+			targetFolders = state.targets[lib.ID]
 		}
-		job, err := newScanJob(ctx, ds, cw, lib, state.fullScan)
+
+		job, err := newScanJob(ctx, ds, cw, lib, state.fullScan, targetFolders)
 		if err != nil {
 			log.Error(ctx, "Scanner: Error creating scan context", "lib", lib.Name, err)
 			state.sendWarning(err.Error())
 			continue
 		}
 		jobs = append(jobs, job)
-		updatedLibs = append(updatedLibs, lib)
 	}
 
-	// Update the state with the libraries that have been processed and have their scan timestamps set
-	state.libraries = updatedLibs
-
 	return &phaseFolders{jobs: jobs, ctx: ctx, ds: ds, state: state}
 }
 
 type scanJob struct {
-	lib         model.Library
-	fs          storage.MusicFS
-	cw          artwork.CacheWarmer
-	lastUpdates map[string]model.FolderUpdateInfo
-	lock        sync.Mutex
-	numFolders  atomic.Int64
+	lib           model.Library
+	fs            storage.MusicFS
+	cw            artwork.CacheWarmer
+	lastUpdates   map[string]model.FolderUpdateInfo // Holds last update info for all (DB) folders in this library
+	targetFolders []string                          // Specific folders to scan (including all descendants)
+	lock          sync.Mutex
+	numFolders    atomic.Int64
 }
 
-func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer, lib model.Library, fullScan bool) (*scanJob, error) {
-	lastUpdates, err := ds.Folder(ctx).GetLastUpdates(lib)
+func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer, lib model.Library, fullScan bool, targetFolders []string) (*scanJob, error) {
+	// Get folder updates, optionally filtered to specific target folders
+	lastUpdates, err := ds.Folder(ctx).GetFolderUpdateInfo(lib, targetFolders...)
 	if err != nil {
 		return nil, fmt.Errorf("getting last updates: %w", err)
 	}
+
 	fileStore, err := storage.For(lib.Path)
 	if err != nil {
 		log.Error(ctx, "Error getting storage for library", "library", lib.Name, "path", lib.Path, err)
@@ -88,15 +76,17 @@ func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer,
 		log.Error(ctx, "Error getting fs for library", "library", lib.Name, "path", lib.Path, err)
 		return nil, fmt.Errorf("getting fs for library: %w", err)
 	}
-	lib.FullScanInProgress = lib.FullScanInProgress || fullScan
 	return &scanJob{
-		lib:         lib,
-		fs:          fsys,
-		cw:          cw,
-		lastUpdates: lastUpdates,
+		lib:           lib,
+		fs:            fsys,
+		cw:            cw,
+		lastUpdates:   lastUpdates,
+		targetFolders: targetFolders,
 	}, nil
 }
 
+// popLastUpdate retrieves and removes the last update info for the given folder ID
+// This is used to track which folders have been found during the walk_dir_tree
 func (j *scanJob) popLastUpdate(folderID string) model.FolderUpdateInfo {
 	j.lock.Lock()
 	defer j.lock.Unlock()
@@ -106,6 +96,15 @@ func (j *scanJob) popLastUpdate(folderID string) model.FolderUpdateInfo {
 	return lastUpdate
 }
 
+// createFolderEntry creates a new folderEntry for the given path, using the last update info from the job
+// to populate the previous update time and hash. It also removes the folder from the job's lastUpdates map.
+// This is used to track which folders have been found during the walk_dir_tree.
+func (j *scanJob) createFolderEntry(path string) *folderEntry {
+	id := model.FolderID(j.lib, path)
+	info := j.popLastUpdate(id)
+	return newFolderEntry(j, id, path, info.UpdatedAt, info.Hash)
+}
+
 // phaseFolders represents the first phase of the scanning process, which is responsible
 // for scanning all libraries and importing new or updated files. This phase involves
 // traversing the directory tree of each library, identifying new or modified media files,
@@ -144,7 +143,8 @@ func (p *phaseFolders) producer() ppl.Producer[*folderEntry] {
 			if utils.IsCtxDone(p.ctx) {
 				break
 			}
-			outputChan, err := walkDirTree(p.ctx, job)
+
+			outputChan, err := walkDirTree(p.ctx, job, job.targetFolders...)
 			if err != nil {
 				log.Warn(p.ctx, "Scanner: Error scanning library", "lib", job.lib.Name, err)
 			}

scanner/phase_2_missing_tracks.go

@@ -69,9 +69,6 @@ func (p *phaseMissingTracks) produce(put func(tracks *missingTracks)) error {
 		}
 	}
 	for _, lib := range p.state.libraries {
-		if lib.LastScanStartedAt.IsZero() {
-			continue
-		}
 		log.Debug(p.ctx, "Scanner: Checking missing tracks", "libraryId", lib.ID, "libraryName", lib.Name)
 		cursor, err := p.ds.MediaFile(p.ctx).GetMissingAndMatching(lib.ID)
 		if err != nil {

scanner/phase_3_refresh_albums.go

@@ -27,14 +27,13 @@ import (
 type phaseRefreshAlbums struct {
 	ds        model.DataStore
 	ctx       context.Context
-	libs      model.Libraries
 	refreshed atomic.Uint32
 	skipped   atomic.Uint32
 	state     *scanState
 }
 
-func createPhaseRefreshAlbums(ctx context.Context, state *scanState, ds model.DataStore, libs model.Libraries) *phaseRefreshAlbums {
-	return &phaseRefreshAlbums{ctx: ctx, ds: ds, libs: libs, state: state}
+func createPhaseRefreshAlbums(ctx context.Context, state *scanState, ds model.DataStore) *phaseRefreshAlbums {
+	return &phaseRefreshAlbums{ctx: ctx, ds: ds, state: state}
 }
 
 func (p *phaseRefreshAlbums) description() string {
@@ -47,7 +46,7 @@ func (p *phaseRefreshAlbums) producer() ppl.Producer[*model.Album] {
 
 func (p *phaseRefreshAlbums) produce(put func(album *model.Album)) error {
 	count := 0
-	for _, lib := range p.libs {
+	for _, lib := range p.state.libraries {
 		cursor, err := p.ds.Album(p.ctx).GetTouchedAlbums(lib.ID)
 		if err != nil {
 			return fmt.Errorf("loading touched albums: %w", err)

scanner/phase_3_refresh_albums_test.go

@@ -32,8 +32,8 @@ var _ = Describe("phaseRefreshAlbums", func() {
 			{ID: 1, Name: "Library 1"},
 			{ID: 2, Name: "Library 2"},
 		}
-		state = &scanState{}
-		phase = createPhaseRefreshAlbums(ctx, state, ds, libs)
+		state = &scanState{libraries: libs}
+		phase = createPhaseRefreshAlbums(ctx, state, ds)
 	})
 
 	Describe("description", func() {

scanner/scanner.go

@@ -3,6 +3,8 @@ package scanner
 import (
 	"context"
 	"fmt"
+	"maps"
+	"slices"
 	"sync/atomic"
 	"time"
 
@@ -15,6 +17,7 @@ import (
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils/run"
+	"github.com/navidrome/navidrome/utils/slice"
 )
 
 type scannerImpl struct {
@@ -28,7 +31,8 @@ type scanState struct {
 	progress        chan<- *ProgressInfo
 	fullScan        bool
 	changesDetected atomic.Bool
-	libraries       model.Libraries // Store libraries list for consistency across phases
+	libraries       model.Libraries  // Store libraries list for consistency across phases
+	targets         map[int][]string // Optional: map[libraryID][]folderPaths for selective scans
 }
 
 func (s *scanState) sendProgress(info *ProgressInfo) {
@@ -37,6 +41,10 @@ func (s *scanState) sendProgress(info *ProgressInfo) {
 	}
 }
 
+func (s *scanState) isSelectiveScan() bool {
+	return len(s.targets) > 0
+}
+
 func (s *scanState) sendWarning(msg string) {
 	s.sendProgress(&ProgressInfo{Warning: msg})
 }
@@ -45,7 +53,7 @@ func (s *scanState) sendError(err error) {
 	s.sendProgress(&ProgressInfo{Error: err.Error()})
 }
 
-func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<- *ProgressInfo) {
+func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo) {
 	startTime := time.Now()
 
 	state := scanState{
@@ -59,38 +67,75 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
 		state.changesDetected.Store(true)
 	}
 
-	libs, err := s.ds.Library(ctx).GetAll()
+	// Get libraries and optionally filter by targets
+	allLibs, err := s.ds.Library(ctx).GetAll()
 	if err != nil {
 		state.sendWarning(fmt.Sprintf("getting libraries: %s", err))
 		return
 	}
-	state.libraries = libs
 
-	log.Info(ctx, "Scanner: Starting scan", "fullScan", state.fullScan, "numLibraries", len(libs))
+	if len(targets) > 0 {
+		// Selective scan: filter libraries and build targets map
+		state.targets = make(map[int][]string)
+
+		for _, target := range targets {
+			folderPath := target.FolderPath
+			if folderPath == "" {
+				folderPath = "."
+			}
+			state.targets[target.LibraryID] = append(state.targets[target.LibraryID], folderPath)
+		}
+
+		// Filter libraries to only those in targets
+		state.libraries = slice.Filter(allLibs, func(lib model.Library) bool {
+			return len(state.targets[lib.ID]) > 0
+		})
+
+		log.Info(ctx, "Scanner: Starting selective scan", "fullScan", state.fullScan, "numLibraries", len(state.libraries), "numTargets", len(targets))
+	} else {
+		// Full library scan
+		state.libraries = allLibs
+		log.Info(ctx, "Scanner: Starting scan", "fullScan", state.fullScan, "numLibraries", len(state.libraries))
+	}
 
 	// Store scan type and start time
 	scanType := "quick"
 	if state.fullScan {
 		scanType = "full"
 	}
+	if state.isSelectiveScan() {
+		scanType += "-selective"
+	}
 	_ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, scanType)
 	_ = s.ds.Property(ctx).Put(consts.LastScanStartTimeKey, startTime.Format(time.RFC3339))
 
 	// if there was a full scan in progress, force a full scan
 	if !state.fullScan {
-		for _, lib := range libs {
+		for _, lib := range state.libraries {
 			if lib.FullScanInProgress {
 				log.Info(ctx, "Scanner: Interrupted full scan detected", "lib", lib.Name)
 				state.fullScan = true
-				_ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, "full")
+				if state.isSelectiveScan() {
+					_ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, "full-selective")
+				} else {
+					_ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, "full")
+				}
 				break
 			}
 		}
 	}
 
+	// Prepare libraries for scanning (initialize LastScanStartedAt if needed)
+	err = s.prepareLibrariesForScan(ctx, &state)
+	if err != nil {
+		log.Error(ctx, "Scanner: Error preparing libraries for scan", err)
+		state.sendError(err)
+		return
+	}
+
 	err = run.Sequentially(
 		// Phase 1: Scan all libraries and import new/updated files
-		runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds, s.cw, libs)),
+		runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds, s.cw)),
 
 		// Phase 2: Process missing files, checking for moves
 		runPhase[*missingTracks](ctx, 2, createPhaseMissingTracks(ctx, &state, s.ds)),
@@ -98,7 +143,7 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
 		// Phases 3 and 4 can be run in parallel
 		run.Parallel(
 			// Phase 3: Refresh all new/changed albums and update artists
-			runPhase[*model.Album](ctx, 3, createPhaseRefreshAlbums(ctx, &state, s.ds, libs)),
+			runPhase[*model.Album](ctx, 3, createPhaseRefreshAlbums(ctx, &state, s.ds)),
 
 			// Phase 4: Import/update playlists
 			runPhase[*model.Folder](ctx, 4, createPhasePlaylists(ctx, &state, s.ds, s.pls, s.cw)),
@@ -131,7 +176,53 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
 		state.sendProgress(&ProgressInfo{ChangesDetected: true})
 	}
 
-	log.Info(ctx, "Scanner: Finished scanning all libraries", "duration", time.Since(startTime))
+	if state.isSelectiveScan() {
+		log.Info(ctx, "Scanner: Finished scanning selected folders", "duration", time.Since(startTime), "numTargets", len(targets))
+	} else {
+		log.Info(ctx, "Scanner: Finished scanning all libraries", "duration", time.Since(startTime))
+	}
+}
+
+// prepareLibrariesForScan initializes the scan for all libraries in the state.
+// It calls ScanBegin for libraries that haven't started scanning yet (LastScanStartedAt is zero),
+// reloads them to get the updated state, and filters out any libraries that fail to initialize.
+func (s *scannerImpl) prepareLibrariesForScan(ctx context.Context, state *scanState) error {
+	var successfulLibs []model.Library
+
+	for _, lib := range state.libraries {
+		if lib.LastScanStartedAt.IsZero() {
+			// This is a new scan - mark it as started
+			err := s.ds.Library(ctx).ScanBegin(lib.ID, state.fullScan)
+			if err != nil {
+				log.Error(ctx, "Scanner: Error marking scan start", "lib", lib.Name, err)
+				state.sendWarning(err.Error())
+				continue
+			}
+
+			// Reload library to get updated state (timestamps, etc.)
+			reloadedLib, err := s.ds.Library(ctx).Get(lib.ID)
+			if err != nil {
+				log.Error(ctx, "Scanner: Error reloading library", "lib", lib.Name, err)
+				state.sendWarning(err.Error())
+				continue
+			}
+			lib = *reloadedLib
+		} else {
+			// This is a resumed scan
+			log.Debug(ctx, "Scanner: Resuming previous scan", "lib", lib.Name,
+				"lastScanStartedAt", lib.LastScanStartedAt, "fullScan", lib.FullScanInProgress)
+		}
+
+		successfulLibs = append(successfulLibs, lib)
+	}
+
+	if len(successfulLibs) == 0 {
+		return fmt.Errorf("no libraries available for scanning")
+	}
+
+	// Update state with only successfully initialized libraries
+	state.libraries = successfulLibs
+	return nil
 }
 
 func (s *scannerImpl) runGC(ctx context.Context, state *scanState) func() error {
@@ -140,7 +231,15 @@ func (s *scannerImpl) runGC(ctx context.Context, state *scanState) func() error
 		return s.ds.WithTx(func(tx model.DataStore) error {
 			if state.changesDetected.Load() {
 				start := time.Now()
-				err := tx.GC(ctx)
+
+				// For selective scans, extract library IDs to scope GC operations
+				var libraryIDs []int
+				if state.isSelectiveScan() {
+					libraryIDs = slices.Collect(maps.Keys(state.targets))
+					log.Debug(ctx, "Scanner: Running selective GC", "libraryIDs", libraryIDs)
+				}
+
+				err := tx.GC(ctx, libraryIDs...)
 				if err != nil {
 					log.Error(ctx, "Scanner: Error running GC", err)
 					return fmt.Errorf("running GC: %w", err)

scanner/scanner_multilibrary_test.go

@@ -32,7 +32,7 @@ var _ = Describe("Scanner - Multi-Library", Ordered, func() {
 	var ctx context.Context
 	var lib1, lib2 model.Library
 	var ds *tests.MockDataStore
-	var s scanner.Scanner
+	var s model.Scanner
 
 	createFS := func(path string, files fstest.MapFS) storagetest.FakeFS {
 		fs := storagetest.FakeFS{}

scanner/scanner_selective_test.go

@@ -0,0 +1,293 @@
+package scanner_test
+
+import (
+	"context"
+	"path/filepath"
+	"testing/fstest"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/artwork"
+	"github.com/navidrome/navidrome/core/metrics"
+	"github.com/navidrome/navidrome/core/storage/storagetest"
+	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/persistence"
+	"github.com/navidrome/navidrome/scanner"
+	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/tests"
+	"github.com/navidrome/navidrome/utils/slice"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ScanFolders", Ordered, func() {
+	var ctx context.Context
+	var lib model.Library
+	var ds model.DataStore
+	var s model.Scanner
+	var fsys storagetest.FakeFS
+
+	BeforeAll(func() {
+		ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "123", IsAdmin: true})
+		tmpDir := GinkgoT().TempDir()
+		conf.Server.DbPath = filepath.Join(tmpDir, "test-selective-scan.db?_journal_mode=WAL")
+		log.Warn("Using DB at " + conf.Server.DbPath)
+		db.Db().SetMaxOpenConns(1)
+	})
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+		conf.Server.MusicFolder = "fake:///music"
+		conf.Server.DevExternalScanner = false
+
+		db.Init(ctx)
+		DeferCleanup(func() {
+			Expect(tests.ClearDB()).To(Succeed())
+		})
+
+		ds = persistence.New(db.Db())
+
+		// Create the admin user in the database to match the context
+		adminUser := model.User{
+			ID:          "123",
+			UserName:    "admin",
+			Name:        "Admin User",
+			IsAdmin:     true,
+			NewPassword: "password",
+		}
+		Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())
+
+		s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
+			core.NewPlaylists(ds), metrics.NewNoopInstance())
+
+		lib = model.Library{ID: 1, Name: "Fake Library", Path: "fake:///music"}
+		Expect(ds.Library(ctx).Put(&lib)).To(Succeed())
+
+		// Initialize fake filesystem
+		fsys = storagetest.FakeFS{}
+		storagetest.Register("fake", &fsys)
+	})
+
+	Describe("Adding tracks to the library", func() {
+		It("scans specified folders recursively including all subdirectories", func() {
+			rock := template(_t{"albumartist": "Rock Artist", "album": "Rock Album"})
+			jazz := template(_t{"albumartist": "Jazz Artist", "album": "Jazz Album"})
+			pop := template(_t{"albumartist": "Pop Artist", "album": "Pop Album"})
+			createFS(fstest.MapFS{
+				"rock/track1.mp3":        rock(track(1, "Rock Track 1")),
+				"rock/track2.mp3":        rock(track(2, "Rock Track 2")),
+				"rock/subdir/track3.mp3": rock(track(3, "Rock Track 3")),
+				"jazz/track4.mp3":        jazz(track(1, "Jazz Track 1")),
+				"jazz/subdir/track5.mp3": jazz(track(2, "Jazz Track 2")),
+				"pop/track6.mp3":         pop(track(1, "Pop Track 1")),
+			})
+
+			// Scan only the "rock" and "jazz" folders (including their subdirectories)
+			targets := []model.ScanTarget{
+				{LibraryID: lib.ID, FolderPath: "rock"},
+				{LibraryID: lib.ID, FolderPath: "jazz"},
+			}
+
+			warnings, err := s.ScanFolders(ctx, false, targets)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(warnings).To(BeEmpty())
+
+			// Verify all tracks in rock and jazz folders (including subdirectories) were imported
+			allFiles, err := ds.MediaFile(ctx).GetAll()
+			Expect(err).ToNot(HaveOccurred())
+
+			// Should have 5 tracks (all rock and jazz tracks including subdirectories)
+			Expect(allFiles).To(HaveLen(5))
+
+			// Get the file paths
+			paths := slice.Map(allFiles, func(mf model.MediaFile) string {
+				return filepath.ToSlash(mf.Path)
+			})
+
+			// Verify the correct files were scanned (including subdirectories)
+			Expect(paths).To(ContainElements(
+				"rock/track1.mp3",
+				"rock/track2.mp3",
+				"rock/subdir/track3.mp3",
+				"jazz/track4.mp3",
+				"jazz/subdir/track5.mp3",
+			))
+
+			// Verify files in the pop folder were NOT scanned
+			Expect(paths).ToNot(ContainElement("pop/track6.mp3"))
+		})
+	})
+
+	Describe("Deleting folders", func() {
+		Context("when a child folder is deleted", func() {
+			var (
+				revolver, help func(...map[string]any) *fstest.MapFile
+				artistFolderID string
+				album1FolderID string
+				album2FolderID string
+				album1TrackIDs []string
+				album2TrackIDs []string
+			)
+
+			BeforeEach(func() {
+				// Setup template functions for creating test files
+				revolver = storagetest.Template(_t{"albumartist": "The Beatles", "album": "Revolver", "year": 1966})
+				help = storagetest.Template(_t{"albumartist": "The Beatles", "album": "Help!", "year": 1965})
+
+				// Initial filesystem with nested folders
+				fsys.SetFiles(fstest.MapFS{
+					"The Beatles/Revolver/01 - Taxman.mp3":        revolver(storagetest.Track(1, "Taxman")),
+					"The Beatles/Revolver/02 - Eleanor Rigby.mp3": revolver(storagetest.Track(2, "Eleanor Rigby")),
+					"The Beatles/Help!/01 - Help!.mp3":            help(storagetest.Track(1, "Help!")),
+					"The Beatles/Help!/02 - The Night Before.mp3": help(storagetest.Track(2, "The Night Before")),
+				})
+
+				// First scan - import everything
+				_, err := s.ScanAll(ctx, true)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Verify initial state - all folders exist
+				folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"library_id": lib.ID}})
+				Expect(err).ToNot(HaveOccurred())
+				Expect(folders).To(HaveLen(4)) // root, Artist, Album1, Album2
+
+				// Store folder IDs for later verification
+				for _, f := range folders {
+					switch f.Name {
+					case "The Beatles":
+						artistFolderID = f.ID
+					case "Revolver":
+						album1FolderID = f.ID
+					case "Help!":
+						album2FolderID = f.ID
+					}
+				}
+
+				// Verify all tracks exist
+				allTracks, err := ds.MediaFile(ctx).GetAll()
+				Expect(err).ToNot(HaveOccurred())
+				Expect(allTracks).To(HaveLen(4))
+
+				// Store track IDs for later verification
+				for _, t := range allTracks {
+					if t.Album == "Revolver" {
+						album1TrackIDs = append(album1TrackIDs, t.ID)
+					} else if t.Album == "Help!" {
+						album2TrackIDs = append(album2TrackIDs, t.ID)
+					}
+				}
+
+				// Verify no tracks are missing initially
+				for _, t := range allTracks {
+					Expect(t.Missing).To(BeFalse())
+				}
+			})
+
+			It("should mark child folder and its tracks as missing when parent is scanned", func() {
+				// Delete the child folder (Help!) from the filesystem
+				fsys.SetFiles(fstest.MapFS{
+					"The Beatles/Revolver/01 - Taxman.mp3":        revolver(storagetest.Track(1, "Taxman")),
+					"The Beatles/Revolver/02 - Eleanor Rigby.mp3": revolver(storagetest.Track(2, "Eleanor Rigby")),
+					// "The Beatles/Help!" folder and its contents are DELETED
+				})
+
+				// Run selective scan on the parent folder (Artist)
+				// This simulates what the watcher does when a child folder is deleted
+				_, err := s.ScanFolders(ctx, false, []model.ScanTarget{
+					{LibraryID: lib.ID, FolderPath: "The Beatles"},
+				})
+				Expect(err).ToNot(HaveOccurred())
+
+				// Verify the deleted child folder is now marked as missing
+				deletedFolder, err := ds.Folder(ctx).Get(album2FolderID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(deletedFolder.Missing).To(BeTrue(), "Deleted child folder should be marked as missing")
+
+				// Verify the deleted folder's tracks are marked as missing
+				for _, trackID := range album2TrackIDs {
+					track, err := ds.MediaFile(ctx).Get(trackID)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(track.Missing).To(BeTrue(), "Track in deleted folder should be marked as missing")
+				}
+
+				// Verify the parent folder is still present and not marked as missing
+				parentFolder, err := ds.Folder(ctx).Get(artistFolderID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(parentFolder.Missing).To(BeFalse(), "Parent folder should not be marked as missing")
+
+				// Verify the sibling folder and its tracks are still present and not missing
+				siblingFolder, err := ds.Folder(ctx).Get(album1FolderID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(siblingFolder.Missing).To(BeFalse(), "Sibling folder should not be marked as missing")
+
+				for _, trackID := range album1TrackIDs {
+					track, err := ds.MediaFile(ctx).Get(trackID)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(track.Missing).To(BeFalse(), "Track in sibling folder should not be marked as missing")
+				}
+			})
+
+			It("should mark deeply nested child folders as missing", func() {
+				// Add a deeply nested folder structure
+				fsys.SetFiles(fstest.MapFS{
+					"The Beatles/Revolver/01 - Taxman.mp3":               revolver(storagetest.Track(1, "Taxman")),
+					"The Beatles/Revolver/02 - Eleanor Rigby.mp3":        revolver(storagetest.Track(2, "Eleanor Rigby")),
+					"The Beatles/Help!/01 - Help!.mp3":                   help(storagetest.Track(1, "Help!")),
+					"The Beatles/Help!/02 - The Night Before.mp3":        help(storagetest.Track(2, "The Night Before")),
+					"The Beatles/Help!/Bonus/01 - Bonus Track.mp3":       help(storagetest.Track(99, "Bonus Track")),
+					"The Beatles/Help!/Bonus/Nested/01 - Deep Track.mp3": help(storagetest.Track(100, "Deep Track")),
+				})
+
+				// Rescan to import the new nested structure
+				_, err := s.ScanAll(ctx, true)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Verify nested folders were created
+				allFolders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"library_id": lib.ID}})
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(allFolders)).To(BeNumerically(">", 4), "Should have more folders with nested structure")
+
+				// Now delete the entire Help! folder including nested children
+				fsys.SetFiles(fstest.MapFS{
+					"The Beatles/Revolver/01 - Taxman.mp3":        revolver(storagetest.Track(1, "Taxman")),
+					"The Beatles/Revolver/02 - Eleanor Rigby.mp3": revolver(storagetest.Track(2, "Eleanor Rigby")),
+					// All Help! subfolders are deleted
+				})
+
+				// Run selective scan on parent
+				_, err = s.ScanFolders(ctx, false, []model.ScanTarget{
+					{LibraryID: lib.ID, FolderPath: "The Beatles"},
+				})
+				Expect(err).ToNot(HaveOccurred())
+
+				// Verify all Help! folders (including nested ones) are marked as missing
+				missingFolders, err := ds.Folder(ctx).GetAll(model.QueryOptions{
+					Filters: squirrel.And{
+						squirrel.Eq{"library_id": lib.ID},
+						squirrel.Eq{"missing": true},
+					},
+				})
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(missingFolders)).To(BeNumerically(">", 0), "At least one folder should be marked as missing")
+
+				// Verify all tracks in deleted folders are marked as missing
+				allTracks, err := ds.MediaFile(ctx).GetAll()
+				Expect(err).ToNot(HaveOccurred())
+				Expect(allTracks).To(HaveLen(6))
+
+				for _, track := range allTracks {
+					if track.Album == "Help!" {
+						Expect(track.Missing).To(BeTrue(), "All tracks in deleted Help! folder should be marked as missing")
+					} else if track.Album == "Revolver" {
+						Expect(track.Missing).To(BeFalse(), "Tracks in Revolver folder should not be marked as missing")
+					}
+				}
+			})
+		})
+	})
+})

scanner/scanner_test.go

@@ -34,19 +34,19 @@ type _t = map[string]any
 var template = storagetest.Template
 var track = storagetest.Track
 
+func createFS(files fstest.MapFS) storagetest.FakeFS {
+	fs := storagetest.FakeFS{}
+	fs.SetFiles(files)
+	storagetest.Register("fake", &fs)
+	return fs
+}
+
 var _ = Describe("Scanner", Ordered, func() {
 	var ctx context.Context
 	var lib model.Library
 	var ds *tests.MockDataStore
 	var mfRepo *mockMediaFileRepo
-	var s scanner.Scanner
-
-	createFS := func(files fstest.MapFS) storagetest.FakeFS {
-		fs := storagetest.FakeFS{}
-		fs.SetFiles(files)
-		storagetest.Register("fake", &fs)
-		return fs
-	}
+	var s model.Scanner
 
 	BeforeAll(func() {
 		ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "123", IsAdmin: true})
@@ -478,6 +478,56 @@ var _ = Describe("Scanner", Ordered, func() {
 			Expect(mf.Missing).To(BeFalse())
 		})
 
+		It("marks tracks as missing when scanning a deleted folder with ScanFolders", func() {
+			By("Adding a third track to Revolver to have more test data")
+			fsys.Add("The Beatles/Revolver/03 - I'm Only Sleeping.mp3", revolver(track(3, "I'm Only Sleeping")))
+			Expect(runScanner(ctx, false)).To(Succeed())
+
+			By("Verifying initial state has 5 tracks")
+			Expect(ds.MediaFile(ctx).CountAll(model.QueryOptions{
+				Filters: squirrel.Eq{"missing": false},
+			})).To(Equal(int64(5)))
+
+			By("Removing the entire Revolver folder from filesystem")
+			fsys.Remove("The Beatles/Revolver/01 - Taxman.mp3")
+			fsys.Remove("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+			fsys.Remove("The Beatles/Revolver/03 - I'm Only Sleeping.mp3")
+
+			By("Scanning the parent folder (simulating watcher behavior)")
+			targets := []model.ScanTarget{
+				{LibraryID: lib.ID, FolderPath: "The Beatles"},
+			}
+			_, err := s.ScanFolders(ctx, false, targets)
+			Expect(err).To(Succeed())
+
+			By("Checking all Revolver tracks are marked as missing")
+			mf, err := findByPath("The Beatles/Revolver/01 - Taxman.mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(mf.Missing).To(BeTrue())
+
+			mf, err = findByPath("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(mf.Missing).To(BeTrue())
+
+			mf, err = findByPath("The Beatles/Revolver/03 - I'm Only Sleeping.mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(mf.Missing).To(BeTrue())
+
+			By("Checking the Help! tracks are not affected")
+			mf, err = findByPath("The Beatles/Help!/01 - Help!.mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(mf.Missing).To(BeFalse())
+
+			mf, err = findByPath("The Beatles/Help!/02 - The Night Before.mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(mf.Missing).To(BeFalse())
+
+			By("Verifying only 2 non-missing tracks remain (Help! tracks)")
+			Expect(ds.MediaFile(ctx).CountAll(model.QueryOptions{
+				Filters: squirrel.Eq{"missing": false},
+			})).To(Equal(int64(2)))
+		})
+
 		It("does not override artist fields when importing an undertagged file", func() {
 			By("Making sure artist in the DB contains MBID and sort name")
 			aa, err := ds.Artist(ctx).GetAll(model.QueryOptions{

scanner/walk_dir_tree.go

@@ -1,7 +1,6 @@
 package scanner
 
 import (
-	"bufio"
 	"context"
 	"io/fs"
 	"maps"
@@ -11,37 +10,69 @@ import (
 	"strings"
 
 	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils"
-	ignore "github.com/sabhiram/go-gitignore"
 )
 
-func walkDirTree(ctx context.Context, job *scanJob) (<-chan *folderEntry, error) {
+// walkDirTree recursively walks the directory tree starting from the given targetFolders.
+// If no targetFolders are provided, it starts from the root folder (".").
+// It returns a channel of folderEntry pointers representing each folder found.
+func walkDirTree(ctx context.Context, job *scanJob, targetFolders ...string) (<-chan *folderEntry, error) {
 	results := make(chan *folderEntry)
+	folders := targetFolders
+	if len(targetFolders) == 0 {
+		// No specific folders provided, scan the root folder
+		folders = []string{"."}
+	}
 	go func() {
 		defer close(results)
-		err := walkFolder(ctx, job, ".", nil, results)
-		if err != nil {
-			log.Error(ctx, "Scanner: There were errors reading directories from filesystem", "path", job.lib.Path, err)
-			return
+		for _, folderPath := range folders {
+			if utils.IsCtxDone(ctx) {
+				return
+			}
+
+			// Check if target folder exists before walking it
+			// If it doesn't exist (e.g., deleted between watcher detection and scan execution),
+			// skip it so it remains in job.lastUpdates and gets handled in following steps
+			_, err := fs.Stat(job.fs, folderPath)
+			if err != nil {
+				log.Warn(ctx, "Scanner: Target folder does not exist.", "path", folderPath, err)
+				continue
+			}
+
+			// Create checker and push patterns from root to this folder
+			checker := newIgnoreChecker(job.fs)
+			err = checker.PushAllParents(ctx, folderPath)
+			if err != nil {
+				log.Error(ctx, "Scanner: Error pushing ignore patterns for target folder", "path", folderPath, err)
+				continue
+			}
+
+			// Recursively walk this folder and all its children
+			err = walkFolder(ctx, job, folderPath, checker, results)
+			if err != nil {
+				log.Error(ctx, "Scanner: Error walking target folder", "path", folderPath, err)
+				continue
+			}
 		}
-		log.Debug(ctx, "Scanner: Finished reading folders", "lib", job.lib.Name, "path", job.lib.Path, "numFolders", job.numFolders.Load())
+		log.Debug(ctx, "Scanner: Finished reading target folders", "lib", job.lib.Name, "path", job.lib.Path, "numFolders", job.numFolders.Load())
 	}()
 	return results, nil
 }
 
-func walkFolder(ctx context.Context, job *scanJob, currentFolder string, ignorePatterns []string, results chan<- *folderEntry) error {
-	ignorePatterns = loadIgnoredPatterns(ctx, job.fs, currentFolder, ignorePatterns)
+func walkFolder(ctx context.Context, job *scanJob, currentFolder string, checker *IgnoreChecker, results chan<- *folderEntry) error {
+	// Push patterns for this folder onto the stack
+	_ = checker.Push(ctx, currentFolder)
+	defer checker.Pop() // Pop patterns when leaving this folder
 
-	folder, children, err := loadDir(ctx, job, currentFolder, ignorePatterns)
+	folder, children, err := loadDir(ctx, job, currentFolder, checker)
 	if err != nil {
 		log.Warn(ctx, "Scanner: Error loading dir. Skipping", "path", currentFolder, err)
 		return nil
 	}
 	for _, c := range children {
-		err := walkFolder(ctx, job, c, ignorePatterns, results)
+		err := walkFolder(ctx, job, c, checker, results)
 		if err != nil {
 			return err
 		}
@@ -59,50 +90,17 @@ func walkFolder(ctx context.Context, job *scanJob, currentFolder string, ignoreP
 	return nil
 }
 
-func loadIgnoredPatterns(ctx context.Context, fsys fs.FS, currentFolder string, currentPatterns []string) []string {
-	ignoreFilePath := path.Join(currentFolder, consts.ScanIgnoreFile)
-	var newPatterns []string
-	if _, err := fs.Stat(fsys, ignoreFilePath); err == nil {
-		// Read and parse the .ndignore file
-		ignoreFile, err := fsys.Open(ignoreFilePath)
-		if err != nil {
-			log.Warn(ctx, "Scanner: Error opening .ndignore file", "path", ignoreFilePath, err)
-			// Continue with previous patterns
-		} else {
-			defer ignoreFile.Close()
-			scanner := bufio.NewScanner(ignoreFile)
-			for scanner.Scan() {
-				line := scanner.Text()
-				if line == "" || strings.HasPrefix(line, "#") {
-					continue // Skip empty lines and comments
-				}
-				newPatterns = append(newPatterns, line)
-			}
-			if err := scanner.Err(); err != nil {
-				log.Warn(ctx, "Scanner: Error reading .ignore file", "path", ignoreFilePath, err)
-			}
-		}
-		// If the .ndignore file is empty, mimic the current behavior and ignore everything
-		if len(newPatterns) == 0 {
-			log.Trace(ctx, "Scanner: .ndignore file is empty, ignoring everything", "path", currentFolder)
-			newPatterns = []string{"**/*"}
-		} else {
-			log.Trace(ctx, "Scanner: .ndignore file found ", "path", ignoreFilePath, "patterns", newPatterns)
-		}
-	}
-	// Combine the patterns from the .ndignore file with the ones passed as argument
-	combinedPatterns := append([]string{}, currentPatterns...)
-	return append(combinedPatterns, newPatterns...)
-}
-
-func loadDir(ctx context.Context, job *scanJob, dirPath string, ignorePatterns []string) (folder *folderEntry, children []string, err error) {
-	folder = newFolderEntry(job, dirPath)
-
+func loadDir(ctx context.Context, job *scanJob, dirPath string, checker *IgnoreChecker) (folder *folderEntry, children []string, err error) {
+	// Check if directory exists before creating the folder entry
+	// This is important to avoid removing the folder from lastUpdates if it doesn't exist
 	dirInfo, err := fs.Stat(job.fs, dirPath)
 	if err != nil {
 		log.Warn(ctx, "Scanner: Error stating dir", "path", dirPath, err)
 		return nil, nil, err
 	}
+
+	// Now that we know the folder exists, create the entry (which removes it from lastUpdates)
+	folder = job.createFolderEntry(dirPath)
 	folder.modTime = dirInfo.ModTime()
 
 	dir, err := job.fs.Open(dirPath)
@@ -117,12 +115,11 @@ func loadDir(ctx context.Context, job *scanJob, dirPath string, ignorePatterns [
 		return folder, children, err
 	}
 
-	ignoreMatcher := ignore.CompileIgnoreLines(ignorePatterns...)
 	entries := fullReadDir(ctx, dirFile)
 	children = make([]string, 0, len(entries))
 	for _, entry := range entries {
 		entryPath := path.Join(dirPath, entry.Name())
-		if len(ignorePatterns) > 0 && isScanIgnored(ctx, ignoreMatcher, entryPath) {
+		if checker.ShouldIgnore(ctx, entryPath) {
 			log.Trace(ctx, "Scanner: Ignoring entry", "path", entryPath)
 			continue
 		}
@@ -234,6 +231,7 @@ func isDirReadable(ctx context.Context, fsys fs.FS, dirPath string) bool {
 var ignoredDirs = []string{
 	"$RECYCLE.BIN",
 	"#snapshot",
+	"@Recycle",
 	"@Recently-Snapshot",
 	".streams",
 	"lost+found",
@@ -254,11 +252,3 @@ func isDirIgnored(name string) bool {
 func isEntryIgnored(name string) bool {
 	return strings.HasPrefix(name, ".") && !strings.HasPrefix(name, "..")
 }
-
-func isScanIgnored(ctx context.Context, matcher *ignore.GitIgnore, entryPath string) bool {
-	matches := matcher.MatchesPath(entryPath)
-	if matches {
-		log.Trace(ctx, "Scanner: Ignoring entry matching .ndignore: ", "path", entryPath)
-	}
-	return matches
-}

scanner/walk_dir_tree_test.go

@@ -25,82 +25,196 @@ var _ = Describe("walk_dir_tree", func() {
 			ctx  context.Context
 		)
 
-		BeforeEach(func() {
-			DeferCleanup(configtest.SetupConfig())
-			ctx = GinkgoT().Context()
-			fsys = &mockMusicFS{
-				FS: fstest.MapFS{
-					"root/a/.ndignore":       {Data: []byte("ignored/*")},
-					"root/a/f1.mp3":          {},
-					"root/a/f2.mp3":          {},
-					"root/a/ignored/bad.mp3": {},
-					"root/b/cover.jpg":       {},
-					"root/c/f3":              {},
-					"root/d":                 {},
-					"root/d/.ndignore":       {},
-					"root/d/f1.mp3":          {},
-					"root/d/f2.mp3":          {},
-					"root/d/f3.mp3":          {},
-					"root/e/original/f1.mp3": {},
-					"root/e/symlink":         {Mode: fs.ModeSymlink, Data: []byte("original")},
+		Context("full library", func() {
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig())
+				ctx = GinkgoT().Context()
+				fsys = &mockMusicFS{
+					FS: fstest.MapFS{
+						"root/a/.ndignore":       {Data: []byte("ignored/*")},
+						"root/a/f1.mp3":          {},
+						"root/a/f2.mp3":          {},
+						"root/a/ignored/bad.mp3": {},
+						"root/b/cover.jpg":       {},
+						"root/c/f3":              {},
+						"root/d":                 {},
+						"root/d/.ndignore":       {},
+						"root/d/f1.mp3":          {},
+						"root/d/f2.mp3":          {},
+						"root/d/f3.mp3":          {},
+						"root/e/original/f1.mp3": {},
+						"root/e/symlink":         {Mode: fs.ModeSymlink, Data: []byte("original")},
+					},
+				}
+				job = &scanJob{
+					fs:  fsys,
+					lib: model.Library{Path: "/music"},
+				}
+			})
+
+			// Helper function to call walkDirTree and collect folders from the results channel
+			getFolders := func() map[string]*folderEntry {
+				results, err := walkDirTree(ctx, job)
+				Expect(err).ToNot(HaveOccurred())
+
+				folders := map[string]*folderEntry{}
+				g := errgroup.Group{}
+				g.Go(func() error {
+					for folder := range results {
+						folders[folder.path] = folder
+					}
+					return nil
+				})
+				_ = g.Wait()
+				return folders
+			}
+
+			DescribeTable("symlink handling",
+				func(followSymlinks bool, expectedFolderCount int) {
+					conf.Server.Scanner.FollowSymlinks = followSymlinks
+					folders := getFolders()
+
+					Expect(folders).To(HaveLen(expectedFolderCount + 2)) // +2 for `.` and `root`
+
+					// Basic folder structure checks
+					Expect(folders["root/a"].audioFiles).To(SatisfyAll(
+						HaveLen(2),
+						HaveKey("f1.mp3"),
+						HaveKey("f2.mp3"),
+					))
+					Expect(folders["root/a"].imageFiles).To(BeEmpty())
+					Expect(folders["root/b"].audioFiles).To(BeEmpty())
+					Expect(folders["root/b"].imageFiles).To(SatisfyAll(
+						HaveLen(1),
+						HaveKey("cover.jpg"),
+					))
+					Expect(folders["root/c"].audioFiles).To(BeEmpty())
+					Expect(folders["root/c"].imageFiles).To(BeEmpty())
+					Expect(folders).ToNot(HaveKey("root/d"))
+
+					// Symlink specific checks
+					if followSymlinks {
+						Expect(folders["root/e/symlink"].audioFiles).To(HaveLen(1))
+					} else {
+						Expect(folders).ToNot(HaveKey("root/e/symlink"))
+					}
 				},
-			}
-			job = &scanJob{
-				fs:  fsys,
-				lib: model.Library{Path: "/music"},
-			}
+				Entry("with symlinks enabled", true, 7),
+				Entry("with symlinks disabled", false, 6),
+			)
 		})
 
-		// Helper function to call walkDirTree and collect folders from the results channel
-		getFolders := func() map[string]*folderEntry {
-			results, err := walkDirTree(ctx, job)
-			Expect(err).ToNot(HaveOccurred())
-
-			folders := map[string]*folderEntry{}
-			g := errgroup.Group{}
-			g.Go(func() error {
-				for folder := range results {
-					folders[folder.path] = folder
+		Context("with target folders", func() {
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig())
+				ctx = GinkgoT().Context()
+				fsys = &mockMusicFS{
+					FS: fstest.MapFS{
+						"Artist/Album1/track1.mp3":      {},
+						"Artist/Album1/track2.mp3":      {},
+						"Artist/Album2/track1.mp3":      {},
+						"Artist/Album2/track2.mp3":      {},
+						"Artist/Album2/Sub/track3.mp3":  {},
+						"OtherArtist/Album3/track1.mp3": {},
+					},
+				}
+				job = &scanJob{
+					fs:  fsys,
+					lib: model.Library{Path: "/music"},
 				}
-				return nil
 			})
-			_ = g.Wait()
-			return folders
-		}
 
-		DescribeTable("symlink handling",
-			func(followSymlinks bool, expectedFolderCount int) {
-				conf.Server.Scanner.FollowSymlinks = followSymlinks
-				folders := getFolders()
+			It("should recursively walk all subdirectories of target folders", func() {
+				results, err := walkDirTree(ctx, job, "Artist")
+				Expect(err).ToNot(HaveOccurred())
 
-				Expect(folders).To(HaveLen(expectedFolderCount + 2)) // +2 for `.` and `root`
+				folders := map[string]*folderEntry{}
+				g := errgroup.Group{}
+				g.Go(func() error {
+					for folder := range results {
+						folders[folder.path] = folder
+					}
+					return nil
+				})
+				_ = g.Wait()
 
-				// Basic folder structure checks
-				Expect(folders["root/a"].audioFiles).To(SatisfyAll(
-					HaveLen(2),
-					HaveKey("f1.mp3"),
-					HaveKey("f2.mp3"),
+				// Should include the target folder and all its descendants
+				Expect(folders).To(SatisfyAll(
+					HaveKey("Artist"),
+					HaveKey("Artist/Album1"),
+					HaveKey("Artist/Album2"),
+					HaveKey("Artist/Album2/Sub"),
 				))
-				Expect(folders["root/a"].imageFiles).To(BeEmpty())
-				Expect(folders["root/b"].audioFiles).To(BeEmpty())
-				Expect(folders["root/b"].imageFiles).To(SatisfyAll(
-					HaveLen(1),
-					HaveKey("cover.jpg"),
-				))
-				Expect(folders["root/c"].audioFiles).To(BeEmpty())
-				Expect(folders["root/c"].imageFiles).To(BeEmpty())
-				Expect(folders).ToNot(HaveKey("root/d"))
 
-				// Symlink specific checks
-				if followSymlinks {
-					Expect(folders["root/e/symlink"].audioFiles).To(HaveLen(1))
-				} else {
-					Expect(folders).ToNot(HaveKey("root/e/symlink"))
+				// Should not include folders outside the target
+				Expect(folders).ToNot(HaveKey("OtherArtist"))
+				Expect(folders).ToNot(HaveKey("OtherArtist/Album3"))
+
+				// Verify audio files are present
+				Expect(folders["Artist/Album1"].audioFiles).To(HaveLen(2))
+				Expect(folders["Artist/Album2"].audioFiles).To(HaveLen(2))
+				Expect(folders["Artist/Album2/Sub"].audioFiles).To(HaveLen(1))
+			})
+
+			It("should handle multiple target folders", func() {
+				results, err := walkDirTree(ctx, job, "Artist/Album1", "OtherArtist")
+				Expect(err).ToNot(HaveOccurred())
+
+				folders := map[string]*folderEntry{}
+				g := errgroup.Group{}
+				g.Go(func() error {
+					for folder := range results {
+						folders[folder.path] = folder
+					}
+					return nil
+				})
+				_ = g.Wait()
+
+				// Should include both target folders and their descendants
+				Expect(folders).To(SatisfyAll(
+					HaveKey("Artist/Album1"),
+					HaveKey("OtherArtist"),
+					HaveKey("OtherArtist/Album3"),
+				))
+
+				// Should not include other folders
+				Expect(folders).ToNot(HaveKey("Artist"))
+				Expect(folders).ToNot(HaveKey("Artist/Album2"))
+				Expect(folders).ToNot(HaveKey("Artist/Album2/Sub"))
+			})
+
+			It("should skip non-existent target folders and preserve them in lastUpdates", func() {
+				// Setup job with lastUpdates for both existing and non-existing folders
+				job.lastUpdates = map[string]model.FolderUpdateInfo{
+					model.FolderID(job.lib, "Artist/Album1"):             {},
+					model.FolderID(job.lib, "NonExistent/DeletedFolder"): {},
+					model.FolderID(job.lib, "OtherArtist/Album3"):        {},
 				}
-			},
-			Entry("with symlinks enabled", true, 7),
-			Entry("with symlinks disabled", false, 6),
-		)
+
+				// Try to scan existing folder and non-existing folder
+				results, err := walkDirTree(ctx, job, "Artist/Album1", "NonExistent/DeletedFolder")
+				Expect(err).ToNot(HaveOccurred())
+
+				// Collect results
+				folders := map[string]struct{}{}
+				for folder := range results {
+					folders[folder.path] = struct{}{}
+				}
+
+				// Should only include the existing folder
+				Expect(folders).To(HaveKey("Artist/Album1"))
+				Expect(folders).ToNot(HaveKey("NonExistent/DeletedFolder"))
+
+				// The non-existent folder should still be in lastUpdates (not removed by popLastUpdate)
+				Expect(job.lastUpdates).To(HaveKey(model.FolderID(job.lib, "NonExistent/DeletedFolder")))
+
+				// The existing folder should have been removed from lastUpdates
+				Expect(job.lastUpdates).ToNot(HaveKey(model.FolderID(job.lib, "Artist/Album1")))
+
+				// Folders not in targets should remain in lastUpdates
+				Expect(job.lastUpdates).To(HaveKey(model.FolderID(job.lib, "OtherArtist/Album3")))
+			})
+		})
 	})
 
 	Describe("helper functions", func() {

scanner/watcher.go

@@ -24,9 +24,9 @@ type Watcher interface {
 type watcher struct {
 	mainCtx         context.Context
 	ds              model.DataStore
-	scanner         Scanner
+	scanner         model.Scanner
 	triggerWait     time.Duration
-	watcherNotify   chan model.Library
+	watcherNotify   chan scanNotification
 	libraryWatchers map[int]*libraryWatcherInstance
 	mu              sync.RWMutex
 }
@@ -36,14 +36,19 @@ type libraryWatcherInstance struct {
 	cancel  context.CancelFunc
 }
 
+type scanNotification struct {
+	Library    *model.Library
+	FolderPath string
+}
+
 // GetWatcher returns the watcher singleton
-func GetWatcher(ds model.DataStore, s Scanner) Watcher {
+func GetWatcher(ds model.DataStore, s model.Scanner) Watcher {
 	return singleton.GetInstance(func() *watcher {
 		return &watcher{
 			ds:              ds,
 			scanner:         s,
 			triggerWait:     conf.Server.Scanner.WatcherWait,
-			watcherNotify:   make(chan model.Library, 1),
+			watcherNotify:   make(chan scanNotification, 1),
 			libraryWatchers: make(map[int]*libraryWatcherInstance),
 		}
 	})
@@ -68,11 +73,11 @@ func (w *watcher) Run(ctx context.Context) error {
 	// Main scan triggering loop
 	trigger := time.NewTimer(w.triggerWait)
 	trigger.Stop()
-	waiting := false
+	targets := make(map[model.ScanTarget]struct{})
 	for {
 		select {
 		case <-trigger.C:
-			log.Info("Watcher: Triggering scan")
+			log.Info("Watcher: Triggering scan for changed folders", "numTargets", len(targets))
 			status, err := w.scanner.Status(ctx)
 			if err != nil {
 				log.Error(ctx, "Watcher: Error retrieving Scanner status", err)
@@ -83,9 +88,23 @@ func (w *watcher) Run(ctx context.Context) error {
 				trigger.Reset(w.triggerWait * 3)
 				continue
 			}
-			waiting = false
+
+			// Convert targets map to slice
+			targetSlice := make([]model.ScanTarget, 0, len(targets))
+			for target := range targets {
+				targetSlice = append(targetSlice, target)
+			}
+
+			// Clear targets for next batch
+			targets = make(map[model.ScanTarget]struct{})
+
 			go func() {
-				_, err := w.scanner.ScanAll(ctx, false)
+				var err error
+				if conf.Server.DevSelectiveWatcher {
+					_, err = w.scanner.ScanFolders(ctx, false, targetSlice)
+				} else {
+					_, err = w.scanner.ScanAll(ctx, false)
+				}
 				if err != nil {
 					log.Error(ctx, "Watcher: Error scanning", err)
 				} else {
@@ -102,13 +121,20 @@ func (w *watcher) Run(ctx context.Context) error {
 			w.libraryWatchers = make(map[int]*libraryWatcherInstance)
 			w.mu.Unlock()
 			return nil
-		case lib := <-w.watcherNotify:
-			if !waiting {
-				log.Debug(ctx, "Watcher: Detected changes. Waiting for more changes before triggering scan",
-					"libraryID", lib.ID, "name", lib.Name, "path", lib.Path)
-				waiting = true
+		case notification := <-w.watcherNotify:
+			lib := notification.Library
+			folderPath := notification.FolderPath
+
+			// If already scheduled for scan, skip
+			target := model.ScanTarget{LibraryID: lib.ID, FolderPath: folderPath}
+			if _, exists := targets[target]; exists {
+				continue
 			}
+			targets[target] = struct{}{}
 			trigger.Reset(w.triggerWait)
+
+			log.Debug(ctx, "Watcher: Detected changes. Waiting for more changes before triggering scan",
+				"libraryID", lib.ID, "name", lib.Name, "path", lib.Path, "folderPath", folderPath)
 		}
 	}
 }
@@ -199,13 +225,18 @@ func (w *watcher) watchLibrary(ctx context.Context, lib *model.Library) error {
 
 	log.Info(ctx, "Watcher started for library", "libraryID", lib.ID, "name", lib.Name, "path", lib.Path, "absoluteLibPath", absLibPath)
 
+	return w.processLibraryEvents(ctx, lib, fsys, c, absLibPath)
+}
+
+// processLibraryEvents processes filesystem events for a library.
+func (w *watcher) processLibraryEvents(ctx context.Context, lib *model.Library, fsys storage.MusicFS, events <-chan string, absLibPath string) error {
 	for {
 		select {
 		case <-ctx.Done():
 			log.Debug(ctx, "Watcher stopped due to context cancellation", "libraryID", lib.ID, "name", lib.Name)
 			return nil
-		case path := <-c:
-			path, err = filepath.Rel(absLibPath, path)
+		case path := <-events:
+			path, err := filepath.Rel(absLibPath, path)
 			if err != nil {
 				log.Error(ctx, "Error getting relative path", "libraryID", lib.ID, "absolutePath", absLibPath, "path", path, err)
 				continue
@@ -215,12 +246,27 @@ func (w *watcher) watchLibrary(ctx context.Context, lib *model.Library) error {
 				log.Trace(ctx, "Ignoring change", "libraryID", lib.ID, "path", path)
 				continue
 			}
-
 			log.Trace(ctx, "Detected change", "libraryID", lib.ID, "path", path, "absoluteLibPath", absLibPath)
 
+			// Check if the original path (before resolution) matches .ndignore patterns
+			// This is crucial for deleted folders - if a deleted folder matches .ndignore,
+			// we should ignore it BEFORE resolveFolderPath walks up to the parent
+			if w.shouldIgnoreFolderPath(ctx, fsys, path) {
+				log.Debug(ctx, "Ignoring change matching .ndignore pattern", "libraryID", lib.ID, "path", path)
+				continue
+			}
+
+			// Find the folder to scan - validate path exists as directory, walk up if needed
+			folderPath := resolveFolderPath(fsys, path)
+			// Double-check after resolution in case the resolved path is different and also matches patterns
+			if folderPath != path && w.shouldIgnoreFolderPath(ctx, fsys, folderPath) {
+				log.Trace(ctx, "Ignoring change in folder matching .ndignore pattern", "libraryID", lib.ID, "folderPath", folderPath)
+				continue
+			}
+
 			// Notify the main watcher of changes
 			select {
-			case w.watcherNotify <- *lib:
+			case w.watcherNotify <- scanNotification{Library: lib, FolderPath: folderPath}:
 			default:
 				// Channel is full, notification already pending
 			}
@@ -228,6 +274,47 @@ func (w *watcher) watchLibrary(ctx context.Context, lib *model.Library) error {
 	}
 }
 
+// resolveFolderPath takes a path (which may be a file or directory) and returns
+// the folder path to scan. If the path is a file, it walks up to find the parent
+// directory. Returns empty string if the path should scan the library root.
+func resolveFolderPath(fsys fs.FS, path string) string {
+	// Handle root paths immediately
+	if path == "." || path == "" {
+		return ""
+	}
+
+	folderPath := path
+	for {
+		info, err := fs.Stat(fsys, folderPath)
+		if err == nil && info.IsDir() {
+			// Found a valid directory
+			return folderPath
+		}
+		if folderPath == "." || folderPath == "" {
+			// Reached root, scan entire library
+			return ""
+		}
+		// Walk up the tree
+		dir, _ := filepath.Split(folderPath)
+		if dir == "" || dir == "." {
+			return ""
+		}
+		// Remove trailing slash
+		folderPath = filepath.Clean(dir)
+	}
+}
+
+// shouldIgnoreFolderPath checks if the given folderPath should be ignored based on .ndignore patterns
+// in the library. It pushes all parent folders onto the IgnoreChecker stack before checking.
+func (w *watcher) shouldIgnoreFolderPath(ctx context.Context, fsys storage.MusicFS, folderPath string) bool {
+	checker := newIgnoreChecker(fsys)
+	err := checker.PushAllParents(ctx, folderPath)
+	if err != nil {
+		log.Warn(ctx, "Watcher: Error pushing ignore patterns for folder", "path", folderPath, err)
+	}
+	return checker.ShouldIgnore(ctx, folderPath)
+}
+
 func isIgnoredPath(_ context.Context, _ fs.FS, path string) bool {
 	baseDir, name := filepath.Split(path)
 	switch {

scanner/watcher_test.go

@@ -0,0 +1,491 @@
+package scanner
+
+import (
+	"context"
+	"io/fs"
+	"path/filepath"
+	"testing/fstest"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Watcher", func() {
+	var ctx context.Context
+	var cancel context.CancelFunc
+	var mockScanner *tests.MockScanner
+	var mockDS *tests.MockDataStore
+	var w *watcher
+	var lib *model.Library
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+		conf.Server.Scanner.WatcherWait = 50 * time.Millisecond // Short wait for tests
+
+		ctx, cancel = context.WithCancel(context.Background())
+		DeferCleanup(cancel)
+
+		lib = &model.Library{
+			ID:   1,
+			Name: "Test Library",
+			Path: "/test/library",
+		}
+
+		// Set up mocks
+		mockScanner = tests.NewMockScanner()
+		mockDS = &tests.MockDataStore{}
+		mockLibRepo := &tests.MockLibraryRepo{}
+		mockLibRepo.SetData(model.Libraries{*lib})
+		mockDS.MockedLibrary = mockLibRepo
+
+		// Create a new watcher instance (not singleton) for testing
+		w = &watcher{
+			ds:              mockDS,
+			scanner:         mockScanner,
+			triggerWait:     conf.Server.Scanner.WatcherWait,
+			watcherNotify:   make(chan scanNotification, 10),
+			libraryWatchers: make(map[int]*libraryWatcherInstance),
+			mainCtx:         ctx,
+		}
+	})
+
+	Describe("Target Collection and Deduplication", func() {
+		BeforeEach(func() {
+			// Start watcher in background
+			go func() {
+				_ = w.Run(ctx)
+			}()
+
+			// Give watcher time to initialize
+			time.Sleep(10 * time.Millisecond)
+		})
+
+		It("creates separate targets for different folders", func() {
+			// Send notifications for different folders
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+			time.Sleep(10 * time.Millisecond)
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist2"}
+
+			// Wait for watcher to process and trigger scan
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+			// Verify two targets
+			calls := mockScanner.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].Targets).To(HaveLen(2))
+
+			// Extract folder paths
+			folderPaths := make(map[string]bool)
+			for _, target := range calls[0].Targets {
+				Expect(target.LibraryID).To(Equal(1))
+				folderPaths[target.FolderPath] = true
+			}
+			Expect(folderPaths).To(HaveKey("artist1"))
+			Expect(folderPaths).To(HaveKey("artist2"))
+		})
+
+		It("handles different folder paths correctly", func() {
+			// Send notification for nested folder
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+
+			// Wait for watcher to process and trigger scan
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+			// Verify the target
+			calls := mockScanner.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].Targets).To(HaveLen(1))
+			Expect(calls[0].Targets[0].FolderPath).To(Equal("artist1/album1"))
+		})
+
+		It("deduplicates folder and file within same folder", func() {
+			// Send notification for a folder
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+			time.Sleep(10 * time.Millisecond)
+			// Send notification for same folder (as if file change was detected there)
+			// In practice, watchLibrary() would walk up from file path to folder
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+			time.Sleep(10 * time.Millisecond)
+			// Send another for same folder
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+
+			// Wait for watcher to process and trigger scan
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+			// Verify only one target despite multiple file/folder changes
+			calls := mockScanner.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].Targets).To(HaveLen(1))
+			Expect(calls[0].Targets[0].FolderPath).To(Equal("artist1/album1"))
+		})
+	})
+
+	Describe("Timer Behavior", func() {
+		BeforeEach(func() {
+			// Start watcher in background
+			go func() {
+				_ = w.Run(ctx)
+			}()
+
+			// Give watcher time to initialize
+			time.Sleep(10 * time.Millisecond)
+		})
+
+		It("resets timer on each change (debouncing)", func() {
+			// Send first notification
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+
+			// Wait a bit less than half the watcher wait time to ensure timer doesn't fire
+			time.Sleep(20 * time.Millisecond)
+
+			// No scan should have been triggered yet
+			Expect(mockScanner.GetScanFoldersCallCount()).To(Equal(0))
+
+			// Send another notification (resets timer)
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+
+			// Wait a bit less than half the watcher wait time again
+			time.Sleep(20 * time.Millisecond)
+
+			// Still no scan
+			Expect(mockScanner.GetScanFoldersCallCount()).To(Equal(0))
+
+			// Wait for full timer to expire after last notification (plus margin)
+			time.Sleep(60 * time.Millisecond)
+
+			// Now scan should have been triggered
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 100*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+		})
+
+		It("triggers scan after quiet period", func() {
+			// Send notification
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+
+			// No scan immediately
+			Expect(mockScanner.GetScanFoldersCallCount()).To(Equal(0))
+
+			// Wait for quiet period
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+		})
+	})
+
+	Describe("Empty and Root Paths", func() {
+		BeforeEach(func() {
+			// Start watcher in background
+			go func() {
+				_ = w.Run(ctx)
+			}()
+
+			// Give watcher time to initialize
+			time.Sleep(10 * time.Millisecond)
+		})
+
+		It("handles empty folder path (library root)", func() {
+			// Send notification with empty folder path
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
+
+			// Wait for scan
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+			// Should scan the library root
+			calls := mockScanner.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].Targets).To(HaveLen(1))
+			Expect(calls[0].Targets[0].FolderPath).To(Equal(""))
+		})
+
+		It("deduplicates empty and dot paths", func() {
+			// Send notifications with empty and dot paths
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
+			time.Sleep(10 * time.Millisecond)
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
+
+			// Wait for scan
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+			// Should have only one target
+			calls := mockScanner.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].Targets).To(HaveLen(1))
+		})
+	})
+
+	Describe("Multiple Libraries", func() {
+		var lib2 *model.Library
+
+		BeforeEach(func() {
+			// Create second library
+			lib2 = &model.Library{
+				ID:   2,
+				Name: "Test Library 2",
+				Path: "/test/library2",
+			}
+
+			mockLibRepo := mockDS.MockedLibrary.(*tests.MockLibraryRepo)
+			mockLibRepo.SetData(model.Libraries{*lib, *lib2})
+
+			// Start watcher in background
+			go func() {
+				_ = w.Run(ctx)
+			}()
+
+			// Give watcher time to initialize
+			time.Sleep(10 * time.Millisecond)
+		})
+
+		It("creates separate targets for different libraries", func() {
+			// Send notifications for both libraries
+			w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+			time.Sleep(10 * time.Millisecond)
+			w.watcherNotify <- scanNotification{Library: lib2, FolderPath: "artist2"}
+
+			// Wait for scan
+			Eventually(func() int {
+				return mockScanner.GetScanFoldersCallCount()
+			}, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+			// Verify two targets for different libraries
+			calls := mockScanner.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].Targets).To(HaveLen(2))
+
+			// Verify library IDs are different
+			libraryIDs := make(map[int]bool)
+			for _, target := range calls[0].Targets {
+				libraryIDs[target.LibraryID] = true
+			}
+			Expect(libraryIDs).To(HaveKey(1))
+			Expect(libraryIDs).To(HaveKey(2))
+		})
+	})
+
+	Describe(".ndignore handling", func() {
+		var ctx context.Context
+		var cancel context.CancelFunc
+		var w *watcher
+		var mockFS *mockMusicFS
+		var lib *model.Library
+		var eventChan chan string
+		var absLibPath string
+
+		BeforeEach(func() {
+			ctx, cancel = context.WithCancel(GinkgoT().Context())
+			DeferCleanup(cancel)
+
+			// Set up library
+			var err error
+			absLibPath, err = filepath.Abs(".")
+			Expect(err).NotTo(HaveOccurred())
+
+			lib = &model.Library{
+				ID:   1,
+				Name: "Test Library",
+				Path: absLibPath,
+			}
+
+			// Create watcher with notification channel
+			w = &watcher{
+				watcherNotify: make(chan scanNotification, 10),
+			}
+
+			eventChan = make(chan string, 10)
+		})
+
+		// Helper to send an event - converts relative path to absolute
+		sendEvent := func(relativePath string) {
+			path := filepath.Join(absLibPath, relativePath)
+			eventChan <- path
+		}
+
+		// Helper to start the real event processing loop
+		startEventProcessing := func() {
+			go func() {
+				defer GinkgoRecover()
+				// Call the actual processLibraryEvents method - testing the real implementation!
+				_ = w.processLibraryEvents(ctx, lib, mockFS, eventChan, absLibPath)
+			}()
+		}
+
+		Context("when a folder matching .ndignore is deleted", func() {
+			BeforeEach(func() {
+				// Create filesystem with .ndignore containing _TEMP pattern
+				// The deleted folder (_TEMP) will NOT exist in the filesystem
+				mockFS = &mockMusicFS{
+					FS: fstest.MapFS{
+						"rock":                       &fstest.MapFile{Mode: fs.ModeDir},
+						"rock/.ndignore":             &fstest.MapFile{Data: []byte("_TEMP\n")},
+						"rock/valid_album":           &fstest.MapFile{Mode: fs.ModeDir},
+						"rock/valid_album/track.mp3": &fstest.MapFile{Data: []byte("audio")},
+					},
+				}
+			})
+
+			It("should NOT send scan notification when deleted folder matches .ndignore", func() {
+				startEventProcessing()
+
+				// Simulate deletion event for rock/_TEMP
+				sendEvent("rock/_TEMP")
+
+				// Wait a bit to ensure event is processed
+				time.Sleep(50 * time.Millisecond)
+
+				// No notification should have been sent
+				Consistently(eventChan, 100*time.Millisecond).Should(BeEmpty())
+			})
+
+			It("should send scan notification for valid folder deletion", func() {
+				startEventProcessing()
+
+				// Simulate deletion event for rock/other_folder (not in .ndignore and doesn't exist)
+				// Since it doesn't exist in mockFS, resolveFolderPath will walk up to "rock"
+				sendEvent("rock/other_folder")
+
+				// Should receive notification for parent folder
+				Eventually(w.watcherNotify, 200*time.Millisecond).Should(Receive(Equal(scanNotification{
+					Library:    lib,
+					FolderPath: "rock",
+				})))
+			})
+		})
+
+		Context("with nested folder patterns", func() {
+			BeforeEach(func() {
+				mockFS = &mockMusicFS{
+					FS: fstest.MapFS{
+						"music":             &fstest.MapFile{Mode: fs.ModeDir},
+						"music/.ndignore":   &fstest.MapFile{Data: []byte("**/temp\n**/cache\n")},
+						"music/rock":        &fstest.MapFile{Mode: fs.ModeDir},
+						"music/rock/artist": &fstest.MapFile{Mode: fs.ModeDir},
+					},
+				}
+			})
+
+			It("should NOT send notification when nested ignored folder is deleted", func() {
+				startEventProcessing()
+
+				// Simulate deletion of music/rock/artist/temp (matches **/temp)
+				sendEvent("music/rock/artist/temp")
+
+				// Wait to ensure event is processed
+				time.Sleep(50 * time.Millisecond)
+
+				// No notification should be sent
+				Expect(w.watcherNotify).To(BeEmpty(), "Expected no scan notification for nested ignored folder")
+			})
+
+			It("should send notification for non-ignored nested folder", func() {
+				startEventProcessing()
+
+				// Simulate change in music/rock/artist (doesn't match any pattern)
+				sendEvent("music/rock/artist")
+
+				// Should receive notification
+				Eventually(w.watcherNotify, 200*time.Millisecond).Should(Receive(Equal(scanNotification{
+					Library:    lib,
+					FolderPath: "music/rock/artist",
+				})))
+			})
+		})
+
+		Context("with file events in ignored folders", func() {
+			BeforeEach(func() {
+				mockFS = &mockMusicFS{
+					FS: fstest.MapFS{
+						"rock":           &fstest.MapFile{Mode: fs.ModeDir},
+						"rock/.ndignore": &fstest.MapFile{Data: []byte("_TEMP\n")},
+					},
+				}
+			})
+
+			It("should NOT send notification for file changes in ignored folders", func() {
+				startEventProcessing()
+
+				// Simulate file change in rock/_TEMP/file.mp3
+				sendEvent("rock/_TEMP/file.mp3")
+
+				// Wait to ensure event is processed
+				time.Sleep(50 * time.Millisecond)
+
+				// No notification should be sent
+				Expect(w.watcherNotify).To(BeEmpty(), "Expected no scan notification for file in ignored folder")
+			})
+		})
+	})
+})
+
+var _ = Describe("resolveFolderPath", func() {
+	var mockFS fs.FS
+
+	BeforeEach(func() {
+		// Create a mock filesystem with some directories and files
+		mockFS = fstest.MapFS{
+			"artist1":                   &fstest.MapFile{Mode: fs.ModeDir},
+			"artist1/album1":            &fstest.MapFile{Mode: fs.ModeDir},
+			"artist1/album1/track1.mp3": &fstest.MapFile{Data: []byte("audio")},
+			"artist1/album1/track2.mp3": &fstest.MapFile{Data: []byte("audio")},
+			"artist1/album2":            &fstest.MapFile{Mode: fs.ModeDir},
+			"artist1/album2/song.flac":  &fstest.MapFile{Data: []byte("audio")},
+			"artist2":                   &fstest.MapFile{Mode: fs.ModeDir},
+			"artist2/cover.jpg":         &fstest.MapFile{Data: []byte("image")},
+		}
+	})
+
+	It("returns directory path when given a directory", func() {
+		result := resolveFolderPath(mockFS, "artist1/album1")
+		Expect(result).To(Equal("artist1/album1"))
+	})
+
+	It("walks up to parent directory when given a file path", func() {
+		result := resolveFolderPath(mockFS, "artist1/album1/track1.mp3")
+		Expect(result).To(Equal("artist1/album1"))
+	})
+
+	It("walks up multiple levels if needed", func() {
+		result := resolveFolderPath(mockFS, "artist1/album1/nonexistent/file.mp3")
+		Expect(result).To(Equal("artist1/album1"))
+	})
+
+	It("returns empty string for non-existent paths at root", func() {
+		result := resolveFolderPath(mockFS, "nonexistent/path/file.mp3")
+		Expect(result).To(Equal(""))
+	})
+
+	It("returns empty string for dot path", func() {
+		result := resolveFolderPath(mockFS, ".")
+		Expect(result).To(Equal(""))
+	})
+
+	It("returns empty string for empty path", func() {
+		result := resolveFolderPath(mockFS, "")
+		Expect(result).To(Equal(""))
+	})
+
+	It("handles nested file paths correctly", func() {
+		result := resolveFolderPath(mockFS, "artist1/album2/song.flac")
+		Expect(result).To(Equal("artist1/album2"))
+	})
+
+	It("resolves to top-level directory", func() {
+		result := resolveFolderPath(mockFS, "artist2/cover.jpg")
+		Expect(result).To(Equal("artist2"))
+	})
+})

server/nativeapi/config_test.go

@@ -29,7 +29,7 @@ var _ = Describe("Config API", func() {
 		conf.Server.DevUIShowConfig = true // Enable config endpoint for tests
 		ds = &tests.MockDataStore{}
 		auth.Init(ds)
-		nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService())
+		nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService(), nil)
 		router = server.JWTVerifier(nativeRouter)
 
 		// Create test users

server/nativeapi/library.go

@@ -13,11 +13,11 @@ import (
 )
 
 // User-library association endpoints (admin only)
-func (n *Router) addUserLibraryRoute(r chi.Router) {
+func (api *Router) addUserLibraryRoute(r chi.Router) {
 	r.Route("/user/{id}/library", func(r chi.Router) {
 		r.Use(parseUserIDMiddleware)
-		r.Get("/", getUserLibraries(n.libs))
-		r.Put("/", setUserLibraries(n.libs))
+		r.Get("/", getUserLibraries(api.libs))
+		r.Put("/", setUserLibraries(api.libs))
 	})
 }
 

server/nativeapi/library_test.go

@@ -30,7 +30,7 @@ var _ = Describe("Library API", func() {
 		DeferCleanup(configtest.SetupConfig())
 		ds = &tests.MockDataStore{}
 		auth.Init(ds)
-		nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService())
+		nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService(), nil)
 		router = server.JWTVerifier(nativeRouter)
 
 		// Create test users

server/nativeapi/missing.go

@@ -8,9 +8,9 @@ import (
 
 	"github.com/Masterminds/squirrel"
 	"github.com/deluan/rest"
+	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
 	"github.com/navidrome/navidrome/utils/req"
 )
 
@@ -63,45 +63,32 @@ func (r *missingRepository) EntityName() string {
 	return "missing_files"
 }
 
-func deleteMissingFiles(ds model.DataStore, w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	p := req.Params(r)
-	ids, _ := p.Strings("id")
-	err := ds.WithTx(func(tx model.DataStore) error {
+func deleteMissingFiles(maintenance core.Maintenance) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+
+		p := req.Params(r)
+		ids, _ := p.Strings("id")
+
+		var err error
 		if len(ids) == 0 {
-			_, err := tx.MediaFile(ctx).DeleteAllMissing()
-			return err
-		}
-		return tx.MediaFile(ctx).DeleteMissing(ids)
-	})
-	if len(ids) == 1 && errors.Is(err, model.ErrNotFound) {
-		log.Warn(ctx, "Missing file not found", "id", ids[0])
-		http.Error(w, "not found", http.StatusNotFound)
-		return
-	}
-	if err != nil {
-		log.Error(ctx, "Error deleting missing tracks from DB", "ids", ids, err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	err = ds.GC(ctx)
-	if err != nil {
-		log.Error(ctx, "Error running GC after deleting missing tracks", err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	// Refresh artist stats in background after deleting missing files
-	go func() {
-		bgCtx := request.AddValues(context.Background(), r.Context())
-		if _, err := ds.Artist(bgCtx).RefreshStats(true); err != nil {
-			log.Error(bgCtx, "Error refreshing artist stats after deleting missing files", err)
+			err = maintenance.DeleteAllMissingFiles(ctx)
 		} else {
-			log.Debug(bgCtx, "Successfully refreshed artist stats after deleting missing files")
+			err = maintenance.DeleteMissingFiles(ctx, ids)
 		}
-	}()
 
-	writeDeleteManyResponse(w, r, ids)
+		if len(ids) == 1 && errors.Is(err, model.ErrNotFound) {
+			log.Warn(ctx, "Missing file not found", "id", ids[0])
+			http.Error(w, "not found", http.StatusNotFound)
+			return
+		}
+		if err != nil {
+			http.Error(w, "failed to delete missing files", http.StatusInternalServerError)
+			return
+		}
+
+		writeDeleteManyResponse(w, r, ids)
+	}
 }
 
 var _ model.ResourceRepository = &missingRepository{}

server/nativeapi/native_api.go

@@ -22,70 +22,71 @@ import (
 
 type Router struct {
 	http.Handler
-	ds        model.DataStore
-	share     core.Share
-	playlists core.Playlists
-	insights  metrics.Insights
-	libs      core.Library
+	ds          model.DataStore
+	share       core.Share
+	playlists   core.Playlists
+	insights    metrics.Insights
+	libs        core.Library
+	maintenance core.Maintenance
 }
 
-func New(ds model.DataStore, share core.Share, playlists core.Playlists, insights metrics.Insights, libraryService core.Library) *Router {
-	r := &Router{ds: ds, share: share, playlists: playlists, insights: insights, libs: libraryService}
+func New(ds model.DataStore, share core.Share, playlists core.Playlists, insights metrics.Insights, libraryService core.Library, maintenance core.Maintenance) *Router {
+	r := &Router{ds: ds, share: share, playlists: playlists, insights: insights, libs: libraryService, maintenance: maintenance}
 	r.Handler = r.routes()
 	return r
 }
 
-func (n *Router) routes() http.Handler {
+func (api *Router) routes() http.Handler {
 	r := chi.NewRouter()
 
 	// Public
-	n.RX(r, "/translation", newTranslationRepository, false)
+	api.RX(r, "/translation", newTranslationRepository, false)
 
 	// Protected
 	r.Group(func(r chi.Router) {
-		r.Use(server.Authenticator(n.ds))
+		r.Use(server.Authenticator(api.ds))
 		r.Use(server.JWTRefresher)
-		r.Use(server.UpdateLastAccessMiddleware(n.ds))
-		n.R(r, "/user", model.User{}, true)
-		n.R(r, "/song", model.MediaFile{}, false)
-		n.R(r, "/album", model.Album{}, false)
-		n.R(r, "/artist", model.Artist{}, false)
-		n.R(r, "/genre", model.Genre{}, false)
-		n.R(r, "/player", model.Player{}, true)
-		n.R(r, "/transcoding", model.Transcoding{}, conf.Server.EnableTranscodingConfig)
-		n.R(r, "/radio", model.Radio{}, true)
-		n.R(r, "/tag", model.Tag{}, true)
+		r.Use(server.UpdateLastAccessMiddleware(api.ds))
+		api.R(r, "/user", model.User{}, true)
+		api.R(r, "/song", model.MediaFile{}, false)
+		api.R(r, "/album", model.Album{}, false)
+		api.R(r, "/artist", model.Artist{}, false)
+		api.R(r, "/genre", model.Genre{}, false)
+		api.R(r, "/player", model.Player{}, true)
+		api.R(r, "/transcoding", model.Transcoding{}, conf.Server.EnableTranscodingConfig)
+		api.R(r, "/radio", model.Radio{}, true)
+		api.R(r, "/tag", model.Tag{}, true)
 		if conf.Server.EnableSharing {
-			n.RX(r, "/share", n.share.NewRepository, true)
+			api.RX(r, "/share", api.share.NewRepository, true)
 		}
 
-		n.addPlaylistRoute(r)
-		n.addPlaylistTrackRoute(r)
-		n.addSongPlaylistsRoute(r)
-		n.addQueueRoute(r)
-		n.addMissingFilesRoute(r)
-		n.addKeepAliveRoute(r)
-		n.addInsightsRoute(r)
+		api.addPlaylistRoute(r)
+		api.addPlaylistTrackRoute(r)
+		api.addSongPlaylistsRoute(r)
+		api.addQueueRoute(r)
+		api.addMissingFilesRoute(r)
+		api.addKeepAliveRoute(r)
+		api.addInsightsRoute(r)
 
 		r.With(adminOnlyMiddleware).Group(func(r chi.Router) {
-			n.addInspectRoute(r)
-			n.addConfigRoute(r)
-			n.addUserLibraryRoute(r)
-			n.RX(r, "/library", n.libs.NewRepository, true)
+			api.addInspectRoute(r)
+			api.addConfigRoute(r)
+			api.addUserLibraryRoute(r)
+			api.RX(r, "/library", api.libs.NewRepository, true)
 		})
 	})
 
 	return r
 }
 
-func (n *Router) R(r chi.Router, pathPrefix string, model interface{}, persistable bool) {
+func (api *Router) R(r chi.Router, pathPrefix string, model interface{}, persistable bool) {
 	constructor := func(ctx context.Context) rest.Repository {
-		return n.ds.Resource(ctx, model)
+		return api.ds.Resource(ctx, model)
 	}
-	n.RX(r, pathPrefix, constructor, persistable)
+	api.RX(r, pathPrefix, constructor, persistable)
 }
 
-func (n *Router) RX(r chi.Router, pathPrefix string, constructor rest.RepositoryConstructor, persistable bool) {
+func (api *Router) RX(r chi.Router, pathPrefix string, constructor rest.RepositoryConstructor, persistable bool) {
 	r.Route(pathPrefix, func(r chi.Router) {
 		r.Get("/", rest.GetAll(constructor))
 		if persistable {
@@ -102,9 +103,9 @@ func (n *Router) RX(r chi.Router, pathPrefix string, constructor rest.Repository
 	})
 }
 
-func (n *Router) addPlaylistRoute(r chi.Router) {
+func (api *Router) addPlaylistRoute(r chi.Router) {
 	constructor := func(ctx context.Context) rest.Repository {
-		return n.ds.Resource(ctx, model.Playlist{})
+		return api.ds.Resource(ctx, model.Playlist{})
 	}
 
 	r.Route("/playlist", func(r chi.Router) {
@@ -114,7 +115,7 @@ func (n *Router) addPlaylistRoute(r chi.Router) {
 				rest.Post(constructor)(w, r)
 				return
 			}
-			createPlaylistFromM3U(n.playlists)(w, r)
+			createPlaylistFromM3U(api.playlists)(w, r)
 		})
 
 		r.Route("/{id}", func(r chi.Router) {
@@ -126,55 +127,53 @@ func (n *Router) addPlaylistRoute(r chi.Router) {
 	})
 }
 
-func (n *Router) addPlaylistTrackRoute(r chi.Router) {
+func (api *Router) addPlaylistTrackRoute(r chi.Router) {
 	r.Route("/playlist/{playlistId}/tracks", func(r chi.Router) {
 		r.Get("/", func(w http.ResponseWriter, r *http.Request) {
-			getPlaylist(n.ds)(w, r)
+			getPlaylist(api.ds)(w, r)
 		})
 		r.With(server.URLParamsMiddleware).Route("/", func(r chi.Router) {
 			r.Delete("/", func(w http.ResponseWriter, r *http.Request) {
-				deleteFromPlaylist(n.ds)(w, r)
+				deleteFromPlaylist(api.ds)(w, r)
 			})
 			r.Post("/", func(w http.ResponseWriter, r *http.Request) {
-				addToPlaylist(n.ds)(w, r)
+				addToPlaylist(api.ds)(w, r)
 			})
 		})
 		r.Route("/{id}", func(r chi.Router) {
 			r.Use(server.URLParamsMiddleware)
 			r.Get("/", func(w http.ResponseWriter, r *http.Request) {
-				getPlaylistTrack(n.ds)(w, r)
+				getPlaylistTrack(api.ds)(w, r)
 			})
 			r.Put("/", func(w http.ResponseWriter, r *http.Request) {
-				reorderItem(n.ds)(w, r)
+				reorderItem(api.ds)(w, r)
 			})
 			r.Delete("/", func(w http.ResponseWriter, r *http.Request) {
-				deleteFromPlaylist(n.ds)(w, r)
+				deleteFromPlaylist(api.ds)(w, r)
 			})
 		})
 	})
 }
 
-func (n *Router) addSongPlaylistsRoute(r chi.Router) {
+func (api *Router) addSongPlaylistsRoute(r chi.Router) {
 	r.With(server.URLParamsMiddleware).Get("/song/{id}/playlists", func(w http.ResponseWriter, r *http.Request) {
-		getSongPlaylists(n.ds)(w, r)
+		getSongPlaylists(api.ds)(w, r)
 	})
 }
 
-func (n *Router) addQueueRoute(r chi.Router) {
+func (api *Router) addQueueRoute(r chi.Router) {
 	r.Route("/queue", func(r chi.Router) {
-		r.Get("/", getQueue(n.ds))
-		r.Post("/", saveQueue(n.ds))
-		r.Put("/", updateQueue(n.ds))
-		r.Delete("/", clearQueue(n.ds))
+		r.Get("/", getQueue(api.ds))
+		r.Post("/", saveQueue(api.ds))
+		r.Put("/", updateQueue(api.ds))
+		r.Delete("/", clearQueue(api.ds))
 	})
 }
 
-func (n *Router) addMissingFilesRoute(r chi.Router) {
+func (api *Router) addMissingFilesRoute(r chi.Router) {
 	r.Route("/missing", func(r chi.Router) {
-		n.RX(r, "/", newMissingRepository(n.ds), false)
-		r.Delete("/", func(w http.ResponseWriter, r *http.Request) {
-			deleteMissingFiles(n.ds, w, r)
-		})
+		api.RX(r, "/", newMissingRepository(api.ds), false)
+		r.Delete("/", deleteMissingFiles(api.maintenance))
 	})
 }
 
@@ -198,7 +197,7 @@ func writeDeleteManyResponse(w http.ResponseWriter, r *http.Request, ids []strin
 	}
 }
 
-func (n *Router) addInspectRoute(r chi.Router) {
+func (api *Router) addInspectRoute(r chi.Router) {
 	if conf.Server.Inspect.Enabled {
 		r.Group(func(r chi.Router) {
 			if conf.Server.Inspect.MaxRequests > 0 {
@@ -207,26 +206,26 @@ func (n *Router) addInspectRoute(r chi.Router) {
 					conf.Server.Inspect.BacklogTimeout)
 				r.Use(middleware.ThrottleBacklog(conf.Server.Inspect.MaxRequests, conf.Server.Inspect.BacklogLimit, time.Duration(conf.Server.Inspect.BacklogTimeout)))
 			}
-			r.Get("/inspect", inspect(n.ds))
+			r.Get("/inspect", inspect(api.ds))
 		})
 	}
 }
 
-func (n *Router) addConfigRoute(r chi.Router) {
+func (api *Router) addConfigRoute(r chi.Router) {
 	if conf.Server.DevUIShowConfig {
 		r.Get("/config/*", getConfig)
 	}
 }
 
-func (n *Router) addKeepAliveRoute(r chi.Router) {
+func (api *Router) addKeepAliveRoute(r chi.Router) {
 	r.Get("/keepalive/*", func(w http.ResponseWriter, r *http.Request) {
 		_, _ = w.Write([]byte(`{"response":"ok", "id":"keepalive"}`))
 	})
 }
 
-func (n *Router) addInsightsRoute(r chi.Router) {
+func (api *Router) addInsightsRoute(r chi.Router) {
 	r.Get("/insights/*", func(w http.ResponseWriter, r *http.Request) {
-		last, success := n.insights.LastRun(r.Context())
+		last, success := api.insights.LastRun(r.Context())
 		if conf.Server.EnableInsightsCollector {
 			_, _ = w.Write([]byte(`{"id":"insights_status", "lastRun":"` + last.Format("2006-01-02 15:04:05") + `", "success":` + strconv.FormatBool(success) + `}`))
 		} else {

server/nativeapi/native_api_song_test.go

@@ -95,7 +95,7 @@ var _ = Describe("Song Endpoints", func() {
 		mfRepo.SetData(testSongs)
 
 		// Create the native API router and wrap it with the JWTVerifier middleware
-		nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService())
+		nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService(), nil)
 		router = server.JWTVerifier(nativeRouter)
 		w = httptest.NewRecorder()
 	})

server/subsonic/api.go

@@ -18,7 +18,6 @@ import (
 	"github.com/navidrome/navidrome/core/scrobbler"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/scanner"
 	"github.com/navidrome/navidrome/server"
 	"github.com/navidrome/navidrome/server/events"
 	"github.com/navidrome/navidrome/server/subsonic/responses"
@@ -39,7 +38,7 @@ type Router struct {
 	players   core.Players
 	provider  external.Provider
 	playlists core.Playlists
-	scanner   scanner.Scanner
+	scanner   model.Scanner
 	broker    events.Broker
 	scrobbler scrobbler.PlayTracker
 	share     core.Share
@@ -48,7 +47,7 @@ type Router struct {
 }
 
 func New(ds model.DataStore, artwork artwork.Artwork, streamer core.MediaStreamer, archiver core.Archiver,
-	players core.Players, provider external.Provider, scanner scanner.Scanner, broker events.Broker,
+	players core.Players, provider external.Provider, scanner model.Scanner, broker events.Broker,
 	playlists core.Playlists, scrobbler scrobbler.PlayTracker, share core.Share, playback playback.PlaybackServer,
 	metrics metrics.Metrics,
 ) *Router {
@@ -148,7 +147,9 @@ func (api *Router) routes() http.Handler {
 			h(r, "createBookmark", api.CreateBookmark)
 			h(r, "deleteBookmark", api.DeleteBookmark)
 			h(r, "getPlayQueue", api.GetPlayQueue)
+			h(r, "getPlayQueueByIndex", api.GetPlayQueueByIndex)
 			h(r, "savePlayQueue", api.SavePlayQueue)
+			h(r, "savePlayQueueByIndex", api.SavePlayQueueByIndex)
 		})
 		r.Group(func(r chi.Router) {
 			r.Use(getPlayer(api.players))

server/subsonic/bookmarks.go

@@ -91,7 +91,7 @@ func (api *Router) GetPlayQueue(r *http.Request) (*responses.Subsonic, error) {
 		Current:   currentID,
 		Position:  pq.Position,
 		Username:  user.UserName,
-		Changed:   &pq.UpdatedAt,
+		Changed:   pq.UpdatedAt,
 		ChangedBy: pq.ChangedBy,
 	}
 	return response, nil
@@ -135,3 +135,74 @@ func (api *Router) SavePlayQueue(r *http.Request) (*responses.Subsonic, error) {
 	}
 	return newResponse(), nil
 }
+
+func (api *Router) GetPlayQueueByIndex(r *http.Request) (*responses.Subsonic, error) {
+	user, _ := request.UserFrom(r.Context())
+
+	repo := api.ds.PlayQueue(r.Context())
+	pq, err := repo.RetrieveWithMediaFiles(user.ID)
+	if err != nil && !errors.Is(err, model.ErrNotFound) {
+		return nil, err
+	}
+	if pq == nil || len(pq.Items) == 0 {
+		return newResponse(), nil
+	}
+
+	response := newResponse()
+
+	var index *int
+	if len(pq.Items) > 0 {
+		index = &pq.Current
+	}
+
+	response.PlayQueueByIndex = &responses.PlayQueueByIndex{
+		Entry:        slice.MapWithArg(pq.Items, r.Context(), childFromMediaFile),
+		CurrentIndex: index,
+		Position:     pq.Position,
+		Username:     user.UserName,
+		Changed:      pq.UpdatedAt,
+		ChangedBy:    pq.ChangedBy,
+	}
+	return response, nil
+}
+
+func (api *Router) SavePlayQueueByIndex(r *http.Request) (*responses.Subsonic, error) {
+	p := req.Params(r)
+	ids, _ := p.Strings("id")
+
+	position := p.Int64Or("position", 0)
+
+	var err error
+	var currentIndex int
+
+	if len(ids) > 0 {
+		currentIndex, err = p.Int("currentIndex")
+		if err != nil || currentIndex < 0 || currentIndex >= len(ids) {
+			return nil, newError(responses.ErrorMissingParameter, "missing parameter index, err: %s", err)
+		}
+	}
+
+	items := slice.Map(ids, func(id string) model.MediaFile {
+		return model.MediaFile{ID: id}
+	})
+
+	user, _ := request.UserFrom(r.Context())
+	client, _ := request.ClientFrom(r.Context())
+
+	pq := &model.PlayQueue{
+		UserID:    user.ID,
+		Current:   currentIndex,
+		Position:  position,
+		ChangedBy: client,
+		Items:     items,
+		CreatedAt: time.Time{},
+		UpdatedAt: time.Time{},
+	}
+
+	repo := api.ds.PlayQueue(r.Context())
+	err = repo.Store(pq)
+	if err != nil {
+		return nil, err
+	}
+	return newResponse(), nil
+}

server/subsonic/library_scanning.go

@@ -1,10 +1,13 @@
 package subsonic
 
 import (
+	"fmt"
 	"net/http"
+	"slices"
 	"time"
 
 	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/request"
 	"github.com/navidrome/navidrome/server/subsonic/responses"
 	"github.com/navidrome/navidrome/utils/req"
@@ -44,15 +47,56 @@ func (api *Router) StartScan(r *http.Request) (*responses.Subsonic, error) {
 	p := req.Params(r)
 	fullScan := p.BoolOr("fullScan", false)
 
+	// Parse optional target parameters for selective scanning
+	var targets []model.ScanTarget
+	if targetParams, err := p.Strings("target"); err == nil && len(targetParams) > 0 {
+		targets, err = model.ParseTargets(targetParams)
+		if err != nil {
+			return nil, newError(responses.ErrorGeneric, fmt.Sprintf("Invalid target parameter: %v", err))
+		}
+
+		// Validate all libraries in targets exist and user has access to them
+		userLibraries, err := api.ds.User(ctx).GetUserLibraries(loggedUser.ID)
+		if err != nil {
+			return nil, newError(responses.ErrorGeneric, "Internal error")
+		}
+
+		// Check each target library
+		for _, target := range targets {
+			if !slices.ContainsFunc(userLibraries, func(lib model.Library) bool { return lib.ID == target.LibraryID }) {
+				return nil, newError(responses.ErrorDataNotFound, fmt.Sprintf("Library with ID %d not found", target.LibraryID))
+			}
+		}
+
+		// Special case: if single library with empty path and it's the only library in DB, call ScanAll
+		if len(targets) == 1 && targets[0].FolderPath == "" {
+			allLibs, err := api.ds.Library(ctx).GetAll()
+			if err != nil {
+				return nil, newError(responses.ErrorGeneric, "Internal error")
+			}
+			if len(allLibs) == 1 {
+				targets = nil // This will trigger ScanAll below
+			}
+		}
+	}
+
 	go func() {
 		start := time.Now()
-		log.Info(ctx, "Triggering manual scan", "fullScan", fullScan, "user", loggedUser.UserName)
-		_, err := api.scanner.ScanAll(ctx, fullScan)
+		var err error
+
+		if len(targets) > 0 {
+			log.Info(ctx, "Triggering on-demand scan", "fullScan", fullScan, "targets", len(targets), "user", loggedUser.UserName)
+			_, err = api.scanner.ScanFolders(ctx, fullScan, targets)
+		} else {
+			log.Info(ctx, "Triggering on-demand scan", "fullScan", fullScan, "user", loggedUser.UserName)
+			_, err = api.scanner.ScanAll(ctx, fullScan)
+		}
+
 		if err != nil {
 			log.Error(ctx, "Error scanning", err)
 			return
 		}
-		log.Info(ctx, "Manual scan complete", "user", loggedUser.UserName, "elapsed", time.Since(start))
+		log.Info(ctx, "On-demand scan complete", "user", loggedUser.UserName, "elapsed", time.Since(start))
 	}()
 
 	return api.GetScanStatus(r)

server/subsonic/library_scanning_test.go

@@ -0,0 +1,396 @@
+package subsonic
+
+import (
+	"context"
+	"errors"
+	"net/http/httptest"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/server/subsonic/responses"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("LibraryScanning", func() {
+	var api *Router
+	var ms *tests.MockScanner
+
+	BeforeEach(func() {
+		ms = tests.NewMockScanner()
+		api = &Router{scanner: ms}
+	})
+
+	Describe("StartScan", func() {
+		It("requires admin authentication", func() {
+			// Create non-admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "user-id",
+				IsAdmin: false,
+			})
+
+			// Create request
+			r := httptest.NewRequest("GET", "/rest/startScan", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should return authorization error
+			Expect(err).To(HaveOccurred())
+			Expect(response).To(BeNil())
+			var subErr subError
+			ok := errors.As(err, &subErr)
+			Expect(ok).To(BeTrue())
+			Expect(subErr.code).To(Equal(responses.ErrorAuthorizationFail))
+		})
+
+		It("triggers a full scan with no parameters", func() {
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with no parameters
+			r := httptest.NewRequest("GET", "/rest/startScan", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+
+			// Verify ScanAll was called (eventually, since it's in a goroutine)
+			Eventually(func() int {
+				return ms.GetScanAllCallCount()
+			}).Should(BeNumerically(">", 0))
+			calls := ms.GetScanAllCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].FullScan).To(BeFalse())
+		})
+
+		It("triggers a full scan with fullScan=true", func() {
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with fullScan parameter
+			r := httptest.NewRequest("GET", "/rest/startScan?fullScan=true", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+
+			// Verify ScanAll was called with fullScan=true
+			Eventually(func() int {
+				return ms.GetScanAllCallCount()
+			}).Should(BeNumerically(">", 0))
+			calls := ms.GetScanAllCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].FullScan).To(BeTrue())
+		})
+
+		It("triggers a selective scan with single target parameter", func() {
+			// Setup mocks
+			mockUserRepo := tests.CreateMockUserRepo()
+			_ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+			mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+			api.ds = mockDS
+
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with single target parameter
+			r := httptest.NewRequest("GET", "/rest/startScan?target=1:Music/Rock", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+
+			// Verify ScanFolders was called with correct targets
+			Eventually(func() int {
+				return ms.GetScanFoldersCallCount()
+			}).Should(BeNumerically(">", 0))
+			calls := ms.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			targets := calls[0].Targets
+			Expect(targets).To(HaveLen(1))
+			Expect(targets[0].LibraryID).To(Equal(1))
+			Expect(targets[0].FolderPath).To(Equal("Music/Rock"))
+		})
+
+		It("triggers a selective scan with multiple target parameters", func() {
+			// Setup mocks
+			mockUserRepo := tests.CreateMockUserRepo()
+			_ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+			mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+			api.ds = mockDS
+
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with multiple target parameters
+			r := httptest.NewRequest("GET", "/rest/startScan?target=1:Music/Reggae&target=2:Classical/Bach", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+
+			// Verify ScanFolders was called with correct targets
+			Eventually(func() int {
+				return ms.GetScanFoldersCallCount()
+			}).Should(BeNumerically(">", 0))
+			calls := ms.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			targets := calls[0].Targets
+			Expect(targets).To(HaveLen(2))
+			Expect(targets[0].LibraryID).To(Equal(1))
+			Expect(targets[0].FolderPath).To(Equal("Music/Reggae"))
+			Expect(targets[1].LibraryID).To(Equal(2))
+			Expect(targets[1].FolderPath).To(Equal("Classical/Bach"))
+		})
+
+		It("triggers a selective full scan with target and fullScan parameters", func() {
+			// Setup mocks
+			mockUserRepo := tests.CreateMockUserRepo()
+			_ = mockUserRepo.SetUserLibraries("admin-id", []int{1})
+			mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+			api.ds = mockDS
+
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with target and fullScan parameters
+			r := httptest.NewRequest("GET", "/rest/startScan?target=1:Music/Jazz&fullScan=true", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+
+			// Verify ScanFolders was called with fullScan=true
+			Eventually(func() int {
+				return ms.GetScanFoldersCallCount()
+			}).Should(BeNumerically(">", 0))
+			calls := ms.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			Expect(calls[0].FullScan).To(BeTrue())
+			targets := calls[0].Targets
+			Expect(targets).To(HaveLen(1))
+		})
+
+		It("returns error for invalid target format", func() {
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with invalid target format (missing colon)
+			r := httptest.NewRequest("GET", "/rest/startScan?target=1MusicRock", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should return error
+			Expect(err).To(HaveOccurred())
+			Expect(response).To(BeNil())
+			var subErr subError
+			ok := errors.As(err, &subErr)
+			Expect(ok).To(BeTrue())
+			Expect(subErr.code).To(Equal(responses.ErrorGeneric))
+		})
+
+		It("returns error for invalid library ID in target", func() {
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with invalid library ID
+			r := httptest.NewRequest("GET", "/rest/startScan?target=0:Music/Rock", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should return error
+			Expect(err).To(HaveOccurred())
+			Expect(response).To(BeNil())
+			var subErr subError
+			ok := errors.As(err, &subErr)
+			Expect(ok).To(BeTrue())
+			Expect(subErr.code).To(Equal(responses.ErrorGeneric))
+		})
+
+		It("returns error when library does not exist", func() {
+			// Setup mocks - user has access to library 1 and 2 only
+			mockUserRepo := tests.CreateMockUserRepo()
+			_ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+			mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+			api.ds = mockDS
+
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with library ID that doesn't exist
+			r := httptest.NewRequest("GET", "/rest/startScan?target=999:Music/Rock", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should return ErrorDataNotFound
+			Expect(err).To(HaveOccurred())
+			Expect(response).To(BeNil())
+			var subErr subError
+			ok := errors.As(err, &subErr)
+			Expect(ok).To(BeTrue())
+			Expect(subErr.code).To(Equal(responses.ErrorDataNotFound))
+		})
+
+		It("calls ScanAll when single library with empty path and only one library exists", func() {
+			// Setup mocks - single library in DB
+			mockUserRepo := tests.CreateMockUserRepo()
+			_ = mockUserRepo.SetUserLibraries("admin-id", []int{1})
+			mockLibraryRepo := &tests.MockLibraryRepo{}
+			mockLibraryRepo.SetData(model.Libraries{
+				{ID: 1, Name: "Music Library", Path: "/music"},
+			})
+			mockDS := &tests.MockDataStore{
+				MockedUser:    mockUserRepo,
+				MockedLibrary: mockLibraryRepo,
+			}
+			api.ds = mockDS
+
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with single library and empty path
+			r := httptest.NewRequest("GET", "/rest/startScan?target=1:", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+
+			// Verify ScanAll was called instead of ScanFolders
+			Eventually(func() int {
+				return ms.GetScanAllCallCount()
+			}).Should(BeNumerically(">", 0))
+			Expect(ms.GetScanFoldersCallCount()).To(Equal(0))
+		})
+
+		It("calls ScanFolders when single library with empty path but multiple libraries exist", func() {
+			// Setup mocks - multiple libraries in DB
+			mockUserRepo := tests.CreateMockUserRepo()
+			_ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+			mockLibraryRepo := &tests.MockLibraryRepo{}
+			mockLibraryRepo.SetData(model.Libraries{
+				{ID: 1, Name: "Music Library", Path: "/music"},
+				{ID: 2, Name: "Audiobooks", Path: "/audiobooks"},
+			})
+			mockDS := &tests.MockDataStore{
+				MockedUser:    mockUserRepo,
+				MockedLibrary: mockLibraryRepo,
+			}
+			api.ds = mockDS
+
+			// Create admin user
+			ctx := request.WithUser(context.Background(), model.User{
+				ID:      "admin-id",
+				IsAdmin: true,
+			})
+
+			// Create request with single library and empty path
+			r := httptest.NewRequest("GET", "/rest/startScan?target=1:", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.StartScan(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+
+			// Verify ScanFolders was called (not ScanAll)
+			Eventually(func() int {
+				return ms.GetScanFoldersCallCount()
+			}).Should(BeNumerically(">", 0))
+			calls := ms.GetScanFoldersCalls()
+			Expect(calls).To(HaveLen(1))
+			targets := calls[0].Targets
+			Expect(targets).To(HaveLen(1))
+			Expect(targets[0].LibraryID).To(Equal(1))
+			Expect(targets[0].FolderPath).To(Equal(""))
+		})
+	})
+
+	Describe("GetScanStatus", func() {
+		It("returns scan status", func() {
+			// Setup mock scanner status
+			ms.SetStatusResponse(&model.ScannerStatus{
+				Scanning:    false,
+				Count:       100,
+				FolderCount: 10,
+			})
+
+			// Create request
+			ctx := context.Background()
+			r := httptest.NewRequest("GET", "/rest/getScanStatus", nil)
+			r = r.WithContext(ctx)
+
+			// Call endpoint
+			response, err := api.GetScanStatus(r)
+
+			// Should succeed
+			Expect(err).ToNot(HaveOccurred())
+			Expect(response).ToNot(BeNil())
+			Expect(response.ScanStatus).ToNot(BeNil())
+			Expect(response.ScanStatus.Scanning).To(BeFalse())
+			Expect(response.ScanStatus.Count).To(Equal(int64(100)))
+			Expect(response.ScanStatus.FolderCount).To(Equal(int64(10)))
+		})
+	})
+})

server/subsonic/opensubsonic.go

@@ -12,6 +12,7 @@ func (api *Router) GetOpenSubsonicExtensions(_ *http.Request) (*responses.Subson
 		{Name: "transcodeOffset", Versions: []int32{1}},
 		{Name: "formPost", Versions: []int32{1}},
 		{Name: "songLyrics", Versions: []int32{1}},
+		{Name: "indexBasedQueue", Versions: []int32{1}},
 	}
 	return response, nil
 }

server/subsonic/opensubsonic_test.go

@@ -35,10 +35,11 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {
 		err := json.Unmarshal(w.Body.Bytes(), &response)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(*response.Subsonic.OpenSubsonicExtensions).To(SatisfyAll(
-			HaveLen(3),
+			HaveLen(4),
 			ContainElement(responses.OpenSubsonicExtension{Name: "transcodeOffset", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "formPost", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "songLyrics", Versions: []int32{1}}),
+			ContainElement(responses.OpenSubsonicExtension{Name: "indexBasedQueue", Versions: []int32{1}}),
 		))
 	})
 })

server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .JSON

@@ -6,6 +6,7 @@
   "openSubsonic": true,
   "playQueue": {
     "username": "",
+    "changed": "0001-01-01T00:00:00Z",
     "changedBy": ""
   }
 }

server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .XML

@@ -1,3 +1,3 @@
 <subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1" type="navidrome" serverVersion="v0.55.0" openSubsonic="true">
-  <playQueue username="" changedBy=""></playQueue>
+  <playQueue username="" changed="0001-01-01T00:00:00Z" changedBy=""></playQueue>
 </subsonic-response>

server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .JSON

@@ -0,0 +1,22 @@
+{
+  "status": "ok",
+  "version": "1.16.1",
+  "type": "navidrome",
+  "serverVersion": "v0.55.0",
+  "openSubsonic": true,
+  "playQueueByIndex": {
+    "entry": [
+      {
+        "id": "1",
+        "isDir": false,
+        "title": "title",
+        "isVideo": false
+      }
+    ],
+    "currentIndex": 0,
+    "position": 243,
+    "username": "user1",
+    "changed": "0001-01-01T00:00:00Z",
+    "changedBy": "a_client"
+  }
+}

server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .XML

@@ -0,0 +1,5 @@
+<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1" type="navidrome" serverVersion="v0.55.0" openSubsonic="true">
+  <playQueueByIndex currentIndex="0" position="243" username="user1" changed="0001-01-01T00:00:00Z" changedBy="a_client">
+    <entry id="1" isDir="false" title="title" isVideo="false"></entry>
+  </playQueueByIndex>
+</subsonic-response>

server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .JSON

@@ -0,0 +1,12 @@
+{
+  "status": "ok",
+  "version": "1.16.1",
+  "type": "navidrome",
+  "serverVersion": "v0.55.0",
+  "openSubsonic": true,
+  "playQueueByIndex": {
+    "username": "",
+    "changed": "0001-01-01T00:00:00Z",
+    "changedBy": ""
+  }
+}

server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .XML

@@ -0,0 +1,3 @@
+<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1" type="navidrome" serverVersion="v0.55.0" openSubsonic="true">
+  <playQueueByIndex username="" changed="0001-01-01T00:00:00Z" changedBy=""></playQueueByIndex>
+</subsonic-response>

server/subsonic/responses/responses.go

@@ -60,6 +60,7 @@ type Subsonic struct {
 	// OpenSubsonic extensions
 	OpenSubsonicExtensions *OpenSubsonicExtensions `xml:"openSubsonicExtensions,omitempty"  json:"openSubsonicExtensions,omitempty"`
 	LyricsList             *LyricsList             `xml:"lyricsList,omitempty"              json:"lyricsList,omitempty"`
+	PlayQueueByIndex       *PlayQueueByIndex       `xml:"playQueueByIndex,omitempty" json:"playQueueByIndex,omitempty"`
 }
 
 const (
@@ -439,12 +440,21 @@ type TopSongs struct {
 }
 
 type PlayQueue struct {
-	Entry     []Child    `xml:"entry,omitempty"         json:"entry,omitempty"`
-	Current   string     `xml:"current,attr,omitempty"  json:"current,omitempty"`
-	Position  int64      `xml:"position,attr,omitempty" json:"position,omitempty"`
-	Username  string     `xml:"username,attr"           json:"username"`
-	Changed   *time.Time `xml:"changed,attr,omitempty"  json:"changed,omitempty"`
-	ChangedBy string     `xml:"changedBy,attr"          json:"changedBy"`
+	Entry     []Child   `xml:"entry,omitempty"         json:"entry,omitempty"`
+	Current   string    `xml:"current,attr,omitempty"  json:"current,omitempty"`
+	Position  int64     `xml:"position,attr,omitempty" json:"position,omitempty"`
+	Username  string    `xml:"username,attr"           json:"username"`
+	Changed   time.Time `xml:"changed,attr"            json:"changed"`
+	ChangedBy string    `xml:"changedBy,attr"          json:"changedBy"`
+}
+
+type PlayQueueByIndex struct {
+	Entry        []Child   `xml:"entry,omitempty"         json:"entry,omitempty"`
+	CurrentIndex *int      `xml:"currentIndex,attr,omitempty"  json:"currentIndex,omitempty"`
+	Position     int64     `xml:"position,attr,omitempty" json:"position,omitempty"`
+	Username     string    `xml:"username,attr"           json:"username"`
+	Changed      time.Time `xml:"changed,attr"            json:"changed"`
+	ChangedBy    string    `xml:"changedBy,attr"          json:"changedBy"`
 }
 
 type Bookmark struct {

server/subsonic/responses/responses_test.go

@@ -768,7 +768,7 @@ var _ = Describe("Responses", func() {
 				response.PlayQueue.Username = "user1"
 				response.PlayQueue.Current = "111"
 				response.PlayQueue.Position = 243
-				response.PlayQueue.Changed = &time.Time{}
+				response.PlayQueue.Changed = time.Time{}
 				response.PlayQueue.ChangedBy = "a_client"
 				child := make([]Child, 1)
 				child[0] = Child{Id: "1", Title: "title", IsDir: false}
@@ -783,6 +783,40 @@ var _ = Describe("Responses", func() {
 		})
 	})
 
+	Describe("PlayQueueByIndex", func() {
+		BeforeEach(func() {
+			response.PlayQueueByIndex = &PlayQueueByIndex{}
+		})
+
+		Context("without data", func() {
+			It("should match .XML", func() {
+				Expect(xml.MarshalIndent(response, "", "  ")).To(MatchSnapshot())
+			})
+			It("should match .JSON", func() {
+				Expect(json.MarshalIndent(response, "", "  ")).To(MatchSnapshot())
+			})
+		})
+
+		Context("with data", func() {
+			BeforeEach(func() {
+				response.PlayQueueByIndex.Username = "user1"
+				response.PlayQueueByIndex.CurrentIndex = gg.P(0)
+				response.PlayQueueByIndex.Position = 243
+				response.PlayQueueByIndex.Changed = time.Time{}
+				response.PlayQueueByIndex.ChangedBy = "a_client"
+				child := make([]Child, 1)
+				child[0] = Child{Id: "1", Title: "title", IsDir: false}
+				response.PlayQueueByIndex.Entry = child
+			})
+			It("should match .XML", func() {
+				Expect(xml.MarshalIndent(response, "", "  ")).To(MatchSnapshot())
+			})
+			It("should match .JSON", func() {
+				Expect(json.MarshalIndent(response, "", "  ")).To(MatchSnapshot())
+			})
+		})
+	})
+
 	Describe("Shares", func() {
 		BeforeEach(func() {
 			response.Shares = &Shares{}

tests/mock_data_store.go

@@ -28,6 +28,10 @@ type MockDataStore struct {
 	MockedRadio          model.RadioRepository
 	scrobbleBufferMu     sync.Mutex
 	repoMu               sync.Mutex
+
+	// GC tracking
+	GCCalled bool
+	GCError  error
 }
 
 func (db *MockDataStore) Library(ctx context.Context) model.LibraryRepository {
@@ -258,6 +262,10 @@ func (db *MockDataStore) Resource(ctx context.Context, m any) model.ResourceRepo
 	}
 }
 
-func (db *MockDataStore) GC(context.Context) error {
+func (db *MockDataStore) GC(context.Context, ...int) error {
+	db.GCCalled = true
+	if db.GCError != nil {
+		return db.GCError
+	}
 	return nil
 }

tests/mock_scanner.go

@@ -0,0 +1,120 @@
+package tests
+
+import (
+	"context"
+	"sync"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+// MockScanner implements scanner.Scanner for testing with proper synchronization
+type MockScanner struct {
+	mu               sync.Mutex
+	scanAllCalls     []ScanAllCall
+	scanFoldersCalls []ScanFoldersCall
+	scanningStatus   bool
+	statusResponse   *model.ScannerStatus
+}
+
+type ScanAllCall struct {
+	FullScan bool
+}
+
+type ScanFoldersCall struct {
+	FullScan bool
+	Targets  []model.ScanTarget
+}
+
+func NewMockScanner() *MockScanner {
+	return &MockScanner{
+		scanAllCalls:     make([]ScanAllCall, 0),
+		scanFoldersCalls: make([]ScanFoldersCall, 0),
+	}
+}
+
+func (m *MockScanner) ScanAll(_ context.Context, fullScan bool) ([]string, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	m.scanAllCalls = append(m.scanAllCalls, ScanAllCall{FullScan: fullScan})
+
+	return nil, nil
+}
+
+func (m *MockScanner) ScanFolders(_ context.Context, fullScan bool, targets []model.ScanTarget) ([]string, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Make a copy of targets to avoid race conditions
+	targetsCopy := make([]model.ScanTarget, len(targets))
+	copy(targetsCopy, targets)
+
+	m.scanFoldersCalls = append(m.scanFoldersCalls, ScanFoldersCall{
+		FullScan: fullScan,
+		Targets:  targetsCopy,
+	})
+
+	return nil, nil
+}
+
+func (m *MockScanner) Status(_ context.Context) (*model.ScannerStatus, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.statusResponse != nil {
+		return m.statusResponse, nil
+	}
+
+	return &model.ScannerStatus{
+		Scanning: m.scanningStatus,
+	}, nil
+}
+
+func (m *MockScanner) GetScanAllCallCount() int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return len(m.scanAllCalls)
+}
+
+func (m *MockScanner) GetScanAllCalls() []ScanAllCall {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	// Return a copy to avoid race conditions
+	calls := make([]ScanAllCall, len(m.scanAllCalls))
+	copy(calls, m.scanAllCalls)
+	return calls
+}
+
+func (m *MockScanner) GetScanFoldersCallCount() int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return len(m.scanFoldersCalls)
+}
+
+func (m *MockScanner) GetScanFoldersCalls() []ScanFoldersCall {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	// Return a copy to avoid race conditions
+	calls := make([]ScanFoldersCall, len(m.scanFoldersCalls))
+	copy(calls, m.scanFoldersCalls)
+	return calls
+}
+
+func (m *MockScanner) Reset() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.scanAllCalls = make([]ScanAllCall, 0)
+	m.scanFoldersCalls = make([]ScanFoldersCall, 0)
+}
+
+func (m *MockScanner) SetScanning(scanning bool) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.scanningStatus = scanning
+}
+
+func (m *MockScanner) SetStatusResponse(status *model.ScannerStatus) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.statusResponse = status
+}

tests/test_helpers.go

@@ -6,7 +6,10 @@ import (
 	"path/filepath"
 
 	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model/id"
+	"github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus/hooks/test"
 )
 
 type testingT interface {
@@ -35,3 +38,23 @@ func ClearDB() error {
 		`)
 	return err
 }
+
+// LogHook sets up a logrus test hook and configures the default logger to use it.
+// It returns the hook and a cleanup function to restore the default logger.
+// Example usage:
+//
+//	hook, cleanup := LogHook()
+//	defer cleanup()
+//	// ... perform logging operations ...
+//	Expect(hook.LastEntry()).ToNot(BeNil())
+//	Expect(hook.LastEntry().Level).To(Equal(logrus.WarnLevel))
+//	Expect(hook.LastEntry().Message).To(Equal("log message"))
+func LogHook() (*test.Hook, func()) {
+	l, hook := test.NewNullLogger()
+	log.SetLevel(log.LevelWarn)
+	log.SetDefaultLogger(l)
+	return hook, func() {
+		// Restore default logger after test
+		log.SetDefaultLogger(logrus.New())
+	}
+}

ui/src/album/AlbumDetails.test.jsx

@@ -14,6 +14,24 @@ vi.mock('@material-ui/core', async () => {
   }
 })
 
+// Mock formatFullDate to return deterministic results
+vi.mock('../utils', async () => {
+  const actual = await import('../utils')
+  return {
+    ...actual,
+    formatFullDate: (date) => {
+      if (!date) return ''
+      // Use en-CA locale for consistent test results
+      return new Date(date).toLocaleDateString('en-CA', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        timeZone: 'UTC',
+      })
+    },
+  }
+})
+
 describe('Details component', () => {
   describe('Desktop view', () => {
     beforeEach(() => {

ui/src/i18n/en.json

@@ -302,6 +302,8 @@
       },
       "actions": {
         "scan": "Scan Library",
+        "quickScan": "Quick Scan",
+        "fullScan": "Full Scan",
         "manageUsers": "Manage User Access",
         "viewDetails": "View Details"
       },
@@ -310,6 +312,9 @@
         "updated": "Library updated successfully",
         "deleted": "Library deleted successfully",
         "scanStarted": "Library scan started",
+        "quickScanStarted": "Quick scan started",
+        "fullScanStarted": "Full scan started",
+        "scanError": "Error starting scan. Check logs",
         "scanCompleted": "Library scan completed"
       },
       "validation": {
@@ -600,11 +605,12 @@
   "activity": {
     "title": "Activity",
     "totalScanned": "Total Folders Scanned",
-    "quickScan": "Quick Scan",
-    "fullScan": "Full Scan",
+    "quickScan": "Quick",
+    "fullScan": "Full",
+    "selectiveScan": "Selective",
     "serverUptime": "Server Uptime",
     "serverDown": "OFFLINE",
-    "scanType": "Type",
+    "scanType": "Last Scan",
     "status": "Scan Error",
     "elapsedTime": "Elapsed Time"
   },

ui/src/layout/ActivityPanel.jsx

@@ -113,6 +113,9 @@ const ActivityPanel = () => {
         return translate('activity.fullScan')
       case 'quick':
         return translate('activity.quickScan')
+      case 'full-selective':
+      case 'quick-selective':
+        return translate('activity.selectiveScan')
       default:
         return ''
     }

ui/src/library/LibraryEdit.jsx

@@ -169,7 +169,7 @@ const LibraryEdit = (props) => {
                         resource={'library'}
                         source={'totalSize'}
                         label={translate('resources.library.fields.totalSize')}
-                        format={formatBytes}
+                        format={(v) => formatBytes(v, 2)}
                         fullWidth
                         variant="outlined"
                       />

ui/src/library/LibraryList.jsx

@@ -9,7 +9,9 @@ import {
   BooleanField,
 } from 'react-admin'
 import { useMediaQuery } from '@material-ui/core'
-import { List, DateField, useResourceRefresh } from '../common'
+import { List, DateField, useResourceRefresh, SizeField } from '../common'
+import LibraryListBulkActions from './LibraryListBulkActions'
+import LibraryListActions from './LibraryListActions'
 
 const LibraryFilter = (props) => (
   <Filter {...props} variant={'outlined'}>
@@ -26,8 +28,9 @@ const LibraryList = (props) => {
       {...props}
       sort={{ field: 'name', order: 'ASC' }}
       exporter={false}
-      bulkActionButtons={false}
+      bulkActionButtons={!isXsmall && <LibraryListBulkActions />}
       filters={<LibraryFilter />}
+      actions={<LibraryListActions />}
     >
       {isXsmall ? (
         <SimpleList
@@ -42,6 +45,7 @@ const LibraryList = (props) => {
           <NumberField source="totalSongs" label="Songs" />
           <NumberField source="totalAlbums" label="Albums" />
           <NumberField source="totalMissingFiles" label="Missing Files" />
+          <SizeField source="totalSize" />
           <DateField
             source="lastScanAt"
             label="Last Scan"

ui/src/library/LibraryListActions.jsx

@@ -0,0 +1,30 @@
+import React, { cloneElement } from 'react'
+import { sanitizeListRestProps, TopToolbar } from 'react-admin'
+import LibraryScanButton from './LibraryScanButton'
+
+const LibraryListActions = ({
+  className,
+  filters,
+  resource,
+  showFilter,
+  displayedFilters,
+  filterValues,
+  ...rest
+}) => {
+  return (
+    <TopToolbar className={className} {...sanitizeListRestProps(rest)}>
+      {filters &&
+        cloneElement(filters, {
+          resource,
+          showFilter,
+          displayedFilters,
+          filterValues,
+          context: 'button',
+        })}
+      <LibraryScanButton fullScan={false} />
+      <LibraryScanButton fullScan={true} />
+    </TopToolbar>
+  )
+}
+
+export default LibraryListActions

ui/src/library/LibraryListBulkActions.jsx

@@ -0,0 +1,11 @@
+import React from 'react'
+import LibraryScanButton from './LibraryScanButton'
+
+const LibraryListBulkActions = (props) => (
+  <>
+    <LibraryScanButton fullScan={false} {...props} />
+    <LibraryScanButton fullScan={true} {...props} />
+  </>
+)
+
+export default LibraryListBulkActions

ui/src/library/LibraryScanButton.jsx

@@ -0,0 +1,77 @@
+import React, { useState } from 'react'
+import PropTypes from 'prop-types'
+import {
+  Button,
+  useNotify,
+  useRefresh,
+  useTranslate,
+  useUnselectAll,
+} from 'react-admin'
+import { useSelector } from 'react-redux'
+import SyncIcon from '@material-ui/icons/Sync'
+import CachedIcon from '@material-ui/icons/Cached'
+import subsonic from '../subsonic'
+
+const LibraryScanButton = ({ fullScan, selectedIds, className }) => {
+  const [loading, setLoading] = useState(false)
+  const notify = useNotify()
+  const refresh = useRefresh()
+  const translate = useTranslate()
+  const unselectAll = useUnselectAll()
+  const scanStatus = useSelector((state) => state.activity.scanStatus)
+
+  const handleClick = async () => {
+    setLoading(true)
+    try {
+      // Build scan options
+      const options = { fullScan }
+
+      // If specific libraries are selected, scan only those
+      // Format: "libraryID:" to scan entire library (no folder path specified)
+      if (selectedIds && selectedIds.length > 0) {
+        options.target = selectedIds.map((id) => `${id}:`)
+      }
+
+      await subsonic.startScan(options)
+      const notificationKey = fullScan
+        ? 'resources.library.notifications.fullScanStarted'
+        : 'resources.library.notifications.quickScanStarted'
+      notify(notificationKey, 'info')
+      refresh()
+
+      // Unselect all items after successful scan
+      unselectAll('library')
+    } catch (error) {
+      notify('resources.library.notifications.scanError', 'warning')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const isDisabled = loading || scanStatus.scanning
+
+  const label = fullScan
+    ? translate('resources.library.actions.fullScan')
+    : translate('resources.library.actions.quickScan')
+
+  const icon = fullScan ? <CachedIcon /> : <SyncIcon />
+
+  return (
+    <Button
+      onClick={handleClick}
+      disabled={isDisabled}
+      label={label}
+      className={className}
+    >
+      {icon}
+    </Button>
+  )
+}
+
+LibraryScanButton.propTypes = {
+  fullScan: PropTypes.bool.isRequired,
+  selectedIds: PropTypes.array,
+  className: PropTypes.string,
+}
+
+export default LibraryScanButton

ui/src/subsonic/index.js

@@ -23,7 +23,13 @@ const url = (command, id, options) => {
       delete options.ts
     }
     Object.keys(options).forEach((k) => {
-      params.append(k, options[k])
+      const value = options[k]
+      // Handle array parameters by appending each value separately
+      if (Array.isArray(value)) {
+        value.forEach((v) => params.append(k, v))
+      } else {
+        params.append(k, value)
+      }
     })
   }
   return `/rest/${command}?${params.toString()}`

ui/src/themes/dark.js

@@ -16,6 +16,11 @@ export default {
         color: 'white',
       },
     },
+    MuiButton: {
+      textPrimary: {
+        color: '#fff',
+      },
+    },
     NDLogin: {
       systemNameLink: {
         color: '#0085ff',