Merge commit from fork

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

.github/copilot-instructions.md

@@ -0,0 +1,53 @@
+# Navidrome Code Guidelines
+
+This is a music streaming server written in Go with a React frontend. The application manages music libraries, provides streaming capabilities, and offers various features like artist information, artwork handling, and external service integrations.
+
+## Code Standards
+
+### Backend (Go)
+- Follow standard Go conventions and idioms
+- Use context propagation for cancellation signals
+- Write unit tests for new functionality using Ginkgo/Gomega
+- Use mutex appropriately for concurrent operations
+- Implement interfaces for dependencies to facilitate testing
+
+### Frontend (React)
+- Use functional components with hooks
+- Follow React best practices for state management
+- Implement PropTypes for component properties
+- Prefer using React-Admin and Material-UI components
+- Icons should be imported from `react-icons` only
+- Follow existing patterns for API interaction
+
+## Repository Structure
+- `core/`: Server-side business logic (artwork handling, playback, etc.)
+- `ui/`: React frontend components
+- `model/`: Data models and repository interfaces
+- `server/`: API endpoints and server implementation
+- `utils/`: Shared utility functions
+- `persistence/`: Database access layer
+- `scanner/`: Music library scanning functionality
+
+## Key Guidelines
+1. Maintain cache management patterns for performance
+2. Follow the existing concurrency patterns (mutex, atomic)
+3. Use the testing framework appropriately (Ginkgo/Gomega for Go)
+4. Keep UI components focused and reusable
+5. Document configuration options in code
+6. Consider performance implications when working with music libraries
+7. Follow existing error handling patterns
+8. Ensure compatibility with external services (LastFM, Spotify)
+
+## Development Workflow
+- Test changes thoroughly, especially around concurrent operations
+- Validate both backend and frontend interactions
+- Consider how changes will affect user experience and performance
+- Test with different music library sizes and configurations
+- Before committing, ALWAYS run `make format lint test`, and make sure there are no issues
+
+## Important commands
+- `make build`: Build the application
+- `make test`: Run Go tests
+- To run tests for a specific package, use `make test PKG=./pkgname/...`
+- `make lintall`: Run linters
+- `make format`: Format code

.github/workflows/pipeline.yml

@@ -71,7 +71,7 @@ jobs:
           version: ${{ env.CROSS_TAGLIB_VERSION }}
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v7
+        uses: golangci/golangci-lint-action@v8
         with:
           version: latest
           problem-matchers: true

.gitignore

@@ -24,4 +24,6 @@ docker-compose.yml
 !contrib/docker-compose.yml
 binaries
 navidrome-master
-*.exe
+AGENTS.md
+*.exe
+bin/

Makefile

@@ -19,7 +19,7 @@ CROSS_TAGLIB_VERSION ?= 2.0.2-1
 
 UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")
 
-setup: check_env download-deps setup-git ##@1_Run_First Install dependencies and prepare development environment
+setup: check_env download-deps install-golangci-lint setup-git ##@1_Run_First Install dependencies and prepare development environment
 	@echo Downloading Node dependencies...
 	@(cd ./ui && npm ci)
 .PHONY: setup
@@ -36,8 +36,9 @@ watch: ##@Development Start Go tests in watch mode (re-run when code changes)
 	go tool ginkgo watch -tags=netgo -notify ./...
 .PHONY: watch
 
+PKG ?= ./...
 test: ##@Development Run Go tests
-	go test -tags netgo ./...
+	go test -tags netgo $(PKG)
 .PHONY: test
 
 testrace: ##@Development Run Go tests with race detector
@@ -45,11 +46,15 @@ testrace: ##@Development Run Go tests with race detector
 .PHONY: test
 
 testall: testrace ##@Development Run Go and JS tests
-	@(cd ./ui && npm run test:ci)
+	@(cd ./ui && npm run test)
 .PHONY: testall
 
-lint: ##@Development Lint Go code
-	go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest run -v --timeout 5m
+install-golangci-lint: ##@Development Install golangci-lint if not present
+	@PATH=$$PATH:./bin which golangci-lint > /dev/null || (echo "Installing golangci-lint..." && curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s v2.1.6)
+.PHONY: install-golangci-lint
+
+lint: install-golangci-lint ##@Development Lint Go code
+	PATH=$$PATH:./bin golangci-lint run -v --timeout 5m
 .PHONY: lint
 
 lintall: lint ##@Development Lint Go and JS code
@@ -156,10 +161,10 @@ package: docker-build ##@Cross_Compilation Create binaries and packages for ALL
 get-music: ##@Development Download some free music from Navidrome's demo instance
 	mkdir -p music
 	( cd music; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=ec2093ec4801402f1e17cc462195cdbb" > brock.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=b376eeb4652d2498aa2b25ba0696725e" > back_on_earth.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=e49c609b542fc51899ee8b53aa858cb4" > ugress.zip; \
-	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=350bcab3a4c1d93869e39ce496464f03" > voodoocuts.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=2Y3qQA6zJC3ObbBrF9ZBoV" > brock.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=04HrSORpypcLGNUdQp37gn" > back_on_earth.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=5xcMPJdeEgNrGtnzYbzAqb" > ugress.zip; \
+	curl "https://demo.navidrome.org/rest/download?u=demo&p=demo&f=json&v=1.8.0&c=dev_download&id=1jjQMAZrG3lUsJ0YH6ZRS0" > voodoocuts.zip; \
 	for file in *.zip; do unzip -n $${file}; done )
 	@echo "Done. Remember to set your MusicFolder to ./music"
 .PHONY: get-music

adapters/taglib/taglib_test.go

@@ -82,15 +82,15 @@ var _ = Describe("Extractor", func() {
 
 			// TabLib 1.12 returns 18, previous versions return 39.
 			// See https://github.com/taglib/taglib/commit/2f238921824741b2cfe6fbfbfc9701d9827ab06b
-			Expect(m.AudioProperties.BitRate).To(BeElementOf(18, 39, 40, 43, 49))
+			Expect(m.AudioProperties.BitRate).To(BeElementOf(18, 19, 39, 40, 43, 49))
 			Expect(m.AudioProperties.Channels).To(BeElementOf(2))
 			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
 			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
-			Expect(m.HasPicture).To(BeFalse())
+			Expect(m.HasPicture).To(BeTrue())
 		})
 
 		DescribeTable("Format-Specific tests",
-			func(file, duration string, channels, samplerate, bitdepth int, albumGain, albumPeak, trackGain, trackPeak string, id3Lyrics bool) {
+			func(file, duration string, channels, samplerate, bitdepth int, albumGain, albumPeak, trackGain, trackPeak string, id3Lyrics bool, image bool) {
 				file = "tests/fixtures/" + file
 				mds, err := e.Parse(file)
 				Expect(err).NotTo(HaveOccurred())
@@ -98,7 +98,7 @@ var _ = Describe("Extractor", func() {
 
 				m := mds[file]
 
-				Expect(m.HasPicture).To(BeFalse())
+				Expect(m.HasPicture).To(Equal(image))
 				Expect(m.AudioProperties.Duration.String()).To(Equal(duration))
 				Expect(m.AudioProperties.Channels).To(Equal(channels))
 				Expect(m.AudioProperties.SampleRate).To(Equal(samplerate))
@@ -168,24 +168,24 @@ var _ = Describe("Extractor", func() {
 			},
 
 			// ffmpeg -f lavfi -i "sine=frequency=1200:duration=1" test.flac
-			Entry("correctly parses flac tags", "test.flac", "1s", 1, 44100, 16, "+4.06 dB", "0.12496948", "+4.06 dB", "0.12496948", false),
+			Entry("correctly parses flac tags", "test.flac", "1s", 1, 44100, 16, "+4.06 dB", "0.12496948", "+4.06 dB", "0.12496948", false, true),
 
-			Entry("correctly parses m4a (aac) gain tags", "01 Invisible (RED) Edit Version.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false),
-			Entry("correctly parses m4a (aac) gain tags (uppercase)", "test.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false),
-			Entry("correctly parses ogg (vorbis) tags", "test.ogg", "1.04s", 2, 8000, 0, "+7.64 dB", "0.11772506", "+7.64 dB", "0.11772506", false),
+			Entry("correctly parses m4a (aac) gain tags", "01 Invisible (RED) Edit Version.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false, true),
+			Entry("correctly parses m4a (aac) gain tags (uppercase)", "test.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false, true),
+			Entry("correctly parses ogg (vorbis) tags", "test.ogg", "1.04s", 2, 8000, 0, "+7.64 dB", "0.11772506", "+7.64 dB", "0.11772506", false, true),
 
 			// ffmpeg -f lavfi -i "sine=frequency=900:duration=1" test.wma
 			// Weird note: for the tag parsing to work, the lyrics are actually stored in the reverse order
-			Entry("correctly parses wma/asf tags", "test.wma", "1.02s", 1, 44100, 16, "3.27 dB", "0.132914", "3.27 dB", "0.132914", false),
+			Entry("correctly parses wma/asf tags", "test.wma", "1.02s", 1, 44100, 16, "3.27 dB", "0.132914", "3.27 dB", "0.132914", false, true),
 
 			// ffmpeg -f lavfi -i "sine=frequency=800:duration=1" test.wv
-			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false),
+			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false, false),
 
 			// ffmpeg -f lavfi -i "sine=frequency=1000:duration=1" test.wav
-			Entry("correctly parses wav tags", "test.wav", "1s", 1, 44100, 16, "3.06 dB", "0.125056", "3.06 dB", "0.125056", true),
+			Entry("correctly parses wav tags", "test.wav", "1s", 1, 44100, 16, "3.06 dB", "0.125056", "3.06 dB", "0.125056", true, true),
 
 			// ffmpeg -f lavfi -i "sine=frequency=1400:duration=1" test.aiff
-			Entry("correctly parses aiff tags", "test.aiff", "1s", 1, 44100, 16, "2.00 dB", "0.124972", "2.00 dB", "0.124972", true),
+			Entry("correctly parses aiff tags", "test.aiff", "1s", 1, 44100, 16, "2.00 dB", "0.124972", "2.00 dB", "0.124972", true, true),
 		)
 
 		// Skip these tests when running as root

adapters/taglib/taglib_wrapper.cpp

@@ -225,18 +225,25 @@ char has_cover(const TagLib::FileRef f) {
   else if (TagLib::Ogg::Opus::File * opusFile{dynamic_cast<TagLib::Ogg::Opus::File *>(f.file())}) {
     hasCover = !opusFile->tag()->pictureList().isEmpty();
   }
-  // ----- WMA
-  else if (TagLib::ASF::File * asfFile{dynamic_cast<TagLib::ASF::File *>(f.file())}) {
-    const TagLib::ASF::Tag *tag{asfFile->tag()};
-    hasCover = tag && tag->attributeListMap().contains("WM/Picture");
-  }
   // ----- WAV
   else if (TagLib::RIFF::WAV::File * wavFile{ dynamic_cast<TagLib::RIFF::WAV::File*>(f.file()) }) {
     if (wavFile->hasID3v2Tag()) {
-        const auto& frameListMap{ wavFile->ID3v2Tag()->frameListMap() };
-        hasCover = !frameListMap["APIC"].isEmpty();
+      const auto& frameListMap{ wavFile->ID3v2Tag()->frameListMap() };
+      hasCover = !frameListMap["APIC"].isEmpty();
     }
   }
+  // ----- AIFF 
+  else if (TagLib::RIFF::AIFF::File * aiffFile{ dynamic_cast<TagLib::RIFF::AIFF::File *>(f.file())}) {
+    if (aiffFile->hasID3v2Tag()) {
+      const auto& frameListMap{ aiffFile->tag()->frameListMap() };
+      hasCover = !frameListMap["APIC"].isEmpty();
+    }
+  }
+  // ----- WMA
+  else if (TagLib::ASF::File * asfFile{dynamic_cast<TagLib::ASF::File *>(f.file())}) {
+    const TagLib::ASF::Tag *tag{ asfFile->tag() };
+    hasCover = tag && asfFile->tag()->attributeListMap().contains("WM/Picture");
+  }
 
   return hasCover;
 }

conf/configuration.go

@@ -72,6 +72,7 @@ type configOptions struct {
 	EnableUserEditing               bool
 	EnableSharing                   bool
 	ShareURL                        string
+	DefaultShareExpiration          time.Duration
 	DefaultDownloadableShare        bool
 	DefaultTheme                    string
 	DefaultLanguage                 string
@@ -93,6 +94,7 @@ type configOptions struct {
 	PID                             pidOptions
 	Inspect                         inspectOptions
 	Subsonic                        subsonicOptions
+	LyricsPriority                  string
 
 	Agents       string
 	LastFM       lastfmOptions
@@ -109,7 +111,6 @@ type configOptions struct {
 	DevActivityPanel                 bool
 	DevActivityPanelUpdateRate       time.Duration
 	DevSidebarPlaylists              bool
-	DevEnableBufferedScrobble        bool
 	DevShowArtistPage                bool
 	DevOffsetOptimize                int
 	DevArtworkMaxRequests            int
@@ -132,6 +133,8 @@ type scannerOptions struct {
 	ArtistJoiner       string
 	GenreSeparators    string // Deprecated: Use Tags.genre.Split instead
 	GroupAlbumReleases bool   // Deprecated: Use PID.Album instead
+	FollowSymlinks     bool   // Whether to follow symlinks when scanning directories
+	PurgeMissing       string // Values: "never", "always", "full"
 }
 
 type subsonicOptions struct {
@@ -151,10 +154,11 @@ type TagConf struct {
 }
 
 type lastfmOptions struct {
-	Enabled  bool
-	ApiKey   string
-	Secret   string
-	Language string
+	Enabled                 bool
+	ApiKey                  string
+	Secret                  string
+	Language                string
+	ScrobbleFirstArtistOnly bool
 }
 
 type spotifyOptions struct {
@@ -275,6 +279,7 @@ func Load(noConfigDump bool) {
 		validateScanSchedule,
 		validateBackupSchedule,
 		validatePlaylistsPath,
+		validatePurgeMissingOption,
 	)
 	if err != nil {
 		os.Exit(1)
@@ -312,6 +317,7 @@ func Load(noConfigDump bool) {
 	}
 	logDeprecatedOptions("Scanner.GenreSeparators")
 	logDeprecatedOptions("Scanner.GroupAlbumReleases")
+	logDeprecatedOptions("DevEnableBufferedScrobble") // Deprecated: Buffered scrobbling is now always enabled and this option is ignored
 
 	// Call init hooks
 	for _, hook := range hooks {
@@ -379,6 +385,24 @@ func validatePlaylistsPath() error {
 	return nil
 }
 
+func validatePurgeMissingOption() error {
+	allowedValues := []string{consts.PurgeMissingNever, consts.PurgeMissingAlways, consts.PurgeMissingFull}
+	valid := false
+	for _, v := range allowedValues {
+		if v == Server.Scanner.PurgeMissing {
+			valid = true
+			break
+		}
+	}
+	if !valid {
+		err := fmt.Errorf("Invalid Scanner.PurgeMissing value: '%s'. Must be one of: %v", Server.Scanner.PurgeMissing, allowedValues)
+		log.Error(err.Error())
+		Server.Scanner.PurgeMissing = consts.PurgeMissingNever
+		return err
+	}
+	return nil
+}
+
 func validateScanSchedule() error {
 	if Server.Scanner.Schedule == "0" || Server.Scanner.Schedule == "" {
 		Server.Scanner.Schedule = ""
@@ -418,7 +442,7 @@ func AddHook(hook func()) {
 	hooks = append(hooks, hook)
 }
 
-func init() {
+func setViperDefaults() {
 	viper.SetDefault("musicfolder", filepath.Join(".", "music"))
 	viper.SetDefault("cachefolder", "")
 	viper.SetDefault("datafolder", ".")
@@ -455,7 +479,6 @@ func init() {
 	viper.SetDefault("indexgroups", "A B C D E F G H I J K L M N O P Q R S T U V W X-Z(XYZ) [Unknown]([)")
 	viper.SetDefault("ffmpegpath", "")
 	viper.SetDefault("mpvcmdtemplate", "mpv --audio-device=%d --no-audio-display --pause %f --input-ipc-server=%s")
-
 	viper.SetDefault("coverartpriority", "cover.*, folder.*, front.*, embedded, external")
 	viper.SetDefault("coverjpegquality", 75)
 	viper.SetDefault("artistartpriority", "artist.*, album/artist.*, external")
@@ -470,6 +493,7 @@ func init() {
 	viper.SetDefault("enablecoveranimation", true)
 	viper.SetDefault("enablesharing", false)
 	viper.SetDefault("shareurl", "")
+	viper.SetDefault("defaultshareexpiration", 8760*time.Hour)
 	viper.SetDefault("defaultdownloadableshare", false)
 	viper.SetDefault("gatrackingid", "")
 	viper.SetDefault("enableinsightscollector", true)
@@ -477,19 +501,15 @@ func init() {
 	viper.SetDefault("authrequestlimit", 5)
 	viper.SetDefault("authwindowlength", 20*time.Second)
 	viper.SetDefault("passwordencryptionkey", "")
-
 	viper.SetDefault("reverseproxyuserheader", "Remote-User")
 	viper.SetDefault("reverseproxywhitelist", "")
-
 	viper.SetDefault("prometheus.enabled", false)
 	viper.SetDefault("prometheus.metricspath", consts.PrometheusDefaultPath)
 	viper.SetDefault("prometheus.password", "")
-
 	viper.SetDefault("jukebox.enabled", false)
 	viper.SetDefault("jukebox.devices", []AudioDeviceDefinition{})
 	viper.SetDefault("jukebox.default", "")
 	viper.SetDefault("jukebox.adminonly", true)
-
 	viper.SetDefault("scanner.enabled", true)
 	viper.SetDefault("scanner.schedule", "0")
 	viper.SetDefault("scanner.extractor", consts.DefaultScannerExtractor)
@@ -498,44 +518,39 @@ func init() {
 	viper.SetDefault("scanner.artistjoiner", consts.ArtistJoiner)
 	viper.SetDefault("scanner.genreseparators", "")
 	viper.SetDefault("scanner.groupalbumreleases", false)
-
+	viper.SetDefault("scanner.followsymlinks", true)
+	viper.SetDefault("scanner.purgemissing", "never")
 	viper.SetDefault("subsonic.appendsubtitle", true)
 	viper.SetDefault("subsonic.artistparticipations", false)
 	viper.SetDefault("subsonic.defaultreportrealpath", false)
 	viper.SetDefault("subsonic.legacyclients", "DSub")
-
 	viper.SetDefault("agents", "lastfm,spotify")
 	viper.SetDefault("lastfm.enabled", true)
 	viper.SetDefault("lastfm.language", "en")
 	viper.SetDefault("lastfm.apikey", "")
 	viper.SetDefault("lastfm.secret", "")
+	viper.SetDefault("lastfm.scrobblefirstartistonly", false)
 	viper.SetDefault("spotify.id", "")
 	viper.SetDefault("spotify.secret", "")
 	viper.SetDefault("listenbrainz.enabled", true)
 	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
-
 	viper.SetDefault("httpsecurityheaders.customframeoptionsvalue", "DENY")
-
 	viper.SetDefault("backup.path", "")
 	viper.SetDefault("backup.schedule", "")
 	viper.SetDefault("backup.count", 0)
-
 	viper.SetDefault("pid.track", consts.DefaultTrackPID)
 	viper.SetDefault("pid.album", consts.DefaultAlbumPID)
-
 	viper.SetDefault("inspect.enabled", true)
 	viper.SetDefault("inspect.maxrequests", 1)
 	viper.SetDefault("inspect.backloglimit", consts.RequestThrottleBacklogLimit)
 	viper.SetDefault("inspect.backlogtimeout", consts.RequestThrottleBacklogTimeout)
-
-	// DevFlags. These are used to enable/disable debugging and incomplete features
+	viper.SetDefault("lyricspriority", ".lrc,.txt,embedded")
 	viper.SetDefault("devlogsourceline", false)
 	viper.SetDefault("devenableprofiler", false)
 	viper.SetDefault("devautocreateadminpassword", "")
 	viper.SetDefault("devautologinusername", "")
 	viper.SetDefault("devactivitypanel", true)
 	viper.SetDefault("devactivitypanelupdaterate", 300*time.Millisecond)
-	viper.SetDefault("devenablebufferedscrobble", true)
 	viper.SetDefault("devsidebarplaylists", true)
 	viper.SetDefault("devshowartistpage", true)
 	viper.SetDefault("devoffsetoptimize", 50000)
@@ -550,6 +565,10 @@ func init() {
 	viper.SetDefault("devenableplayerinsights", true)
 }
 
+func init() {
+	setViperDefaults()
+}
+
 func InitConfig(cfgFile string) {
 	codecRegistry := viper.NewCodecRegistry()
 	_ = codecRegistry.RegisterCodec("ini", ini.Codec{})

conf/configuration_test.go

@@ -5,7 +5,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	. "github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	"github.com/spf13/viper"
@@ -20,9 +20,10 @@ var _ = Describe("Configuration", func() {
 	BeforeEach(func() {
 		// Reset viper configuration
 		viper.Reset()
+		conf.SetViperDefaults()
 		viper.SetDefault("datafolder", GinkgoT().TempDir())
 		viper.SetDefault("loglevel", "error")
-		ResetConf()
+		conf.ResetConf()
 	})
 
 	DescribeTable("should load configuration from",
@@ -30,17 +31,17 @@ var _ = Describe("Configuration", func() {
 			filename := filepath.Join("testdata", "cfg."+format)
 
 			// Initialize config with the test file
-			InitConfig(filename)
+			conf.InitConfig(filename)
 			// Load the configuration (with noConfigDump=true)
-			Load(true)
+			conf.Load(true)
 
 			// Execute the format-specific assertions
-			Expect(Server.MusicFolder).To(Equal(fmt.Sprintf("/%s/music", format)))
-			Expect(Server.UIWelcomeMessage).To(Equal("Welcome " + format))
-			Expect(Server.Tags["custom"].Aliases).To(Equal([]string{format, "test"}))
+			Expect(conf.Server.MusicFolder).To(Equal(fmt.Sprintf("/%s/music", format)))
+			Expect(conf.Server.UIWelcomeMessage).To(Equal("Welcome " + format))
+			Expect(conf.Server.Tags["custom"].Aliases).To(Equal([]string{format, "test"}))
 
 			// The config file used should be the one we created
-			Expect(Server.ConfigFile).To(Equal(filename))
+			Expect(conf.Server.ConfigFile).To(Equal(filename))
 		},
 		Entry("TOML format", "toml"),
 		Entry("YAML format", "yaml"),

conf/export_test.go

@@ -3,3 +3,5 @@ package conf
 func ResetConf() {
 	Server = &configOptions{}
 }
+
+var SetViperDefaults = setViperDefaults

consts/consts.go

@@ -14,6 +14,9 @@ const (
 	DefaultDbPath                 = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL&_foreign_keys=on&synchronous=normal"
 	InitialSetupFlagKey           = "InitialSetup"
 	FullScanAfterMigrationFlagKey = "FullScanAfterMigration"
+	LastScanErrorKey              = "LastScanError"
+	LastScanTypeKey               = "LastScanType"
+	LastScanStartTimeKey          = "LastScanStartTime"
 
 	UIAuthorizationHeader  = "X-ND-Authorization"
 	UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"
@@ -112,6 +115,12 @@ const (
 	InsightsInitialDelay   = 30 * time.Minute
 )
 
+const (
+	PurgeMissingNever  = "never"
+	PurgeMissingAlways = "always"
+	PurgeMissingFull   = "full"
+)
+
 var (
 	DefaultDownsamplingFormat = "opus"
 	DefaultTranscodings       = []struct {

core/agents/lastfm/agent.go

@@ -279,6 +279,13 @@ func (l *lastfmAgent) callArtistGetTopTracks(ctx context.Context, artistName str
 	return t.Track, nil
 }
 
+func (l *lastfmAgent) getArtistForScrobble(track *model.MediaFile) string {
+	if conf.Server.LastFM.ScrobbleFirstArtistOnly && len(track.Participants[model.RoleArtist]) > 0 {
+		return track.Participants[model.RoleArtist][0].Name
+	}
+	return track.Artist
+}
+
 func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
 	sk, err := l.sessionKeys.Get(ctx, userId)
 	if err != nil || sk == "" {
@@ -286,7 +293,7 @@ func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *mode
 	}
 
 	err = l.client.updateNowPlaying(ctx, sk, ScrobbleInfo{
-		artist:      track.Artist,
+		artist:      l.getArtistForScrobble(track),
 		track:       track.Title,
 		album:       track.Album,
 		trackNumber: track.TrackNumber,
@@ -312,7 +319,7 @@ func (l *lastfmAgent) Scrobble(ctx context.Context, userId string, s scrobbler.S
 		return nil
 	}
 	err = l.client.scrobble(ctx, sk, ScrobbleInfo{
-		artist:      s.Artist,
+		artist:      l.getArtistForScrobble(&s.MediaFile),
 		track:       s.Title,
 		album:       s.Album,
 		trackNumber: s.TrackNumber,
@@ -344,6 +351,8 @@ func (l *lastfmAgent) IsAuthorized(ctx context.Context, userId string) bool {
 func init() {
 	conf.AddHook(func() {
 		agents.Register(lastFMAgentName, func(ds model.DataStore) agents.Interface {
+			// This is a workaround for the fact that a (Interface)(nil) is not the same as a (*lastfmAgent)(nil)
+			// See https://go.dev/doc/faq#nil_error
 			a := lastFMConstructor(ds)
 			if a != nil {
 				return a
@@ -351,6 +360,8 @@ func init() {
 			return nil
 		})
 		scrobbler.Register(lastFMAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
+			// Same as above - this is a workaround for the fact that a (Scrobbler)(nil) is not the same as a (*lastfmAgent)(nil)
+			// See https://go.dev/doc/faq#nil_error
 			a := lastFMConstructor(ds)
 			if a != nil {
 				return a

core/agents/lastfm/agent_test.go

@@ -196,6 +196,12 @@ var _ = Describe("lastfmAgent", func() {
 				TrackNumber:    1,
 				Duration:       180,
 				MbzRecordingID: "mbz-123",
+				Participants: map[model.Role]model.ParticipantList{
+					model.RoleArtist: []model.Participant{
+						{Artist: model.Artist{ID: "ar-1", Name: "First Artist"}},
+						{Artist: model.Artist{ID: "ar-2", Name: "Second Artist"}},
+					},
+				},
 			}
 		})
 
@@ -247,6 +253,23 @@ var _ = Describe("lastfmAgent", func() {
 				Expect(sentParams.Get("timestamp")).To(Equal(strconv.FormatInt(ts.Unix(), 10)))
 			})
 
+			When("ScrobbleFirstArtistOnly is true", func() {
+				BeforeEach(func() {
+					conf.Server.LastFM.ScrobbleFirstArtistOnly = true
+				})
+
+				It("uses only the first artist", func() {
+					ts := time.Now()
+					httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
+
+					err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: ts})
+
+					Expect(err).ToNot(HaveOccurred())
+					sentParams := httpClient.SavedRequest.URL.Query()
+					Expect(sentParams.Get("artist")).To(Equal("First Artist"))
+				})
+			})
+
 			It("skips songs with less than 31 seconds", func() {
 				track.Duration = 29
 				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}

core/archiver.go

@@ -98,7 +98,7 @@ func (a *archiver) ZipShare(ctx context.Context, id string, out io.Writer) error
 		return model.ErrNotAuthorized
 	}
 	log.Debug(ctx, "Zipping share", "name", s.ID, "format", s.Format, "bitrate", s.MaxBitRate, "numTracks", len(s.Tracks))
-	return a.zipMediaFiles(ctx, id, s.Format, s.MaxBitRate, out, s.Tracks)
+	return a.zipMediaFiles(ctx, id, s.ID, s.Format, s.MaxBitRate, out, s.Tracks, false)
 }
 
 func (a *archiver) ZipPlaylist(ctx context.Context, id string, format string, bitrate int, out io.Writer) error {
@@ -109,15 +109,40 @@ func (a *archiver) ZipPlaylist(ctx context.Context, id string, format string, bi
 	}
 	mfs := pls.MediaFiles()
 	log.Debug(ctx, "Zipping playlist", "name", pls.Name, "format", format, "bitrate", bitrate, "numTracks", len(mfs))
-	return a.zipMediaFiles(ctx, id, format, bitrate, out, mfs)
+	return a.zipMediaFiles(ctx, id, pls.Name, format, bitrate, out, mfs, true)
 }
 
-func (a *archiver) zipMediaFiles(ctx context.Context, id string, format string, bitrate int, out io.Writer, mfs model.MediaFiles) error {
+func (a *archiver) zipMediaFiles(ctx context.Context, id, name string, format string, bitrate int, out io.Writer, mfs model.MediaFiles, addM3U bool) error {
 	z := createZipWriter(out, format, bitrate)
+
+	zippedMfs := make(model.MediaFiles, len(mfs))
 	for idx, mf := range mfs {
 		file := a.playlistFilename(mf, format, idx)
 		_ = a.addFileToZip(ctx, z, mf, format, bitrate, file)
+		mf.Path = file
+		zippedMfs[idx] = mf
 	}
+
+	// Add M3U file if requested
+	if addM3U && len(zippedMfs) > 0 {
+		plsName := sanitizeName(name)
+		w, err := z.CreateHeader(&zip.FileHeader{
+			Name:     plsName + ".m3u",
+			Modified: mfs[0].UpdatedAt,
+			Method:   zip.Store,
+		})
+		if err != nil {
+			log.Error(ctx, "Error creating playlist zip entry", err)
+			return err
+		}
+
+		_, err = w.Write([]byte(zippedMfs.ToM3U8(plsName, false)))
+		if err != nil {
+			log.Error(ctx, "Error writing m3u in zip", err)
+			return err
+		}
+	}
+
 	err := z.Close()
 	if err != nil {
 		log.Error(ctx, "Error closing zip file", "id", id, err)

core/archiver_test.go

@@ -145,9 +145,21 @@ var _ = Describe("Archiver", func() {
 			zr, err := zip.NewReader(bytes.NewReader(out.Bytes()), int64(out.Len()))
 			Expect(err).To(BeNil())
 
-			Expect(len(zr.File)).To(Equal(2))
+			Expect(len(zr.File)).To(Equal(3))
 			Expect(zr.File[0].Name).To(Equal("01 - AC_DC - track1.mp3"))
 			Expect(zr.File[1].Name).To(Equal("02 - Artist 2 - track2.mp3"))
+			Expect(zr.File[2].Name).To(Equal("Test Playlist.m3u"))
+
+			// Verify M3U content
+			m3uFile, err := zr.File[2].Open()
+			Expect(err).To(BeNil())
+			defer m3uFile.Close()
+
+			m3uContent, err := io.ReadAll(m3uFile)
+			Expect(err).To(BeNil())
+
+			expectedM3U := "#EXTM3U\n#PLAYLIST:Test Playlist\n#EXTINF:0,AC/DC - track1\n01 - AC_DC - track1.mp3\n#EXTINF:0,Artist 2 - track2\n02 - Artist 2 - track2.mp3\n"
+			Expect(string(m3uContent)).To(Equal(expectedM3U))
 		})
 	})
 })

core/artwork/artwork.go

@@ -115,7 +115,7 @@ func (a *artwork) getArtworkReader(ctx context.Context, artID model.ArtworkID, s
 	} else {
 		switch artID.Kind {
 		case model.KindArtistArtwork:
-			artReader, err = newArtistReader(ctx, a, artID, a.provider)
+			artReader, err = newArtistArtworkReader(ctx, a, artID, a.provider)
 		case model.KindAlbumArtwork:
 			artReader, err = newAlbumArtworkReader(ctx, a, artID, a.provider)
 		case model.KindMediaFileArtwork:

core/artwork/artwork_internal_test.go

@@ -4,7 +4,11 @@ import (
 	"context"
 	"errors"
 	"image"
+	"image/jpeg"
+	"image/png"
 	"io"
+	"os"
+	"path/filepath"
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
@@ -15,11 +19,11 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-// TODO Fix tests
-var _ = XDescribe("Artwork", func() {
+var _ = Describe("Artwork", func() {
 	var aw *artwork
 	var ds model.DataStore
 	var ffmpeg *tests.MockFFmpeg
+	var folderRepo *fakeFolderRepo
 	ctx := log.NewContext(context.TODO())
 	var alOnlyEmbed, alEmbedNotFound, alOnlyExternal, alExternalNotFound, alMultipleCovers model.Album
 	var arMultipleCovers model.Artist
@@ -30,20 +34,21 @@ var _ = XDescribe("Artwork", func() {
 		conf.Server.ImageCacheSize = "0" // Disable cache
 		conf.Server.CoverArtPriority = "folder.*, cover.*, embedded , front.*"
 
-		ds = &tests.MockDataStore{MockedTranscoding: &tests.MockTranscodingRepo{}}
-		alOnlyEmbed = model.Album{ID: "222", Name: "Only embed", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3"}
-		alEmbedNotFound = model.Album{ID: "333", Name: "Embed not found", EmbedArtPath: "tests/fixtures/NON_EXISTENT.mp3"}
-		//alOnlyExternal = model.Album{ID: "444", Name: "Only external", ImageFiles: "tests/fixtures/artist/an-album/front.png"}
-		//alExternalNotFound = model.Album{ID: "555", Name: "External not found", ImageFiles: "tests/fixtures/NON_EXISTENT.png"}
+		folderRepo = &fakeFolderRepo{}
+		ds = &tests.MockDataStore{
+			MockedTranscoding: &tests.MockTranscodingRepo{},
+			MockedFolder:      folderRepo,
+		}
+		alOnlyEmbed = model.Album{ID: "222", Name: "Only embed", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}}
+		alEmbedNotFound = model.Album{ID: "333", Name: "Embed not found", EmbedArtPath: "tests/fixtures/NON_EXISTENT.mp3", FolderIDs: []string{"f1"}}
+		alOnlyExternal = model.Album{ID: "444", Name: "Only external", FolderIDs: []string{"f1"}}
+		alExternalNotFound = model.Album{ID: "555", Name: "External not found", FolderIDs: []string{"f2"}}
 		arMultipleCovers = model.Artist{ID: "777", Name: "All options"}
 		alMultipleCovers = model.Album{
-			ID:           "666",
-			Name:         "All options",
-			EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3",
-			//Paths:        []string{"tests/fixtures/artist/an-album"},
-			//ImageFiles: "tests/fixtures/artist/an-album/cover.jpg" + consts.Zwsp +
-			//	"tests/fixtures/artist/an-album/front.png" + consts.Zwsp +
-			//	"tests/fixtures/artist/an-album/artist.png",
+			ID:            "666",
+			Name:          "All options",
+			EmbedArtPath:  "tests/fixtures/artist/an-album/test.mp3",
+			FolderIDs:     []string{"f1"},
 			AlbumArtistID: "777",
 		}
 		mfWithEmbed = model.MediaFile{ID: "22", Path: "tests/fixtures/test.mp3", HasCoverArt: true, AlbumID: "222"}
@@ -65,6 +70,7 @@ var _ = XDescribe("Artwork", func() {
 		})
 		Context("Embed images", func() {
 			BeforeEach(func() {
+				folderRepo.result = nil
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alOnlyEmbed,
 					alEmbedNotFound,
@@ -87,12 +93,17 @@ var _ = XDescribe("Artwork", func() {
 		})
 		Context("External images", func() {
 			BeforeEach(func() {
+				folderRepo.result = []model.Folder{}
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alOnlyExternal,
 					alExternalNotFound,
 				})
 			})
 			It("returns external cover", func() {
+				folderRepo.result = []model.Folder{{
+					Path:       "tests/fixtures/artist/an-album",
+					ImageFiles: []string{"front.png"},
+				}}
 				aw, err := newAlbumArtworkReader(ctx, aw, alOnlyExternal.CoverArtID(), nil)
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
@@ -100,6 +111,7 @@ var _ = XDescribe("Artwork", func() {
 				Expect(path).To(Equal("tests/fixtures/artist/an-album/front.png"))
 			})
 			It("returns ErrUnavailable if external file is not available", func() {
+				folderRepo.result = []model.Folder{}
 				aw, err := newAlbumArtworkReader(ctx, aw, alExternalNotFound.CoverArtID(), nil)
 				Expect(err).ToNot(HaveOccurred())
 				_, _, err = aw.Reader(ctx)
@@ -108,6 +120,10 @@ var _ = XDescribe("Artwork", func() {
 		})
 		Context("Multiple covers", func() {
 			BeforeEach(func() {
+				folderRepo.result = []model.Folder{{
+					Path:       "tests/fixtures/artist/an-album",
+					ImageFiles: []string{"cover.jpg", "front.png", "artist.png"},
+				}}
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alMultipleCovers,
 				})
@@ -130,6 +146,10 @@ var _ = XDescribe("Artwork", func() {
 	Describe("artistArtworkReader", func() {
 		Context("Multiple covers", func() {
 			BeforeEach(func() {
+				folderRepo.result = []model.Folder{{
+					Path:       "tests/fixtures/artist/an-album",
+					ImageFiles: []string{"artist.png"},
+				}}
 				ds.Artist(ctx).(*tests.MockArtistRepo).SetData(model.Artists{
 					arMultipleCovers,
 				})
@@ -143,7 +163,7 @@ var _ = XDescribe("Artwork", func() {
 			DescribeTable("ArtistArtPriority",
 				func(priority string, expected string) {
 					conf.Server.ArtistArtPriority = priority
-					aw, err := newArtistReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)
+					aw, err := newArtistArtworkReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)
 					Expect(err).ToNot(HaveOccurred())
 					_, path, err := aw.Reader(ctx)
 					Expect(err).ToNot(HaveOccurred())
@@ -157,12 +177,16 @@ var _ = XDescribe("Artwork", func() {
 	Describe("mediafileArtworkReader", func() {
 		Context("ID not found", func() {
 			It("returns ErrNotFound if mediafile is not in the DB", func() {
-				_, err := newAlbumArtworkReader(ctx, aw, alMultipleCovers.CoverArtID(), nil)
+				_, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-NOT-FOUND"))
 				Expect(err).To(MatchError(model.ErrNotFound))
 			})
 		})
 		Context("Embed images", func() {
 			BeforeEach(func() {
+				folderRepo.result = []model.Folder{{
+					Path:       "tests/fixtures/artist/an-album",
+					ImageFiles: []string{"front.png"},
+				}}
 				ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 					alOnlyEmbed,
 					alOnlyExternal,
@@ -185,11 +209,17 @@ var _ = XDescribe("Artwork", func() {
 				Expect(err).ToNot(HaveOccurred())
 				r, path, err := aw.Reader(ctx)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(io.ReadAll(r)).To(Equal([]byte("content from ffmpeg")))
+				data, _ := io.ReadAll(r)
+				Expect(data).ToNot(BeEmpty())
 				Expect(path).To(Equal("tests/fixtures/test.ogg"))
 			})
 			It("returns album cover if cannot read embed artwork", func() {
+				// Force fromTag to fail
+				mfCorruptedCover.Path = "tests/fixtures/DOES_NOT_EXIST.ogg"
+				Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfCorruptedCover)).To(Succeed())
+				// Simulate ffmpeg error
 				ffmpeg.Error = errors.New("not available")
+
 				aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
@@ -207,6 +237,10 @@ var _ = XDescribe("Artwork", func() {
 	})
 	Describe("resizedArtworkReader", func() {
 		BeforeEach(func() {
+			folderRepo.result = []model.Folder{{
+				Path:       "tests/fixtures/artist/an-album",
+				ImageFiles: []string{"cover.jpg", "front.png"},
+			}}
 			ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 				alMultipleCovers,
 			})
@@ -241,12 +275,13 @@ var _ = XDescribe("Artwork", func() {
 			DescribeTable("resize",
 				func(format string, landscape bool, size int) {
 					coverFileName := "cover." + format
-					//dirName := createImage(format, landscape, size)
+					dirName := createImage(format, landscape, size)
 					alCover = model.Album{
-						ID:   "444",
-						Name: "Only external",
-						//ImageFiles: filepath.Join(dirName, coverFileName),
+						ID:        "444",
+						Name:      "Only external",
+						FolderIDs: []string{"tmp"},
 					}
+					folderRepo.result = []model.Folder{{Path: dirName, ImageFiles: []string{coverFileName}}}
 					ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
 						alCover,
 					})
@@ -270,24 +305,24 @@ var _ = XDescribe("Artwork", func() {
 	})
 })
 
-//func createImage(format string, landscape bool, size int) string {
-//	var img image.Image
-//
-//	if landscape {
-//		img = image.NewRGBA(image.Rect(0, 0, size, size/2))
-//	} else {
-//		img = image.NewRGBA(image.Rect(0, 0, size/2, size))
-//	}
-//
-//	tmpDir := GinkgoT().TempDir()
-//	f, _ := os.Create(filepath.Join(tmpDir, "cover."+format))
-//	defer f.Close()
-//	switch format {
-//	case "png":
-//		_ = png.Encode(f, img)
-//	case "jpg":
-//		_ = jpeg.Encode(f, img, &jpeg.Options{Quality: 75})
-//	}
-//
-//	return tmpDir
-//}
+func createImage(format string, landscape bool, size int) string {
+	var img image.Image
+
+	if landscape {
+		img = image.NewRGBA(image.Rect(0, 0, size, size/2))
+	} else {
+		img = image.NewRGBA(image.Rect(0, 0, size/2, size))
+	}
+
+	tmpDir := GinkgoT().TempDir()
+	f, _ := os.Create(filepath.Join(tmpDir, "cover."+format))
+	defer f.Close()
+	switch format {
+	case "png":
+		_ = png.Encode(f, img)
+	case "jpg":
+		_ = jpeg.Encode(f, img, &jpeg.Options{Quality: 75})
+	}
+
+	return tmpDir
+}

core/artwork/cache_warmer.go

@@ -31,6 +31,12 @@ func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {
 		return &noopCacheWarmer{}
 	}
 
+	// If the file cache is disabled, return a NOOP implementation
+	if cache.Disabled(context.Background()) {
+		log.Debug("Image cache disabled. Cache warmer will not run")
+		return &noopCacheWarmer{}
+	}
+
 	a := &cacheWarmer{
 		artwork:    artwork,
 		cache:      cache,
@@ -53,6 +59,9 @@ type cacheWarmer struct {
 }
 
 func (a *cacheWarmer) PreCache(artID model.ArtworkID) {
+	if a.cache.Disabled(context.Background()) {
+		return
+	}
 	a.mutex.Lock()
 	defer a.mutex.Unlock()
 	a.buffer[artID] = struct{}{}
@@ -74,6 +83,17 @@ func (a *cacheWarmer) run(ctx context.Context) {
 			break
 		}
 
+		if a.cache.Disabled(ctx) {
+			a.mutex.Lock()
+			pending := len(a.buffer)
+			a.buffer = make(map[model.ArtworkID]struct{})
+			a.mutex.Unlock()
+			if pending > 0 {
+				log.Trace(ctx, "Cache disabled, discarding precache buffer", "bufferLen", pending)
+			}
+			return
+		}
+
 		// If cache not available, keep waiting
 		if !a.cache.Available(ctx) {
 			if len(a.buffer) > 0 {

core/artwork/cache_warmer_test.go

@@ -0,0 +1,216 @@
+package artwork
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/cache"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("CacheWarmer", func() {
+	var (
+		fc *mockFileCache
+		aw *mockArtwork
+	)
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+		fc = &mockFileCache{}
+		aw = &mockArtwork{}
+	})
+
+	Context("initialization", func() {
+		It("returns noop when cache is disabled", func() {
+			fc.SetDisabled(true)
+			cw := NewCacheWarmer(aw, fc)
+			_, ok := cw.(*noopCacheWarmer)
+			Expect(ok).To(BeTrue())
+		})
+
+		It("returns noop when ImageCacheSize is 0", func() {
+			conf.Server.ImageCacheSize = "0"
+			cw := NewCacheWarmer(aw, fc)
+			_, ok := cw.(*noopCacheWarmer)
+			Expect(ok).To(BeTrue())
+		})
+
+		It("returns noop when EnableArtworkPrecache is false", func() {
+			conf.Server.EnableArtworkPrecache = false
+			cw := NewCacheWarmer(aw, fc)
+			_, ok := cw.(*noopCacheWarmer)
+			Expect(ok).To(BeTrue())
+		})
+
+		It("returns real implementation when properly configured", func() {
+			conf.Server.ImageCacheSize = "100MB"
+			conf.Server.EnableArtworkPrecache = true
+			fc.SetDisabled(false)
+			cw := NewCacheWarmer(aw, fc)
+			_, ok := cw.(*cacheWarmer)
+			Expect(ok).To(BeTrue())
+		})
+	})
+
+	Context("buffer management", func() {
+		BeforeEach(func() {
+			conf.Server.ImageCacheSize = "100MB"
+			conf.Server.EnableArtworkPrecache = true
+			fc.SetDisabled(false)
+		})
+
+		It("drops buffered items when cache becomes disabled", func() {
+			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
+			cw.PreCache(model.MustParseArtworkID("al-test"))
+			fc.SetDisabled(true)
+			Eventually(func() int {
+				cw.mutex.Lock()
+				defer cw.mutex.Unlock()
+				return len(cw.buffer)
+			}).Should(Equal(0))
+		})
+
+		It("adds multiple items to buffer", func() {
+			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
+			cw.PreCache(model.MustParseArtworkID("al-1"))
+			cw.PreCache(model.MustParseArtworkID("al-2"))
+			cw.mutex.Lock()
+			defer cw.mutex.Unlock()
+			Expect(len(cw.buffer)).To(Equal(2))
+		})
+
+		It("deduplicates items in buffer", func() {
+			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
+			cw.PreCache(model.MustParseArtworkID("al-1"))
+			cw.PreCache(model.MustParseArtworkID("al-1"))
+			cw.mutex.Lock()
+			defer cw.mutex.Unlock()
+			Expect(len(cw.buffer)).To(Equal(1))
+		})
+	})
+
+	Context("error handling", func() {
+		BeforeEach(func() {
+			conf.Server.ImageCacheSize = "100MB"
+			conf.Server.EnableArtworkPrecache = true
+			fc.SetDisabled(false)
+		})
+
+		It("continues processing after artwork retrieval error", func() {
+			aw.err = errors.New("artwork error")
+			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
+			cw.PreCache(model.MustParseArtworkID("al-error"))
+			cw.PreCache(model.MustParseArtworkID("al-1"))
+
+			Eventually(func() int {
+				cw.mutex.Lock()
+				defer cw.mutex.Unlock()
+				return len(cw.buffer)
+			}).Should(Equal(0))
+		})
+
+		It("continues processing after cache error", func() {
+			fc.err = errors.New("cache error")
+			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
+			cw.PreCache(model.MustParseArtworkID("al-error"))
+			cw.PreCache(model.MustParseArtworkID("al-1"))
+
+			Eventually(func() int {
+				cw.mutex.Lock()
+				defer cw.mutex.Unlock()
+				return len(cw.buffer)
+			}).Should(Equal(0))
+		})
+	})
+
+	Context("background processing", func() {
+		BeforeEach(func() {
+			conf.Server.ImageCacheSize = "100MB"
+			conf.Server.EnableArtworkPrecache = true
+			fc.SetDisabled(false)
+		})
+
+		It("processes items in batches", func() {
+			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
+			for i := 0; i < 5; i++ {
+				cw.PreCache(model.MustParseArtworkID(fmt.Sprintf("al-%d", i)))
+			}
+
+			Eventually(func() int {
+				cw.mutex.Lock()
+				defer cw.mutex.Unlock()
+				return len(cw.buffer)
+			}).Should(Equal(0))
+		})
+
+		It("wakes up on new items", func() {
+			cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
+
+			// Add first batch
+			cw.PreCache(model.MustParseArtworkID("al-1"))
+			Eventually(func() int {
+				cw.mutex.Lock()
+				defer cw.mutex.Unlock()
+				return len(cw.buffer)
+			}).Should(Equal(0))
+
+			// Add second batch
+			cw.PreCache(model.MustParseArtworkID("al-2"))
+			Eventually(func() int {
+				cw.mutex.Lock()
+				defer cw.mutex.Unlock()
+				return len(cw.buffer)
+			}).Should(Equal(0))
+		})
+	})
+})
+
+type mockArtwork struct {
+	err error
+}
+
+func (m *mockArtwork) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (io.ReadCloser, time.Time, error) {
+	if m.err != nil {
+		return nil, time.Time{}, m.err
+	}
+	return io.NopCloser(strings.NewReader("test")), time.Now(), nil
+}
+
+func (m *mockArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {
+	return m.Get(ctx, model.ArtworkID{}, size, square)
+}
+
+type mockFileCache struct {
+	disabled atomic.Bool
+	ready    atomic.Bool
+	err      error
+}
+
+func (f *mockFileCache) Get(ctx context.Context, item cache.Item) (*cache.CachedStream, error) {
+	if f.err != nil {
+		return nil, f.err
+	}
+	return &cache.CachedStream{Reader: io.NopCloser(strings.NewReader("cached"))}, nil
+}
+
+func (f *mockFileCache) Available(ctx context.Context) bool {
+	return f.ready.Load() && !f.disabled.Load()
+}
+
+func (f *mockFileCache) Disabled(ctx context.Context) bool {
+	return f.disabled.Load()
+}
+
+func (f *mockFileCache) SetDisabled(v bool) {
+	f.disabled.Store(v)
+	f.ready.Store(true)
+}

core/artwork/reader_artist.go

@@ -29,7 +29,7 @@ type artistReader struct {
 	imgFiles     []string
 }
 
-func newArtistReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*artistReader, error) {
+func newArtistArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*artistReader, error) {
 	ar, err := artwork.ds.Artist(ctx).Get(artID.ID)
 	if err != nil {
 		return nil, err

core/artwork/reader_artist_test.go

@@ -12,7 +12,7 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("artistReader", func() {
+var _ = Describe("artistArtworkReader", func() {
 	var _ = Describe("loadArtistFolder", func() {
 		var (
 			ctx             context.Context

core/common_test.go

@@ -0,0 +1,55 @@
+package core
+
+import (
+	"context"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/tests"
+)
+
+var _ = Describe("common.go", func() {
+	Describe("userName", func() {
+		It("returns the username from context", func() {
+			ctx := request.WithUser(context.Background(), model.User{UserName: "testuser"})
+			Expect(userName(ctx)).To(Equal("testuser"))
+		})
+
+		It("returns 'UNKNOWN' if no user in context", func() {
+			ctx := context.Background()
+			Expect(userName(ctx)).To(Equal("UNKNOWN"))
+		})
+	})
+
+	Describe("AbsolutePath", func() {
+		var (
+			ds    *tests.MockDataStore
+			libId int
+			path  string
+		)
+
+		BeforeEach(func() {
+			ds = &tests.MockDataStore{}
+			libId = 1
+			path = "music/file.mp3"
+			mockLib := &tests.MockLibraryRepo{}
+			mockLib.SetData(model.Libraries{{ID: libId, Path: "/library/root"}})
+			ds.MockedLibrary = mockLib
+		})
+
+		It("returns the absolute path when library exists", func() {
+			ctx := context.Background()
+			abs := AbsolutePath(ctx, ds, libId, path)
+			Expect(abs).To(Equal("/library/root/music/file.mp3"))
+		})
+
+		It("returns the original path if library not found", func() {
+			ctx := context.Background()
+			abs := AbsolutePath(ctx, ds, 999, path)
+			Expect(abs).To(Equal(path))
+		})
+	})
+})

core/lyrics/lyrics.go

@@ -0,0 +1,37 @@
+package lyrics
+
+import (
+	"context"
+	"strings"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+func GetLyrics(ctx context.Context, mf *model.MediaFile) (model.LyricList, error) {
+	var lyricsList model.LyricList
+	var err error
+
+	for pattern := range strings.SplitSeq(strings.ToLower(conf.Server.LyricsPriority), ",") {
+		pattern = strings.TrimSpace(pattern)
+		switch {
+		case pattern == "embedded":
+			lyricsList, err = fromEmbedded(ctx, mf)
+		case strings.HasPrefix(pattern, "."):
+			lyricsList, err = fromExternalFile(ctx, mf, pattern)
+		default:
+			log.Error(ctx, "Invalid lyric pattern", "pattern", pattern)
+		}
+
+		if err != nil {
+			log.Error(ctx, "error parsing lyrics", "source", pattern, err)
+		}
+
+		if len(lyricsList) > 0 {
+			return lyricsList, nil
+		}
+	}
+
+	return nil, nil
+}

core/lyrics/lyrics_suite_test.go

@@ -0,0 +1,17 @@
+package lyrics_test
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestLyrics(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelFatal)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Lyrics Suite")
+}

core/lyrics/lyrics_test.go

@@ -0,0 +1,124 @@
+package lyrics_test
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/core/lyrics"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+	"github.com/navidrome/navidrome/utils/gg"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("sources", func() {
+	var mf model.MediaFile
+	var ctx context.Context
+
+	const badLyrics = "This is a set of lyrics\nThat is not good"
+	unsynced, _ := model.ToLyrics("xxx", badLyrics)
+	embeddedLyrics := model.LyricList{*unsynced}
+
+	syncedLyrics := model.LyricList{
+		model.Lyrics{
+			DisplayArtist: "Rick Astley",
+			DisplayTitle:  "That one song",
+			Lang:          "eng",
+			Line: []model.Line{
+				{
+					Start: gg.P(int64(18800)),
+					Value: "We're no strangers to love",
+				},
+				{
+					Start: gg.P(int64(22801)),
+					Value: "You know the rules and so do I",
+				},
+			},
+			Offset: gg.P(int64(-100)),
+			Synced: true,
+		},
+	}
+
+	unsyncedLyrics := model.LyricList{
+		model.Lyrics{
+			Lang: "xxx",
+			Line: []model.Line{
+				{
+					Value: "We're no strangers to love",
+				},
+				{
+					Value: "You know the rules and so do I",
+				},
+			},
+			Synced: false,
+		},
+	}
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+
+		lyricsJson, _ := json.Marshal(embeddedLyrics)
+
+		mf = model.MediaFile{
+			Lyrics: string(lyricsJson),
+			Path:   "tests/fixtures/test.mp3",
+		}
+		ctx = context.Background()
+	})
+
+	DescribeTable("Lyrics Priority", func(priority string, expected model.LyricList) {
+		conf.Server.LyricsPriority = priority
+		list, err := lyrics.GetLyrics(ctx, &mf)
+		Expect(err).To(BeNil())
+		Expect(list).To(Equal(expected))
+	},
+		Entry("embedded > lrc > txt", "embedded,.lrc,.txt", embeddedLyrics),
+		Entry("lrc > embedded > txt", ".lrc,embedded,.txt", syncedLyrics),
+		Entry("txt > lrc > embedded", ".txt,.lrc,embedded", unsyncedLyrics))
+
+	Context("Errors", func() {
+		var RegularUserContext = XContext
+		var isRegularUser = os.Getuid() != 0
+		if isRegularUser {
+			RegularUserContext = Context
+		}
+
+		RegularUserContext("run without root permissions", func() {
+			var accessForbiddenFile string
+
+			BeforeEach(func() {
+				accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")
+
+				f, err := os.OpenFile(accessForbiddenFile, os.O_WRONLY|os.O_CREATE, 0222)
+				Expect(err).ToNot(HaveOccurred())
+
+				mf.Path = accessForbiddenFile
+
+				DeferCleanup(func() {
+					Expect(f.Close()).To(Succeed())
+					Expect(os.Remove(accessForbiddenFile)).To(Succeed())
+				})
+			})
+
+			It("should fallback to embedded if an error happens when parsing file", func() {
+				conf.Server.LyricsPriority = ".mp3,embedded"
+
+				list, err := lyrics.GetLyrics(ctx, &mf)
+				Expect(err).To(BeNil())
+				Expect(list).To(Equal(embeddedLyrics))
+			})
+
+			It("should return nothing if error happens when trying to parse file", func() {
+				conf.Server.LyricsPriority = ".mp3"
+
+				list, err := lyrics.GetLyrics(ctx, &mf)
+				Expect(err).To(BeNil())
+				Expect(list).To(BeEmpty())
+			})
+		})
+	})
+})

core/lyrics/sources.go

@@ -0,0 +1,51 @@
+package lyrics
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+func fromEmbedded(ctx context.Context, mf *model.MediaFile) (model.LyricList, error) {
+	if mf.Lyrics != "" {
+		log.Trace(ctx, "embedded lyrics found in file", "title", mf.Title)
+		return mf.StructuredLyrics()
+	}
+
+	log.Trace(ctx, "no embedded lyrics for file", "path", mf.Title)
+
+	return nil, nil
+}
+
+func fromExternalFile(ctx context.Context, mf *model.MediaFile, suffix string) (model.LyricList, error) {
+	basePath := mf.AbsolutePath()
+	ext := path.Ext(basePath)
+
+	externalLyric := basePath[0:len(basePath)-len(ext)] + suffix
+
+	contents, err := os.ReadFile(externalLyric)
+
+	if errors.Is(err, os.ErrNotExist) {
+		log.Trace(ctx, "no lyrics found at path", "path", externalLyric)
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+
+	lyrics, err := model.ToLyrics("xxx", string(contents))
+	if err != nil {
+		log.Error(ctx, "error parsing lyric external file", "path", externalLyric, err)
+		return nil, err
+	} else if lyrics == nil {
+		log.Trace(ctx, "empty lyrics from external file", "path", externalLyric)
+		return nil, nil
+	}
+
+	log.Trace(ctx, "retrieved lyrics from external file", "path", externalLyric)
+
+	return model.LyricList{*lyrics}, nil
+}

core/lyrics/sources_test.go

@@ -0,0 +1,112 @@
+package lyrics
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils/gg"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("sources", func() {
+	ctx := context.Background()
+
+	Describe("fromEmbedded", func() {
+		It("should return nothing for a media file with no lyrics", func() {
+			mf := model.MediaFile{}
+			lyrics, err := fromEmbedded(ctx, &mf)
+
+			Expect(err).To(BeNil())
+			Expect(lyrics).To(HaveLen(0))
+		})
+
+		It("should return lyrics for a media file with well-formatted lyrics", func() {
+			const syncedLyrics = "[00:18.80]We're no strangers to love\n[00:22.801]You know the rules and so do I"
+			const unsyncedLyrics = "We're no strangers to love\nYou know the rules and so do I"
+
+			synced, _ := model.ToLyrics("eng", syncedLyrics)
+			unsynced, _ := model.ToLyrics("xxx", unsyncedLyrics)
+
+			expectedList := model.LyricList{*synced, *unsynced}
+			lyricsJson, err := json.Marshal(expectedList)
+
+			Expect(err).ToNot(HaveOccurred())
+
+			mf := model.MediaFile{
+				Lyrics: string(lyricsJson),
+			}
+
+			lyrics, err := fromEmbedded(ctx, &mf)
+			Expect(err).To(BeNil())
+			Expect(lyrics).ToNot(BeNil())
+			Expect(lyrics).To(Equal(expectedList))
+		})
+
+		It("should return an error if somehow the JSON is bad", func() {
+			mf := model.MediaFile{Lyrics: "["}
+			lyrics, err := fromEmbedded(ctx, &mf)
+
+			Expect(lyrics).To(HaveLen(0))
+			Expect(err).ToNot(BeNil())
+		})
+	})
+
+	Describe("fromExternalFile", func() {
+		It("should return nil for lyrics that don't exist", func() {
+			mf := model.MediaFile{Path: "tests/fixtures/01 Invisible (RED) Edit Version.mp3"}
+			lyrics, err := fromExternalFile(ctx, &mf, ".lrc")
+
+			Expect(err).To(BeNil())
+			Expect(lyrics).To(HaveLen(0))
+		})
+
+		It("should return synchronized lyrics from a file", func() {
+			mf := model.MediaFile{Path: "tests/fixtures/test.mp3"}
+			lyrics, err := fromExternalFile(ctx, &mf, ".lrc")
+
+			Expect(err).To(BeNil())
+			Expect(lyrics).To(Equal(model.LyricList{
+				model.Lyrics{
+					DisplayArtist: "Rick Astley",
+					DisplayTitle:  "That one song",
+					Lang:          "eng",
+					Line: []model.Line{
+						{
+							Start: gg.P(int64(18800)),
+							Value: "We're no strangers to love",
+						},
+						{
+							Start: gg.P(int64(22801)),
+							Value: "You know the rules and so do I",
+						},
+					},
+					Offset: gg.P(int64(-100)),
+					Synced: true,
+				},
+			}))
+		})
+
+		It("should return unsynchronized lyrics from a file", func() {
+			mf := model.MediaFile{Path: "tests/fixtures/test.mp3"}
+			lyrics, err := fromExternalFile(ctx, &mf, ".txt")
+
+			Expect(err).To(BeNil())
+			Expect(lyrics).To(Equal(model.LyricList{
+				model.Lyrics{
+					Lang: "xxx",
+					Line: []model.Line{
+						{
+							Value: "We're no strangers to love",
+						},
+						{
+							Value: "You know the rules and so do I",
+						},
+					},
+					Synced: false,
+				},
+			}))
+		})
+	})
+})

core/scrobbler/play_tracker.go

@@ -5,7 +5,6 @@ import (
 	"sort"
 	"time"
 
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
@@ -61,9 +60,7 @@ func newPlayTracker(ds model.DataStore, broker events.Broker) *playTracker {
 			continue
 		}
 		enabled = append(enabled, name)
-		if conf.Server.DevEnableBufferedScrobble {
-			s = newBufferedScrobbler(ds, s, name)
-		}
+		s = newBufferedScrobbler(ds, s, name)
 		p.scrobblers[name] = s
 	}
 	log.Debug("List of scrobblers enabled", "names", enabled)
@@ -183,11 +180,7 @@ func (p *playTracker) dispatchScrobble(ctx context.Context, t *model.MediaFile,
 		if !s.IsAuthorized(ctx, u.ID) {
 			continue
 		}
-		if conf.Server.DevEnableBufferedScrobble {
-			log.Debug(ctx, "Buffering Scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist)
-		} else {
-			log.Debug(ctx, "Sending Scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist)
-		}
+		log.Debug(ctx, "Buffering Scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist)
 		err := s.Scrobble(ctx, u.ID, scrobble)
 		if err != nil {
 			log.Error(ctx, "Error sending Scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist, err)

core/scrobbler/play_tracker_test.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"time"
 
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 
 	"github.com/navidrome/navidrome/model"
@@ -27,9 +26,6 @@ var _ = Describe("PlayTracker", func() {
 	var fake fakeScrobbler
 
 	BeforeEach(func() {
-		// Remove buffering to simplify tests
-		conf.Server.DevEnableBufferedScrobble = false
-
 		ctx = context.Background()
 		ctx = request.WithUser(ctx, model.User{ID: "u-1"})
 		ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
@@ -42,6 +38,7 @@ var _ = Describe("PlayTracker", func() {
 			return nil
 		})
 		tracker = newPlayTracker(ds, events.GetBroker())
+		tracker.(*playTracker).scrobblers["fake"] = &fake // Bypass buffering for tests
 
 		track = model.MediaFile{
 			ID:             "123",

core/share.go

@@ -8,6 +8,7 @@ import (
 	"github.com/Masterminds/squirrel"
 	"github.com/deluan/rest"
 	gonanoid "github.com/matoous/go-nanoid/v2"
+	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	. "github.com/navidrome/navidrome/utils/gg"
@@ -93,7 +94,7 @@ func (r *shareRepositoryWrapper) Save(entity interface{}) (string, error) {
 	}
 	s.ID = id
 	if V(s.ExpiresAt).IsZero() {
-		s.ExpiresAt = P(time.Now().Add(365 * 24 * time.Hour))
+		s.ExpiresAt = P(time.Now().Add(conf.Server.DefaultShareExpiration))
 	}
 
 	firstId := strings.SplitN(s.ResourceIDs, ",", 2)[0]

db/migrations/20250522013904_share_user_id_on_delete.sql

@@ -0,0 +1,36 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE share_tmp
+(
+    id              varchar(255) not null
+        primary key,
+    expires_at      datetime,
+    last_visited_at datetime,
+    resource_ids    varchar      not null,
+    created_at      datetime,
+    updated_at      datetime,
+    user_id         varchar(255) not null
+        constraint share_user_id_fk
+            references user
+                on update cascade on delete cascade,
+    downloadable bool not null default false,
+    description varchar not null default '',
+    resource_type varchar not null default '',
+    contents varchar not null default '',
+    format varchar not null default '',
+    max_bit_rate integer not null default 0,
+    visit_count integer not null default 0
+);
+
+
+INSERT INTO share_tmp(
+    id, expires_at, last_visited_at, resource_ids, created_at, updated_at, user_id, downloadable, description, resource_type, contents, format, max_bit_rate, visit_count
+) SELECT id, expires_at, last_visited_at, resource_ids, created_at, updated_at, user_id, downloadable, description, resource_type, contents, format, max_bit_rate, visit_count 
+FROM share;
+
+DROP TABLE share;
+
+ALTER TABLE share_tmp RENAME To share;
+-- +goose StatementEnd
+
+-- +goose Down

docs/plugins-implementation-plan.md

@@ -1,305 +0,0 @@
-# Navidrome Plugin System Implementation Plan
-
-## Progress Tracking
-
-### Phase 1: Foundational Infrastructure
-
-- [ ] 1.1: Plugin Manifest and Configuration
-- [ ] 1.2: Basic WebAssembly Runtime Integration
-- [ ] 1.3: Permission Management System
-  - [ ] 1.3.1: URL Allowlist Implementation
-  - [ ] 1.3.2: Local Network Access Control
-  - [ ] 1.3.3: Host Function Access Control
-- [ ] 1.4: Project Structure and CLI Commands
-- [ ] 1.5: Plugin Verification System
-
-### Phase 2: Protocol Definition and Host Functions
-
-- [ ] 2.1: Protocol Buffer Definitions
-- [ ] 2.2: Host Function Implementation
-- [ ] 2.3: Plugin Context Management
-
-### Phase 3: Plugin Loading and Execution
-
-- [ ] 3.1: WebAssembly Runtime Configuration
-- [ ] 3.2: Testing Infrastructure
-- [ ] 3.3: Plugin Developer Tools
-
-### Phase 4: Agent Plugin Integration
-
-- [ ] 4.1: Agent Plugin Adapter Implementation
-- [ ] 4.2: Plugin Registration with Agent System
-- [ ] 4.3: Last.fm Agent Plugin Implementation
-- [ ] 4.4: Integration Testing
-
-### Phase 5: Enhanced Management and User Experience
-
-- [ ] 5.1: Enhanced CLI Management
-- [ ] 5.2: Plugin Package Format
-- [ ] 5.3: Runtime Monitoring
-- [ ] 5.4: Administrative UI (Optional)
-
-### Phase 6: Documentation and Release
-
-- [ ] 6.1: User Documentation
-- [ ] 6.2: Developer Documentation
-- [ ] 6.3: Example Plugin Templates
-- [ ] 6.4: Final Testing and Feature Flags
-
-## Phase 1: Foundational Infrastructure
-
-**Goal:** Establish the core plugin infrastructure without affecting existing functionality.
-
-### 1.1: Plugin Manifest and Configuration
-
-- Create plugin manifest schema and validation functions
-- Add plugin-related configuration to `conf` package:
-  - Global plugin settings: enabled, directory, default limits
-  - Per-plugin settings: enabled, limits, configuration
-- Add tests for manifest validation and configuration parsing
-
-### 1.2: Basic WebAssembly Runtime Integration
-
-- Add `knqyf263/go-plugin` dependency
-- Create initial plugin loader that can:
-  - Discover plugin files in configured directory
-  - Read and validate manifests
-  - Basic security validation (no plugin execution yet)
-- Add unit tests for plugin discovery and manifest loading
-
-### 1.3: Permission Management System
-
-- Implement the `PermissionManager` component:
-  - URL allowlist validation
-  - Host function allowlist validation
-  - Internal network access prevention
-  - Configuration access control
-- Add comprehensive security tests for all permission rules
-- Implement local network access control feature:
-  - Add `allowLocalNetwork` flag to manifest schema
-  - Update permission checks in HTTP requests
-  - Add configuration option for default behavior
-- Add tests for local network access control
-
-### 1.4: Project Structure and CLI Commands
-
-- Create plugin-related directory structure:
-  ```
-  plugins/
-  ├── proto/       # Protocol Buffer definitions
-  ├── manager.go   # Plugin Manager implementation
-  ├── host.go      # Host function implementations
-  ├── permission.go # Permission manager
-  └── adapters/    # Adapters for different plugin types
-  ```
-- Implement basic CLI commands for plugin management:
-  - `navidrome plugin list`
-  - `navidrome plugin info [name]`
-
-### 1.5: Plugin Verification System
-
-- Implement plugin binary integrity verification:
-  - Add hash calculation and storage during installation
-  - Add verification during plugin loading
-  - Create a local store for plugin hashes
-- Add tests for plugin verification workflow
-- Update CLI commands to display verification status
-
-**Deliverable:** Foundation layer with security features including local network control and plugin verification.
-
-## Phase 2: Protocol Definition and Host Functions
-
-**Goal:** Define the communication protocol between Navidrome and plugins.
-
-### 2.1: Protocol Buffer Definitions
-
-- Define Protocol Buffer specifications for:
-  - Agent plugin interface
-  - Host functions interface
-  - Common request/response structures
-- Generate Go code from Protocol Buffers
-- Create test stubs for interface implementations
-
-### 2.2: Host Function Implementation
-
-- Implement core host functions:
-  - `GetConfig` for configuration access
-  - `Log` for plugin logging
-  - `HttpDo` for controlled HTTP access
-- Add comprehensive tests for each host function
-- Implement permission checks for all host functions
-
-### 2.3: Plugin Context Management
-
-- Create plugin context structure to track:
-  - Current plugin name
-  - Permission scope
-  - Runtime state
-- Implement proper isolation between plugin calls
-
-**Deliverable:** Complete protocol definition and host function implementations without executing actual plugins.
-
-## Phase 3: Plugin Loading and Execution (Minimal)
-
-**Goal:** Enable basic plugin loading and execution in isolation from the rest of the system.
-
-### 3.1: WebAssembly Runtime Configuration
-
-- Configure WebAssembly runtime with appropriate security settings
-- Implement plugin initialization with configuration passing
-- Add proper error handling for plugin loading failures
-
-### 3.2: Testing Infrastructure
-
-- Create test harness for plugin execution
-- Implement simple test plugins for validation
-- Add integration tests for plugin loading and execution
-- Add tests for local network access
-- Add tests for plugin verification and integrity checks
-
-### 3.3: Plugin Developer Tools
-
-- Implement development commands:
-  - `navidrome plugin dev [folder_path]`
-  - `navidrome plugin refresh [name]`
-- Create basic development documentation
-
-**Deliverable:** Working plugin loading and execution system that can be tested in isolation.
-
-## Phase 4: Agent Plugin Integration
-
-**Goal:** Connect the plugin system to the existing agent architecture.
-
-### 4.1: Agent Plugin Adapter Implementation
-
-- Create adapter that implements all agent interfaces:
-  - Convert between Protobuf and agent interfaces
-  - Implement proper error handling and timeouts
-  - Add trace logging for debugging
-- Add unit tests for all adapter methods
-- Update adapter to respect plugin's declared capabilities
-
-### 4.2: Plugin Registration with Agent System
-
-- Implement plugin registration with the existing agent system
-- Extend configuration to support plugin agent ordering
-- Make plugin agents respect the same priority system as built-in agents
-
-### 4.3: Last.fm Agent Plugin Implementation
-
-- Implement prototype Last.fm plugin as proof of concept
-- Create plugin manifest with necessary permissions
-- Add tests comparing plugin behavior to built-in agent
-
-### 4.4: Integration Testing
-
-- Add comprehensive integration tests for:
-  - Plugin discovery and loading
-  - Agent API functionality
-  - Error handling and recovery
-  - Configuration changes
-
-**Deliverable:** Working plugin system with Last.fm plugin implementation that can be toggled via configuration without breaking existing functionality.
-
-## Phase 5: Enhanced Management and User Experience
-
-**Goal:** Improve plugin management and user experience.
-
-### 5.1: Enhanced CLI Management
-
-- Complete remaining CLI commands:
-  - `navidrome plugin install [file]`
-  - `navidrome plugin remove [name]`
-  - `navidrome plugin config-template [name]`
-- Add command validation and error handling
-
-### 5.2: Plugin Package Format
-
-- Implement `.ndp` package format:
-  - Package creation
-  - Validation
-  - Installation
-- Add tests for package integrity checking
-
-### 5.3: Runtime Monitoring
-
-- Add runtime statistics:
-  - Plugin execution time
-  - Resource usage
-  - Error tracking
-- Implement health checks and recovery mechanisms
-
-### 5.4: Administrative UI (Optional)
-
-- Create basic admin UI for plugin management:
-  - View installed plugins
-  - Enable/disable plugins
-  - View permissions
-  - Configure plugins
-
-**Deliverable:** Complete plugin management tooling with good user experience.
-
-## Phase 6: Documentation and Release
-
-**Goal:** Prepare the plugin system for production use and developer adoption.
-
-### 6.1: User Documentation
-
-- Create comprehensive user documentation:
-  - Plugin installation and management
-  - Configuration options
-  - Security considerations
-  - Troubleshooting
-
-### 6.2: Developer Documentation
-
-- Create plugin development guide:
-  - API reference
-  - Development workflow
-  - Best practices
-  - Examples
-
-### 6.3: Example Plugin Templates
-
-- Create starter templates for common plugin types:
-  - Basic agent plugin
-  - Custom service plugin
-- Include CI/CD configurations
-- Add examples for different permission scenarios:
-  - Standard external API access
-  - Local network access (with `allowLocalNetwork: true`)
-  - Different capability declarations
-
-### 6.4: Final Testing and Feature Flags
-
-- Add feature flag to enable/disable plugin system
-- Perform comprehensive integration testing
-- Address any final security concerns
-
-**Deliverable:** Production-ready plugin system with documentation and examples.
-
-## Risk Assessment and Mitigation
-
-1. **Security Risks**
-
-   - **Risk**: Plugin execution could compromise system security
-   - **Mitigation**: Strict permission model, WebAssembly sandbox, URL validation
-
-2. **Performance Impact**
-
-   - **Risk**: WebAssembly execution might be slower than native code
-   - **Mitigation**: Benchmarking, caching mechanisms, performance monitoring
-
-3. **Backward Compatibility**
-
-   - **Risk**: Changes might break existing functionality
-   - **Mitigation**: Feature flags, phased integration, comprehensive testing
-
-4. **User Experience**
-
-   - **Risk**: Plugin management could be complex for users
-   - **Mitigation**: Clear documentation, intuitive CLI, potential UI integration
-
-5. **Developer Adoption**
-   - **Risk**: Plugin development might be too complex
-   - **Mitigation**: Clear documentation, example templates, developer tooling

go.mod

@@ -35,17 +35,17 @@ require (
 	github.com/jellydator/ttlcache/v3 v3.3.0
 	github.com/kardianos/service v1.2.2
 	github.com/kr/pretty v0.3.1
-	github.com/lestrrat-go/jwx/v2 v2.1.4
+	github.com/lestrrat-go/jwx/v2 v2.1.6
 	github.com/matoous/go-nanoid/v2 v2.1.0
-	github.com/mattn/go-sqlite3 v1.14.27
+	github.com/mattn/go-sqlite3 v1.14.28
 	github.com/microcosm-cc/bluemonday v1.0.27
 	github.com/mileusna/useragent v1.3.5
 	github.com/onsi/ginkgo/v2 v2.23.4
 	github.com/onsi/gomega v1.37.0
 	github.com/pelletier/go-toml/v2 v2.2.4
 	github.com/pocketbase/dbx v1.11.0
-	github.com/pressly/goose/v3 v3.24.2
-	github.com/prometheus/client_golang v1.21.1
+	github.com/pressly/goose/v3 v3.24.3
+	github.com/prometheus/client_golang v1.22.0
 	github.com/rjeczalik/notify v0.9.3
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
@@ -56,12 +56,12 @@ require (
 	github.com/unrolled/secure v1.17.0
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1
 	go.uber.org/goleak v1.3.0
-	golang.org/x/exp v0.0.0-20250305212735-054e65f0b394
-	golang.org/x/image v0.26.0
-	golang.org/x/net v0.38.0
-	golang.org/x/sync v0.13.0
-	golang.org/x/sys v0.32.0
-	golang.org/x/text v0.24.0
+	golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6
+	golang.org/x/image v0.27.0
+	golang.org/x/net v0.40.0
+	golang.org/x/sync v0.14.0
+	golang.org/x/sys v0.33.0
+	golang.org/x/text v0.25.0
 	golang.org/x/time v0.11.0
 	gopkg.in/yaml.v3 v3.0.1
 )
@@ -80,18 +80,17 @@ require (
 	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
 	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
-	github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 // indirect
+	github.com/google/pprof v0.0.0-20250501235452-c0086092b71a // indirect
 	github.com/google/subcommands v1.2.0 // indirect
 	github.com/gorilla/css v1.0.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
 	github.com/kr/text v0.2.0 // indirect
 	github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
 	github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
-	github.com/lestrrat-go/blackmagic v1.0.2 // indirect
+	github.com/lestrrat-go/blackmagic v1.0.3 // indirect
 	github.com/lestrrat-go/httpcc v1.0.1 // indirect
 	github.com/lestrrat-go/httprc v1.0.6 // indirect
 	github.com/lestrrat-go/iter v1.0.2 // indirect
@@ -102,23 +101,23 @@ require (
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
 	github.com/prometheus/common v0.62.0 // indirect
-	github.com/prometheus/procfs v0.16.0 // indirect
+	github.com/prometheus/procfs v0.16.1 // indirect
 	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	github.com/sagikazarmark/locafero v0.9.0 // indirect
 	github.com/segmentio/asm v1.2.0 // indirect
 	github.com/sethvargo/go-retry v0.3.0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.14.0 // indirect
-	github.com/spf13/cast v1.7.1 // indirect
+	github.com/spf13/cast v1.8.0 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/zeebo/xxh3 v1.0.2 // indirect
 	go.uber.org/automaxprocs v1.6.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.37.0 // indirect
+	golang.org/x/crypto v0.38.0 // indirect
 	golang.org/x/mod v0.24.0 // indirect
-	golang.org/x/tools v0.31.0 // indirect
+	golang.org/x/tools v0.33.0 // indirect
 	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect

go.sum

@@ -66,8 +66,8 @@ github.com/go-chi/jwtauth/v5 v5.3.3/go.mod h1:O4QvPRuZLZghl9WvfVaON+ARfGzpD2PBX/
 github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
 github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
-github.com/go-sql-driver/mysql v1.9.1 h1:FrjNGn/BsJQjVRuSa8CBrM5BWA9BWoXXat3KrtSb/iI=
-github.com/go-sql-driver/mysql v1.9.1/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
+github.com/go-sql-driver/mysql v1.9.2 h1:4cNKDYQ1I84SXslGddlsrMhc8k4LeDVj6Ad6WRjiHuU=
+github.com/go-sql-driver/mysql v1.9.2/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
 github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
 github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
 github.com/go-viper/encoding/ini v0.1.1 h1:MVWY7B2XNw7lnOqHutGRc97bF3rP7omOdgjdMPAJgbs=
@@ -85,8 +85,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/go-pipeline v0.0.0-20230411140531-6cbedfc1d3fc h1:hd+uUVsB1vdxohPneMrhGH2YfQuH5hRIK9u4/XCeUtw=
 github.com/google/go-pipeline v0.0.0-20230411140531-6cbedfc1d3fc/go.mod h1:SL66SJVysrh7YbDCP9tH30b8a9o/N2HeiQNUm85EKhc=
-github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8=
-github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
+github.com/google/pprof v0.0.0-20250501235452-c0086092b71a h1:rDA3FfmxwXR+BVKKdz55WwMJ1pD2hJQNW31d+l3mPk4=
+github.com/google/pprof v0.0.0-20250501235452-c0086092b71a/go.mod h1:5hDyRhoBCxViHszMt12TnOpEI4VVi+U8Gm9iphldiMA=
 github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE=
 github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -130,24 +130,24 @@ github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 h1:SOEGU9fKiNWd/HOJuq
 github.com/lann/builder v0.0.0-20180802200727-47ae307949d0/go.mod h1:dXGbAdH5GtBTC4WfIxhKZfyBF/HBFgRZSWwZ9g/He9o=
 github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 h1:P6pPBnrTSX3DEVR4fDembhRWSsG5rVo6hYhAB/ADZrk=
 github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0/go.mod h1:vmVJ0l/dxyfGW6FmdpVm2joNMFikkuWg0EoCKLGUMNw=
-github.com/lestrrat-go/blackmagic v1.0.2 h1:Cg2gVSc9h7sz9NOByczrbUvLopQmXrfFx//N+AkAr5k=
-github.com/lestrrat-go/blackmagic v1.0.2/go.mod h1:UrEqBzIR2U6CnzVyUtfM6oZNMt/7O7Vohk2J0OGSAtU=
+github.com/lestrrat-go/blackmagic v1.0.3 h1:94HXkVLxkZO9vJI/w2u1T0DAoprShFd13xtnSINtDWs=
+github.com/lestrrat-go/blackmagic v1.0.3/go.mod h1:6AWFyKNNj0zEXQYfTMPfZrAXUWUfTIZ5ECEUEJaijtw=
 github.com/lestrrat-go/httpcc v1.0.1 h1:ydWCStUeJLkpYyjLDHihupbn2tYmZ7m22BGkcvZZrIE=
 github.com/lestrrat-go/httpcc v1.0.1/go.mod h1:qiltp3Mt56+55GPVCbTdM9MlqhvzyuL6W/NMDA8vA5E=
 github.com/lestrrat-go/httprc v1.0.6 h1:qgmgIRhpvBqexMJjA/PmwSvhNk679oqD1RbovdCGW8k=
 github.com/lestrrat-go/httprc v1.0.6/go.mod h1:mwwz3JMTPBjHUkkDv/IGJ39aALInZLrhBp0X7KGUZlo=
 github.com/lestrrat-go/iter v1.0.2 h1:gMXo1q4c2pHmC3dn8LzRhJfP1ceCbgSiT9lUydIzltI=
 github.com/lestrrat-go/iter v1.0.2/go.mod h1:Momfcq3AnRlRjI5b5O8/G5/BvpzrhoFTZcn06fEOPt4=
-github.com/lestrrat-go/jwx/v2 v2.1.4 h1:uBCMmJX8oRZStmKuMMOFb0Yh9xmEMgNJLgjuKKt4/qc=
-github.com/lestrrat-go/jwx/v2 v2.1.4/go.mod h1:nWRbDFR1ALG2Z6GJbBXzfQaYyvn751KuuyySN2yR6is=
+github.com/lestrrat-go/jwx/v2 v2.1.6 h1:hxM1gfDILk/l5ylers6BX/Eq1m/pnxe9NBwW6lVfecA=
+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/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=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-sqlite3 v1.14.27 h1:drZCnuvf37yPfs95E5jd9s3XhdVWLal+6BOK6qrv6IU=
-github.com/mattn/go-sqlite3 v1.14.27/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/mattn/go-sqlite3 v1.14.28 h1:ThEiQrnbtumT+QMknw63Befp/ce/nUPgBPMlRFEum7A=
+github.com/mattn/go-sqlite3 v1.14.28/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY=
 github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg=
 github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
@@ -174,16 +174,16 @@ github.com/pocketbase/dbx v1.11.0 h1:LpZezioMfT3K4tLrqA55wWFw1EtH1pM4tzSVa7kgszU
 github.com/pocketbase/dbx v1.11.0/go.mod h1:xXRCIAKTHMgUCyCKZm55pUOdvFziJjQfXaWKhu2vhMs=
 github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
 github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
-github.com/pressly/goose/v3 v3.24.2 h1:c/ie0Gm8rnIVKvnDQ/scHErv46jrDv9b4I0WRcFJzYU=
-github.com/pressly/goose/v3 v3.24.2/go.mod h1:kjefwFB0eR4w30Td2Gj2Mznyw94vSP+2jJYkOVNbD1k=
-github.com/prometheus/client_golang v1.21.1 h1:DOvXXTqVzvkIewV/CDPFdejpMCGeMcbGCQ8YOmu+Ibk=
-github.com/prometheus/client_golang v1.21.1/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
+github.com/pressly/goose/v3 v3.24.3 h1:DSWWNwwggVUsYZ0X2VitiAa9sKuqtBfe+Jr9zFGwWlM=
+github.com/pressly/goose/v3 v3.24.3/go.mod h1:v9zYL4xdViLHCUUJh/mhjnm6JrK7Eul8AS93IxiZM4E=
+github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
+github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
 github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
 github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
 github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=
 github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=
-github.com/prometheus/procfs v0.16.0 h1:xh6oHhKwnOJKMYiYBDWmkHqQPyiY40sny36Cmx2bbsM=
-github.com/prometheus/procfs v0.16.0/go.mod h1:8veyXUu3nGP7oaCxhX6yeaM5u4stL2FeMXnCqhDthZg=
+github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
+github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rjeczalik/notify v0.9.3 h1:6rJAzHTGKXGj76sbRgDiDcYj/HniypXmSJo1SWakZeY=
@@ -213,8 +213,8 @@ github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9yS
 github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
 github.com/spf13/afero v1.14.0 h1:9tH6MapGnn/j0eb0yIXiLjERO8RB6xIVZRDCX7PtqWA=
 github.com/spf13/afero v1.14.0/go.mod h1:acJQ8t0ohCGuMN3O+Pv0V0hgMxNYDlvdk+VTfyZmbYo=
-github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
-github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cast v1.8.0 h1:gEN9K4b8Xws4EX0+a0reLmhq8moKn7ntRlQYgjPeCDk=
+github.com/spf13/cast v1.8.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
 github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
 github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
@@ -256,13 +256,13 @@ golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1m
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
-golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
-golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw=
-golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6 h1:y5zboxd6LQAqYIhHnB48p0ByQ/GnQx2BE33L8BOHQkI=
+golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6/go.mod h1:U6Lno4MTRCDY+Ba7aCcauB9T60gsv5s4ralQzP72ZoQ=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.26.0 h1:4XjIFEZWQmCZi6Wv8BoxsDhRU3RVnLX04dToTDAEPlY=
-golang.org/x/image v0.26.0/go.mod h1:lcxbMFAovzpnJxzXS3nyL83K27tmqtKzIJpctK8YO5c=
+golang.org/x/image v0.27.0 h1:C8gA4oWU/tKkdCfYT6T2u4faJu3MeNS5O8UPWlPF61w=
+golang.org/x/image v0.27.0/go.mod h1:xbdrClrAUway1MUTEZDq9mz/UpRwYAkFFNUslZtcB+g=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
@@ -283,8 +283,8 @@ golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
-golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -292,8 +292,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.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
-golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 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=
@@ -312,8 +312,8 @@ golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 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.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
-golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -334,8 +334,8 @@ golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
-golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0=
 golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -346,8 +346,8 @@ golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/tools v0.31.0 h1:0EedkvKDbh+qistFTd0Bcwe/YLh4vHwWEkiI0toFIBU=
-golang.org/x/tools v0.31.0/go.mod h1:naFTU+Cev749tSJRXJlna0T3WxKvb1kWEx15xA4SdmQ=
+golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
+golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
@@ -363,11 +363,11 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-modernc.org/libc v1.61.13 h1:3LRd6ZO1ezsFiX1y+bHd1ipyEHIJKvuprv0sLTBwLW8=
-modernc.org/libc v1.61.13/go.mod h1:8F/uJWL/3nNil0Lgt1Dpz+GgkApWh04N3el3hxJcA6E=
+modernc.org/libc v1.65.0 h1:e183gLDnAp9VJh6gWKdTy0CThL9Pt7MfcR/0bgb7Y1Y=
+modernc.org/libc v1.65.0/go.mod h1:7m9VzGq7APssBTydds2zBcxGREwvIGpuUBaKTXdm2Qs=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
-modernc.org/memory v1.9.1 h1:V/Z1solwAVmMW1yttq3nDdZPJqV1rM05Ccq6KMSZ34g=
-modernc.org/memory v1.9.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
-modernc.org/sqlite v1.36.2 h1:vjcSazuoFve9Wm0IVNHgmJECoOXLZM1KfMXbcX2axHA=
-modernc.org/sqlite v1.36.2/go.mod h1:ADySlx7K4FdY5MaJcEv86hTJ0PjedAloTUuif0YS3ws=
+modernc.org/memory v1.10.0 h1:fzumd51yQ1DxcOxSO+S6X7+QTuVU+n8/Aj7swYjFfC4=
+modernc.org/memory v1.10.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
+modernc.org/sqlite v1.37.0 h1:s1TMe7T3Q3ovQiK2Ouz4Jwh7dw4ZDqbebSDTlSJdfjI=
+modernc.org/sqlite v1.37.0/go.mod h1:5YiWv+YviqGMuGw4V+PNplcyaJ5v+vQd7TQOgkACoJM=

model/artist.go

@@ -32,6 +32,8 @@ type Artist struct {
 	SimilarArtists        Artists    `structs:"similar_artists"  json:"-"`
 	ExternalInfoUpdatedAt *time.Time `structs:"external_info_updated_at" json:"externalInfoUpdatedAt,omitempty"`
 
+	Missing bool `structs:"missing" json:"missing"`
+
 	CreatedAt *time.Time `structs:"created_at" json:"createdAt,omitempty"`
 	UpdatedAt *time.Time `structs:"updated_at" json:"updatedAt,omitempty"`
 }
@@ -76,7 +78,7 @@ type ArtistRepository interface {
 	UpdateExternalInfo(a *Artist) error
 	Get(id string) (*Artist, error)
 	GetAll(options ...QueryOptions) (Artists, error)
-	GetIndex(roles ...Role) (ArtistIndexes, error)
+	GetIndex(includeMissing bool, roles ...Role) (ArtistIndexes, error)
 
 	// The following methods are used exclusively by the scanner:
 	RefreshPlayCounts() (int64, error)

model/criteria/criteria.go

@@ -4,6 +4,7 @@ package criteria
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"strings"
 
 	"github.com/Masterminds/squirrel"
@@ -40,6 +41,9 @@ func (c Criteria) OrderBy() string {
 		} else {
 			mapped = f.field
 		}
+		if f.numeric {
+			mapped = fmt.Sprintf("CAST(%s AS REAL)", mapped)
+		}
 	}
 	if c.Order != "" {
 		if strings.EqualFold(c.Order, "asc") || strings.EqualFold(c.Order, "desc") {

model/criteria/criteria_test.go

@@ -109,6 +109,15 @@ var _ = Describe("Criteria", func() {
 				)
 			})
 
+			It("casts numeric tags when sorting", func() {
+				AddTagNames([]string{"rate"})
+				AddNumericTags([]string{"rate"})
+				goObj.Sort = "rate"
+				gomega.Expect(goObj.OrderBy()).To(
+					gomega.Equal("CAST(COALESCE(json_extract(media_file.tags, '$.rate[0].value'), '') AS REAL) asc"),
+				)
+			})
+
 			It("sorts by random", func() {
 				newObj := goObj
 				newObj.Sort = "random"

model/criteria/fields.go

@@ -54,11 +54,12 @@ var fieldMap = map[string]*mappedField{
 }
 
 type mappedField struct {
-	field  string
-	order  string
-	isRole bool   // true if the field is a role (e.g. "artist", "composer", "conductor", etc.)
-	isTag  bool   // true if the field is a tag imported from the file metadata
-	alias  string // name from `mappings.yml` that may differ from the name used in the smart playlist
+	field   string
+	order   string
+	isRole  bool   // true if the field is a role (e.g. "artist", "composer", "conductor", etc.)
+	isTag   bool   // true if the field is a tag imported from the file metadata
+	alias   string // name from `mappings.yml` that may differ from the name used in the smart playlist
+	numeric bool   // true if the field/tag should be treated as numeric
 }
 
 func mapFields(expr map[string]any) map[string]any {
@@ -145,6 +146,12 @@ type tagCond struct {
 
 func (e tagCond) ToSql() (string, []any, error) {
 	cond, args, err := e.cond.ToSql()
+
+	// Check if this tag is marked as numeric in the fieldMap
+	if fm, ok := fieldMap[e.tag]; ok && fm.numeric {
+		cond = strings.ReplaceAll(cond, "value", "CAST(value AS REAL)")
+	}
+
 	cond = fmt.Sprintf("exists (select 1 from json_tree(tags, '$.%s') where key='value' and %s)",
 		e.tag, cond)
 	if e.not {
@@ -205,3 +212,16 @@ func AddTagNames(tagNames []string) {
 		}
 	}
 }
+
+// AddNumericTags marks the given tag names as numeric so they can be cast
+// when used in comparisons or sorting.
+func AddNumericTags(tagNames []string) {
+	for _, name := range tagNames {
+		name := strings.ToLower(name)
+		if fm, ok := fieldMap[name]; ok {
+			fm.numeric = true
+		} else {
+			fieldMap[name] = &mappedField{field: name, isTag: true, numeric: true}
+		}
+	}
+}

model/criteria/operators_test.go

@@ -13,6 +13,7 @@ import (
 var _ = BeforeSuite(func() {
 	AddRoles([]string{"artist", "composer"})
 	AddTagNames([]string{"genre"})
+	AddNumericTags([]string{"rate"})
 })
 
 var _ = Describe("Operators", func() {
@@ -68,6 +69,15 @@ var _ = Describe("Operators", func() {
 		Entry("role endsWith [string]", EndsWith{"composer": "Lennon"}, "exists (select 1 from json_tree(participants, '$.composer') where key='name' and value LIKE ?)", "%Lennon"),
 	)
 
+	// TODO Validate operators that are not valid for each field type.
+	XDescribeTable("ToSQL - Invalid Operators",
+		func(op Expression, expectedError string) {
+			_, _, err := op.ToSql()
+			gomega.Expect(err).To(gomega.MatchError(expectedError))
+		},
+		Entry("numeric tag contains", Contains{"rate": 5}, "numeric tag 'rate' cannot be used with Contains operator"),
+	)
+
 	Describe("Custom Tags", func() {
 		It("generates valid SQL", func() {
 			AddTagNames([]string{"mood"})
@@ -77,6 +87,14 @@ var _ = Describe("Operators", func() {
 			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(tags, '$.mood') where key='value' and value LIKE ?)"))
 			gomega.Expect(args).To(gomega.HaveExactElements("%Soft"))
 		})
+		It("casts numeric comparisons", func() {
+			AddNumericTags([]string{"rate"})
+			op := Lt{"rate": 6}
+			sql, args, err := op.ToSql()
+			gomega.Expect(err).ToNot(gomega.HaveOccurred())
+			gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(tags, '$.rate') where key='value' and CAST(value AS REAL) < ?)"))
+			gomega.Expect(args).To(gomega.HaveExactElements(6))
+		})
 		It("skips unknown tag names", func() {
 			op := EndsWith{"unknown": "value"}
 			sql, args, _ := op.ToSql()

model/lyrics.go

@@ -32,7 +32,7 @@ var (
 	// Should either be at the beginning of file, or beginning of line
 	syncRegex  = regexp.MustCompile(`(^|\n)\s*` + timeRegexString)
 	timeRegex  = regexp.MustCompile(timeRegexString)
-	lrcIdRegex = regexp.MustCompile(`\[(ar|ti|offset):([^]]+)]`)
+	lrcIdRegex = regexp.MustCompile(`\[(ar|ti|offset|lang):([^]]+)]`)
 )
 
 func (l Lyrics) IsEmpty() bool {
@@ -72,6 +72,8 @@ func ToLyrics(language, text string) (*Lyrics, error) {
 				switch idTag[1] {
 				case "ar":
 					artist = str.SanitizeText(strings.TrimSpace(idTag[2]))
+				case "lang":
+					language = str.SanitizeText(strings.TrimSpace(idTag[2]))
 				case "offset":
 					{
 						off, err := strconv.ParseInt(strings.TrimSpace(idTag[2]), 10, 64)

model/lyrics_test.go

@@ -9,8 +9,9 @@ import (
 var _ = Describe("ToLyrics", func() {
 	It("should parse tags with spaces", func() {
 		num := int64(1551)
-		lyrics, err := ToLyrics("xxx", "[offset: 1551 ]\n[ti: A title ]\n[ar: An artist ]\n[00:00.00]Hi there")
+		lyrics, err := ToLyrics("xxx", "[lang:  eng  ]\n[offset: 1551 ]\n[ti: A title ]\n[ar: An artist ]\n[00:00.00]Hi there")
 		Expect(err).ToNot(HaveOccurred())
+		Expect(lyrics.Lang).To(Equal("eng"))
 		Expect(lyrics.Synced).To(BeTrue())
 		Expect(lyrics.DisplayArtist).To(Equal("An artist"))
 		Expect(lyrics.DisplayTitle).To(Equal("A title"))

model/mediafile.go

@@ -9,6 +9,7 @@ import (
 	"mime"
 	"path/filepath"
 	"slices"
+	"strings"
 	"time"
 
 	"github.com/gohugoio/hashstructure"
@@ -330,6 +331,23 @@ func firstArtPath(currentPath string, currentDisc int, m MediaFile) (string, int
 	return currentPath, currentDisc
 }
 
+// ToM3U8 exports the playlist to the Extended M3U8 format, as specified in
+// https://docs.fileformat.com/audio/m3u/#extended-m3u
+func (mfs MediaFiles) ToM3U8(title string, absolutePaths bool) string {
+	buf := strings.Builder{}
+	buf.WriteString("#EXTM3U\n")
+	buf.WriteString(fmt.Sprintf("#PLAYLIST:%s\n", title))
+	for _, t := range mfs {
+		buf.WriteString(fmt.Sprintf("#EXTINF:%.f,%s - %s\n", t.Duration, t.Artist, t.Title))
+		if absolutePaths {
+			buf.WriteString(t.AbsolutePath() + "\n")
+		} else {
+			buf.WriteString(t.Path + "\n")
+		}
+	}
+	return buf.String()
+}
+
 type MediaFileCursor iter.Seq2[MediaFile, error]
 
 type MediaFileRepository interface {
@@ -342,6 +360,7 @@ type MediaFileRepository interface {
 	GetCursor(options ...QueryOptions) (MediaFileCursor, error)
 	Delete(id string) error
 	DeleteMissing(ids []string) error
+	DeleteAllMissing() (int64, error)
 	FindByPaths(paths []string) (MediaFiles, error)
 
 	// The following methods are used exclusively by the scanner:

model/mediafile_test.go

@@ -402,6 +402,72 @@ var _ = Describe("MediaFiles", func() {
 			})
 		})
 	})
+
+	Describe("ToM3U8", func() {
+		It("returns header only for empty MediaFiles", func() {
+			mfs = MediaFiles{}
+			result := mfs.ToM3U8("My Playlist", false)
+			Expect(result).To(Equal("#EXTM3U\n#PLAYLIST:My Playlist\n"))
+		})
+
+		DescribeTable("duration formatting",
+			func(duration float32, expected string) {
+				mfs = MediaFiles{{Title: "Song", Artist: "Artist", Duration: duration, Path: "song.mp3"}}
+				result := mfs.ToM3U8("Test", false)
+				Expect(result).To(ContainSubstring(expected))
+			},
+			Entry("zero duration", float32(0.0), "#EXTINF:0,"),
+			Entry("whole number", float32(120.0), "#EXTINF:120,"),
+			Entry("rounds 0.5 down", float32(180.5), "#EXTINF:180,"),
+			Entry("rounds 0.6 up", float32(240.6), "#EXTINF:241,"),
+		)
+
+		Context("multiple tracks", func() {
+			BeforeEach(func() {
+				mfs = MediaFiles{
+					{Title: "Song One", Artist: "Artist A", Duration: 120, Path: "a/song1.mp3", LibraryPath: "/music"},
+					{Title: "Song Two", Artist: "Artist B", Duration: 241, Path: "b/song2.mp3", LibraryPath: "/music"},
+					{Title: "Song with \"quotes\" & ampersands", Artist: "Artist with Ümläuts", Duration: 90, Path: "special/file.mp3", LibraryPath: "/música"},
+				}
+			})
+
+			DescribeTable("generates correct output",
+				func(absolutePaths bool, expectedContent string) {
+					result := mfs.ToM3U8("Multi Track", absolutePaths)
+					Expect(result).To(Equal(expectedContent))
+				},
+				Entry("relative paths",
+					false,
+					"#EXTM3U\n#PLAYLIST:Multi Track\n#EXTINF:120,Artist A - Song One\na/song1.mp3\n#EXTINF:241,Artist B - Song Two\nb/song2.mp3\n#EXTINF:90,Artist with Ümläuts - Song with \"quotes\" & ampersands\nspecial/file.mp3\n",
+				),
+				Entry("absolute paths",
+					true,
+					"#EXTM3U\n#PLAYLIST:Multi Track\n#EXTINF:120,Artist A - Song One\n/music/a/song1.mp3\n#EXTINF:241,Artist B - Song Two\n/music/b/song2.mp3\n#EXTINF:90,Artist with Ümläuts - Song with \"quotes\" & ampersands\n/música/special/file.mp3\n",
+				),
+				Entry("special characters",
+					false,
+					"#EXTM3U\n#PLAYLIST:Multi Track\n#EXTINF:120,Artist A - Song One\na/song1.mp3\n#EXTINF:241,Artist B - Song Two\nb/song2.mp3\n#EXTINF:90,Artist with Ümläuts - Song with \"quotes\" & ampersands\nspecial/file.mp3\n",
+				),
+			)
+		})
+
+		Context("path variations", func() {
+			It("handles different path structures", func() {
+				mfs = MediaFiles{
+					{Title: "Root", Artist: "Artist", Duration: 60, Path: "song.mp3", LibraryPath: "/lib"},
+					{Title: "Nested", Artist: "Artist", Duration: 60, Path: "deep/nested/song.mp3", LibraryPath: "/lib"},
+				}
+
+				relativeResult := mfs.ToM3U8("Test", false)
+				Expect(relativeResult).To(ContainSubstring("song.mp3\n"))
+				Expect(relativeResult).To(ContainSubstring("deep/nested/song.mp3\n"))
+
+				absoluteResult := mfs.ToM3U8("Test", true)
+				Expect(absoluteResult).To(ContainSubstring("/lib/song.mp3\n"))
+				Expect(absoluteResult).To(ContainSubstring("/lib/deep/nested/song.mp3\n"))
+			})
+		})
+	})
 })
 
 var _ = Describe("MediaFile", func() {

model/metadata/map_participants_test.go

@@ -564,6 +564,58 @@ var _ = Describe("Participants", func() {
 				))
 			})
 		})
+
+		When("MUSICBRAINZ_PERFORMERID tag is set", func() {
+			matchPerformer := func(name, orderName, subRole, mbid string) types.GomegaMatcher {
+				return MatchFields(IgnoreExtras, Fields{
+					"Artist": MatchFields(IgnoreExtras, Fields{
+						"Name":            Equal(name),
+						"OrderArtistName": Equal(orderName),
+						"MbzArtistID":     Equal(mbid),
+					}),
+					"SubRole": Equal(subRole),
+				})
+			}
+
+			It("should map MBIDs to the correct performer", func() {
+				mf = toMediaFile(model.RawTags{
+					"PERFORMER:GUITAR":               {"Eric Clapton", "B.B. King"},
+					"PERFORMER:BASS":                 {"Nathan East"},
+					"MUSICBRAINZ_PERFORMERID:GUITAR": {"mbid1", "mbid2"},
+					"MUSICBRAINZ_PERFORMERID:BASS":   {"mbid3"},
+				})
+
+				participants := mf.Participants
+				Expect(participants).To(HaveKeyWithValue(model.RolePerformer, HaveLen(3)))
+
+				p := participants[model.RolePerformer]
+				Expect(p).To(ContainElements(
+					matchPerformer("Eric Clapton", "eric clapton", "Guitar", "mbid1"),
+					matchPerformer("B.B. King", "b.b. king", "Guitar", "mbid2"),
+					matchPerformer("Nathan East", "nathan east", "Bass", "mbid3"),
+				))
+			})
+
+			It("should handle mismatched performer names and MBIDs for sub-roles", func() {
+				mf = toMediaFile(model.RawTags{
+					"PERFORMER:VOCALS":               {"Singer A", "Singer B", "Singer C"},
+					"MUSICBRAINZ_PERFORMERID:VOCALS": {"mbid_vocals_a", "mbid_vocals_b"}, // Fewer MBIDs
+					"PERFORMER:DRUMS":                {"Drummer X"},
+					"MUSICBRAINZ_PERFORMERID:DRUMS":  {"mbid_drums_x", "mbid_drums_y"}, // More MBIDs
+				})
+
+				participants := mf.Participants
+				Expect(participants).To(HaveKeyWithValue(model.RolePerformer, HaveLen(4))) // 3 vocalists + 1 drummer
+
+				p := participants[model.RolePerformer]
+				Expect(p).To(ContainElements(
+					matchPerformer("Singer A", "singer a", "Vocals", "mbid_vocals_a"),
+					matchPerformer("Singer B", "singer b", "Vocals", "mbid_vocals_b"),
+					matchPerformer("Singer C", "singer c", "Vocals", ""),
+					matchPerformer("Drummer X", "drummer x", "Drums", "mbid_drums_x"),
+				))
+			})
+		})
 	})
 
 	Describe("Other tags", func() {
@@ -592,7 +644,6 @@ var _ = Describe("Participants", func() {
 			Entry("REMIXER", model.RoleRemixer, "REMIXER"),
 			Entry("DJMIXER", model.RoleDJMixer, "DJMIXER"),
 			Entry("DIRECTOR", model.RoleDirector, "DIRECTOR"),
-			// TODO PERFORMER
 		)
 	})
 

model/playlist.go

@@ -1,10 +1,8 @@
 package model
 
 import (
-	"fmt"
 	"slices"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/navidrome/navidrome/model/criteria"
@@ -53,17 +51,9 @@ func (pls *Playlist) RemoveTracks(idxToRemove []int) {
 	pls.Tracks = newTracks
 }
 
-// ToM3U8 exports the playlist to the Extended M3U8 format, as specified in
-// https://docs.fileformat.com/audio/m3u/#extended-m3u
+// ToM3U8 exports the playlist to the Extended M3U8 format
 func (pls *Playlist) ToM3U8() string {
-	buf := strings.Builder{}
-	buf.WriteString("#EXTM3U\n")
-	buf.WriteString(fmt.Sprintf("#PLAYLIST:%s\n", pls.Name))
-	for _, t := range pls.Tracks {
-		buf.WriteString(fmt.Sprintf("#EXTINF:%.f,%s - %s\n", t.Duration, t.Artist, t.Title))
-		buf.WriteString(t.AbsolutePath() + "\n")
-	}
-	return buf.String()
+	return pls.MediaFiles().ToM3U8(pls.Name, true)
 }
 
 func (pls *Playlist) AddTracks(mediaFileIds []string) {

model/playlist_test.go

@@ -13,13 +13,17 @@ var _ = Describe("Playlist", func() {
 			pls = model.Playlist{Name: "Mellow sunset"}
 			pls.Tracks = model.PlaylistTracks{
 				{MediaFile: model.MediaFile{Artist: "Morcheeba feat. Kurt Wagner", Title: "What New York Couples Fight About",
-					Duration: 377.84, Path: "/music/library/Morcheeba/Charango/01-06 What New York Couples Fight About.mp3"}},
+					Duration:    377.84,
+					LibraryPath: "/music/library", Path: "Morcheeba/Charango/01-06 What New York Couples Fight About.mp3"}},
 				{MediaFile: model.MediaFile{Artist: "A Tribe Called Quest", Title: "Description of a Fool (Groove Armada's Acoustic mix)",
-					Duration: 374.49, Path: "/music/library/Groove Armada/Back to Mine_ Groove Armada/01-01 Description of a Fool (Groove Armada's Acoustic mix).mp3"}},
+					Duration:    374.49,
+					LibraryPath: "/music/library", Path: "Groove Armada/Back to Mine_ Groove Armada/01-01 Description of a Fool (Groove Armada's Acoustic mix).mp3"}},
 				{MediaFile: model.MediaFile{Artist: "Lou Reed", Title: "Walk on the Wild Side",
-					Duration: 253.1, Path: "/music/library/Lou Reed/Walk on the Wild Side_ The Best of Lou Reed/01-06 Walk on the Wild Side.m4a"}},
+					Duration:    253.1,
+					LibraryPath: "/music/library", Path: "Lou Reed/Walk on the Wild Side_ The Best of Lou Reed/01-06 Walk on the Wild Side.m4a"}},
 				{MediaFile: model.MediaFile{Artist: "Legião Urbana", Title: "On the Way Home",
-					Duration: 163.89, Path: "/music/library/Legião Urbana/Música p_ acampamentos/02-05 On the Way Home.mp3"}},
+					Duration:    163.89,
+					LibraryPath: "/music/library", Path: "Legião Urbana/Música p_ acampamentos/02-05 On the Way Home.mp3"}},
 			}
 		})
 		It("generates the correct M3U format", func() {

model/share.go

@@ -2,7 +2,6 @@ package model
 
 import (
 	"cmp"
-	"fmt"
 	"strings"
 	"time"
 
@@ -50,17 +49,9 @@ func (s Share) CoverArtID() ArtworkID {
 
 type Shares []Share
 
-// ToM3U8 exports the playlist to the Extended M3U8 format, as specified in
-// https://docs.fileformat.com/audio/m3u/#extended-m3u
+// ToM3U8 exports the share to the Extended M3U8 format.
 func (s Share) ToM3U8() string {
-	buf := strings.Builder{}
-	buf.WriteString("#EXTM3U\n")
-	buf.WriteString(fmt.Sprintf("#PLAYLIST:%s\n", cmp.Or(s.Description, s.ID)))
-	for _, t := range s.Tracks {
-		buf.WriteString(fmt.Sprintf("#EXTINF:%.f,%s - %s\n", t.Duration, t.Artist, t.Title))
-		buf.WriteString(t.Path + "\n")
-	}
-	return buf.String()
+	return s.Tracks.ToM3U8(cmp.Or(s.Description, s.ID), false)
 }
 
 type ShareRepository interface {

model/tag.go

@@ -191,6 +191,7 @@ const (
 	TagReleaseCountry TagName = "releasecountry"
 	TagMedia          TagName = "media"
 	TagCatalogNumber  TagName = "catalognumber"
+	TagISRC           TagName = "isrc"
 	TagBPM            TagName = "bpm"
 	TagExplicitStatus TagName = "explicitstatus"
 

model/tag_mappings.go

@@ -162,6 +162,17 @@ func tagNames() []string {
 	return names
 }
 
+func numericTagNames() []string {
+	mappings := TagMappings()
+	names := make([]string, 0)
+	for k, cfg := range mappings {
+		if cfg.Type == TagTypeInteger || cfg.Type == TagTypeFloat {
+			names = append(names, string(k))
+		}
+	}
+	return names
+}
+
 func loadTagMappings() {
 	mappingsFile, err := resources.FS().Open("mappings.yaml")
 	if err != nil {
@@ -228,5 +239,6 @@ func init() {
 		// used in smart playlists
 		criteria.AddRoles(slices.Collect(maps.Keys(AllRoles)))
 		criteria.AddTagNames(tagNames())
+		criteria.AddNumericTags(numericTagNames())
 	})
 }

persistence/album_repository.go

@@ -315,7 +315,7 @@ func (r *albumRepository) GetTouchedAlbums(libID int) (model.AlbumCursor, error)
 // RefreshPlayCounts updates the play count and last play date annotations for all albums, based
 // on the media files associated with them.
 func (r *albumRepository) RefreshPlayCounts() (int64, error) {
-	query := rawSQL(`
+	query := Expr(`
 with play_counts as (
     select user_id, album_id, sum(play_count) as total_play_count, max(play_date) as last_play_date
     from media_file

persistence/artist_repository.go

@@ -116,6 +116,7 @@ func NewArtistRepository(ctx context.Context, db dbx.Builder) model.ArtistReposi
 		"name":    fullTextFilter(r.tableName),
 		"starred": booleanFilter,
 		"role":    roleFilter,
+		"missing": booleanFilter,
 	})
 	r.setSortMappings(map[string]string{
 		"name":        "order_artist_name",
@@ -128,7 +129,12 @@ func NewArtistRepository(ctx context.Context, db dbx.Builder) model.ArtistReposi
 }
 
 func roleFilter(_ string, role any) Sqlizer {
-	return NotEq{fmt.Sprintf("stats ->> '$.%v'", role): nil}
+	if role, ok := role.(string); ok {
+		if _, ok := model.AllRoles[role]; ok {
+			return NotEq{fmt.Sprintf("stats ->> '$.%v'", role): nil}
+		}
+	}
+	return Eq{"1": 2}
 }
 
 func (r *artistRepository) selectArtist(options ...model.QueryOptions) SelectBuilder {
@@ -202,7 +208,7 @@ func (r *artistRepository) getIndexKey(a model.Artist) string {
 }
 
 // TODO Cache the index (recalculate when there are changes to the DB)
-func (r *artistRepository) GetIndex(roles ...model.Role) (model.ArtistIndexes, error) {
+func (r *artistRepository) GetIndex(includeMissing bool, roles ...model.Role) (model.ArtistIndexes, error) {
 	options := model.QueryOptions{Sort: "name"}
 	if len(roles) > 0 {
 		roleFilters := slice.Map(roles, func(r model.Role) Sqlizer {
@@ -210,6 +216,13 @@ func (r *artistRepository) GetIndex(roles ...model.Role) (model.ArtistIndexes, e
 		})
 		options.Filters = And(roleFilters)
 	}
+	if !includeMissing {
+		if options.Filters == nil {
+			options.Filters = Eq{"artist.missing": false}
+		} else {
+			options.Filters = And{options.Filters, Eq{"artist.missing": false}}
+		}
+	}
 	artists, err := r.GetAll(options)
 	if err != nil {
 		return nil, err
@@ -236,10 +249,29 @@ func (r *artistRepository) purgeEmpty() error {
 	return nil
 }
 
+// markMissing marks artists as missing if all their albums are missing.
+func (r *artistRepository) markMissing() error {
+	q := Expr(`
+with artists_with_non_missing_albums as (
+    select distinct aa.artist_id
+    from album_artists aa
+    join album a on aa.album_id = a.id
+    where a.missing = false
+)
+update artist
+set missing = (artist.id not in (select artist_id from artists_with_non_missing_albums));
+        `)
+	_, err := r.executeSQL(q)
+	if err != nil {
+		return fmt.Errorf("marking missing artists: %w", err)
+	}
+	return nil
+}
+
 // RefreshPlayCounts updates the play count and last play date annotations for all artists, based
 // on the media files associated with them.
 func (r *artistRepository) RefreshPlayCounts() (int64, error) {
-	query := rawSQL(`
+	query := Expr(`
 with play_counts as (
     select user_id, atom as artist_id, sum(play_count) as total_play_count, max(play_date) as last_play_date
     from media_file
@@ -259,76 +291,123 @@ on conflict (user_id, item_id, item_type) do update
 	return r.executeSQL(query)
 }
 
-// RefreshStats updates the stats field for all artists, based on the media files associated with them.
-// BFR Maybe filter by "touched" artists?
+// RefreshStats updates the stats field for artists whose associated media files were updated after the oldest recorded library scan time.
+// It processes artists in batches to handle potentially large updates.
 func (r *artistRepository) RefreshStats() (int64, error) {
-	// First get all counters, one query groups by artist/role, and another with totals per artist.
-	// Union both queries and group by artist to get a single row of counters per artist/role.
-	// Then format the counters in a JSON object, one key for each role.
-	// Finally update the artist table with the new counters
-	// In all queries, atom is the artist ID and path is the role (or "total" for the totals)
-	query := rawSQL(`
--- CTE to get counters for each artist, grouped by role
-with artist_role_counters as (
-    -- Get counters for each artist, grouped by role
-    -- (remove the index from the role: composer[0] => composer
-    select atom as artist_id,
-           substr(
-                   replace(jt.path, '$.', ''),
-                   1,
-                   case when instr(replace(jt.path, '$.', ''), '[') > 0
-                            then instr(replace(jt.path, '$.', ''), '[') - 1
-                        else length(replace(jt.path, '$.', ''))
-                       end
-           ) as role,
-           count(distinct album_id) as album_count,
-           count(mf.id) as count,
-           sum(size) as size
-    from media_file mf
-             left join json_tree(participants) jt
-    where atom is not null and key = 'id'
-    group by atom, role
-),
+	touchedArtistsQuerySQL := `
+        SELECT DISTINCT mfa.artist_id
+        FROM media_file_artists mfa
+        JOIN media_file mf ON mfa.media_file_id = mf.id
+        WHERE mf.updated_at > (SELECT last_scan_at FROM library ORDER BY last_scan_at ASC LIMIT 1)
+        `
 
--- CTE to get the totals for each artist
-artist_total_counters as (
-	select mfa.artist_id,
-		   'total' as role,
-		   count(distinct mf.album_id) as album_count,
-		   count(distinct mf.id) as count,
-		   sum(mf.size) as size
-	from (select artist_id, media_file_id
-		  from main.media_file_artists) as mfa
-			 join main.media_file mf on mfa.media_file_id = mf.id
-	group by mfa.artist_id
-),
+	var allTouchedArtistIDs []string
+	if err := r.db.NewQuery(touchedArtistsQuerySQL).Column(&allTouchedArtistIDs); err != nil {
+		return 0, fmt.Errorf("fetching touched artist IDs: %w", err)
+	}
 
--- CTE to combine role and total counters
-combined_counters as (
-	select artist_id, role, album_count, count, size
-	from artist_role_counters
-	union
-	select artist_id, role, album_count, count, size
-	from artist_total_counters
-),
+	if len(allTouchedArtistIDs) == 0 {
+		log.Debug(r.ctx, "RefreshStats: No artists to update.")
+		return 0, nil
+	}
+	log.Debug(r.ctx, "RefreshStats: Found artists to update.", "count", len(allTouchedArtistIDs))
 
--- CTE to format the counters in a JSON object
-artist_counters as (
-	select artist_id as id,
-		   json_group_object(
-				   replace(role, '"', ''),
-				   json_object('a', album_count, 'm', count, 's', size)
-		   ) as counters
-	from combined_counters
-	group by artist_id
-)
+	// Template for the batch update with placeholder markers that we'll replace
+	batchUpdateStatsSQL := `
+    WITH artist_role_counters AS (
+        SELECT jt.atom AS artist_id,
+               substr(
+                       replace(jt.path, '$.', ''),
+                       1,
+                       CASE WHEN instr(replace(jt.path, '$.', ''), '[') > 0
+                                THEN instr(replace(jt.path, '$.', ''), '[') - 1
+                            ELSE length(replace(jt.path, '$.', ''))
+                           END
+               ) AS role,
+               count(DISTINCT mf.album_id) AS album_count,
+               count(mf.id) AS count,
+               sum(mf.size) AS size
+        FROM media_file mf
+        JOIN json_tree(mf.participants) jt ON jt.key = 'id' AND jt.atom IS NOT NULL
+        WHERE jt.atom IN (ROLE_IDS_PLACEHOLDER) -- Will replace with actual placeholders
+        GROUP BY jt.atom, role
+    ),
+    artist_total_counters AS (
+        SELECT mfa.artist_id,
+               'total' AS role,
+               count(DISTINCT mf.album_id) AS album_count,
+               count(DISTINCT mf.id) AS count,
+               sum(mf.size) AS size
+        FROM media_file_artists mfa
+        JOIN media_file mf ON mfa.media_file_id = mf.id
+        WHERE mfa.artist_id IN (TOTAL_IDS_PLACEHOLDER) -- Will replace with actual placeholders
+        GROUP BY mfa.artist_id
+    ),
+    combined_counters AS (
+        SELECT artist_id, role, album_count, count, size FROM artist_role_counters
+        UNION
+        SELECT artist_id, role, album_count, count, size FROM artist_total_counters
+    ),
+    artist_counters AS (
+        SELECT artist_id AS id,
+               json_group_object(
+                       replace(role, '"', ''),
+                       json_object('a', album_count, 'm', count, 's', size)
+               ) AS counters
+        FROM combined_counters
+        GROUP BY artist_id
+    )
+    UPDATE artist
+    SET stats = coalesce((SELECT counters FROM artist_counters ac WHERE ac.id = artist.id), '{}'),
+       updated_at = datetime(current_timestamp, 'localtime')
+    WHERE artist.id IN (UPDATE_IDS_PLACEHOLDER) AND artist.id <> '';` // Will replace with actual placeholders
 
--- Update the artist table with the new counters
-update artist
-set stats = coalesce((select counters from artist_counters where artist_counters.id = artist.id), '{}'),
-   updated_at = datetime(current_timestamp, 'localtime')
-where id <> ''; -- always true, to avoid warnings`)
-	return r.executeSQL(query)
+	var totalRowsAffected int64 = 0
+	const batchSize = 1000
+
+	batchCounter := 0
+	for artistIDBatch := range slice.CollectChunks(slices.Values(allTouchedArtistIDs), batchSize) {
+		batchCounter++
+		log.Trace(r.ctx, "RefreshStats: Processing batch", "batchNum", batchCounter, "batchSize", len(artistIDBatch))
+
+		// Create placeholders for each ID in the IN clauses
+		placeholders := make([]string, len(artistIDBatch))
+		for i := range artistIDBatch {
+			placeholders[i] = "?"
+		}
+		// Don't add extra parentheses, the IN clause already expects them in SQL syntax
+		inClause := strings.Join(placeholders, ",")
+
+		// Replace the placeholder markers with actual SQL placeholders
+		batchSQL := strings.Replace(batchUpdateStatsSQL, "ROLE_IDS_PLACEHOLDER", inClause, 1)
+		batchSQL = strings.Replace(batchSQL, "TOTAL_IDS_PLACEHOLDER", inClause, 1)
+		batchSQL = strings.Replace(batchSQL, "UPDATE_IDS_PLACEHOLDER", inClause, 1)
+
+		// Create a single parameter array with all IDs (repeated 3 times for each IN clause)
+		// We need to repeat each ID 3 times (once for each IN clause)
+		var args []interface{}
+		for _, id := range artistIDBatch {
+			args = append(args, id) // For ROLE_IDS_PLACEHOLDER
+		}
+		for _, id := range artistIDBatch {
+			args = append(args, id) // For TOTAL_IDS_PLACEHOLDER
+		}
+		for _, id := range artistIDBatch {
+			args = append(args, id) // For UPDATE_IDS_PLACEHOLDER
+		}
+
+		// Now use Expr with the expanded SQL and all parameters
+		sqlizer := Expr(batchSQL, args...)
+
+		rowsAffected, err := r.executeSQL(sqlizer)
+		if err != nil {
+			return totalRowsAffected, fmt.Errorf("executing batch update for artist stats (batch %d): %w", batchCounter, err)
+		}
+		totalRowsAffected += rowsAffected
+	}
+
+	log.Debug(r.ctx, "RefreshStats: Successfully updated stats.", "totalArtistsProcessed", len(allTouchedArtistIDs), "totalDBRowsAffected", totalRowsAffected)
+	return totalRowsAffected, nil
 }
 
 func (r *artistRepository) Search(q string, offset int, size int, includeMissing bool) (model.Artists, error) {

persistence/artist_repository_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 
+	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/log"
@@ -94,7 +95,7 @@ var _ = Describe("ArtistRepository", func() {
 				er := repo.Put(&artistBeatles)
 				Expect(er).To(BeNil())
 
-				idx, err := repo.GetIndex()
+				idx, err := repo.GetIndex(false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(idx).To(HaveLen(2))
 				Expect(idx[0].ID).To(Equal("F"))
@@ -112,7 +113,7 @@ var _ = Describe("ArtistRepository", func() {
 
 			// BFR Empty SortArtistName is not saved in the DB anymore
 			XIt("returns the index when PreferSortTags is true and SortArtistName is empty", func() {
-				idx, err := repo.GetIndex()
+				idx, err := repo.GetIndex(false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(idx).To(HaveLen(2))
 				Expect(idx[0].ID).To(Equal("B"))
@@ -134,7 +135,7 @@ var _ = Describe("ArtistRepository", func() {
 				er := repo.Put(&artistBeatles)
 				Expect(er).To(BeNil())
 
-				idx, err := repo.GetIndex()
+				idx, err := repo.GetIndex(false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(idx).To(HaveLen(2))
 				Expect(idx[0].ID).To(Equal("B"))
@@ -151,7 +152,7 @@ var _ = Describe("ArtistRepository", func() {
 			})
 
 			It("returns the index when SortArtistName is empty", func() {
-				idx, err := repo.GetIndex()
+				idx, err := repo.GetIndex(false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(idx).To(HaveLen(2))
 				Expect(idx[0].ID).To(Equal("B"))
@@ -233,5 +234,113 @@ var _ = Describe("ArtistRepository", func() {
 				Expect(m).ToNot(HaveKey("mbz_artist_id"))
 			})
 		})
+
+		Describe("Missing artist visibility", func() {
+			var raw *artistRepository
+			var missing model.Artist
+
+			insertMissing := func() {
+				missing = model.Artist{ID: "m1", Name: "Missing", OrderArtistName: "missing"}
+				Expect(repo.Put(&missing)).To(Succeed())
+				raw = repo.(*artistRepository)
+				_, err := raw.executeSQL(squirrel.Update(raw.tableName).Set("missing", true).Where(squirrel.Eq{"id": missing.ID}))
+				Expect(err).ToNot(HaveOccurred())
+			}
+
+			removeMissing := func() {
+				if raw != nil {
+					_, _ = raw.executeSQL(squirrel.Delete(raw.tableName).Where(squirrel.Eq{"id": missing.ID}))
+				}
+			}
+
+			Context("regular user", func() {
+				BeforeEach(func() {
+					ctx := log.NewContext(context.TODO())
+					ctx = request.WithUser(ctx, model.User{ID: "u1"})
+					repo = NewArtistRepository(ctx, GetDBXBuilder())
+					insertMissing()
+				})
+
+				AfterEach(func() { removeMissing() })
+
+				It("does not return missing artist in GetAll", func() {
+					artists, err := repo.GetAll(model.QueryOptions{Filters: squirrel.Eq{"artist.missing": false}})
+					Expect(err).ToNot(HaveOccurred())
+					Expect(artists).To(HaveLen(2))
+				})
+
+				It("does not return missing artist in Search", func() {
+					res, err := repo.Search("missing", 0, 10, false)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(res).To(BeEmpty())
+				})
+
+				It("does not return missing artist in GetIndex", func() {
+					idx, err := repo.GetIndex(false)
+					Expect(err).ToNot(HaveOccurred())
+					// Only 2 artists should be present
+					total := 0
+					for _, ix := range idx {
+						total += len(ix.Artists)
+					}
+					Expect(total).To(Equal(2))
+				})
+			})
+
+			Context("admin user", func() {
+				BeforeEach(func() {
+					ctx := log.NewContext(context.TODO())
+					ctx = request.WithUser(ctx, model.User{ID: "admin", IsAdmin: true})
+					repo = NewArtistRepository(ctx, GetDBXBuilder())
+					insertMissing()
+				})
+
+				AfterEach(func() { removeMissing() })
+
+				It("returns missing artist in GetAll", func() {
+					artists, err := repo.GetAll()
+					Expect(err).ToNot(HaveOccurred())
+					Expect(artists).To(HaveLen(3))
+				})
+
+				It("returns missing artist in Search", func() {
+					res, err := repo.Search("missing", 0, 10, true)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(res).To(HaveLen(1))
+				})
+
+				It("returns missing artist in GetIndex when included", func() {
+					idx, err := repo.GetIndex(true)
+					Expect(err).ToNot(HaveOccurred())
+					total := 0
+					for _, ix := range idx {
+						total += len(ix.Artists)
+					}
+					Expect(total).To(Equal(3))
+				})
+			})
+		})
+	})
+
+	Describe("roleFilter", func() {
+		It("filters out roles not present in the participants model", func() {
+			Expect(roleFilter("", "artist")).To(Equal(squirrel.NotEq{"stats ->> '$.artist'": nil}))
+			Expect(roleFilter("", "albumartist")).To(Equal(squirrel.NotEq{"stats ->> '$.albumartist'": nil}))
+			Expect(roleFilter("", "composer")).To(Equal(squirrel.NotEq{"stats ->> '$.composer'": nil}))
+			Expect(roleFilter("", "conductor")).To(Equal(squirrel.NotEq{"stats ->> '$.conductor'": nil}))
+			Expect(roleFilter("", "lyricist")).To(Equal(squirrel.NotEq{"stats ->> '$.lyricist'": nil}))
+			Expect(roleFilter("", "arranger")).To(Equal(squirrel.NotEq{"stats ->> '$.arranger'": nil}))
+			Expect(roleFilter("", "producer")).To(Equal(squirrel.NotEq{"stats ->> '$.producer'": nil}))
+			Expect(roleFilter("", "director")).To(Equal(squirrel.NotEq{"stats ->> '$.director'": nil}))
+			Expect(roleFilter("", "engineer")).To(Equal(squirrel.NotEq{"stats ->> '$.engineer'": nil}))
+			Expect(roleFilter("", "mixer")).To(Equal(squirrel.NotEq{"stats ->> '$.mixer'": nil}))
+			Expect(roleFilter("", "remixer")).To(Equal(squirrel.NotEq{"stats ->> '$.remixer'": nil}))
+			Expect(roleFilter("", "djmixer")).To(Equal(squirrel.NotEq{"stats ->> '$.djmixer'": nil}))
+			Expect(roleFilter("", "performer")).To(Equal(squirrel.NotEq{"stats ->> '$.performer'": nil}))
+
+			Expect(roleFilter("", "wizard")).To(Equal(squirrel.Eq{"1": 2}))
+			Expect(roleFilter("", "songanddanceman")).To(Equal(squirrel.Eq{"1": 2}))
+			Expect(roleFilter("", "artist') SELECT LIKE(CHAR(65,66,67,68,69,70,71),UPPER(HEX(RANDOMBLOB(500000000/2))))--")).To(Equal(squirrel.Eq{"1": 2}))
+		})
 	})
 })

persistence/helpers.go

@@ -57,14 +57,6 @@ func toCamelCase(str string) string {
 	})
 }
 
-// rawSQL is a string that will be used as is in the SQL query executor
-// It does not support arguments
-type rawSQL string
-
-func (r rawSQL) ToSql() (string, []interface{}, error) {
-	return string(r), nil, nil
-}
-
 func Exists(subTable string, cond squirrel.Sqlizer) existsCond {
 	return existsCond{subTable: subTable, cond: cond, not: false}
 }

persistence/library_repository.go

@@ -136,7 +136,7 @@ func (r *libraryRepository) ScanEnd(id int) error {
 		return err
 	}
 	// https://www.sqlite.org/pragma.html#pragma_optimize
-	_, err = r.executeSQL(rawSQL("PRAGMA optimize=0x10012;"))
+	_, err = r.executeSQL(Expr("PRAGMA optimize=0x10012;"))
 	return err
 }
 

persistence/mediafile_repository.go

@@ -77,7 +77,7 @@ func NewMediaFileRepository(ctx context.Context, db dbx.Builder) model.MediaFile
 		"title":        "order_title",
 		"artist":       "order_artist_name, order_album_name, release_date, disc_number, track_number",
 		"album_artist": "order_album_artist_name, order_album_name, release_date, disc_number, track_number",
-		"album":        "order_album_name, release_date, disc_number, track_number, order_artist_name, title",
+		"album":        "order_album_name, album_id, disc_number, track_number, order_artist_name, title",
 		"random":       "random",
 		"created_at":   "media_file.created_at",
 		"starred_at":   "starred, starred_at",
@@ -87,11 +87,12 @@ func NewMediaFileRepository(ctx context.Context, db dbx.Builder) model.MediaFile
 
 var mediaFileFilter = sync.OnceValue(func() map[string]filterFunc {
 	filters := map[string]filterFunc{
-		"id":       idFilter("media_file"),
-		"title":    fullTextFilter("media_file"),
-		"starred":  booleanFilter,
-		"genre_id": tagIDFilter,
-		"missing":  booleanFilter,
+		"id":         idFilter("media_file"),
+		"title":      fullTextFilter("media_file"),
+		"starred":    booleanFilter,
+		"genre_id":   tagIDFilter,
+		"missing":    booleanFilter,
+		"artists_id": artistFilter,
 	}
 	// Add all album tags as filters
 	for tag := range model.TagMappings() {
@@ -191,6 +192,15 @@ func (r *mediaFileRepository) Delete(id string) error {
 	return r.delete(Eq{"id": id})
 }
 
+func (r *mediaFileRepository) DeleteAllMissing() (int64, error) {
+	user := loggedUser(r.ctx)
+	if !user.IsAdmin {
+		return 0, rest.ErrPermissionDenied
+	}
+	del := Delete(r.tableName).Where(Eq{"missing": true})
+	return r.executeSQL(del)
+}
+
 func (r *mediaFileRepository) DeleteMissing(ids []string) error {
 	user := loggedUser(r.ctx)
 	if !user.IsAdmin {
@@ -242,7 +252,7 @@ func (r *mediaFileRepository) MarkMissingByFolder(missing bool, folderIDs ...str
 
 // GetMissingAndMatching returns all mediafiles that are missing and their potential matches (comparing PIDs)
 // that were added/updated after the last scan started. The result is ordered by PID.
-// It does not need to load bookmarks, annotations and participnts, as they are not used by the scanner.
+// It does not need to load bookmarks, annotations and participants, as they are not used by the scanner.
 func (r *mediaFileRepository) GetMissingAndMatching(libId int) (model.MediaFileCursor, error) {
 	subQ := r.newSelect().Columns("pid").
 		Where(And{

persistence/mediafile_repository_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/id"
@@ -44,14 +45,39 @@ var _ = Describe("MediaRepository", func() {
 
 	It("delete tracks by id", func() {
 		newID := id.NewRandom()
-		Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID})).To(BeNil())
+		Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID})).To(Succeed())
 
-		Expect(mr.Delete(newID)).To(BeNil())
+		Expect(mr.Delete(newID)).To(Succeed())
 
 		_, err := mr.Get(newID)
 		Expect(err).To(MatchError(model.ErrNotFound))
 	})
 
+	It("deletes all missing files", func() {
+		new1 := model.MediaFile{ID: id.NewRandom(), LibraryID: 1}
+		new2 := model.MediaFile{ID: id.NewRandom(), LibraryID: 1}
+		Expect(mr.Put(&new1)).To(Succeed())
+		Expect(mr.Put(&new2)).To(Succeed())
+		Expect(mr.MarkMissing(true, &new1, &new2)).To(Succeed())
+
+		adminCtx := request.WithUser(log.NewContext(context.TODO()), model.User{ID: "userid", IsAdmin: true})
+		adminRepo := NewMediaFileRepository(adminCtx, GetDBXBuilder())
+
+		// Ensure the files are marked as missing and we have 2 of them
+		count, err := adminRepo.CountAll(model.QueryOptions{Filters: squirrel.Eq{"missing": true}})
+		Expect(count).To(BeNumerically("==", 2))
+		Expect(err).ToNot(HaveOccurred())
+
+		count, err = adminRepo.DeleteAllMissing()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(count).To(BeNumerically("==", 2))
+
+		_, err = mr.Get(new1.ID)
+		Expect(err).To(MatchError(model.ErrNotFound))
+		_, err = mr.Get(new2.ID)
+		Expect(err).To(MatchError(model.ErrNotFound))
+	})
+
 	Context("Annotations", func() {
 		It("increments play count when the tracks does not have annotations", func() {
 			id := "incplay.firsttime"

persistence/persistence.go

@@ -170,6 +170,7 @@ func (s *SQLStore) GC(ctx context.Context) error {
 	err := chain.RunSequentially(
 		trace(ctx, "purge empty albums", func() error { return s.Album(ctx).(*albumRepository).purgeEmpty() }),
 		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, "clean album annotations", func() error { return s.Album(ctx).(*albumRepository).cleanAnnotations() }),
 		trace(ctx, "clean artist annotations", func() error { return s.Artist(ctx).(*artistRepository).cleanAnnotations() }),

persistence/sql_base_repository.go

@@ -65,6 +65,11 @@ func loggedUser(ctx context.Context) *model.User {
 	}
 }
 
+func isAdmin(ctx context.Context) bool {
+	user := loggedUser(ctx)
+	return user.IsAdmin
+}
+
 func (r *sqlRepository) registerModel(instance any, filters map[string]filterFunc) {
 	if r.tableName == "" {
 		r.tableName = strings.TrimPrefix(reflect.TypeOf(instance).String(), "*model.")

persistence/tag_repository.go

@@ -60,7 +60,7 @@ where tag.id = updated_values.id;
 `
 	for _, table := range []string{"album", "media_file"} {
 		start := time.Now()
-		query := rawSQL(fmt.Sprintf(template, table))
+		query := Expr(fmt.Sprintf(template, table))
 		c, err := r.executeSQL(query)
 		log.Debug(r.ctx, "Updated tag counts", "table", table, "elapsed", time.Since(start), "updated", c)
 		if err != nil {

persistence/transcoding_repository.go

@@ -41,6 +41,9 @@ func (r *transcodingRepository) FindByFormat(format string) (*model.Transcoding,
 }
 
 func (r *transcodingRepository) Put(t *model.Transcoding) error {
+	if !isAdmin(r.ctx) {
+		return rest.ErrPermissionDenied
+	}
 	_, err := r.put(t.ID, t)
 	return err
 }
@@ -69,6 +72,9 @@ func (r *transcodingRepository) NewInstance() interface{} {
 }
 
 func (r *transcodingRepository) Save(entity interface{}) (string, error) {
+	if !isAdmin(r.ctx) {
+		return "", rest.ErrPermissionDenied
+	}
 	t := entity.(*model.Transcoding)
 	id, err := r.put(t.ID, t)
 	if errors.Is(err, model.ErrNotFound) {
@@ -78,6 +84,9 @@ func (r *transcodingRepository) Save(entity interface{}) (string, error) {
 }
 
 func (r *transcodingRepository) Update(id string, entity interface{}, cols ...string) error {
+	if !isAdmin(r.ctx) {
+		return rest.ErrPermissionDenied
+	}
 	t := entity.(*model.Transcoding)
 	t.ID = id
 	_, err := r.put(id, t)
@@ -88,6 +97,9 @@ func (r *transcodingRepository) Update(id string, entity interface{}, cols ...st
 }
 
 func (r *transcodingRepository) Delete(id string) error {
+	if !isAdmin(r.ctx) {
+		return rest.ErrPermissionDenied
+	}
 	err := r.delete(Eq{"id": id})
 	if errors.Is(err, model.ErrNotFound) {
 		return rest.ErrNotFound

persistence/transcoding_repository_test.go

@@ -0,0 +1,96 @@
+package persistence
+
+import (
+	"github.com/deluan/rest"
+	"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"
+)
+
+var _ = Describe("TranscodingRepository", func() {
+	var repo model.TranscodingRepository
+	var adminRepo model.TranscodingRepository
+
+	BeforeEach(func() {
+		ctx := log.NewContext(GinkgoT().Context())
+		ctx = request.WithUser(ctx, regularUser)
+		repo = NewTranscodingRepository(ctx, GetDBXBuilder())
+
+		adminCtx := log.NewContext(GinkgoT().Context())
+		adminCtx = request.WithUser(adminCtx, adminUser)
+		adminRepo = NewTranscodingRepository(adminCtx, GetDBXBuilder())
+	})
+
+	AfterEach(func() {
+		// Clean up any transcoding created during the tests
+		tc, err := adminRepo.FindByFormat("test_format")
+		if err == nil {
+			err = adminRepo.(*transcodingRepository).Delete(tc.ID)
+			Expect(err).ToNot(HaveOccurred())
+		}
+	})
+
+	Describe("Admin User", func() {
+		It("creates a new transcoding", func() {
+			base, err := adminRepo.CountAll()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = adminRepo.Put(&model.Transcoding{ID: "new", Name: "new", TargetFormat: "test_format", DefaultBitRate: 320, Command: "ffmpeg"})
+			Expect(err).ToNot(HaveOccurred())
+
+			count, err := adminRepo.CountAll()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(count).To(Equal(base + 1))
+		})
+
+		It("updates an existing transcoding", func() {
+			tr := &model.Transcoding{ID: "upd", Name: "old", TargetFormat: "test_format", DefaultBitRate: 100, Command: "ffmpeg"}
+			Expect(adminRepo.Put(tr)).To(Succeed())
+			tr.Name = "updated"
+			err := adminRepo.Put(tr)
+			Expect(err).ToNot(HaveOccurred())
+			res, err := adminRepo.FindByFormat("test_format")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Name).To(Equal("updated"))
+		})
+
+		It("deletes a transcoding", func() {
+			err := adminRepo.Put(&model.Transcoding{ID: "to-delete", Name: "temp", TargetFormat: "test_format", DefaultBitRate: 256, Command: "ffmpeg"})
+			Expect(err).ToNot(HaveOccurred())
+			err = adminRepo.(*transcodingRepository).Delete("to-delete")
+			Expect(err).ToNot(HaveOccurred())
+			_, err = adminRepo.Get("to-delete")
+			Expect(err).To(MatchError(model.ErrNotFound))
+		})
+	})
+
+	Describe("Regular User", func() {
+		It("fails to create", func() {
+			err := repo.Put(&model.Transcoding{ID: "bad", Name: "bad", TargetFormat: "test_format", DefaultBitRate: 64, Command: "ffmpeg"})
+			Expect(err).To(Equal(rest.ErrPermissionDenied))
+		})
+
+		It("fails to update", func() {
+			tr := &model.Transcoding{ID: "updreg", Name: "old", TargetFormat: "test_format", DefaultBitRate: 64, Command: "ffmpeg"}
+			Expect(adminRepo.Put(tr)).To(Succeed())
+
+			tr.Name = "bad"
+			err := repo.Put(tr)
+			Expect(err).To(Equal(rest.ErrPermissionDenied))
+
+			//_ = adminRepo.(*transcodingRepository).Delete("updreg")
+		})
+
+		It("fails to delete", func() {
+			tr := &model.Transcoding{ID: "delreg", Name: "temp", TargetFormat: "test_format", DefaultBitRate: 64, Command: "ffmpeg"}
+			Expect(adminRepo.Put(tr)).To(Succeed())
+
+			err := repo.(*transcodingRepository).Delete("delreg")
+			Expect(err).To(Equal(rest.ErrPermissionDenied))
+
+			//_ = adminRepo.(*transcodingRepository).Delete("delreg")
+		})
+	})
+})

resources/i18n/ca.json

@@ -18,6 +18,9 @@
                 "size": "Mida del fitxer",
                 "updatedAt": "Actualitzat",
                 "bitRate": "Taxa de bits",
+                "bitDepth": "Bits",
+                "sampleRate": "Freqüencia de mostreig",
+                "channels": "Canals",
                 "discSubtitle": "Subtítol del disc",
                 "starred": "Preferit",
                 "comment": "Comentari",
@@ -25,8 +28,13 @@
                 "quality": "Qualitat",
                 "bpm": "tempo",
                 "playDate": "Darrer resproduït",
-                "channels": "Canals",
-                "createdAt": ""
+                "createdAt": "Creat el",
+                "grouping": "Agrupació",
+                "mood": "Sentiment",
+                "participants": "Participants",
+                "tags": "Etiquetes",
+                "mappedTags": "Etiquetes assignades",
+                "rawTags": "Etiquetes sense processar"
             },
             "actions": {
                 "addToQueue": "Reprodueix després",
@@ -46,6 +54,7 @@
                 "duration": "Durada",
                 "songCount": "Cançons",
                 "playCount": "Reproduccions",
+                "size": "Mida",
                 "name": "Nom",
                 "genre": "Gènere",
                 "compilation": "Compilació",
@@ -53,22 +62,28 @@
                 "updatedAt": "Actualitzat ",
                 "comment": "Comentari",
                 "rating": "Valoració",
-                "createdAt": "",
-                "size": "",
-                "originalDate": "",
-                "releaseDate": "",
-                "releases": "",
-                "released": ""
+                "createdAt": "Creat el",
+                "size": "Mida",
+                "originalDate": "Original",
+                "releaseDate": "Publicat",
+                "releases": "LLançament |||| Llançaments",
+                "released": "Publicat",
+                "recordLabel": "Discogràfica",
+                "catalogNum": "Número de catàleg",
+                "releaseType": "Tipus de publicació",
+                "grouping": "Agrupació",
+                "media": "Mitjà",
+                "mood": "Sentiment"
             },
             "actions": {
                 "playAll": "Reprodueix",
                 "playNext": "Reprodueix la següent",
                 "addToQueue": "Reprodueix després",
+                "share": "Compartir",
                 "shuffle": "Aleatori",
                 "addToPlaylist": "Afegeix a la llista",
                 "download": "Descarrega",
-                "info": "Obtén informació",
-                "share": ""
+                "info": "Obtén informació" 
             },
             "lists": {
                 "all": "Tot",
@@ -85,11 +100,27 @@
             "fields": {
                 "name": "Nom",
                 "albumCount": "Nombre d'àlbums",
-                "songCount": "Compte de cançons",
+                "songCount": "Nombre de cançons",
+                "size": "Mida",
                 "playCount": "Reproduccions",
                 "rating": "Valoració",
                 "genre": "Gènere",
-                "size": ""
+                "role": "Rol"
+            },
+            "roles": {
+            "albumartist": "Artista de l'Àlbum |||| Artistes de l'Àlbum",
+            "artist": "Artista |||| Artistes",
+            "composer": "Compositor |||| Compositors",
+            "conductor": "Conductor |||| Conductors",
+            "lyricist": "Lletrista |||| Lletristes",
+            "arranger": "Arranjador |||| Arranjadors",
+            "producer": "Productor |||| Productors",
+            "director": "Director |||| Directors",
+            "engineer": "Enginyer |||| Enginyers",
+            "mixer": "Mesclador |||| Mescladors",
+            "remixer": "Remesclador |||| Remescladors",
+            "djmixer": "DJ Mesclador |||| DJ Mescladors",
+            "performer": "Intèrpret |||| Intèrprets"
             }
         },
         "user": {
@@ -98,6 +129,7 @@
                 "userName": "Nom d'usuari",
                 "isAdmin": "És admin",
                 "lastLoginAt": "Última connexió",
+                "lastAccessAt": "Últim Accés",
                 "updatedAt": "Actualitzat",
                 "name": "Nom",
                 "password": "Contrasenya",
@@ -169,36 +201,53 @@
             }
         },
         "radio": {
-            "name": "",
+            "name": "Ràdio |||| Ràdios",
             "fields": {
-                "name": "",
-                "streamUrl": "",
-                "homePageUrl": "",
-                "updatedAt": "",
-                "createdAt": ""
+                "name": "Nom",
+                "streamUrl": "URL del flux",
+                "homePageUrl": "URL principal",
+                "updatedAt": "Actualitzat",
+                "createdAt": "Creat"
             },
             "actions": {
-                "playNow": ""
+                "playNow": "Reprodueix"
             }
         },
         "share": {
-            "name": "",
+            "name": "Compartir |||| Compartits",
             "fields": {
-                "username": "",
-                "url": "",
-                "description": "",
-                "contents": "",
-                "expiresAt": "",
-                "lastVisitedAt": "",
-                "visitCount": "",
-                "format": "",
-                "maxBitRate": "",
-                "updatedAt": "",
-                "createdAt": "",
-                "downloadable": ""
-            }
-        }
-    },
+                "username": "Compartit per",
+                "url": "URL",
+                "description": "Descripció",
+                "downloadable": "Permet descarregar?",
+                "contents": "Continguts",
+                "expiresAt": "Caduca",
+                "lastVisitedAt": "Última Visita",
+                "visitCount": "Visites",
+                "format": "Format",
+                "maxBitRate": "Taxa de bits màx.",
+                "updatedAt": "Actualitzat",
+                "createdAt": "Creat"
+            },
+            "notifications": {},
+            "actions": {}
+        },
+      "missing": {
+      "name": "Fitxer faltant |||| Fitxers Faltants",
+      "empty": "No falten fitxers",
+      "fields": {
+        "path": "Directori",
+        "size": "Mida",
+        "updatedAt": "Desaparegut"
+      },
+      "actions": {
+        "remove": "Eliminar"
+      },
+      "notifications": {
+        "removed": "Fitxers faltants eliminats"
+      }
+    }
+  },
     "ra": {
         "auth": {
             "welcome1": "Gràcies d'haver instal·lat Navidrome!",
@@ -211,28 +260,30 @@
             "password": "Contrasenya",
             "sign_in": "Inicia sessió",
             "sign_in_error": "L'autenticació ha fallat, torneu-ho a intentar",
-            "logout": "Sortida"
+            "logout": "Sortida",
+            "insightsCollectionNote": "Navidrome recull dades d'us anonimitzades per\najudar a millorar el projecte. Clica [aquí] per a saber-ne\nmés i no participar-hi si no vols"
         },
         "validation": {
-            "invalidChars": "Si us plau, useu solament lletres i nombres",
+            "invalidChars": "Si us plau, useu només lletres i nombres",
             "passwordDoesNotMatch": "Les contrasenyes no coincideixen",
             "required": "Obligatori",
             "minLength": "Ha de tenir, si més no, %{min} caràcters",
-            "maxLength": "Ha de tenir %{max} caràcter o menys",
-            "minValue": "Ha de ser si més no %{min}",
+            "maxLength": "Ha de tenir %{max} caràcters o menys",
+            "minValue": "Ha de ser com a mínim %{min}",
             "maxValue": "Ha de ser %{max} o menys",
             "number": "Ha de ser un nombre",
             "email": "Ha de ser un correu vàlid",
             "oneOf": "Ha de ser un de: %{options}",
             "regex": "Ha de tenir el format (regexp): %{pattern}",
             "unique": "Ha de ser únic",
-            "url": ""
+            "url": "Ha de ser una URL vàlida"
         },
         "action": {
             "add_filter": "Afegeix un filtre",
             "add": "Afegeix",
             "back": "Enrere",
             "bulk_actions": "1 element seleccionat |||| %{smart_count} elements seleccionats",
+            "bulk_actions_mobile": "1 |||| %{smart_count}",
             "cancel": "Cancel·la",
             "clear_input_value": "Neteja el valor",
             "clone": "Clona",
@@ -256,9 +307,8 @@
             "close_menu": "Tanca el menú",
             "unselect": "Anul·la la selecció",
             "skip": "Omet",
-            "bulk_actions_mobile": "",
-            "share": "",
-            "download": ""
+            "share": "Compartir",
+            "download": "Descarregar"
         },
         "boolean": {
             "true": "Sí",
@@ -334,7 +384,7 @@
             "i18n_error": "No ha estat possible carregar les traduccions per a l'idioma indicat",
             "canceled": "Acció cancel·lada",
             "logged_out": "La sessió ha acabat, si us plau reconnecteu",
-            "new_version": "Hi ha una versió nova disponible! Si us plau refresqueu aquesta finestra."
+            "new_version": "Hi ha una versió nova disponible! Si us plau actualitzeu aquesta finestra."
         },
         "toggleFieldsMenu": {
             "columnsToDisplay": "Columnes a mostrar",
@@ -351,29 +401,31 @@
         "noPlaylistsAvailable": "No n'hi ha cap disponible",
         "delete_user_title": "Esborra usuari '%{nom}'",
         "delete_user_content": "Segur que voleu eliminar aquest usuari i les seues dades\n(incloent-hi llistes i preferències)",
+         "remove_missing_title": "Eliminar fitxers faltants",
+        "remove_missing_content": "Segur que vols eliminar els fitxers faltants seleccionats de la base de dades? Això eliminarà permanentment les referències a ells, incloent-hi el nombre de reproduccions i les valoracions.", 
         "notifications_blocked": "Heu blocat les notificacions d'escriptori en les preferències del navegador",
         "notifications_not_available": "El navegador no suporta les notificacions o no heu connectat a Navidrome per https",
         "lastfmLinkSuccess": "Ha reexit la vinculació amb Last.fm i se n'ha activat el seguiment",
         "lastfmLinkFailure": "No ha estat possible la vinculació amb Last.fm",
         "lastfmUnlinkSuccess": "Desvinculat de Last.fm i desactivat el seguiment",
         "lastfmUnlinkFailure": "No s'ha pogut desvincular de Last.fm",
+        "listenBrainzLinkSuccess": "Connectat correctament a ListenBrainz i seguiment activat com a: %{user}",
+        "listenBrainzLinkFailure": "No s'ha pogut connectar a ListenBrainz: %{error}",
+        "listenBrainzUnlinkSuccess": "ListenBrainz desconnectat i seguiment desactivat",
+        "listenBrainzUnlinkFailure": "No s'ha pogut desconnectar de ListenBrainz",
         "openIn": {
             "lastfm": "Obri en Last.fm",
             "musicbrainz": "Obri en MusicBrainz"
         },
         "lastfmLink": "Llegeix més...",
-        "listenBrainzLinkSuccess": "Ha reexit la vinculació amb ListenBrainz i se n'ha activat el seguiment com a usuari: %{user}",
-        "listenBrainzLinkFailure": "No ha estat possible vincular-se a ListenBrainz: %{error}",
-        "listenBrainzUnlinkSuccess": "Desvinculat de ListenBrainz i desactivat el seguiment",
-        "listenBrainzUnlinkFailure": "No s'ha pogut desvincular de ListenBrainz",
-        "downloadOriginalFormat": "",
-        "shareOriginalFormat": "",
-        "shareDialogTitle": "",
-        "shareBatchDialogTitle": "",
-        "shareSuccess": "",
-        "shareFailure": "",
-        "downloadDialogTitle": "",
-        "shareCopyToClipboard": ""
+        "shareOriginalFormat": "Compartir en format original",
+        "shareDialogTitle": "Compartir %{resource} '%{name}'",
+        "shareBatchDialogTitle": "Compartir 1 %{resource} |||| Compartir %{smart_count} %{resource}",
+        "shareCopyToClipboard": "Copiar al porta-retalls: Ctrl+C, Enter",
+        "shareSuccess": "URL copiada al porta-retalls: %{url}",
+        "shareFailure": "Error copiant URL %{url} al porta-retalls",
+        "downloadDialogTitle": "Deascarregar %{resource} '%{name}' (%{size})",
+        "downloadOriginalFormat": "Descarregar en format original"
     },
     "menu": {
         "library": "Discoteca",
@@ -387,14 +439,15 @@
                 "language": "Llengua",
                 "defaultView": "Vista per defecte",
                 "desktop_notifications": "Notificacions d'escriptori",
+                "lastfmNotConfigured": "No s'ha configurat l'API de Last.fm",
                 "lastfmScrobbling": "Activa el seguiment de Last.fm",
                 "listenBrainzScrobbling": "Activa el seguiment de ListenBrainz",
-                "replaygain": "",
-                "preAmp": "",
+                "replaygain": "Mode ReplayGain",
+                "preAmp": "PreAmp de ReplayGain (dB)",
                 "gain": {
-                    "none": "",
-                    "album": "",
-                    "track": ""
+                    "none": "Cap",
+                    "album": "Guany de l'àlbum",
+                    "track": "Guany de la pista"
                 }
             }
         },
@@ -432,7 +485,12 @@
         "links": {
             "homepage": "Inici",
             "source": "Codi font",
-            "featureRequests": "Sol·licitud de funcionalitats"
+            "featureRequests": "Sol·licitud de funcionalitats",
+            "lastInsightsCollection": "Última recolecció d'informació",
+            "insights": {
+                "disabled": "Desactivada",
+                "waiting": "Esperant"
+            }
         }
     },
     "activity": {
@@ -454,7 +512,7 @@
             "vol_up": "Apuja el volum",
             "vol_down": "Abaixa el volum",
             "toggle_love": "Afegeix la pista a favorits",
-            "current_song": ""
+            "current_song": "Anar a la cançó actual"
         }
     }
-}
+}

resources/i18n/de.json

@@ -32,12 +32,15 @@
         "participants": "Weitere Beteiligte",
         "tags": "Weitere Tags",
         "mappedTags": "Gemappte Tags",
-        "rawTags": "Tag Rohdaten"
+        "rawTags": "Tag Rohdaten",
+        "bitDepth": "Bittiefe",
+        "sampleRate": "Samplerate",
+        "missing": "Fehlend"
       },
       "actions": {
         "addToQueue": "Später abspielen",
         "playNow": "Jetzt abspielen",
-        "addToPlaylist": "Zur Playlist hinzufügen",
+        "addToPlaylist": "Zu einer Wiedergabeliste hinzufügen",
         "shuffleAll": "Zufallswiedergabe",
         "download": "Herunterladen",
         "playNext": "Als nächstes abspielen",
@@ -70,14 +73,16 @@
         "releaseType": "Typ",
         "grouping": "Gruppierung",
         "media": "Medium",
-        "mood": "Stimmung"
+        "mood": "Stimmung",
+        "date": "Aufnahmedatum",
+        "missing": "Fehlend"
       },
       "actions": {
         "playAll": "Abspielen",
         "playNext": "Als nächstes abspielen",
         "addToQueue": "Später abspielen",
         "shuffle": "Zufallswiedergabe",
-        "addToPlaylist": "Zur Playlist hinzufügen",
+        "addToPlaylist": "Zu einer Wiedergabeliste hinzufügen",
         "download": "Herunterladen",
         "info": "Mehr Informationen",
         "share": "Freigabe erstellen"
@@ -102,7 +107,8 @@
         "rating": "Bewertung",
         "genre": "Genre",
         "size": "Größe",
-        "role": "Rolle"
+        "role": "Rolle",
+        "missing": "Fehlend"
       },
       "roles": {
         "albumartist": "Albuminterpret |||| Albuminterpreten",
@@ -172,7 +178,7 @@
       }
     },
     "playlist": {
-      "name": "Playlist |||| Playlists",
+      "name": "Wiedergabeliste |||| Wiedergabelisten",
       "fields": {
         "name": "Name",
         "duration": "Dauer",
@@ -186,11 +192,12 @@
         "path": "Importieren aus"
       },
       "actions": {
-        "selectPlaylist": "Titel zur Playlist hinzufügen",
+        "selectPlaylist": "Wiedergabeliste auswählen:",
         "addNewPlaylist": "\"%{name}\" erstellen",
         "export": "Exportieren",
         "makePublic": "Öffentlich machen",
-        "makePrivate": "Privat stellen"
+        "makePrivate": "Privat stellen",
+        "saveQueue": "Warteschlange in Wiedergabeliste speichern"
       },
       "message": {
         "duplicate_song": "Duplikate hinzufügen",
@@ -235,11 +242,13 @@
         "updatedAt": "Fehlt seit"
       },
       "actions": {
-        "remove": "Entfernen"
+        "remove": "Entfernen",
+        "remove_all": "alle entfernen"
       },
       "notifications": {
         "removed": "Fehlende Datei(en) entfernt"
-      }
+      },
+      "empty": "keine fehlenden Dateien"
     }
   },
   "ra": {
@@ -391,10 +400,10 @@
     "note": "HINWEIS",
     "transcodingDisabled": "Die Änderung der Transcodierungskonfiguration über die Web-UI ist aus Sicherheitsgründen deaktiviert. Wenn du die Transcodierungsoptionen ändern (bearbeiten oder hinzufügen) möchtest, starte den Server mit der Konfigurationsoption %{config} neu.",
     "transcodingEnabled": "Navidrome läuft derzeit mit %{config}, wodurch es möglich ist, Systembefehle aus den Transkodierungseinstellungen über die Webschnittstelle auszuführen. Wir empfehlen, es aus Sicherheitsgründen zu deaktivieren und nur bei der Konfiguration von Transkodierungsoptionen zu aktivieren.",
-    "songsAddedToPlaylist": "Einen Titel zur Playlist hinzugefügt |||| %{smart_count} Titel zur Playlist hinzugefügt",
-    "noPlaylistsAvailable": "Keine Playlist verfügbar",
+    "songsAddedToPlaylist": "Einen Titel zur Wiedergabeliste hinzugefügt |||| %{smart_count} Titel zur Wiedergabeliste hinzugefügt",
+    "noPlaylistsAvailable": "Keine Wiedergabeliste verfügbar",
     "delete_user_title": "Benutzer '%{name}' löschen",
-    "delete_user_content": "Möchtest du diesen Benutzer und alle seine Daten (einschließlich Playlisten und Einstellungen) wirklich löschen?",
+    "delete_user_content": "Möchtest du diesen Benutzer und alle seine Daten (einschließlich Wiedergabelisten und Einstellungen) wirklich löschen?",
     "notifications_blocked": "Sie haben Benachrichtigungen für diese Seite in den Einstellungen Ihres Browsers blockiert",
     "notifications_not_available": "Dieser Browser unterstützt keine Desktop-Benachrichtigungen",
     "lastfmLinkSuccess": "Last.fm Verbindung hergestellt und scrobbling aktiviert",
@@ -419,7 +428,9 @@
     "downloadDialogTitle": "Download %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "In Zwischenablage kopieren: Ctrl+C, Enter",
     "remove_missing_title": "Fehlende Dateien entfernen",
-    "remove_missing_content": "Möchtest du die ausgewählten Fehlenden Dateien wirklich aus der Datenbank entfernen? Alle Referenzen zu den Dateien wie Anzahl Wiedergaben und Bewertungen werden permanent gelöscht."
+    "remove_missing_content": "Möchtest du die ausgewählten Fehlenden Dateien wirklich aus der Datenbank entfernen? Alle Referenzen zu den Dateien wie Anzahl Wiedergaben und Bewertungen werden permanent gelöscht.",
+    "remove_all_missing_title": "Alle fehlenden Dateien entfernen",
+    "remove_all_missing_content": "Möchtest du wirklich alle Fehlenden Dateien aus der Datenbank entfernen? Alle Referenzen zu den Dateien wie Anzahl Wiedergaben und Bewertungen werden permanent gelöscht."
   },
   "menu": {
     "library": "Bibliothek",
@@ -447,8 +458,8 @@
     },
     "albumList": "Alben",
     "about": "Über",
-    "playlists": "Playlisten",
-    "sharedPlaylists": "Geteilte Playlisten"
+    "playlists": "Wiedergabelisten",
+    "sharedPlaylists": "Geteilte Wiedergabelisten"
   },
   "player": {
     "playListsText": "Wiedergabeliste abspielen",
@@ -493,7 +504,10 @@
     "quickScan": "Schneller Scan",
     "fullScan": "Kompletter Scan",
     "serverUptime": "Server-Betriebszeit",
-    "serverDown": "OFFLINE"
+    "serverDown": "OFFLINE",
+    "scanType": "Typ",
+    "status": "Scan Fehler",
+    "elapsedTime": "Laufzeit"
   },
   "help": {
     "title": "Navidrome Hotkeys",

resources/i18n/el.json

@@ -33,7 +33,9 @@
         "tags": "Πρόσθετες Ετικέτες",
         "mappedTags": "Χαρτογραφημένες ετικέτες",
         "rawTags": "Ακατέργαστες ετικέτες",
-        "bitDepth": "Λίγο βάθος"
+        "bitDepth": "Λίγο βάθος",
+        "sampleRate": "Ποσοστό δειγματοληψίας",
+        "missing": "Απών"
       },
       "actions": {
         "addToQueue": "Αναπαραγωγη Μετα",
@@ -72,7 +74,8 @@
         "grouping": "Ομαδοποίηση",
         "media": "Μέσα",
         "mood": "Διάθεση",
-        "date": "Ημερομηνία Ηχογράφησης"
+        "date": "Ημερομηνία Ηχογράφησης",
+        "missing": "Απών"
       },
       "actions": {
         "playAll": "Αναπαραγωγή",
@@ -104,7 +107,8 @@
         "rating": "Βαθμολογια",
         "genre": "Είδος",
         "size": "Μέγεθος",
-        "role": "Ρόλος"
+        "role": "Ρόλος",
+        "missing": "Απών"
       },
       "roles": {
         "albumartist": "Καλλιτέχνης Άλμπουμ |||| Καλλιτέχνες άλμπουμ",
@@ -132,7 +136,7 @@
         "name": "Όνομα",
         "password": "Κωδικός Πρόσβασης",
         "createdAt": "Δημιουργήθηκε στις",
-        "changePassword": "Αλλαγή Κωδικού Πρόσβασης;",
+        "changePassword": "Αλλαγή Κωδικού Πρόσβασης?",
         "currentPassword": "Υπάρχων Κωδικός Πρόσβασης",
         "newPassword": "Νέος Κωδικός Πρόσβασης",
         "token": "Token",
@@ -192,11 +196,12 @@
         "addNewPlaylist": "Δημιουργία \"%{name}\"",
         "export": "Εξαγωγη",
         "makePublic": "Να γίνει δημόσιο",
-        "makePrivate": "Να γίνει ιδιωτικό"
+        "makePrivate": "Να γίνει ιδιωτικό",
+        "saveQueue": "Αποθήκευση ουράς στη λίστα αναπαραγωγής"
       },
       "message": {
         "duplicate_song": "Προσθήκη διπλοεγγραφών τραγουδιών",
-        "song_exist": "Υπάρχουν διπλοεγγραφές στην λίστα αναπαραγωγής. Θέλετε να προστεθούν οι διπλοεγγραφές ή να τις παραβλέψετε;"
+        "song_exist": "Υπάρχουν διπλοεγγραφές στην λίστα αναπαραγωγής. Θέλετε να προστεθούν οι διπλοεγγραφές ή να τις παραβλέψετε?"
       }
     },
     "radio": {
@@ -237,7 +242,8 @@
         "updatedAt": "Εξαφανίστηκε"
       },
       "actions": {
-        "remove": "Αφαίρεση"
+        "remove": "Αφαίρεση",
+        "remove_all": "Αφαίρεση όλων"
       },
       "notifications": {
         "removed": "Λείπει αρχείο(α) αφαιρέθηκε"
@@ -305,7 +311,7 @@
       "skip": "Παράβλεψη",
       "bulk_actions_mobile": "1 |||| %{smart_count}",
       "share": "Κοινοποίηση",
-      "download": "Λήψη "
+      "download": "Λήψη"
     },
     "boolean": {
       "true": "Ναι",
@@ -344,10 +350,10 @@
     },
     "message": {
       "about": "Σχετικά",
-      "are_you_sure": "Είστε σίγουροι;",
-      "bulk_delete_content": "Είστε σίγουροι πως θέλετε να διαγράψετε το %{name}; |||| Είστε σίγουροι πως θέλετε να διαγράψετε τα %{smart_count};",
+      "are_you_sure": "Είστε σίγουροι?",
+      "bulk_delete_content": "Είστε σίγουροι πως θέλετε να διαγράψετε το %{name}? |||| Είστε σίγουροι πως θέλετε να διαγράψετε τα %{smart_count}?",
       "bulk_delete_title": "Διαγραφή του %{name} |||| Διαγραφή του %{smart_count} %{name}",
-      "delete_content": "Είστε σίγουροι πως θέλετε να διαγράψετε αυτό το αντικείμενο;",
+      "delete_content": "Είστε σίγουροι πως θέλετε να διαγράψετε αυτό το αντικείμενο?",
       "delete_title": "Διαγραφή του %{name} #%{id}",
       "details": "Λεπτομέρειες",
       "error": "Παρουσιάστηκε ένα πρόβλημα από τη μεριά του πελάτη και το αίτημα σας δεν μπορεί να ολοκληρωθεί.",
@@ -356,12 +362,12 @@
       "no": "Όχι",
       "not_found": "Είτε έχετε εισάγει λανθασμένο URL, είτε ακολουθήσατε έναν υπερσύνδεσμο που δεν ισχύει.",
       "yes": "Ναι",
-      "unsaved_changes": "Μερικές από τις αλλαγές σας δεν έχουν αποθηκευτεί. Είστε σίγουροι πως θέλετε να τις αγνοήσετε;"
+      "unsaved_changes": "Μερικές από τις αλλαγές σας δεν έχουν αποθηκευτεί. Είστε σίγουροι πως θέλετε να τις αγνοήσετε?"
     },
     "navigation": {
       "no_results": "Δεν βρέθηκαν αποτελέσματα",
       "no_more_results": "Η σελίδα %{page} είναι εκτός ορίων. Δοκιμάστε την προηγούμενη σελίδα.",
-      "page_out_of_boundaries": "Η σελίδα {page} είναι εκτός ορίων",
+      "page_out_of_boundaries": "Η σελίδα %{page} είναι εκτός ορίων",
       "page_out_from_end": "Δεν είναι δυνατή η πλοήγηση πέραν της τελευταίας σελίδας",
       "page_out_from_begin": "Δεν είναι δυνατή η πλοήγηση πριν τη σελίδα 1",
       "page_range_info": "%{offsetBegin}-%{offsetEnd} από %{total}",
@@ -397,7 +403,7 @@
     "songsAddedToPlaylist": "Προστέθηκε 1 τραγούδι στη λίστα αναπαραγωγής |||| Προστέθηκαν %{smart_count} τραγούδια στη λίστα αναπαραγωγής",
     "noPlaylistsAvailable": "Κανένα διαθέσιμο",
     "delete_user_title": "Διαγραφή του χρήστη '%{name}'",
-    "delete_user_content": "Είστε σίγουροι πως θέλετε να διαγράψετε αυτό το χρήστη και όλα τα δεδομένα του (συμπεριλαμβανομένων των λιστών αναπαραγωγής και προτιμήσεων);",
+    "delete_user_content": "Είστε σίγουροι πως θέλετε να διαγράψετε αυτό το χρήστη και όλα τα δεδομένα του (συμπεριλαμβανομένων των λιστών αναπαραγωγής και προτιμήσεων)?",
     "notifications_blocked": "Έχετε μπλοκάρει τις Ειδοποιήσεις από τη σελίδα, μέσω των ρυθμίσεων του περιηγητή ιστού σας",
     "notifications_not_available": "Αυτός ο περιηγητής ιστού δεν υποστηρίζει ειδοποιήσεις στην επιφάνεια εργασίας ή δεν έχετε πρόσβαση στο Navidrome μέσω https",
     "lastfmLinkSuccess": "Το Last.fm έχει διασυνδεθεί επιτυχώς και η λειτουργία scrobbling ενεργοποιήθηκε",
@@ -422,7 +428,9 @@
     "downloadDialogTitle": "Λήψη %{resource} '%{name}'(%{size})",
     "shareCopyToClipboard": "Αντιγραφή στο πρόχειρο: Ctrl+C, Enter",
     "remove_missing_title": "Αφαιρέστε τα αρχεία που λείπουν",
-    "remove_missing_content": "Είστε βέβαιοι ότι θέλετε να αφαιρέσετε τα επιλεγμένα αρχεία που λείπουν από τη βάση δεδομένων; Αυτό θα καταργήσει οριστικά τυχόν αναφορές σε αυτά, συμπεριλαμβανομένων των αριθμών παιχνιδιών και των αξιολογήσεών τους."
+    "remove_missing_content": "Είστε βέβαιοι ότι θέλετε να αφαιρέσετε τα επιλεγμένα αρχεία που λείπουν από τη βάση δεδομένων? Αυτό θα καταργήσει οριστικά τυχόν αναφορές σε αυτά, συμπεριλαμβανομένων των αριθμών παιχνιδιών και των αξιολογήσεών τους.",
+    "remove_all_missing_title": "Αφαίρεση όλων των αρχείων που λείπουν",
+    "remove_all_missing_content": "Είστε βέβαιοι ότι θέλετε να καταργήσετε όλα τα αρχεία που λείπουν από τη βάση δεδομένων? Αυτό θα καταργήσει οριστικά τυχόν αναφορές σε αυτά, συμπεριλαμβανομένου του αριθμού αναπαραγωγών και των αξιολογήσεών τους."
   },
   "menu": {
     "library": "Βιβλιοθήκη",
@@ -496,7 +504,10 @@
     "quickScan": "Γρήγορη Σάρωση",
     "fullScan": "Πλήρης Σάρωση",
     "serverUptime": "Λειτουργία Διακομιστή",
-    "serverDown": "ΕΚΤΟΣ ΣΥΝΔΕΣΗΣ"
+    "serverDown": "ΕΚΤΟΣ ΣΥΝΔΕΣΗΣ",
+    "scanType": "Τύπος",
+    "status": "Σφάλμα σάρωσης",
+    "elapsedTime": "Χρόνος που πέρασε"
   },
   "help": {
     "title": "Συντομεύσεις του Navidrome",

resources/i18n/eo.json

@@ -24,16 +24,18 @@
         "rating": "Takso",
         "quality": "Kvalito",
         "bpm": "Pulsrapideco",
-        "playDate": "",
-        "channels": "",
-        "createdAt": "",
+        "playDate": "Laste Ludita",
+        "channels": "Kanaloj",
+        "createdAt": "Dato de aligo",
         "grouping": "",
-        "mood": "",
+        "mood": "Humoro",
         "participants": "",
-        "tags": "",
-        "mappedTags": "",
-        "rawTags": "",
-        "bitDepth": ""
+        "tags": "Aldonaj Etikedoj",
+        "mappedTags": "Mapigitaj etikedoj",
+        "rawTags": "Krudaj etikedoj",
+        "bitDepth": "",
+        "sampleRate": "",
+        "missing": ""
       },
       "actions": {
         "addToQueue": "Ludi Poste",
@@ -42,7 +44,7 @@
         "shuffleAll": "Miksu Ĉiujn",
         "download": "Elŝuti",
         "playNext": "Ludu Poste",
-        "info": ""
+        "info": "Akiri Informon"
       }
     },
     "album": {
@@ -60,19 +62,20 @@
         "updatedAt": "Ĝisdatigita je :",
         "comment": "Komento",
         "rating": "Takso",
-        "createdAt": "",
-        "size": "",
-        "originalDate": "",
-        "releaseDate": "",
-        "releases": "",
-        "released": "",
+        "createdAt": "Dato aldonita",
+        "size": "Grando",
+        "originalDate": "Originala",
+        "releaseDate": "Publikiĝis",
+        "releases": "Publikiĝo |||| Publikiĝoj",
+        "released": "Publikiĝis",
         "recordLabel": "",
         "catalogNum": "",
-        "releaseType": "",
+        "releaseType": "Tipo",
         "grouping": "",
         "media": "",
-        "mood": "",
-        "date": ""
+        "mood": "Humoro",
+        "date": "",
+        "missing": ""
       },
       "actions": {
         "playAll": "Ludi",
@@ -81,43 +84,44 @@
         "shuffle": "Miksi",
         "addToPlaylist": "Aldoni al la Ludlisto",
         "download": "Elŝuti",
-        "info": "",
-        "share": ""
+        "info": "Akiri Informon",
+        "share": "Diskonigi"
       },
       "lists": {
         "all": "Ĉiuj",
-        "random": "Hazarda",
-        "recentlyAdded": "Lastatempe Aldonita",
-        "recentlyPlayed": "Lastatempe Ludita",
+        "random": "Hazardaj",
+        "recentlyAdded": "Lastatempe Aldonitaj",
+        "recentlyPlayed": "Lastatempe Luditaj",
         "mostPlayed": "Plej Luditaj",
-        "starred": "Stelplena",
-        "topRated": "Plej Alte Taksite"
+        "starred": "Stelplenaj",
+        "topRated": "Plej Alte Taksitaj"
       }
     },
     "artist": {
       "name": "Artisto |||| Artistoj",
       "fields": {
         "name": "Nomo",
-        "albumCount": "Nombro da albumoj",
-        "songCount": "Kanto kalkula",
-        "playCount": "Teatraĵoj",
+        "albumCount": "Kvanto da Albumoj",
+        "songCount": "Kanta Kalkulo",
+        "playCount": "Ludoj",
         "rating": "Takso",
-        "genre": "",
-        "size": "",
-        "role": ""
+        "genre": "Ĝenro",
+        "size": "Grando",
+        "role": "",
+        "missing": ""
       },
       "roles": {
-        "albumartist": "",
-        "artist": "",
-        "composer": "",
-        "conductor": "",
-        "lyricist": "",
-        "arranger": "",
+        "albumartist": "Albuma Artisto |||| Albumaj Artistoj",
+        "artist": "Artisto |||| Artistoj",
+        "composer": "Komponisto |||| Komponistoj",
+        "conductor": "Dirigento |||| Dirigentoj",
+        "lyricist": "Kantoteksisto |||| Kantotekstistoj",
+        "arranger": "Aranĝisto |||| Aranĝistoj",
         "producer": "",
         "director": "",
         "engineer": "",
-        "mixer": "",
-        "remixer": "",
+        "mixer": "Miksisto |||| Miksistoj",
+        "remixer": "Remiksisto |||| Remiksistoj",
         "djmixer": "",
         "performer": ""
       }
@@ -135,8 +139,8 @@
         "changePassword": "Ĉu Ŝanĝi Pasvorton?",
         "currentPassword": "Nuna Pasvorto",
         "newPassword": "Nova Pasvorto",
-        "token": "",
-        "lastAccessAt": ""
+        "token": "Ĵetono",
+        "lastAccessAt": "Lasta Atingo"
       },
       "helperTexts": {
         "name": "Ŝanĝoj de via nomo nur ĝisdatiĝs je via sekvanta ensaluto"
@@ -147,8 +151,8 @@
         "deleted": "Uzanto forigita"
       },
       "message": {
-        "listenBrainzToken": "",
-        "clickHereForToken": ""
+        "listenBrainzToken": "Enigi vian uzantan ĵetonon de ListenBrainz.",
+        "clickHereForToken": "Alkakli ĉi tie por akiri vian ĵetonon"
       }
     },
     "player": {
@@ -161,7 +165,7 @@
         "userName": "Uzantnomo",
         "lastSeen": "Laste Vidita Je",
         "reportRealPath": "Raporti vera pado",
-        "scrobbleEnabled": ""
+        "scrobbleEnabled": "Sendi Scrobbles al eksteraj servoj"
       }
     },
     "transcoding": {
@@ -191,8 +195,9 @@
         "selectPlaylist": "Elektu ludliston :",
         "addNewPlaylist": "Krei \"%{name}\"",
         "export": "Eksporti",
-        "makePublic": "",
-        "makePrivate": ""
+        "makePublic": "Publikigi",
+        "makePrivate": "Malpublikigi",
+        "saveQueue": ""
       },
       "message": {
         "duplicate_song": "Aldoni duobligitajn kantojn",
@@ -200,33 +205,33 @@
       }
     },
     "radio": {
-      "name": "",
+      "name": "Radio |||| Radioj",
       "fields": {
-        "name": "",
-        "streamUrl": "",
-        "homePageUrl": "",
-        "updatedAt": "",
-        "createdAt": ""
+        "name": "Nomo",
+        "streamUrl": "Flua Ligilo",
+        "homePageUrl": "Hejmpaĝa Ligilo",
+        "updatedAt": "Ĝisdatiĝis je",
+        "createdAt": "Kreiĝis je"
       },
       "actions": {
-        "playNow": ""
+        "playNow": "Ludi Nun"
       }
     },
     "share": {
-      "name": "",
+      "name": "Diskonigo |||| Diskonigoj",
       "fields": {
-        "username": "",
-        "url": "",
-        "description": "",
-        "contents": "",
-        "expiresAt": "",
-        "lastVisitedAt": "",
-        "visitCount": "",
-        "format": "",
-        "maxBitRate": "",
-        "updatedAt": "",
-        "createdAt": "",
-        "downloadable": ""
+        "username": "Diskonigite De",
+        "url": "Ligilo",
+        "description": "Priskribo",
+        "contents": "Enhavo",
+        "expiresAt": "Senvalidiĝas",
+        "lastVisitedAt": "Laste Vizitita",
+        "visitCount": "Vizitoj",
+        "format": "Formato",
+        "maxBitRate": "Maks. Bitrapido",
+        "updatedAt": "Ĝisdatiĝis je",
+        "createdAt": "Fariĝis je",
+        "downloadable": "Ĉu Ebligi Elŝutojn?"
       }
     },
     "missing": {
@@ -237,7 +242,8 @@
         "updatedAt": ""
       },
       "actions": {
-        "remove": ""
+        "remove": "",
+        "remove_all": ""
       },
       "notifications": {
         "removed": ""
@@ -258,7 +264,7 @@
       "sign_in": "Ensaluti",
       "sign_in_error": "Aŭtentikigo malsukcesis, bonvolu reprovi",
       "logout": "Elsaluti",
-      "insightsCollectionNote": ""
+      "insightsCollectionNote": "Navidrome kolektas anoniman uzdatumon por helpi\nplibonigi la projekton. Alklaku [ĉi tie] por lerni pli kaj\nsupozi permeson se vi volas"
     },
     "validation": {
       "invalidChars": "Bonvolu uzi nur literojn kaj ciferojn",
@@ -273,7 +279,7 @@
       "oneOf": "Devas esti unu el: %{options}",
       "regex": "Devas kongrui kun specifa formato (regexp): %{pattern}",
       "unique": "Devas esti unika",
-      "url": ""
+      "url": "Devas esti valida ligilo"
     },
     "action": {
       "add_filter": "Aldoni filtrilon",
@@ -303,9 +309,9 @@
       "close_menu": "Fermu menuon",
       "unselect": "Malelekti",
       "skip": "Pasigi",
-      "bulk_actions_mobile": "",
-      "share": "",
-      "download": ""
+      "bulk_actions_mobile": "1 |||| %{smart_count}",
+      "share": "Diskonigi",
+      "download": "Elŝuti"
     },
     "boolean": {
       "true": "Jes",
@@ -381,13 +387,13 @@
       "i18n_error": "Ne eblas ŝargi la tradukojn por la specifa lingvo",
       "canceled": "Ago nuligita",
       "logged_out": "Via seanco finiĝis, bonvolu rekonekti.",
-      "new_version": ""
+      "new_version": "Nova versio haveblas! Bonvolu reŝargi la fenestron."
     },
     "toggleFieldsMenu": {
-      "columnsToDisplay": "",
+      "columnsToDisplay": "Kolumnoj Por Montri",
       "layout": "Aranĝo",
       "grid": "Krado",
-      "table": ""
+      "table": "Tabelo"
     }
   },
   "message": {
@@ -400,29 +406,31 @@
     "delete_user_content": "Ĉu vi certas, ke vi volas forigi ĉi tiun uzanton kaj ĉiujn iliajn datumojn (inkluzive ludlistojn kaj preferojn) ?",
     "notifications_blocked": "Vi blokis sciigojn por ĉi tiu retejo en la agordoj de via retumilo",
     "notifications_not_available": "Ĉi tiu retumilo ne subtenas labortablajn sciigojn aŭ vi ne aliras Navidrome per https",
-    "lastfmLinkSuccess": "",
-    "lastfmLinkFailure": "",
-    "lastfmUnlinkSuccess": "",
-    "lastfmUnlinkFailure": "",
+    "lastfmLinkSuccess": "Last.fm sukcese ligiĝis kaj scrobbling ebliĝis",
+    "lastfmLinkFailure": "Last.fm ne povis ligiĝi",
+    "lastfmUnlinkSuccess": "Last.fm malligiĝis kaj scrobbling malebliĝis",
+    "lastfmUnlinkFailure": "Last.fm ne povis malligiĝi",
     "openIn": {
-      "lastfm": "",
-      "musicbrainz": ""
+      "lastfm": "Malfermi en Last.fm",
+      "musicbrainz": "Malfermi en MusicBrainz"
     },
-    "lastfmLink": "",
-    "listenBrainzLinkSuccess": "",
-    "listenBrainzLinkFailure": "",
-    "listenBrainzUnlinkSuccess": "",
-    "listenBrainzUnlinkFailure": "",
-    "downloadOriginalFormat": "",
-    "shareOriginalFormat": "",
-    "shareDialogTitle": "",
-    "shareBatchDialogTitle": "",
-    "shareSuccess": "",
-    "shareFailure": "",
-    "downloadDialogTitle": "",
-    "shareCopyToClipboard": "",
+    "lastfmLink": "Legi Pli...",
+    "listenBrainzLinkSuccess": "ListenBrainz sukcese ligiĝis kaj scrobbling ebliĝis kiel uzanto: %{user}",
+    "listenBrainzLinkFailure": "ListenBrainz ne povis ligiĝi: %{error}",
+    "listenBrainzUnlinkSuccess": "ListenBrainz malligiĝis kaj scrobbling malebliĝis",
+    "listenBrainzUnlinkFailure": "ListenBrainz ne povis malligiĝi",
+    "downloadOriginalFormat": "Elŝuti en originala formato",
+    "shareOriginalFormat": "Diskonigi en originala formato",
+    "shareDialogTitle": "Diskonigi %{resource} '%{name}'",
+    "shareBatchDialogTitle": "Diskonigi 1 %{resource} |||| Diskonigi %{smart_count} %{resource}",
+    "shareSuccess": "Ligilo kopiiĝis al la tondujo: %{url}",
+    "shareFailure": "Eraro de kopio de ligilo %{url} al la tondujo",
+    "downloadDialogTitle": "Elŝuti %{resource} '%{name}' (%{size})",
+    "shareCopyToClipboard": "Kopii al la tondujo: Ctrl+C, Enter",
     "remove_missing_title": "",
-    "remove_missing_content": ""
+    "remove_missing_content": "Ĉu vi certas, ke vi volas forigi la elektitajn mankajn dosierojn de la datumbazo? Ĉi tio forigos eterne ĉiujn referencojn de ili, inkluzive iliajn ludkvantojn kaj taksojn.",
+    "remove_all_missing_title": "",
+    "remove_all_missing_content": ""
   },
   "menu": {
     "library": "Biblioteko",
@@ -436,22 +444,22 @@
         "language": "Lingvo",
         "defaultView": "Defaŭlta Vido",
         "desktop_notifications": "Labortablaj sciigoj",
-        "lastfmScrobbling": "",
-        "listenBrainzScrobbling": "",
-        "replaygain": "",
-        "preAmp": "",
+        "lastfmScrobbling": "Scrobble al Last.fm",
+        "listenBrainzScrobbling": "Scrobble al ListenBrainz",
+        "replaygain": "ReplayGain-Reĝimo",
+        "preAmp": "ReplayGain PreAmp (dB)",
         "gain": {
-          "none": "",
-          "album": "",
-          "track": ""
+          "none": "Malebligita",
+          "album": "Uzi Albuman Songajnon",
+          "track": "Uzi Kantan Songajnon"
         },
         "lastfmNotConfigured": ""
       }
     },
     "albumList": "Albumoj",
     "about": "Pri",
-    "playlists": "",
-    "sharedPlaylists": ""
+    "playlists": "Ludlistoj",
+    "sharedPlaylists": "Diskonigitaj Ludistoj"
   },
   "player": {
     "playListsText": "Atendovico",
@@ -485,7 +493,7 @@
       "featureRequests": "Trajta peto",
       "lastInsightsCollection": "",
       "insights": {
-        "disabled": "",
+        "disabled": "Malebligita",
         "waiting": ""
       }
     }
@@ -496,7 +504,10 @@
     "quickScan": "Rapida Skanado",
     "fullScan": "Plena Skanado",
     "serverUptime": "Servila daŭro de funkciado",
-    "serverDown": "SENKONEKTA"
+    "serverDown": "SENKONEKTA",
+    "scanType": "",
+    "status": "",
+    "elapsedTime": ""
   },
   "help": {
     "title": "Navidrome klavkomando",
@@ -509,7 +520,7 @@
       "vol_up": "Pli volumo",
       "vol_down": "Malpli volumo",
       "toggle_love": "Baskuli la stelon de nuna kanto",
-      "current_song": ""
+      "current_song": "Iri al Nuna Kanto"
     }
   }
 }

resources/i18n/es.json

@@ -28,16 +28,19 @@
         "channels": "Canales",
         "createdAt": "Creado el",
         "grouping": "Agrupación",
-        "mood": "",
+        "mood": "Estado de ánimo",
         "participants": "Participantes",
         "tags": "Etiquetas",
         "mappedTags": "Etiquetas asignadas",
-        "rawTags": "Etiquetas sin procesar"
+        "rawTags": "Etiquetas sin procesar",
+        "bitDepth": "Profundidad de bits",
+        "sampleRate": "Frecuencia de muestreo",
+        "missing": "Faltante"
       },
       "actions": {
         "addToQueue": "Reproducir después",
         "playNow": "Reproducir ahora",
-        "addToPlaylist": "Agregar a la lista de reproducción",
+        "addToPlaylist": "Agregar a la playlist",
         "shuffleAll": "Todas aleatorias",
         "download": "Descarga",
         "playNext": "Siguiente",
@@ -69,8 +72,10 @@
         "catalogNum": "Número de catálogo",
         "releaseType": "Tipo de lanzamiento",
         "grouping": "Agrupación",
-        "media": "",
-        "mood": ""
+        "media": "Medios",
+        "mood": "Estado de ánimo",
+        "date": "Fecha de grabación",
+        "missing": "Faltante"
       },
       "actions": {
         "playAll": "Reproducir",
@@ -102,7 +107,8 @@
         "rating": "Calificación",
         "genre": "Género",
         "size": "Tamaño",
-        "role": "Rol"
+        "role": "Rol",
+        "missing": "Faltante"
       },
       "roles": {
         "albumartist": "Artista del álbum",
@@ -190,11 +196,12 @@
         "addNewPlaylist": "Creada \"%{name}\"",
         "export": "Exportar",
         "makePublic": "Hazla pública",
-        "makePrivate": "Hazla privada"
+        "makePrivate": "Hazla privada",
+        "saveQueue": "Guardar la fila de reproducción en una playlist"
       },
       "message": {
-        "duplicate_song": "Algunas de las canciones seleccionadas están presentes en la lista de reproducción",
-        "song_exist": "Se están agregando duplicados a la lista de reproducción. ¿Quieres agregar los duplicados o omitirlos?"
+        "duplicate_song": "Algunas de las canciones seleccionadas están presentes en la playlist",
+        "song_exist": "Se están agregando duplicados a la playlist. ¿Quieres agregar los duplicados o omitirlos?"
       }
     },
     "radio": {
@@ -235,11 +242,13 @@
         "updatedAt": "Actualizado el"
       },
       "actions": {
-        "remove": "Eliminar"
+        "remove": "Eliminar",
+        "remove_all": "Eliminar todo"
       },
       "notifications": {
         "removed": "Eliminado"
-      }
+      },
+      "empty": "No hay archivos perdidos"
     }
   },
   "ra": {
@@ -419,7 +428,9 @@
     "downloadDialogTitle": "Descargar %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Copiar al portapapeles: Ctrl+C, Intro",
     "remove_missing_title": "Eliminar elemento faltante",
-    "remove_missing_content": ""
+    "remove_missing_content": "¿Realmente desea eliminar los archivos faltantes seleccionados de la base de datos? Esto eliminará permanentemente cualquier referencia a ellos, incluidas sus reproducciones y valoraciones.",
+    "remove_all_missing_title": "Eliminar todos los archivos perdidos",
+    "remove_all_missing_content": "¿Realmente desea eliminar todos los archivos faltantes de la base de datos? Esto eliminará permanentemente cualquier referencia a ellos, incluidas sus reproducciones y valoraciones."
   },
   "menu": {
     "library": "Biblioteca",
@@ -451,7 +462,7 @@
     "sharedPlaylists": "Playlists Compartidas"
   },
   "player": {
-    "playListsText": "Lista de reproducción",
+    "playListsText": "Fila de reproducción",
     "openText": "Abrir",
     "closeText": "Cerrar",
     "notContentText": "Sin música",
@@ -493,7 +504,10 @@
     "quickScan": "Escaneo rápido",
     "fullScan": "Escaneo completo",
     "serverUptime": "Uptime del servidor",
-    "serverDown": "OFFLINE"
+    "serverDown": "OFFLINE",
+    "scanType": "Tipo",
+    "status": "Error de escaneo",
+    "elapsedTime": "Tiempo transcurrido"
   },
   "help": {
     "title": "Atajos de teclado de Navidrome",
@@ -509,4 +523,4 @@
       "current_song": "Canción actual"
     }
   }
-}
+}

resources/i18n/eu.json

@@ -17,7 +17,10 @@
         "year": "Urtea",
         "size": "Fitxategiaren tamaina",
         "updatedAt": "Eguneratze-data:",
-        "bitRate": "Bit tasa",
+        "bitRate": "Bit-tasa",
+        "bitDepth": "Bit-sakonera",
+        "sampleRate": "Lagin-tasa",
+        "channels": "Kanalak",
         "discSubtitle": "Diskoaren azpititulua",
         "starred": "Gogokoa",
         "comment": "Iruzkina",
@@ -25,14 +28,13 @@
         "quality": "Kalitatea",
         "bpm": "BPM",
         "playDate": "Azkenekoz erreproduzitua:",
-        "channels": "Kanalak",
         "createdAt": "Gehitu zen data:",
-        "grouping": "",
-        "mood": "",
-        "participants": "",
-        "tags": "",
-        "mappedTags": "",
-        "rawTags": ""
+        "grouping": "Multzokatzea",
+        "mood": "Aldartea",
+        "participants": "Partaide gehiago",
+        "tags": "Traola gehiago",
+        "mappedTags": "Esleitutako traolak",
+        "rawTags": "Traola gordinak"
       },
       "actions": {
         "addToQueue": "Erreproduzitu ondoren",
@@ -52,25 +54,26 @@
         "duration": "Iraupena",
         "songCount": "abesti",
         "playCount": "Erreprodukzioak",
+        "size": "Fitxategiaren tamaina",
         "name": "Izena",
         "genre": "Generoa",
         "compilation": "Konpilazioa",
         "year": "Urtea",
-        "updatedAt": "Aktualizatze-data:",
-        "comment": "Iruzkina",
-        "rating": "Balorazioa",
-        "createdAt": "Gehitu zen data:",
-        "size": "Fitxategiaren tamaina",
+        "date": "Recording Date",
         "originalDate": "Jatorrizkoa",
         "releaseDate": "Argitaratze-data:",
         "releases": "Argitaratzea |||| Argitaratzeak",
         "released": "Argitaratua",
-        "recordLabel": "",
-        "catalogNum": "",
-        "releaseType": "",
-        "grouping": "",
-        "media": "",
-        "mood": ""
+        "updatedAt": "Aktualizatze-data:",
+        "comment": "Iruzkina",
+        "rating": "Balorazioa",
+        "createdAt": "Gehitu zen data:",
+        "recordLabel": "Disketxea",
+        "catalogNum": "Katalogo-zenbakia",
+        "releaseType": "Mota",
+        "grouping": "Multzokatzea",
+        "media": "Multimedia",
+        "mood": "Aldartea"
       },
       "actions": {
         "playAll": "Erreproduzitu",
@@ -84,7 +87,7 @@
       },
       "lists": {
         "all": "Guztiak",
-        "random": "Aleatorioa",
+        "random": "Aleatorioki",
         "recentlyAdded": "Berriki gehitutakoak",
         "recentlyPlayed": "Berriki entzundakoak",
         "mostPlayed": "Gehien entzundakoak",
@@ -98,26 +101,26 @@
         "name": "Izena",
         "albumCount": "Album kopurua",
         "songCount": "Abesti kopurua",
+        "size": "Tamaina",
         "playCount": "Erreprodukzio kopurua",
         "rating": "Balorazioa",
         "genre": "Generoa",
-        "size": "Tamaina",
-        "role": ""
+        "role": "Rola"
       },
       "roles": {
-        "albumartist": "",
-        "artist": "",
-        "composer": "",
-        "conductor": "",
-        "lyricist": "",
-        "arranger": "",
-        "producer": "",
-        "director": "",
-        "engineer": "",
-        "mixer": "",
-        "remixer": "",
-        "djmixer": "",
-        "performer": ""
+        "albumartist": "Albumeko egilea |||| Albumeko artistak",
+        "artist": "Artista |||| Artistak",
+        "composer": "Konpositorea |||| Konpositoreak",
+        "conductor": "Orkestra zuzendaria |||| Orkestra zuzendariak",
+        "lyricist": "Hitzen egilea |||| Hitzen egileak",
+        "arranger": "Moldatzailea |||| Moldatzaileak",
+        "producer": "Produktorea |||| Produktoreak",
+        "director": "Zuzendaria |||| Zuzendaria",
+        "engineer": "Teknikaria |||| Teknikariak",
+        "mixer": "Nahaslea |||| Nahasleak",
+        "remixer": "Remixerra |||| Remixerrak",
+        "djmixer": "DJ nahaslea |||| DJ nahasleak",
+        "performer": "Interpretatzailea |||| Interpretatzaileak"
       }
     },
     "user": {
@@ -238,7 +241,8 @@
         "updatedAt": "Desagertze-data:"
       },
       "actions": {
-        "remove": "Kendu"
+        "remove": "Kendu",
+        "remove_all": "Kendu guztia"
       },
       "notifications": {
         "removed": "Faltan zeuden fitxategiak kendu dira"
@@ -258,7 +262,7 @@
       "sign_in": "Sartu",
       "sign_in_error": "Autentifikazioak huts egin du, saiatu berriro",
       "logout": "Amaitu saioa",
-      "insightsCollectionNote": ""
+      "insightsCollectionNote": "Navidromek erabilera-datu anonimoak biltzen ditu\nproiektua hobetzen laguntzeko. Egin klik [hemen]\ngehiago ikasteko, eta datuak ez biltzeko eskatzeko,\nhala nahi izanez gero."
     },
     "validation": {
       "invalidChars": "Erabili hizkiak eta zenbakiak bakarrik",
@@ -398,31 +402,33 @@
     "noPlaylistsAvailable": "Ez dago zerrendarik erabilgarri",
     "delete_user_title": "Ezabatu '%{name}' erabiltzailea",
     "delete_user_content": "Ziur zaide erabiltzaile hau eta bere datu guztiak (zerrendak eta hobespenak barne) ezabatu nahi dituzula?",
+    "remove_missing_title": "Kendu faltan dauden fitxategiak",
+    "remove_missing_content": "Ziur hautatutako fitxategiak datu-basetik kendu nahi dituzula? Betiko kenduko dira haiei buruzko erreferentziak, erreprodukzio-zenbaketak eta sailkapenak barne.",
+    "remove_all_missing_title": "Kendu faltan dauden fitxategi guztiak",
+    "remove_all_missing_content": "Ziur aurkitu ez diren fitxategi guztiak datu-basetik kendu nahi dituzula? Betiko kenduko dira haiei buruzko erreferentziak, erreprodukzio-zenbaketak eta sailkapenak barne.",
     "notifications_blocked": "Nabigatzaileak jakinarazpenak blokeatzen ditu",
     "notifications_not_available": "Nabigatzaile hau ez da jakinarazpenekin bateragarria edo Navidrome ez da HTTPS erabiltzen ari",
     "lastfmLinkSuccess": "Last.fm konektatuta dago eta erabiltzailearen ohiturak hirugarrenen zerbitzuekin partekatzea gaituta dago",
     "lastfmLinkFailure": "Ezin izan da Last.fm-rekin konektatu",
     "lastfmUnlinkSuccess": "Last.fm deskonektatu da eta erabiltzailearen ohiturak hirugarrenen zerbitzuekin partekatzea ezgaitu da",
     "lastfmUnlinkFailure": "Ezin izan da Last.fm deskonektatu",
+    "listenBrainzLinkSuccess": "Ondo konektatu da ListenBrainz-ekin eta %{user} erabiltzailearen ohiturak hirugarrenen zerbitzuekin partekatzea aktibatu da",
+    "listenBrainzLinkFailure": "Ezin izan da ListenBrainz-ekin konektatu: %{error}",
+    "listenBrainzUnlinkSuccess": "ListenBrainz deskonektatu da eta erabiltzailearen ohiturak hirugarrenen zerbitzuekin partekatzea desaktibatu da",
+    "listenBrainzUnlinkFailure": "Ezin izan da ListenBrainz deskonektatu",
     "openIn": {
       "lastfm": "Ikusi Last.fm-n",
       "musicbrainz": "Ikusi MusicBrainz-en"
     },
     "lastfmLink": "Irakurri gehiago…",
-    "listenBrainzLinkSuccess": "Ondo konektatu da ListenBrainz-ekin eta %{user} erabiltzailearen ohiturak hirugarrenen zerbitzuekin partekatzea aktibatu da",
-    "listenBrainzLinkFailure": "Ezin izan da ListenBrainz-ekin konektatu: %{error}",
-    "listenBrainzUnlinkSuccess": "ListenBrainz deskonektatu da eta erabiltzailearen ohiturak hirugarrenen zerbitzuekin partekatzea desaktibatu da",
-    "listenBrainzUnlinkFailure": "Ezin izan da ListenBrainz deskonektatu",
-    "downloadOriginalFormat": "Deskargatu jatorrizko formatua",
     "shareOriginalFormat": "Partekatu jatorrizko formatua",
     "shareDialogTitle": "Partekatu '%{name}' %{resource}",
     "shareBatchDialogTitle": "Partekatu %{resource} bat |||| Partekatu %{smart_count} %{resource}",
+    "shareCopyToClipboard": "Kopiatu arbelera: Ktrl + C, Sartu tekla",
     "shareSuccess": "URLa arbelera kopiatu da: %{url}",
     "shareFailure": "Errorea %{url} URLa arbelera kopiatzean",
     "downloadDialogTitle": "Deskargatu '%{name}' %{resource}, (%{size})",
-    "shareCopyToClipboard": "Kopiatu arbelera: Ktrl + C, Sartu tekla",
-    "remove_missing_title": "",
-    "remove_missing_content": ""
+    "downloadOriginalFormat": "Deskargatu jatorrizko formatua"    
   },
   "menu": {
     "library": "Liburutegia",
@@ -436,6 +442,7 @@
         "language": "Hizkuntza",
         "defaultView": "Bista, defektuz",
         "desktop_notifications": "Mahaigaineko jakinarazpenak",
+        "lastfmNotConfigured": "Last.fm-ren API-gakoa ez dago konfiguratuta",
         "lastfmScrobbling": "Bidali Last.fm-ra erabiltzailearen ohiturak",
         "listenBrainzScrobbling": "Bidali ListenBrainz-era erabiltzailearen ohiturak",
         "replaygain": "ReplayGain modua",
@@ -444,14 +451,13 @@
           "none": "Bat ere ez",
           "album": "Albuma",
           "track": "Pista"
-        },
-        "lastfmNotConfigured": ""
+        }
       }
     },
     "albumList": "Albumak",
-    "about": "Honi buruz",
     "playlists": "Zerrendak",
-    "sharedPlaylists": "Partekatutako erreprodukzio-zerrendak"
+    "sharedPlaylists": "Partekatutako erreprodukzio-zerrendak",
+    "about": "Honi buruz"
   },
   "player": {
     "playListsText": "Erreprodukzio-zerrenda",
@@ -483,10 +489,10 @@
       "homepage": "Hasierako orria",
       "source": "Iturburu kodea",
       "featureRequests": "Eskatu ezaugarria",
-      "lastInsightsCollection": "",
+      "lastInsightsCollection": "Bildutako azken datuak",
       "insights": {
-        "disabled": "",
-        "waiting": ""
+        "disabled": "Ezgaituta",
+        "waiting": "Zain"
       }
     }
   },
@@ -496,7 +502,10 @@
     "quickScan": "Arakatze azkarra",
     "fullScan": "Arakatze sakona",
     "serverUptime": "Zerbitzariak piztuta daraman denbora",
-    "serverDown": "LINEAZ KANPO"
+    "serverDown": "LINEAZ KANPO",
+    "scanType": "Mota",
+    "status": "Errorea arakatzean",
+    "elapsedTime": "Igarotako denbora"
   },
   "help": {
     "title": "Navidromeren laster-teklak",

resources/i18n/fi.json

@@ -32,7 +32,10 @@
         "participants": "Lisäosallistujat",
         "tags": "Lisätunnisteet",
         "mappedTags": "Mäpättyt tunnisteet",
-        "rawTags": "Raakatunnisteet"
+        "rawTags": "Raakatunnisteet",
+        "bitDepth": "Bittisyvyys",
+        "sampleRate": "Näytteenottotaajuus",
+        "missing": ""
       },
       "actions": {
         "addToQueue": "Lisää jonoon",
@@ -70,7 +73,9 @@
         "releaseType": "Tyyppi",
         "grouping": "Ryhmittely",
         "media": "Media",
-        "mood": "Tunnelma"
+        "mood": "Tunnelma",
+        "date": "Tallennuspäivä",
+        "missing": ""
       },
       "actions": {
         "playAll": "Soita",
@@ -102,7 +107,8 @@
         "rating": "Arvostelu",
         "genre": "Tyylilaji",
         "size": "Koko",
-        "role": "Rooli"
+        "role": "Rooli",
+        "missing": ""
       },
       "roles": {
         "albumartist": "Albumitaiteilija |||| Albumitaiteilijat",
@@ -190,7 +196,8 @@
         "addNewPlaylist": "Luo \"%{name}\"",
         "export": "Vie",
         "makePublic": "Tee julkinen",
-        "makePrivate": "Tee yksityinen"
+        "makePrivate": "Tee yksityinen",
+        "saveQueue": ""
       },
       "message": {
         "duplicate_song": "Lisää olemassa oleva kappale",
@@ -235,11 +242,13 @@
         "updatedAt": "Katosi"
       },
       "actions": {
-        "remove": "Poista"
+        "remove": "Poista",
+        "remove_all": ""
       },
       "notifications": {
         "removed": "Puuttuvat tiedostot poistettu"
-      }
+      },
+      "empty": "Ei puuttuvia tiedostoja"
     }
   },
   "ra": {
@@ -419,7 +428,9 @@
     "downloadDialogTitle": "Lataa %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Kopio leikepöydälle: Ctrl+C, Enter",
     "remove_missing_title": "Poista puuttuvat tiedostot",
-    "remove_missing_content": "Oletko varma, että haluat poistaa valitut puuttuvat tiedostot tietokannasta? Tämä poistaa pysyvästi kaikki viittaukset niihin, mukaan lukien niiden soittojen määrät ja arvostelut."
+    "remove_missing_content": "Oletko varma, että haluat poistaa valitut puuttuvat tiedostot tietokannasta? Tämä poistaa pysyvästi kaikki viittaukset niihin, mukaan lukien niiden soittojen määrät ja arvostelut.",
+    "remove_all_missing_title": "",
+    "remove_all_missing_content": ""
   },
   "menu": {
     "library": "Kirjasto",
@@ -493,7 +504,10 @@
     "quickScan": "Nopea tarkistus",
     "fullScan": "Täysi tarkistus",
     "serverUptime": "Palvelun käyttöaika",
-    "serverDown": "SAMMUTETTU"
+    "serverDown": "SAMMUTETTU",
+    "scanType": "",
+    "status": "",
+    "elapsedTime": ""
   },
   "help": {
     "title": "Navidrome pikapainikkeet",

resources/i18n/fr.json

@@ -33,7 +33,9 @@
         "tags": "Étiquettes supplémentaires",
         "mappedTags": "Étiquettes correspondantes",
         "rawTags": "Étiquettes brutes",
-        "bitDepth": "Profondeur de bit"
+        "bitDepth": "Profondeur de bits",
+        "sampleRate": "Fréquence d'échantillonnage",
+        "missing": "Manquant"
       },
       "actions": {
         "addToQueue": "Ajouter à la file",
@@ -71,7 +73,9 @@
         "releaseType": "Type",
         "grouping": "Regroupement",
         "media": "Média",
-        "mood": "Humeur"
+        "mood": "Humeur",
+        "date": "Date d'enregistrement",
+        "missing": "Manquant"
       },
       "actions": {
         "playAll": "Lire",
@@ -103,7 +107,8 @@
         "rating": "Classement",
         "genre": "Genre",
         "size": "Taille",
-        "role": "Rôle"
+        "role": "Rôle",
+        "missing": "Manquant"
       },
       "roles": {
         "albumartist": "Artiste de l'album |||| Artistes de l'album",
@@ -191,7 +196,8 @@
         "addNewPlaylist": "Créer \"%{name}\"",
         "export": "Exporter",
         "makePublic": "Rendre publique",
-        "makePrivate": "Rendre privée"
+        "makePrivate": "Rendre privée",
+        "saveQueue": "Sauvegarder la file de lecture dans la playlist"
       },
       "message": {
         "duplicate_song": "Pistes déjà présentes dans la playlist",
@@ -236,7 +242,8 @@
         "updatedAt": "A disparu le"
       },
       "actions": {
-        "remove": "Supprimer"
+        "remove": "Supprimer",
+        "remove_all": "Tout supprimer"
       },
       "notifications": {
         "removed": "Fichier(s) manquant(s) supprimé(s)"
@@ -421,7 +428,9 @@
     "downloadDialogTitle": "Télécharger %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Copier vers le presse-papier : Ctrl+C, Enter",
     "remove_missing_title": "Supprimer les fichiers manquants",
-    "remove_missing_content": "Êtes-vous sûr(e) de vouloir supprimer les fichiers manquants sélectionnés de la base de données ? Ceci supprimera définitivement toute référence à ceux-ci, y compris leurs nombres d'écoutes et leurs notations"
+    "remove_missing_content": "Êtes-vous sûr(e) de vouloir supprimer les fichiers manquants sélectionnés de la base de données ? Ceci supprimera définitivement toute référence à ceux-ci, y compris leurs nombres d'écoutes et leurs notations",
+    "remove_all_missing_title": "Supprimer tous les fichiers manquants",
+    "remove_all_missing_content": "Êtes-vous sûr(e) de vouloir supprimer tous les fichiers manquants de la base de données ? Cette action est permanente et supprimera leurs nombres d'écoutes,  leur notations et tout ce qui y fait référence."
   },
   "menu": {
     "library": "Bibliothèque",
@@ -495,7 +504,10 @@
     "quickScan": "Scan rapide",
     "fullScan": "Scan complet",
     "serverUptime": "Disponibilité du serveur",
-    "serverDown": "HORS LIGNE"
+    "serverDown": "HORS LIGNE",
+    "scanType": "Type",
+    "status": "Erreur de scan",
+    "elapsedTime": "Temps écoulé"
   },
   "help": {
     "title": "Raccourcis Navidrome",

resources/i18n/hu.json

@@ -18,6 +18,8 @@
         "size": "Fájlméret",
         "updatedAt": "Legutóbb frissítve",
         "bitRate": "Bitráta",
+        "bitDepth": "Bitmélység",
+        "sampleRate": "Mintavételezési frekvencia",
         "discSubtitle": "Lemezfelirat",
         "starred": "Kedvenc",
         "comment": "Megjegyzés",
@@ -32,7 +34,8 @@
         "participants": "További résztvevők",
         "tags": "További címkék",
         "mappedTags": "Feldolgozott címkék",
-        "rawTags": "Nyers címkék"
+        "rawTags": "Nyers címkék",
+        "missing": "Hiányzó"
       },
       "actions": {
         "addToQueue": "Lejátszás útolsóként",
@@ -56,6 +59,7 @@
         "genre": "Stílus",
         "compilation": "Válogatásalbum",
         "year": "Év",
+        "date": "Felvétel dátuma",
         "updatedAt": "Legutóbb frissítve",
         "comment": "Megjegyzés",
         "rating": "Értékelés",
@@ -70,7 +74,8 @@
         "releaseType": "Típus",
         "grouping": "Csoportosítás",
         "media": "Média",
-        "mood": "Hangulat"
+        "mood": "Hangulat",
+        "missing": "Hiányzó"
       },
       "actions": {
         "playAll": "Lejátszás",
@@ -102,7 +107,8 @@
         "rating": "Értékelés",
         "genre": "Stílus",
         "size": "Méret",
-        "role": "Szerep"
+        "role": "Szerep",
+        "missing": "Hiányzó"
       },
       "roles": {
         "albumartist": "Album előadó |||| Album előadók",
@@ -189,6 +195,7 @@
         "selectPlaylist": "Válassz egy lejátszási listát:",
         "addNewPlaylist": "\"%{name}\" létrehozása",
         "export": "Exportálás",
+        "saveQueue": "Műsorlista elmentése lejátszási listaként",
         "makePublic": "Publikussá tétel",
         "makePrivate": "Priváttá tétel"
       },
@@ -229,13 +236,15 @@
     },
     "missing": {
       "name": "Hiányzó fájl|||| Hiányzó fájlok",
+      "empty": "Nincsenek hiányzó fájlok",
       "fields": {
         "path": "Útvonal",
         "size": "Méret",
         "updatedAt": "Eltűnt ekkor:"
       },
       "actions": {
-        "remove": "Eltávolítás"
+        "remove": "Eltávolítás",
+        "remove_all": "Összes eltávolítása"
       },
       "notifications": {
         "removed": "Hiányzó fájl(ok) eltávolítva"
@@ -395,6 +404,8 @@
     "noPlaylistsAvailable": "Nem áll rendelkezésre",
     "delete_user_title": "Felhasználó törlése '%{name}'",
     "delete_user_content": "Biztos, hogy törölni akarod ezt a felhasználót az adataival (beállítások és lejátszási listák) együtt?",
+    "remove_all_missing_title": "Összes hiányzó fájl eltávolítása",
+    "remove_all_missing_content": "Biztos, hogy minden hiányzó fájlt törölni akarsz az adatbázisból? Ez minden hozzájuk fűződő referenciát törölni fog, beleértve a lejátszásaikat és értékeléseiket.",
     "notifications_blocked": "A böngésződ beállításaiban letiltottad az értesítéseket erre az oldalra.",
     "notifications_not_available": "Ez a böngésző nem támogatja az asztali értesítéseket, vagy a Navidrome-ot nem https-en keresztül használod.",
     "lastfmLinkSuccess": "Sikeresen összekapcsolva Last.fm-el és halgatott számok küldése engedélyezve.",
@@ -406,7 +417,7 @@
       "musicbrainz": "Megnyitás MusicBrainz-ben"
     },
     "lastfmLink": "Bővebben...",
-    "listenBrainzLinkSuccess": "Sikeresen összekapcsolva ListenBrainz-el és halgatott számok küldése %{user} felhasználónak engedélyezve.",
+    "listenBrainzLinkSuccess": "Sikeresen összekapcsolva ListenBrainz-el. Halgatott számok küldése %{user} felhasználónak engedélyezve.",
     "listenBrainzLinkFailure": "Nem lehet kapcsolódni a Listenbrainz-hez: %{error}",
     "listenBrainzUnlinkSuccess": "ListenBrainz Last.fm leválasztva és a halgatott számok küldése kikapcsolva.",
     "listenBrainzUnlinkFailure": "Nem sikerült leválasztani a ListenBrainz-et.",
@@ -451,7 +462,7 @@
     "sharedPlaylists": "Megosztott lej. listák"
   },
   "player": {
-    "playListsText": "Lejátszási lista",
+    "playListsText": "Műsorlista",
     "openText": "Megnyitás",
     "closeText": "Bezárás",
     "notContentText": "Nincs zene",
@@ -493,7 +504,10 @@
     "quickScan": "Gyors beolvasás",
     "fullScan": "Teljes beolvasás",
     "serverUptime": "Szerver üzemidő",
-    "serverDown": "OFFLINE"
+    "serverDown": "OFFLINE",
+    "scanType": "Típus",
+    "status": "Szkennelési hiba",
+    "elapsedTime": "Eltelt idő"
   },
   "help": {
     "title": "Navidrome Gyorsbillentyűk",

resources/i18n/id.json

@@ -32,7 +32,10 @@
         "participants": "Partisipan tambahan",
         "tags": "Tag tambahan",
         "mappedTags": "Tag yang dipetakan",
-        "rawTags": "Tag raw"
+        "rawTags": "Tag raw",
+        "bitDepth": "Bit depth",
+        "sampleRate": "Sample rate",
+        "missing": "Hilang"
       },
       "actions": {
         "addToQueue": "Tambah ke antrean",
@@ -70,7 +73,9 @@
         "releaseType": "Tipe",
         "grouping": "Pengelompokkan",
         "media": "Media",
-        "mood": "Mood"
+        "mood": "Mood",
+        "date": "Tanggal Perekaman",
+        "missing": "Hilang"
       },
       "actions": {
         "playAll": "Putar",
@@ -102,7 +107,8 @@
         "rating": "Peringkat",
         "genre": "Genre",
         "size": "Ukuran",
-        "role": "Peran"
+        "role": "Peran",
+        "missing": "Hilang"
       },
       "roles": {
         "albumartist": "Artis Album |||| Artis Album",
@@ -163,7 +169,7 @@
       }
     },
     "transcoding": {
-      "name": "Transkode |||| Transkode",
+      "name": "Transkoding |||| Transkoding",
       "fields": {
         "name": "Nama",
         "targetFormat": "Target Format",
@@ -190,7 +196,8 @@
         "addNewPlaylist": "Buat \"%{name}\"",
         "export": "Ekspor",
         "makePublic": "Jadikan Publik",
-        "makePrivate": "Jadikan Pribadi"
+        "makePrivate": "Jadikan Pribadi",
+        "saveQueue": "Simpan Antrean ke Playlist"
       },
       "message": {
         "duplicate_song": "Tambahkan lagu duplikat",
@@ -235,11 +242,13 @@
         "updatedAt": "Tidak muncul di"
       },
       "actions": {
-        "remove": "Hapus"
+        "remove": "Hapus",
+        "remove_all": "Hapus Semua"
       },
       "notifications": {
         "removed": "File yang hilang dihapus"
-      }
+      },
+      "empty": "Tidak ada File yang Hilang"
     }
   },
   "ra": {
@@ -277,7 +286,7 @@
       "add": "Tambah",
       "back": "Kembali",
       "bulk_actions": "1 item dipilih |||| %{smart_count} item dipilih",
-      "cancel": "Batalkan",
+      "cancel": "Batal",
       "clear_input_value": "Hapus",
       "clone": "Klon",
       "confirm": "Konfirmasi",
@@ -292,7 +301,7 @@
       "save": "Simpan",
       "search": "Cari",
       "show": "Tampilkan",
-      "sort": "Sortir",
+      "sort": "Urutkan",
       "undo": "Batalkan",
       "expand": "Luaskan",
       "close": "Tutup",
@@ -312,7 +321,7 @@
       "create": "Buat %{name}",
       "dashboard": "Dasbor",
       "edit": "%{name} #%{id}",
-      "error": "Ada yang tidak beres",
+      "error": "Terjadi kesalahan",
       "list": "%{name}",
       "loading": "Memuat",
       "not_found": "Tidak ditemukan",
@@ -356,7 +365,7 @@
       "unsaved_changes": "Beberapa perubahan tidak disimpan. Apakah Kamu yakin ingin mengabaikannya?"
     },
     "navigation": {
-      "no_results": "Tidak ada hasil yang ditemukan",
+      "no_results": "Hasil tidak ditemukan",
       "no_more_results": "Nomor halaman %{page} melampaui batas. Coba halaman sebelumnya.",
       "page_out_of_boundaries": "Nomor halaman %{page} melampaui batas",
       "page_out_from_end": "Tidak dapat menelusuri sebelum halaman terakhir",
@@ -371,8 +380,8 @@
       "updated": "Elemen diperbarui |||| %{smart_count} elemen diperbarui",
       "created": "Elemen dibuat",
       "deleted": "Elemen dihapus |||| %{smart_count} elemen dihapus",
-      "bad_item": "Elemen salah",
-      "item_doesnt_exist": "Tidak ada elemen",
+      "bad_item": "Kesalahan elemen",
+      "item_doesnt_exist": "Elemen tidak ditemukan",
       "http_error": "Kesalahan komunikasi peladen",
       "data_provider_error": "dataProvider galat. Periksa konsol untuk detailnya.",
       "i18n_error": "Tidak dapat memuat terjemahan untuk bahasa yang diatur",
@@ -419,7 +428,9 @@
     "downloadDialogTitle": "Unduh %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Salin ke papan klip: Ctrl+C, Enter",
     "remove_missing_title": "Hapus file yang hilang",
-    "remove_missing_content": "Apakah Anda yakin ingin menghapus file-file yang hilang dari basis data? Tindakan ini akan menghapus secara permanen semua referensi ke file-file tersebut, termasuk jumlah pemutaran dan peringkatnya."
+    "remove_missing_content": "Apakah Anda yakin ingin menghapus file-file yang hilang dari basis data? Tindakan ini akan menghapus secara permanen semua referensi ke file-file tersebut, termasuk jumlah pemutaran dan peringkatnya.",
+    "remove_all_missing_title": "Hapus semua file yang hilang",
+    "remove_all_missing_content": "Apa kamu yakin ingin menghapus semua file dari database? Ini akan menghapus permanen dan apapun referensi ke mereka, termasuk hitungan pemutaran dan rating mereka."
   },
   "menu": {
     "library": "Pustaka",
@@ -451,7 +462,7 @@
     "sharedPlaylists": "Playlist yang Dibagikan"
   },
   "player": {
-    "playListsText": "Mainkan Antrean",
+    "playListsText": "Putar Antrean",
     "openText": "Buka",
     "closeText": "Tutup",
     "notContentText": "Tidak ada musik",
@@ -471,7 +482,7 @@
     "playModeText": {
       "order": "Berurutan",
       "orderLoop": "Ulang",
-      "singleLoop": "Ulangi Satu",
+      "singleLoop": "Ulangi Sekali",
       "shufflePlay": "Acak"
     }
   },
@@ -493,7 +504,10 @@
     "quickScan": "Pemindaian Cepat",
     "fullScan": "Pemindaian Penuh",
     "serverUptime": "Waktu Aktif Peladen",
-    "serverDown": "LURING"
+    "serverDown": "LURING",
+    "scanType": "Tipe",
+    "status": "Kesalahan Memindai",
+    "elapsedTime": "Waktu Berakhir"
   },
   "help": {
     "title": "Tombol Pintasan Navidrome",

resources/i18n/ko.json

@@ -1,460 +1,518 @@
 {
-    "languageName": "한국어",
-    "resources": {
-        "song": {
-            "name": "노래 |||| 노래들",
-            "fields": {
-                "albumArtist": "앨범 아티스트",
-                "duration": "시간",
-                "trackNumber": "#",
-                "playCount": "재생 횟수",
-                "title": "제목",
-                "artist": "아티스트",
-                "album": "앨범",
-                "path": "파일 경로",
-                "genre": "장르",
-                "compilation": "컴필레이션",
-                "year": "년",
-                "size": "파일 크기",
-                "updatedAt": "업데이트됨",
-                "bitRate": "비트레이트",
-                "discSubtitle": "디스크 서브타이틀",
-                "starred": "즐겨찾기",
-                "comment": "댓글",
-                "rating": "평가",
-                "quality": "품질",
-                "bpm": "BPM",
-                "playDate": "마지막 재생",
-                "channels": "채널",
-                "createdAt": "추가된 날짜"
-            },
-            "actions": {
-                "addToQueue": "나중에 재생",
-                "playNow": "지금 재생",
-                "addToPlaylist": "재생목록에 추가",
-                "shuffleAll": "모든 노래 셔플",
-                "download": "다운로드",
-                "playNext": "다음 재생",
-                "info": "정보"
-            }
-        },
-        "album": {
-            "name": "앨범 |||| 앨범들",
-            "fields": {
-                "albumArtist": "앨범 아티스트",
-                "artist": "아티스트",
-                "duration": "시간",
-                "songCount": "노래",
-                "playCount": "재생 횟수",
-                "name": "이름",
-                "genre": "장르",
-                "compilation": "컴필레이션",
-                "year": "년",
-                "updatedAt": "업데이트됨",
-                "comment": "댓글",
-                "rating": "평가",
-                "createdAt": "추가된 날짜",
-                "size": "크기",
-                "originalDate": "오리지널",
-                "releaseDate": "발매일",
-                "releases": "발매 음반 |||| 발매 음반들",
-                "released": "발매됨"
-            },
-            "actions": {
-                "playAll": "재생",
-                "playNext": "다음에 재생",
-                "addToQueue": "나중에 재생",
-                "shuffle": "셔플",
-                "addToPlaylist": "재생목록 추가",
-                "download": "다운로드",
-                "info": "정보",
-                "share": "공유"
-            },
-            "lists": {
-                "all": "모두",
-                "random": "랜덤",
-                "recentlyAdded": "최근 추가됨",
-                "recentlyPlayed": "최근 재생됨",
-                "mostPlayed": "가장 많이 재생됨",
-                "starred": "즐겨찾기",
-                "topRated": "높은 평가"
-            }
-        },
-        "artist": {
-            "name": "아티스트 |||| 아티스트들",
-            "fields": {
-                "name": "이름",
-                "albumCount": "앨범 수",
-                "songCount": "노래 수",
-                "playCount": "재생 횟수",
-                "rating": "평가",
-                "genre": "장르",
-                "size": "크기"
-            }
-        },
-        "user": {
-            "name": "사용자 |||| 사용자들",
-            "fields": {
-                "userName": "사용자이름",
-                "isAdmin": "관리자",
-                "lastLoginAt": "마지막 로그인",
-                "updatedAt": "업데이트됨",
-                "name": "이름",
-                "password": "비밀번호",
-                "createdAt": "생성됨",
-                "changePassword": "비밀번호를 변경할까요?",
-                "currentPassword": "현재 비밀번호",
-                "newPassword": "새 비밀번호",
-                "token": "토큰"
-            },
-            "helperTexts": {
-                "name": "이름 변경 사항은 다음 로그인 이후에 반영됨"
-            },
-            "notifications": {
-                "created": "사용자 생성됨",
-                "updated": "사용자 업데이트됨",
-                "deleted": "사용자 삭제됨"
-            },
-            "message": {
-                "listenBrainzToken": "ListenBrainz 사용자 토큰을 입력하세요.",
-                "clickHereForToken": "여기를 클릭하여 토큰을 얻으세요"
-            }
-        },
-        "player": {
-            "name": "플레이어 |||| 플레이어들",
-            "fields": {
-                "name": "이름",
-                "transcodingId": "트랜스코딩",
-                "maxBitRate": "최대 비트레이트",
-                "client": "클라이언트",
-                "userName": "사용자이름",
-                "lastSeen": "마지막으로 봤음",
-                "reportRealPath": "실제 경로 보고서",
-                "scrobbleEnabled": "외부 서비스에 스크로블 보내기"
-            }
-        },
-        "transcoding": {
-            "name": "트랜스코딩 |||| 트랜스코딩들",
-            "fields": {
-                "name": "이름",
-                "targetFormat": "대상 포맷",
-                "defaultBitRate": "기본 비트레이트",
-                "command": "명령"
-            }
-        },
-        "playlist": {
-            "name": "재생목록 |||| 재생목록들",
-            "fields": {
-                "name": "이름",
-                "duration": "지속",
-                "ownerName": "소유자",
-                "public": "공개",
-                "updatedAt": "업데이트됨",
-                "createdAt": "생성됨",
-                "songCount": "노래",
-                "comment": "댓글",
-                "sync": "자동 가져오기",
-                "path": "다음에서 가져오기"
-            },
-            "actions": {
-                "selectPlaylist": "재생목록 선택:",
-                "addNewPlaylist": "\"%{name}\" 만들기",
-                "export": "내보내기",
-                "makePublic": "공개",
-                "makePrivate": "비공개"
-            },
-            "message": {
-                "duplicate_song": "중복된 노래 추가",
-                "song_exist": "이미 재생목록에 존재하는 노래입니다. 중복을 추가할까요 아니면 건너뛸까요?"
-            }
-        },
-        "radio": {
-            "name": "라디오 |||| 라디오들",
-            "fields": {
-                "name": "이름",
-                "streamUrl": "스트리밍 URL",
-                "homePageUrl": "홈페이지 URL",
-                "updatedAt": "업데이트됨",
-                "createdAt": "생성됨"
-            },
-            "actions": {
-                "playNow": "지금 재생"
-            }
-        },
-        "share": {
-            "name": "공유 |||| 공유되는 것들",
-            "fields": {
-                "username": "공유됨",
-                "url": "URL",
-                "description": "설명",
-                "contents": "컨텐츠",
-                "expiresAt": "만료",
-                "lastVisitedAt": "마지막 방문",
-                "visitCount": "방문 수",
-                "format": "포맷",
-                "maxBitRate": "최대 비트레이트",
-                "updatedAt": "업데이트됨",
-                "createdAt": "생성됨",
-                "downloadable": "다운로드를 허용할까요?"
-            }
-        }
+  "languageName": "한국어",
+  "resources": {
+    "song": {
+      "name": "노래 |||| 노래들",
+      "fields": {
+        "albumArtist": "앨범 아티스트",
+        "duration": "시간",
+        "trackNumber": "#",
+        "playCount": "재생 횟수",
+        "title": "제목",
+        "artist": "아티스트",
+        "album": "앨범",
+        "path": "파일 경로",
+        "genre": "장르",
+        "compilation": "컴필레이션",
+        "year": "년",
+        "size": "파일 크기",
+        "updatedAt": "업데이트됨",
+        "bitRate": "비트레이트",
+        "bitDepth": "비트 심도",
+        "sampleRate": "샘플레이트",
+        "channels": "채널",
+        "discSubtitle": "디스크 서브타이틀",
+        "starred": "즐겨찾기",
+        "comment": "댓글",
+        "rating": "평가",
+        "quality": "품질",
+        "bpm": "BPM",
+        "playDate": "마지막 재생",
+        "createdAt": "추가된 날짜",
+        "grouping": "그룹",
+        "mood": "분위기",
+        "participants": "추가 참가자",
+        "tags": "추가 태그",
+        "mappedTags": "매핑된 태그",
+        "rawTags": "원시 태그"
+      },
+      "actions": {
+        "addToQueue": "나중에 재생",
+        "playNow": "지금 재생",
+        "addToPlaylist": "재생목록에 추가",
+        "shuffleAll": "모든 노래 셔플",
+        "download": "다운로드",
+        "playNext": "다음 재생",
+        "info": "정보 얻기"
+      }
     },
-    "ra": {
-        "auth": {
-            "welcome1": "Navidrome을 설치해 주셔서 감사합니다!",
-            "welcome2": "관리자를 만들고 시작해 보세요",
-            "confirmPassword": "비밀번호 확인",
-            "buttonCreateAdmin": "관리자 만들기",
-            "auth_check_error": "계속하려면 로그인하세요",
-            "user_menu": "프로파일",
-            "username": "사용자이름",
-            "password": "비밀번호",
-            "sign_in": "가입",
-            "sign_in_error": "인증에 실패했습니다. 다시 시도하세요",
-            "logout": "로그아웃"
-        },
-        "validation": {
-            "invalidChars": "문자와 숫자만 사용하세요",
-            "passwordDoesNotMatch": "비밀번호가 일치하지 않음",
-            "required": "필수 항목임",
-            "minLength": "%{min}자 이하여야 함",
-            "maxLength": "%{max}자 이하여야 함",
-            "minValue": "%{min}자 이상이어야 함",
-            "maxValue": "%{max}자 이하여야 함",
-            "number": "숫자여야 함",
-            "email": "유효한 이메일이어야 함",
-            "oneOf": "다음 중 하나여야 함: %{options}",
-            "regex": "특정 형식(정규식)과 일치해야 함: %{pattern}",
-            "unique": "고유해야 함",
-            "url": "유효한 URL이어야 함"
-        },
-        "action": {
-            "add_filter": "필터 추가",
-            "add": "추가",
-            "back": "뒤로 가기",
-            "bulk_actions": "1 개 항목이 선택되었음 |||| %{smart_count} 개 항목이 선택되었음",
-            "cancel": "취소",
-            "clear_input_value": "값 지우기",
-            "clone": "복제",
-            "confirm": "확인",
-            "create": "만들기",
-            "delete": "삭제",
-            "edit": "편집",
-            "export": "내보내기",
-            "list": "목록",
-            "refresh": "새로 고침",
-            "remove_filter": "이 필터 제거",
-            "remove": "제거",
-            "save": "저장",
-            "search": "검색",
-            "show": "표시",
-            "sort": "정렬",
-            "undo": "실행 취소",
-            "expand": "확장",
-            "close": "닫기",
-            "open_menu": "메뉴 열기",
-            "close_menu": "메뉴 닫기",
-            "unselect": "선택 해제",
-            "skip": "건너뛰기",
-            "bulk_actions_mobile": "1 |||| %{smart_count}",
-            "share": "공유",
-            "download": "다운로드"
-        },
-        "boolean": {
-            "true": "예",
-            "false": "아니요"
-        },
-        "page": {
-            "create": "%{name} 만들기",
-            "dashboard": "대시보드",
-            "edit": "%{name} #%{id}",
-            "error": "문제가 발생하였음",
-            "list": "%{name}",
-            "loading": "로딩 중",
-            "not_found": "찾을 수 없음",
-            "show": "%{name} #%{id}",
-            "empty": "아직 %{name}이(가) 없습니다.",
-            "invite": "추가할까요?"
-        },
-        "input": {
-            "file": {
-                "upload_several": "업로드할 파일을 몇 개 놓거나 클릭하여 하나를 선택하세요.",
-                "upload_single": "업로드할 파일을 몇 개 놓거나 클릭하여 선택하세요."
-            },
-            "image": {
-                "upload_several": "업로드할 사진을 몇 개 놓거나 클릭하여 하나를 선택하세요.",
-                "upload_single": "업로드할 사진을 몇 개 놓거나 클릭하여 선택하세요."
-            },
-            "references": {
-                "all_missing": "참조 데이터를 찾을 수 없습니다.",
-                "many_missing": "연관된 참조 중 적어도 하나는 더 이상 사용할 수 없는 것 같습니다.",
-                "single_missing": "연관된 참조는 더 이상 사용할 수 없는 것 같습니다."
-            },
-            "password": {
-                "toggle_visible": "비밀번호 숨기기",
-                "toggle_hidden": "비밀번호 표시"
-            }
-        },
-        "message": {
-            "about": "정보",
-            "are_you_sure": "확실한가요?",
-            "bulk_delete_content": "이 %{name}을(를) 삭제할까요? |||| 이 %{smart_count} 개의 항목을 삭제할까요?",
-            "bulk_delete_title": "%{name} 삭제 |||| %{smart_count} %{name} 삭제",
-            "delete_content": "이 항목을 삭제할까요?",
-            "delete_title": "%{name} #%{id} 삭제",
-            "details": "상세 정보",
-            "error": "클라이언트 오류가 발생하여 요청을 완료할 수 없습니다.",
-            "invalid_form": "양식이 유효하지 않습니다. 오류를 확인하세요",
-            "loading": "페이지가 로드 중입니다. 잠시만 기다려 주세요",
-            "no": "아니요",
-            "not_found": "잘못된 URL을 입력했거나 잘못된 링크를 클릭했습니다.",
-            "yes": "예",
-            "unsaved_changes": "일부 변경 사항이 저장되지 않았습니다. 무시할까요?"
-        },
-        "navigation": {
-            "no_results": "결과를 찾을 수 없음",
-            "no_more_results": "페이지 번호 %{page}이(가) 경계를 벗어났습니다. 이전 페이지를 시도해 보세요.",
-            "page_out_of_boundaries": "페이지 번호 %{page}이(가) 경계를 벗어남",
-            "page_out_from_end": "마지막 페이지 뒤로 갈 수 없음",
-            "page_out_from_begin": "첫 페이지 앞으로 갈 수 없음",
-            "page_range_info": "%{offsetBegin}-%{offsetEnd} / %{total}",
-            "page_rows_per_page": "페이지당 항목:",
-            "next": "다음",
-            "prev": "이전",
-            "skip_nav": "콘텐츠 건너뛰기"
-        },
-        "notification": {
-            "updated": "요소 업데이트됨 |||| %{smart_count} 개 요소 업데이트됨",
-            "created": "요소 생성됨",
-            "deleted": "요소 삭제됨 |||| %{smart_count} 개 요소 삭제됨",
-            "bad_item": "잘못된 요소",
-            "item_doesnt_exist": "요소가 존재하지 않음",
-            "http_error": "서버 통신 오류",
-            "data_provider_error": "dataProvider 오류입니다. 자세한 내용은 콘솔을 확인하세요.",
-            "i18n_error": "지정된 언어에 대한 번역을 로드할 수 없음",
-            "canceled": "작업이 취소됨",
-            "logged_out": "세션이 종료되었습니다. 다시 연결하세요.",
-            "new_version": "새로운 버전이 출시되었습니다! 이 창을 새로 고침하세요."
-        },
-        "toggleFieldsMenu": {
-            "columnsToDisplay": "표시할 열",
-            "layout": "레이아웃",
-            "grid": "격자",
-            "table": "표"
-        }
+    "album": {
+      "name": "앨범 |||| 앨범들",
+      "fields": {
+        "albumArtist": "앨범 아티스트",
+        "artist": "아티스트",
+        "duration": "시간",
+        "songCount": "노래",
+        "playCount": "재생 횟수",
+        "size": "크기",
+        "name": "이름",
+        "genre": "장르",
+        "compilation": "컴필레이션",
+        "year": "년",
+        "date": "녹음 날짜",
+        "originalDate": "오리지널",
+        "releaseDate": "발매일",
+        "releases": "발매 음반 |||| 발매 음반들",
+        "released": "발매됨",
+        "updatedAt": "업데이트됨",
+        "comment": "댓글",
+        "rating": "평가",
+        "createdAt": "추가된 날짜",
+        "recordLabel": "레이블",
+        "catalogNum": "카탈로그 번호",
+        "releaseType": "유형",
+        "grouping": "그룹",
+        "media": "미디어",
+        "mood": "분위기"
+      },
+      "actions": {
+        "playAll": "재생",
+        "playNext": "다음 재생",
+        "addToQueue": "나중에 재생",
+        "share": "공유",
+        "shuffle": "셔플",
+        "addToPlaylist": "재생목록 추가",
+        "download": "다운로드",
+        "info": "정보 얻기"
+      },
+      "lists": {
+        "all": "모두",
+        "random": "랜덤",
+        "recentlyAdded": "최근 추가됨",
+        "recentlyPlayed": "최근 재생됨",
+        "mostPlayed": "가장 많이 재생됨",
+        "starred": "즐겨찾기",
+        "topRated": "높은 평가"
+      }
     },
-    "message": {
-        "note": "참고",
-        "transcodingDisabled": "웹 인터페이스를 통한 트랜스코딩 구성 변경은 보안상의 이유로 비활성화되어 있습니다. 트랜스코딩 옵션을 변경(편집 또는 추가)하려면, %{config} 구성 옵션으로 서버를 다시 시작하세요.",
-        "transcodingEnabled": "Navidrome은 현재 %{config}로 실행 중이므로 웹 인터페이스를 사용하여 트랜스코딩 설정에서 시스템 명령을 실행할 수 있습니다. 보안상의 이유로 비활성화하고 트랜스코딩 옵션을 구성할 때만 활성화하는 것이 좋습니다.",
-        "songsAddedToPlaylist": "1 개의 노래를 재생목록에 추가하였음 |||| %{smart_count} 개의 노래를 재생 목록에 추가하였음",
-        "noPlaylistsAvailable": "사용 가능한 노래 없음",
-        "delete_user_title": "사용자 '%{name}' 삭제",
-        "delete_user_content": "이 사용자와 (재생목록 및 기본 설정 포함된) 모든 데이터를 삭제할까요?",
-        "notifications_blocked": "탐색기 설정에서 이 사이트의 알림을 차단하였음",
-        "notifications_not_available": "이 탐색기는 데스크톱 알림을 지원하지 않거나 https를 통해 Navidrome에 접속하지 않음",
-        "lastfmLinkSuccess": "Last.fm이 성공적으로 연결되었고 스크로블링이 활성화되었음",
-        "lastfmLinkFailure": "Last.fm을 연결할 수 없음",
-        "lastfmUnlinkSuccess": "Last.fm이 연결 해제되었고 스크로블링이 비활성화되었음",
-        "lastfmUnlinkFailure": "Last.fm을 연결 해제할 수 없음",
-        "openIn": {
-            "lastfm": "Last.fm에서 열기",
-            "musicbrainz": "MusicBrainz에서 열기"
-        },
-        "lastfmLink": "더 읽기...",
-        "listenBrainzLinkSuccess": "ListenBrainz가 성공적으로 연결되었고 스크로블링이 사용자로 활성화되었음: %{user}",
-        "listenBrainzLinkFailure": "ListenBrainz를 연결할 수 없음: %{error}",
-        "listenBrainzUnlinkSuccess": "ListenBrainz가 연결 해제되었고 스크로블링이 비활성화되었음",
-        "listenBrainzUnlinkFailure": "ListenBrainz를 연결 해제할 수 없음",
-        "downloadOriginalFormat": "오리지널 형식으로 다운로드",
-        "shareOriginalFormat": "오리지널 형식으로 공유",
-        "shareDialogTitle": "%{resource} '%{name}' 공유",
-        "shareBatchDialogTitle": "1 %{resource} 공유 |||| %{smart_count} %{resource} 공유",
-        "shareSuccess": "URL이 클립보드에 복사됨: %{url}",
-        "shareFailure": "%{url}을 클립보드에 복사하는 중 오류 발생",
-        "downloadDialogTitle": "%{resource} '%{name}' (%{size}) 다운로드",
-        "shareCopyToClipboard": "클립보드에 복사: Ctrl+C, Enter"
+    "artist": {
+      "name": "아티스트 |||| 아티스트들",
+      "fields": {
+        "name": "이름",
+        "albumCount": "앨범 수",
+        "songCount": "노래 수",
+        "size": "크기",
+        "playCount": "재생 횟수",
+        "rating": "평가",
+        "genre": "장르",
+        "role": "역할"
+      },
+      "roles": {
+        "albumartist": "앨범 아티스트 |||| 앨범 아티스트들",
+        "artist": "아티스트 |||| 아티스트들",
+        "composer": "작곡가 |||| 작곡가들",
+        "conductor": "지휘자 |||| 지휘자들",
+        "lyricist": "작사가 |||| 작사가들",
+        "arranger": "편곡가 |||| 편곡가들",
+        "producer": "제작자 |||| 제작자들",
+        "director": "감독 |||| 감독들",
+        "engineer": "엔지니어 |||| 엔지니어들",
+        "mixer": "믹서 |||| 믹서들",
+        "remixer": "리믹서 |||| 리믹서들",
+        "djmixer": "DJ 믹서 |||| DJ 믹서들",
+        "performer": "공연자 |||| 공연자들"
+      }
     },
-    "menu": {
-        "library": "라이브러리",
-        "settings": "설정",
-        "version": "버전",
-        "theme": "테마",
-        "personal": {
-            "name": "개인 설정",
-            "options": {
-                "theme": "테마",
-                "language": "언어",
-                "defaultView": "기본 보기",
-                "desktop_notifications": "데스크톱 알림",
-                "lastfmScrobbling": "Last.fm으로 스크로블",
-                "listenBrainzScrobbling": "ListenBrainz로 스크로블",
-                "replaygain": "리플레이게인 모드",
-                "preAmp": "리플레이게인 프리앰프 (dB)",
-                "gain": {
-                    "none": "비활성화",
-                    "album": "앨범 게인 사용",
-                    "track": "트랙 게인 사용"
-                }
-            }
-        },
-        "albumList": "앨범",
-        "about": "정보",
-        "playlists": "재생목록",
-        "sharedPlaylists": "공유된 재생목록"
+    "user": {
+      "name": "사용자 |||| 사용자들",
+      "fields": {
+        "userName": "사용자이름",
+        "isAdmin": "관리자",
+        "lastLoginAt": "마지막 로그인",
+        "lastAccessAt": "마지막 접속",
+        "updatedAt": "업데이트됨",
+        "name": "이름",
+        "password": "비밀번호",
+        "createdAt": "생성됨",
+        "changePassword": "비밀번호를 변경할까요?",
+        "currentPassword": "현재 비밀번호",
+        "newPassword": "새 비밀번호",
+        "token": "토큰"
+      },
+      "helperTexts": {
+        "name": "이름 변경 사항은 다음 로그인 시에만 반영됨"
+      },
+      "notifications": {
+        "created": "사용자 생성됨",
+        "updated": "사용자 업데이트됨",
+        "deleted": "사용자 삭제됨"
+      },
+      "message": {
+        "listenBrainzToken": "ListenBrainz 사용자 토큰을 입력하세요.",
+        "clickHereForToken": "여기를 클릭하여 토큰을 얻으세요"
+      }
     },
     "player": {
-        "playListsText": "대기열 재생",
-        "openText": "열기",
-        "closeText": "닫기",
-        "notContentText": "음악 없음",
-        "clickToPlayText": "재생하려면 클릭",
-        "clickToPauseText": "일시 중지하려면 클릭",
-        "nextTrackText": "다음 트랙",
-        "previousTrackText": "이전 트랙",
-        "reloadText": "다시 로드하기",
-        "volumeText": "볼륨",
-        "toggleLyricText": "가사 전환",
-        "toggleMiniModeText": "최소화",
-        "destroyText": "제거",
-        "downloadText": "다운로드",
-        "removeAudioListsText": "오디오 목록 삭제",
-        "clickToDeleteText": "%{name}을(를) 삭제하려면 클릭",
-        "emptyLyricText": "가사 없음",
-        "playModeText": {
-            "order": "순서대로",
-            "orderLoop": "반복",
-            "singleLoop": "노래 하나 반복",
-            "shufflePlay": "셔플"
-        }
+      "name": "플레이어 |||| 플레이어들",
+      "fields": {
+        "name": "이름",
+        "transcodingId": "트랜스코딩",
+        "maxBitRate": "최대 비트레이트",
+        "client": "클라이언트",
+        "userName": "사용자이름",
+        "lastSeen": "마지막으로 봤음",
+        "reportRealPath": "실제 경로 보고서",
+        "scrobbleEnabled": "외부 서비스에 스크로블 보내기"
+      }
     },
-    "about": {
-        "links": {
-            "homepage": "홈페이지",
-            "source": "소스 코드",
-            "featureRequests": "기능 요청"
-        }
+"transcoding": {
+      "name": "트랜스코딩 |||| 트랜스코딩",
+      "fields": {
+        "name": "이름",
+        "targetFormat": "대상 형식",
+        "defaultBitRate": "기본 비트레이트",
+        "command": "명령"
+      }
     },
-    "activity": {
-        "title": "활동",
-        "totalScanned": "스캔된 전체 폴더",
-        "quickScan": "빠른 스캔",
-        "fullScan": "전체 스캔",
-        "serverUptime": "서버 가동 시간",
-        "serverDown": "오프라인"
+    "playlist": {
+      "name": "재생목록 |||| 재생목록들",
+      "fields": {
+        "name": "이름",
+        "duration": "지속",
+        "ownerName": "소유자",
+        "public": "공개",
+        "updatedAt": "업데이트됨",
+        "createdAt": "생성됨",
+        "songCount": "노래",
+        "comment": "댓글",
+        "sync": "자동 가져오기",
+        "path": "다음에서 가져오기"
+      },
+      "actions": {
+        "selectPlaylist": "재생목록 선택:",
+        "addNewPlaylist": "\"%{name}\" 만들기",
+        "export": "내보내기",
+        "makePublic": "공개 만들기",
+        "makePrivate": "비공개 만들기"
+      },
+      "message": {
+        "duplicate_song": "중복된 노래 추가",
+        "song_exist": "이미 재생목록에 존재하는 노래입니다. 중복을 추가할까요 아니면 건너뛸까요?"
+      }
     },
-    "help": {
-        "title": "Navidrome 단축키",
-        "hotkeys": {
-            "show_help": "이 도움말 표시",
-            "toggle_menu": "메뉴 사이드바 전환",
-            "toggle_play": "재생 / 일시 중지",
-            "prev_song": "이전 노래",
-            "next_song": "다음 노래",
-            "vol_up": "볼륨 높이기",
-            "vol_down": "볼륨 낮추기",
-            "toggle_love": "이 트랙을 즐겨찾기에 추가",
-            "current_song": "현재 노래로 이동"
-        }
+    "radio": {
+      "name": "라디오 |||| 라디오들",
+      "fields": {
+        "name": "이름",
+        "streamUrl": "스트리밍 URL",
+        "homePageUrl": "홈페이지 URL",
+        "updatedAt": "업데이트됨",
+        "createdAt": "생성됨"
+      },
+      "actions": {
+        "playNow": "지금 재생"
+      }
+    },
+    "share": {
+      "name": "공유 |||| 공유되는 것들",
+      "fields": {
+        "username": "공유됨",
+        "url": "URL",
+        "description": "설명",
+        "downloadable": "다운로드를 허용할까요?",
+        "contents": "컨텐츠",
+        "expiresAt": "만료",
+        "lastVisitedAt": "마지막 방문",
+        "visitCount": "방문 수",
+        "format": "형식",
+        "maxBitRate": "최대 비트레이트",
+        "updatedAt": "업데이트됨",
+        "createdAt": "생성됨"
+      },
+      "notifications": {},
+      "actions": {}
+    },
+    "missing": {
+      "name": "누락 파일 |||| 누락 파일들",
+      "empty": "누락 파일 없음",
+      "fields": {
+        "path": "경로",
+        "size": "크기",
+        "updatedAt": "사라짐"
+      },
+      "actions": {
+        "remove": "제거"
+      },
+      "notifications": {
+        "removed": "누락된 파일이 제거되었음"
+      }
     }
+  },
+  "ra": {
+    "auth": {
+      "welcome1": "Navidrome을 설치해 주셔서 감사합니다!",
+      "welcome2": "관리자를 만들고 시작해 보세요",
+      "confirmPassword": "비밀번호 확인",
+      "buttonCreateAdmin": "관리자 만들기",
+      "auth_check_error": "계속하려면 로그인하세요",
+      "user_menu": "프로파일",
+      "username": "사용자이름",
+      "password": "비밀번호",
+      "sign_in": "가입",
+      "sign_in_error": "인증에 실패했습니다. 다시 시도하세요",
+      "logout": "로그아웃",
+      "insightsCollectionNote": "Navidrome은 프로젝트 개선을 위해 익명의 사용 데이터를\n수집합니다. 자세한 내용을 알아보고 원치 않으시면 [여기]를\n클릭하여 수신 거부하세요"
+    },
+    "validation": {
+      "invalidChars": "문자와 숫자만 사용하세요",
+      "passwordDoesNotMatch": "비밀번호가 일치하지 않음",
+      "required": "필수 항목임",
+      "minLength": "%{min}자 이하여야 함",
+      "maxLength": "%{max}자 이하여야 함",
+      "minValue": "%{min}자 이상이어야 함",
+      "maxValue": "%{max}자 이하여야 함",
+      "number": "숫자여야 함",
+      "email": "유효한 이메일이어야 함",
+      "oneOf": "다음 중 하나여야 함: %{options}",
+      "regex": "특정 형식(정규식)과 일치해야 함: %{pattern}",
+      "unique": "고유해야 함",
+      "url": "유효한 URL이어야 함"
+    },
+    "action": {
+      "add_filter": "필터 추가",
+      "add": "추가",
+      "back": "뒤로 가기",
+      "bulk_actions": "1 item selected |||| %{smart_count} 개 항목이 선택되었음",
+      "bulk_actions_mobile": "1 |||| %{smart_count}",
+      "cancel": "취소",
+      "clear_input_value": "값 지우기",
+      "clone": "복제",
+      "confirm": "확인",
+      "create": "만들기",
+      "delete": "삭제",
+      "edit": "편집",
+      "export": "내보내기",
+      "list": "목록",
+      "refresh": "새로 고침",
+      "remove_filter": "이 필터 제거",
+      "remove": "제거",
+      "save": "저장",
+      "search": "검색",
+      "show": "표시",
+      "sort": "정렬",
+      "undo": "실행 취소",
+      "expand": "확장",
+      "close": "닫기",
+      "open_menu": "메뉴 열기",
+      "close_menu": "메뉴 닫기",
+      "unselect": "선택 해제",
+      "skip": "건너뛰기",
+      "share": "공유",
+      "download": "다운로드"
+    },
+    "boolean": {
+      "true": "예",
+      "false": "아니오"
+    },
+    "page": {
+      "create": "%{name} 만들기",
+      "dashboard": "대시보드",
+      "edit": "%{name} #%{id}",
+      "error": "문제가 발생하였음",
+      "list": "%{name}",
+      "loading": "불러오기 중",
+      "not_found": "찾을 수 없음",
+      "show": "%{name} #%{id}",
+      "empty": "아직 %{name}이(가) 없습니다.",
+      "invite": "추가할까요?"
+    },
+    "input": {
+      "file": {
+        "upload_several": "업로드할 파일을 몇 개 놓거나 클릭하여 하나를 선택하세요.",
+        "upload_single": "업로드할 파일을 몇 개 놓거나 클릭하여 선택하세요."
+      },
+      "image": {
+        "upload_several": "업로드할 사진을 몇 개 놓거나 클릭하여 하나를 선택하세요.",
+        "upload_single": "업로드할 사진을 몇 개 놓거나 클릭하여 선택하세요."
+      },
+      "references": {
+        "all_missing": "참조 데이터를 찾을 수 없습니다.",
+        "many_missing": "연관된 참조 중 적어도 하나는 더 이상 사용할 수 없는 것 같습니다.",
+        "single_missing": "연관된 참조는 더 이상 사용할 수 없는 것 같습니다."
+      },
+      "password": {
+        "toggle_visible": "비밀번호 숨기기",
+        "toggle_hidden": "비밀번호 표시"
+      }
+    },
+    "message": {
+      "about": "정보",
+      "are_you_sure": "확실한가요?",
+      "bulk_delete_content": "이 %{name}을(를) 삭제할까요? |||| 이 %{smart_count} 개의 항목을 삭제할까요?",
+      "bulk_delete_title": "%{name} 삭제 |||| %{smart_count} %{name} 삭제",
+      "delete_content": "이 항목을 삭제할까요?",
+      "delete_title": "%{name} #%{id} 삭제",
+      "details": "상세정보",
+      "error": "클라이언트 오류가 발생하여 요청을 완료할 수 없습니다.",
+      "invalid_form": "양식이 유효하지 않습니다. 오류를 확인하세요",
+      "loading": "페이지가 로드 중입니다. 잠시만 기다려 주세요",
+      "no": "아니오",
+      "not_found": "잘못된 URL을 입력했거나 잘못된 링크를 클릭했습니다.",
+      "yes": "예",
+      "unsaved_changes": "일부 변경 사항이 저장되지 않았습니다. 무시할까요?"
+    },
+    "navigation": {
+      "no_results": "결과를 찾을 수 없음",
+      "no_more_results": "페이지 번호 %{page}이(가) 경계를 벗어났습니다. 이전 페이지를 시도해 보세요.",
+      "page_out_of_boundaries": "페이지 번호 %{page}이(가) 경계를 벗어남",
+      "page_out_from_end": "마지막 페이지 뒤로 갈 수 없음",
+      "page_out_from_begin": "1 페이지 앞으로 갈 수 없음",
+      "page_range_info": "%{offsetBegin}-%{offsetEnd} / %{total}",
+      "page_rows_per_page": "페이지당 항목:",
+      "next": "다음",
+      "prev": "이전",
+      "skip_nav": "콘텐츠 건너뛰기"
+    },
+    "notification": {
+      "updated": "요소 업데이트됨 |||| %{smart_count} 개 요소 업데이트됨",
+      "created": "요소 생성됨",
+      "deleted": "요소 삭제됨 |||| %{smart_count} 개 요소 삭제됨",
+      "bad_item": "잘못된 요소",
+      "item_doesnt_exist": "요소가 존재하지 않음",
+      "http_error": "서버 통신 오류",
+      "data_provider_error": "dataProvider 오류입니다. 자세한 내용은 콘솔을 확인하세요.",
+      "i18n_error": "지정된 언어에 대한 번역을 로드할 수 없음",
+      "canceled": "작업이 취소됨",
+      "logged_out": "세션이 종료되었습니다. 다시 연결하세요.",
+      "new_version": "새로운 버전이 출시되었습니다! 이 창을 새로 고침하세요."
+    },
+    "toggleFieldsMenu": {
+      "columnsToDisplay": "표시할 열",
+      "layout": "레이아웃",
+      "grid": "격자",
+      "table": "표"
+    }
+  },
+  "message": {
+    "note": "참고",
+    "transcodingDisabled": "웹 인터페이스를 통한 트랜스코딩 구성 변경은 보안상의 이유로 비활성화되어 있습니다. 트랜스코딩 옵션을 변경(편집 또는 추가)하려면, %{config} 구성 옵션으로 서버를 다시 시작하세요.",
+    "transcodingEnabled": "Navidrome은 현재 %{config}로 실행 중이므로 웹 인터페이스를 사용하여 트랜스코딩 설정에서 시스템 명령을 실행할 수 있습니다. 보안상의 이유로 비활성화하고 트랜스코딩 옵션을 구성할 때만 활성화하는 것이 좋습니다.",
+    "songsAddedToPlaylist": "1 개의 노래를 재생목록에 추가하였음 |||| %{smart_count} 개의 노래를 재생 목록에 추가하였음",
+    "noPlaylistsAvailable": "사용 가능한 노래 없음",
+    "delete_user_title": "사용자 '%{name}' 삭제",
+    "delete_user_content": "이 사용자와 해당 사용자의 모든 데이터(재생 목록 및 환경 설정 포함)를 삭제할까요?",
+    "remove_missing_title": "누락된 파일들 제거",
+    "remove_missing_content": "선택한 누락된 파일을 데이터베이스에서 삭제할까요? 삭제하면 재생 횟수 및 평점을 포함하여 해당 파일에 대한 모든 참조가 영구적으로 삭제됩니다.",
+    "notifications_blocked": "브라우저 설정에서 이 사이트의 알림을 차단하였음",
+    "notifications_not_available": "이 브라우저는 데스크톱 알림을 지원하지 않거나 https를 통해 Navidrome에 접속하고 있지 않음",
+    "lastfmLinkSuccess": "Last.fm이 성공적으로 연결되었고 스크로블링이 활성화되었음",
+    "lastfmLinkFailure": "Last.fm을 연결 해제할 수 없음",
+    "lastfmUnlinkSuccess": "Last.fm 연결 해제 및 스크로블링 비활성화",
+    "lastfmUnlinkFailure": "Last.fm을 연결 해제할 수 없음",
+    "listenBrainzLinkSuccess": "ListenBrainz가 성공적으로 연결되었고, 다음 사용자로 스크로블링이 활성화되었음: %{user}",
+    "listenBrainzLinkFailure": "ListenBrainz를 연결할 수 없음: %{error}",
+    "listenBrainzUnlinkSuccess": "ListenBrainz가 연결 해제되었고 스크로블링이 비활성화되었음",
+    "listenBrainzUnlinkFailure": "ListenBrainz를 연결 해제할 수 없음",
+    "openIn": {
+      "lastfm": "Last.fm에서 열기",
+      "musicbrainz": "MusicBrainz에서 열기"
+    },
+    "lastfmLink": "더 읽기...",
+    "shareOriginalFormat": "오리지널 형식으로 공유",
+    "shareDialogTitle": "%{resource} '%{name}' 공유",
+    "shareBatchDialogTitle": "1 %{resource} 공유 |||| %{smart_count} %{resource} 공유",
+    "shareCopyToClipboard": "클립보드에 복사: Ctrl+C, Enter",
+    "shareSuccess": "URL이 클립보드에 복사되었음: %{url}",
+    "shareFailure": "URL %{url}을 클립보드에 복사하는 중 오류가 발생하였음",
+    "downloadDialogTitle": "%{resource} '%{name}' (%{size}) 다운로드",
+    "downloadOriginalFormat": "오리지널 형식으로 다운로드"
+  },
+  "menu": {
+    "library": "라이브러리",
+    "settings": "설정",
+    "version": "버전",
+    "theme": "테마",
+    "personal": {
+      "name": "개인 설정",
+      "options": {
+        "theme": "테마",
+        "language": "언어",
+        "defaultView": "기본 보기",
+        "desktop_notifications": "데스크톱 알림",
+        "lastfmNotConfigured": "Last.fm API 키가 구성되지 않았음",
+        "lastfmScrobbling": "Last.fm으로 스크로블",
+        "listenBrainzScrobbling": "ListenBrainz로 스크로블",
+        "replaygain": "리플레이게인 모드",
+        "preAmp": "리플레이게인 프리앰프 (dB)",
+        "gain": {
+          "none": "비활성화",
+          "album": "앨범 게인 사용",
+          "track": "트랙 게인 사용"
+        }
+      }
+    },
+    "albumList": "앨범",
+    "playlists": "재생목록",
+    "sharedPlaylists": "공유된 재생목록",
+    "about": "정보"
+  },
+  "player": {
+    "playListsText": "대기열 재생",
+    "openText": "열기",
+    "closeText": "닫기",
+    "notContentText": "음악 없음",
+    "clickToPlayText": "재생하려면 클릭",
+    "clickToPauseText": "일시 중지하려면 클릭",
+    "nextTrackText": "다음 트랙",
+    "previousTrackText": "이전 트랙",
+    "reloadText": "다시 로드하기",
+    "volumeText": "볼륨",
+    "toggleLyricText": "가사 전환",
+    "toggleMiniModeText": "최소화",
+    "destroyText": "제거",
+    "downloadText": "다운로드",
+    "removeAudioListsText": "오디오 목록 삭제",
+    "clickToDeleteText": "%{name}을(를) 삭제하려면 클릭",
+    "emptyLyricText": "가사 없음",
+    "playModeText": {
+      "order": "순서대로",
+      "orderLoop": "반복",
+      "singleLoop": "노래 하나 반복",
+      "shufflePlay": "셔플"
+    }
+  },
+  "about": {
+    "links": {
+      "homepage": "홈페이지",
+      "source": "소스 코드",
+      "featureRequests": "기능 요청",
+      "lastInsightsCollection": "마지막 인사이트 컬렉션",
+      "insights": {
+        "disabled": "비활성화",
+        "waiting": "대기중"
+      }
+    }
+  },
+  "activity": {
+    "title": "활동",
+    "totalScanned": "스캔된 전체 폴더",
+    "quickScan": "빠른 스캔",
+    "fullScan": "전체 스캔",
+    "serverUptime": "서버 가동 시간",
+    "serverDown": "오프라인"
+  },
+  "help": {
+    "title": "Navidrome 단축키",
+    "hotkeys": {
+      "show_help": "이 도움말 표시",
+      "toggle_menu": "메뉴 사이드바 전환",
+      "toggle_play": "재생 / 일시 중지",
+      "prev_song": "이전 노래",
+      "next_song": "다음 노래",
+      "current_song": "현재 노래로 이동",
+      "vol_up": "볼륨 높이기",
+      "vol_down": "볼륨 낮추기",
+      "toggle_love": "이 트랙을 즐겨찾기에 추가"
+    }
+  }
 }

resources/i18n/nl.json

@@ -26,7 +26,16 @@
         "bpm": "BPM",
         "playDate": "Laatst afgespeeld",
         "channels": "Kanalen",
-        "createdAt": "Datum toegevoegd"
+        "createdAt": "Datum toegevoegd",
+        "grouping": "Groep",
+        "mood": "Sfeer",
+        "participants": "Extra deelnemers",
+        "tags": "Extra tags",
+        "mappedTags": "Gemapte tags",
+        "rawTags": "Onbewerkte tags",
+        "bitDepth": "Bit diepte",
+        "sampleRate": "Sample waarde",
+        "missing": "Ontbrekend"
       },
       "actions": {
         "addToQueue": "Voeg toe aan wachtrij",
@@ -58,7 +67,15 @@
         "originalDate": "Origineel",
         "releaseDate": "Uitgegeven",
         "releases": "Uitgave |||| Uitgaven",
-        "released": "Uitgegeven"
+        "released": "Uitgegeven",
+        "recordLabel": "Label",
+        "catalogNum": "Catalogus nummer",
+        "releaseType": "Type",
+        "grouping": "Groep",
+        "media": "Media",
+        "mood": "Sfeer",
+        "date": "Opnamedatum",
+        "missing": "Ontbrekend"
       },
       "actions": {
         "playAll": "Afspelen",
@@ -89,7 +106,24 @@
         "playCount": "Afgespeeld",
         "rating": "Beoordeling",
         "genre": "Genre",
-        "size": "Grootte"
+        "size": "Grootte",
+        "role": "Rol",
+        "missing": "Ontbrekend"
+      },
+      "roles": {
+        "albumartist": "Album artiest |||| Album artiesten",
+        "artist": "Artiest |||| Artiesten",
+        "composer": "Componist |||| Componisten",
+        "conductor": "Dirigent |||| Dirigenten",
+        "lyricist": "Tekstschrijver |||| Tekstschrijvers",
+        "arranger": "Arrangeur |||| Arrangeurs",
+        "producer": "Producent |||| Producenten",
+        "director": "Regisseur |||| Regisseurs",
+        "engineer": "Opnametechnicus |||| Opnametechnici",
+        "mixer": "Mixer |||| Mixers",
+        "remixer": "Remixer |||| Remixers",
+        "djmixer": "DJ Mixer |||| DJ Mixers",
+        "performer": "Performer |||| Performers"
       }
     },
     "user": {
@@ -162,7 +196,8 @@
         "addNewPlaylist": "Creëer \"%{name}\"",
         "export": "Exporteer",
         "makePublic": "Openbaar maken",
-        "makePrivate": "Privé maken"
+        "makePrivate": "Privé maken",
+        "saveQueue": "Bewaar wachtrij als playlist"
       },
       "message": {
         "duplicate_song": "Dubbele nummers toevoegen",
@@ -198,6 +233,22 @@
         "createdAt": "Gecreëerd op",
         "downloadable": "Downloads toestaan?"
       }
+    },
+    "missing": {
+      "name": "Ontbrekend bestand |||| Ontbrekende bestanden",
+      "fields": {
+        "path": "Pad",
+        "size": "Grootte",
+        "updatedAt": "Verdwenen op"
+      },
+      "actions": {
+        "remove": "Verwijder",
+        "remove_all": "Alles verwijderen"
+      },
+      "notifications": {
+        "removed": "Ontbrekende bestanden verwijderd"
+      },
+      "empty": "Geen ontbrekende bestanden"
     }
   },
   "ra": {
@@ -212,7 +263,8 @@
       "password": "Wachtwoord",
       "sign_in": "Inloggen",
       "sign_in_error": "Authenticatie mislukt, probeer opnieuw a.u.b.",
-      "logout": "Uitloggen"
+      "logout": "Uitloggen",
+      "insightsCollectionNote": "Navidrome verzamelt anonieme gebruiksdata om het project te verbeteren. Klik [hier] voor meer info en de mogelijkheid om te weigeren"
     },
     "validation": {
       "invalidChars": "Gebruik alleen letters en cijfers",
@@ -374,7 +426,11 @@
     "shareSuccess": "URL gekopieeerd naar klembord: %{url}",
     "shareFailure": "Fout bij kopieren URL %{url} naar klembord",
     "downloadDialogTitle": "Download %{resource} '%{name}' (%{size})",
-    "shareCopyToClipboard": "Kopieeer naar klembord: Ctrl+C, Enter"
+    "shareCopyToClipboard": "Kopieeer naar klembord: Ctrl+C, Enter",
+    "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."
   },
   "menu": {
     "library": "Bibliotheek",
@@ -396,16 +452,17 @@
           "none": "Uitgeschakeld",
           "album": "Gebruik Album Gain",
           "track": "Gebruik Track Gain"
-        }
+        },
+        "lastfmNotConfigured": "Last.fm API-sleutel is niet geconfigureerd"
       }
     },
     "albumList": "Albums",
     "about": "Over",
-    "playlists": "Playlists",
-    "sharedPlaylists": "Gedeelde playlists"
+    "playlists": "Afspeellijsten",
+    "sharedPlaylists": "Gedeelde afspeellijsten"
   },
   "player": {
-    "playListsText": "Afspeellijst afspelen",
+    "playListsText": "Wachtrij",
     "openText": "Openen",
     "closeText": "Sluiten",
     "notContentText": "Geen muziek",
@@ -433,7 +490,12 @@
     "links": {
       "homepage": "Thuispagina",
       "source": "Broncode",
-      "featureRequests": "Functie verzoeken"
+      "featureRequests": "Functie verzoeken",
+      "lastInsightsCollection": "Laatste inzichten",
+      "insights": {
+        "disabled": "Uitgeschakeld",
+        "waiting": "Wachten"
+      }
     }
   },
   "activity": {
@@ -442,7 +504,10 @@
     "quickScan": "Snelle scan",
     "fullScan": "Volledige scan",
     "serverUptime": "Server uptime",
-    "serverDown": "Offline"
+    "serverDown": "Offline",
+    "scanType": "Type",
+    "status": "Scan fout",
+    "elapsedTime": "Verlopen tijd"
   },
   "help": {
     "title": "Navidrome sneltoetsen",

resources/i18n/no.json

@@ -1,8 +1,8 @@
 {
-  "languageName": "Engelsk",
+  "languageName": "Norsk",
   "resources": {
     "song": {
-      "name": "Låt |||| Låter",
+      "name": "Sang |||| Sanger",
       "fields": {
         "albumArtist": "Album Artist",
         "duration": "Tid",
@@ -11,164 +11,165 @@
         "title": "Tittel",
         "artist": "Artist",
         "album": "Album",
-        "path": "Filbane",
+        "path": "Filsti",
         "genre": "Sjanger",
-        "compilation": "Samling",
+        "compilation": "Samlingg",
         "year": "År",
         "size": "Filstørrelse",
-        "updatedAt": "Oppdatert kl",
-        "bitRate": "Bithastighet",
-        "discSubtitle": "Diskundertekst",
+        "updatedAt": "Oppdatert",
+        "bitRate": "Bit rate",
+        "bitDepth": "Bit depth",
+        "channels": "Kanaler",
+        "discSubtitle": "Disk Undertittel",
         "starred": "Favoritt",
         "comment": "Kommentar",
-        "rating": "Vurdering",
+        "rating": "Rangering",
         "quality": "Kvalitet",
         "bpm": "BPM",
-        "playDate": "Sist spilt",
-        "channels": "Kanaler",
-        "createdAt": "",
-        "grouping": "",
-        "mood": "",
-        "participants": "",
-        "tags": "",
-        "mappedTags": "",
-        "rawTags": "",
-        "bitDepth": ""
+        "playDate": "Sist Avspilt",
+        "createdAt": "Lagt til",
+        "grouping": "Gruppering",
+        "mood": "Stemning",
+        "participants": "Ytterlige deltakere",
+        "tags": "Ytterlige Tags",
+        "mappedTags": "Kartlagte tags",
+        "rawTags": "Rå tags"
       },
       "actions": {
-        "addToQueue": "Spill Senere",
-        "playNow": "Leke nå",
+        "addToQueue": "Avspill senere",
+        "playNow": "Avspill nå",
         "addToPlaylist": "Legg til i spilleliste",
-        "shuffleAll": "Bland alle",
-        "download": "nedlasting",
-        "playNext": "Spill Neste",
-        "info": "Få informasjon"
+        "shuffleAll": "Shuffle Alle",
+        "download": "Last ned",
+        "playNext": "Avspill neste",
+        "info": "Få Info"
       }
     },
     "album": {
-      "name": "Album",
+      "name": "Album |||| Album",
       "fields": {
         "albumArtist": "Album Artist",
         "artist": "Artist",
         "duration": "Tid",
         "songCount": "Sanger",
         "playCount": "Avspillinger",
+        "size": "Størrelse",
         "name": "Navn",
         "genre": "Sjanger",
         "compilation": "Samling",
         "year": "År",
-        "updatedAt": "Oppdatert kl",
+        "date": "Inspillingsdato",
+        "originalDate": "Original",
+        "releaseDate": "Utgitt",
+        "releases": "Utgivelse |||| Utgivelser",
+        "released": "Utgitt",
+        "updatedAt": "Oppdatert",
         "comment": "Kommentar",
-        "rating": "Vurdering",
-        "createdAt": "",
-        "size": "",
-        "originalDate": "",
-        "releaseDate": "",
-        "releases": "",
-        "released": "",
-        "recordLabel": "",
-        "catalogNum": "",
-        "releaseType": "",
-        "grouping": "",
-        "media": "",
-        "mood": ""
+        "rating": "Rangering",
+        "createdAt": "Lagt Til",
+        "recordLabel": "Plateselskap",
+        "catalogNum": "Katalognummer",
+        "releaseType": "Type",
+        "grouping": "Gruppering",
+        "media": "Media",
+        "mood": "Stemning"
       },
       "actions": {
-        "playAll": "Spill",
-        "playNext": "Spill neste",
-        "addToQueue": "Spille senere",
-        "shuffle": "Bland",
+        "playAll": "Avspill",
+        "playNext": "Avspill Neste",
+        "addToQueue": "Avspill Senere",
+        "share": "Del",
+        "shuffle": "Shuffle",
         "addToPlaylist": "Legg til i spilleliste",
-        "download": "nedlasting",
-        "info": "Få informasjon",
-        "share": ""
+        "download": "Last ned",
+        "info": "Få Info"
       },
       "lists": {
         "all": "Alle",
         "random": "Tilfeldig",
         "recentlyAdded": "Nylig lagt til",
-        "recentlyPlayed": "Nylig spilt",
-        "mostPlayed": "Mest spilte",
+        "recentlyPlayed": "Nylig Avspilt",
+        "mostPlayed": "Mest Avspilt",
         "starred": "Favoritter",
-        "topRated": "Topp rangert"
+        "topRated": "Top Rangert"
       }
     },
     "artist": {
       "name": "Artist |||| Artister",
       "fields": {
         "name": "Navn",
-        "albumCount": "Antall album",
-        "songCount": "Antall sanger",
-        "playCount": "Spiller",
-        "rating": "Vurdering",
+        "albumCount": "Album Antall",
+        "songCount": "Song Antall",
+        "size": "Størrelse",
+        "playCount": "Avspillinger",
+        "rating": "Rangering",
         "genre": "Sjanger",
-        "size": "",
-        "role": ""
+        "role": "Rolle"
       },
       "roles": {
-        "albumartist": "",
-        "artist": "",
-        "composer": "",
-        "conductor": "",
-        "lyricist": "",
-        "arranger": "",
-        "producer": "",
-        "director": "",
-        "engineer": "",
-        "mixer": "",
-        "remixer": "",
-        "djmixer": "",
-        "performer": ""
+        "albumartist": "Album Artist |||| Album Artister",
+        "artist": "Artist |||| Artister",
+        "composer": "Composer |||| Composers",
+        "conductor": "Conductor |||| Conductors",
+        "lyricist": "Lyriker |||| Lyriker",
+        "arranger": "Arranger |||| Arrangers",
+        "producer": "Produsent |||| Produsenter",
+        "director": "Director |||| Directors",
+        "engineer": "Engineer |||| Engineers",
+        "mixer": "Mixer |||| Mixers",
+        "remixer": "Remixer |||| Remixers",
+        "djmixer": "DJ Mixer |||| DJ Mixers",
+        "performer": "Performer |||| Performers"
       }
     },
     "user": {
       "name": "Bruker |||| Brukere",
       "fields": {
         "userName": "Brukernavn",
-        "isAdmin": "er admin",
-        "lastLoginAt": "Siste pålogging kl",
-        "updatedAt": "Oppdatert kl",
+        "isAdmin": "Admin",
+        "lastLoginAt": "Sist Pålogging",
+        "lastAccessAt": "Sist Tilgang",
+        "updatedAt": "Oppdatert",
         "name": "Navn",
         "password": "Passord",
-        "createdAt": "Opprettet kl",
-        "changePassword": "Bytte Passord",
+        "createdAt": "Opprettet",
+        "changePassword": "Bytt Passord?",
         "currentPassword": "Nåværende Passord",
         "newPassword": "Nytt Passord",
-        "token": "Token",
-        "lastAccessAt": ""
+        "token": "Token"
       },
       "helperTexts": {
-        "name": "Endringer i navnet ditt vil kun gjenspeiles ved neste pålogging"
+        "name": "Navnendringer vil ikke være synlig før neste pålogging"
       },
       "notifications": {
         "created": "Bruker opprettet",
         "updated": "Bruker oppdatert",
-        "deleted": "Bruker fjernet"
+        "deleted": "Bruker slettet"
       },
       "message": {
-        "listenBrainzToken": "Skriv inn ListenBrainz-brukertokenet ditt.",
-        "clickHereForToken": "Klikk her for å få tokenet ditt"
+        "listenBrainzToken": "Fyll inn din ListenBrainz bruker token.",
+        "clickHereForToken": "Klikk her for å hente din token"
       }
     },
     "player": {
-      "name": "Avspiller |||| Avspillere",
+      "name": "Musikkavspiller |||| Musikkavspillere",
       "fields": {
         "name": "Navn",
-        "transcodingId": "Omkoding",
-        "maxBitRate": "Maks. Bithastighet",
+        "transcodingId": "Transkoding",
+        "maxBitRate": "Maks. Bit Rate",
         "client": "Klient",
         "userName": "Brukernavn",
-        "lastSeen": "Sist sett kl",
-        "reportRealPath": "Rapporter ekte sti",
+        "lastSeen": "Sist sett",
+        "reportRealPath": "Rapporter ekte filsti",
         "scrobbleEnabled": "Send Scrobbles til eksterne tjenester"
       }
     },
     "transcoding": {
-      "name": "Omkoding |||| Omkodinger",
+      "name": "Transkoding |||| Transkodinger",
       "fields": {
         "name": "Navn",
-        "targetFormat": "Målformat",
-        "defaultBitRate": "Standard bithastighet",
+        "targetFormat": "Mål Format",
+        "defaultBitRate": "Default Bit Rate",
         "command": "Kommando"
       }
     },
@@ -176,135 +177,137 @@
       "name": "Spilleliste |||| Spillelister",
       "fields": {
         "name": "Navn",
-        "duration": "Varighet",
-        "ownerName": "Eieren",
+        "duration": "Lengde",
+        "ownerName": "Eier",
         "public": "Offentlig",
-        "updatedAt": "Oppdatert kl",
-        "createdAt": "Opprettet kl",
+        "updatedAt": "Oppdatert",
+        "createdAt": "Opprettet",
         "songCount": "Sanger",
         "comment": "Kommentar",
-        "sync": "Autoimport",
-        "path": "Import fra"
+        "sync": "Auto-importer",
+        "path": "Importer fra"
       },
       "actions": {
         "selectPlaylist": "Velg en spilleliste:",
         "addNewPlaylist": "Opprett \"%{name}\"",
-        "export": "Eksport",
-        "makePublic": "Gjør offentlig",
-        "makePrivate": "Gjør privat"
+        "export": "Eksporter",
+        "makePublic": "Gjør Offentlig",
+        "makePrivate": "Gjør Privat"
       },
       "message": {
-        "duplicate_song": "Legg til dupliserte sanger",
-        "song_exist": "Det legges til duplikater i spillelisten. Vil du legge til duplikatene eller hoppe over dem?"
+        "duplicate_song": "Legg til Duplikater",
+        "song_exist": "Duplikater har blitt lagt til i spillelisten. Ønsker du å legge til duplikater eller hoppe over de?"
       }
     },
     "radio": {
-      "name": "",
+      "name": "Radio |||| Radio",
       "fields": {
-        "name": "",
-        "streamUrl": "",
-        "homePageUrl": "",
-        "updatedAt": "",
-        "createdAt": ""
+        "name": "Navn",
+        "streamUrl": "Stream URL",
+        "homePageUrl": "Hjemmeside URL",
+        "updatedAt": "Oppdatert",
+        "createdAt": "Opprettet"
       },
       "actions": {
-        "playNow": ""
+        "playNow": "Avspill"
       }
     },
     "share": {
-      "name": "",
+      "name": "Del |||| Delinger",
       "fields": {
-        "username": "",
-        "url": "",
-        "description": "",
-        "contents": "",
-        "expiresAt": "",
-        "lastVisitedAt": "",
-        "visitCount": "",
-        "format": "",
-        "maxBitRate": "",
-        "updatedAt": "",
-        "createdAt": "",
-        "downloadable": ""
-      }
+        "username": "Delt Av",
+        "url": "URL",
+        "description": "Beskrivelse",
+        "downloadable": "Tillat Nedlastinger?",
+        "contents": "Innhold",
+        "expiresAt": "Utløper",
+        "lastVisitedAt": "Sist Besøkt",
+        "visitCount": "Visninger",
+        "format": "Format",
+        "maxBitRate": "Maks. Bit Rate",
+        "updatedAt": "Oppdatert",
+        "createdAt": "Opprettet"
+      },
+      "notifications": {},
+      "actions": {}
     },
     "missing": {
-      "name": "",
+      "name": "Manglende Fil|||| Manglende Filer",
+      "empty": "Ingen Manglende Filer",
       "fields": {
-        "path": "",
-        "size": "",
-        "updatedAt": ""
+        "path": "Filsti",
+        "size": "Størrelse",
+        "updatedAt": "Ble borte"
       },
       "actions": {
-        "remove": ""
+        "remove": "Fjern"
       },
       "notifications": {
-        "removed": ""
-      },
-      "empty": ""
+        "removed": "Manglende fil(er) fjernet"
+      }
     }
   },
   "ra": {
     "auth": {
       "welcome1": "Takk for at du installerte Navidrome!",
-      "welcome2": "Opprett en admin -bruker for å starte",
+      "welcome2": "La oss begynne med å lage en admin bruker.",
       "confirmPassword": "Bekreft Passord",
       "buttonCreateAdmin": "Opprett Admin",
-      "auth_check_error": "Vennligst Logg inn for å fortsette",
+      "auth_check_error": "Logg inn for å fortsette",
       "user_menu": "Profil",
       "username": "Brukernavn",
       "password": "Passord",
       "sign_in": "Logg inn",
-      "sign_in_error": "Autentisering mislyktes. Prøv på nytt",
+      "sign_in_error": "Autentiseringsfeil, vennligst prøv igjen",
       "logout": "Logg ut",
-      "insightsCollectionNote": ""
+      "insightsCollectionNote": "Navidrome innhenter anonymisert forbruksdata\nfor å hjelpe og forbedre prosjektet.\nTrykk [her] for å lære mer og for å melde deg av hvis ønskelig."
     },
     "validation": {
-      "invalidChars": "Bruk bare bokstaver og tall",
-      "passwordDoesNotMatch": "Passordet er ikke like",
-      "required": "Obligatorisk",
-      "minLength": "Må være minst %{min} tegn",
-      "maxLength": "Må være %{max} tegn eller færre",
+      "invalidChars": "Det er kun bokstaver og tall som støttes",
+      "passwordDoesNotMatch": "Passord samstemmer ikke",
+      "required": "Kreves",
+      "minLength": "Må være minst %{min} karakterer.",
+      "maxLength": "Må være %{max} karakterer eller mindre",
       "minValue": "Må være minst %{min}",
       "maxValue": "Må være %{max} eller mindre",
       "number": "Må være et tall",
-      "email": "Må være en gyldig e-post",
+      "email": "Må være en gyldig epost",
       "oneOf": "Må være en av: %{options}",
-      "regex": "Må samsvare med et spesifikt format (regexp): %{pattern}",
-      "unique": "Må være unik",
-      "url": ""
+      "regex": "Må samstemme med et spesifikt format (regexp): %{pattern}",
+      "unique": "Må være unikt",
+      "url": "Må være en gyldig URL"
     },
     "action": {
       "add_filter": "Legg til filter",
-      "add": "Legge til",
-      "back": "Gå tilbake",
-      "bulk_actions": "1 element valgt |||| %{smart_count} elementer er valgt",
+      "add": "Legg Til",
+      "back": "Tilbake",
+      "bulk_actions": "1 element valgt |||| %{smart_count} elementer valgt",
+      "bulk_actions_mobile": "1 |||| %{smart_count}",
       "cancel": "Avbryt",
-      "clear_input_value": "Klar verdi",
+      "clear_input_value": "Nullstill verdi",
       "clone": "Klone",
-      "confirm": "Bekrefte",
-      "create": "Skape",
+      "confirm": "Bekreft",
+      "create": "Opprett",
       "delete": "Slett",
-      "edit": "Redigere",
-      "export": "Eksport",
+      "edit": "Rediger",
+      "export": "Eksporter",
       "list": "Liste",
-      "refresh": "oppdater",
+      "refresh": "Oppdater",
       "remove_filter": "Fjern dette filteret",
-      "remove": "Fjerne",
+      "remove": "Fjern",
       "save": "Lagre",
       "search": "Søk",
       "show": "Vis",
-      "sort": "Sortere",
+      "sort": "Sorter",
       "undo": "Angre",
-      "expand": "Utvide",
+      "expand": "Utvid",
       "close": "Lukk",
-      "open_menu": "Åpne menyen",
-      "close_menu": "Lukk menyen",
-      "unselect": "Fjern valget",
+      "open_menu": "Åpne meny",
+      "close_menu": "Lukk meny",
+      "unselect": "Avvelg",
       "skip": "Hopp over",
-      "bulk_actions_mobile": "",
-      "share": "",
-      "download": ""
+      "share": "Del",
+      "download": "Last Ned"
     },
     "boolean": {
       "true": "Ja",
@@ -312,29 +315,29 @@
     },
     "page": {
       "create": "Opprett %{name}",
-      "dashboard": "Dashbord",
+      "dashboard": "Dashboard",
       "edit": "%{name} #%{id}",
       "error": "Noe gikk galt",
-      "list": "%{Navn}",
+      "list": "%{name}",
       "loading": "Laster",
-      "not_found": "Ikke funnet",
+      "not_found": "Ikke Funnet",
       "show": "%{name} #%{id}",
-      "empty": "Ingen %{name} ennå.",
-      "invite": "Vil du legge til en?"
+      "empty": "Ingen %{name} enda.",
+      "invite": "Ønsker du å legge til en?"
     },
     "input": {
       "file": {
-        "upload_several": "Slipp noen filer for å laste opp, eller klikk for å velge en.",
-        "upload_single": "Slipp en fil for å laste opp, eller klikk for å velge den."
+        "upload_several": "Dra filer hit for å laste opp, eller klikk for å velge en.",
+        "upload_single": "Dra en fil hit for å laste opp, eller klikk for å velge den."
       },
       "image": {
-        "upload_several": "Slipp noen bilder for å laste opp, eller klikk for å velge ett.",
-        "upload_single": "Slipp et bilde for å laste opp, eller klikk for å velge det."
+        "upload_several": "Dra bilder hit for å laste opp, eller klikk for å velge en.",
+        "upload_single": "Dra et bilde hit for å laste opp, eller klikk for å velge den."
       },
       "references": {
-        "all_missing": "Kan ikke finne referansedata.",
-        "many_missing": "Minst én av de tilknyttede referansene ser ikke ut til å være tilgjengelig lenger.",
-        "single_missing": "Tilknyttet referanse ser ikke lenger ut til å være tilgjengelig."
+        "all_missing": "Finner ikke referansedata.",
+        "many_missing": "Minst en av de tilhørende referansene ser ikke lenger ut til å være tilgjengelig.",
+        "single_missing": "Tilhørende referanse ser ikke lenger ut til å være tilgjengelig."
       },
       "password": {
         "toggle_visible": "Skjul passord",
@@ -346,86 +349,86 @@
       "are_you_sure": "Er du sikker?",
       "bulk_delete_content": "Er du sikker på at du vil slette denne %{name}? |||| Er du sikker på at du vil slette disse %{smart_count} elementene?",
       "bulk_delete_title": "Slett %{name} |||| Slett %{smart_count} %{name}",
-      "delete_content": "Er du sikker på at du vil slette dette elementet?",
+      "delete_content": "Er du sikker på at du ønsker å slette dette elementet?",
       "delete_title": "Slett %{name} #%{id}",
       "details": "Detaljer",
-      "error": "Det oppstod en klientfeil og forespørselen din kunne ikke fullføres.",
-      "invalid_form": "Skjemaet er ikke gyldig. Vennligst se etter feil",
-      "loading": "Siden lastes, bare et øyeblikk",
+      "error": "En klient feil har oppstått og din forespørsel lot seg ikke gjennomføre.",
+      "invalid_form": "Skjemaet er ikke gyldig. Vennligst se etter feil.",
+      "loading": "Siden laster, vennligst vent.",
       "no": "Nei",
-      "not_found": "Enten skrev du inn feil URL, eller så fulgte du en dårlig lenke.",
+      "not_found": "Enten skrev du feil URL, eller så har du fulgt en dårlig link.",
       "yes": "Ja",
-      "unsaved_changes": "Noen av endringene dine ble ikke lagret. Er du sikker på at du vil ignorere dem?"
+      "unsaved_changes": "Noen av dine endringer ble ikke lagret. Er du sikker på at du ønsker å ignorere de?"
     },
     "navigation": {
       "no_results": "Ingen resultater",
-      "no_more_results": "Sidetallet %{page} er utenfor grensene. Prøv forrige side.",
-      "page_out_of_boundaries": "Sidetall %{page} utenfor grensene",
-      "page_out_from_end": "Kan ikke gå etter siste side",
-      "page_out_from_begin": "Kan ikke gå før side 1",
+      "no_more_results": "Sidenummeret %{page} er utenfor grensene. Prøv forrige side.",
+      "page_out_of_boundaries": "Sidenummer %{page} er utenfor grensene",
+      "page_out_from_end": "Kan ikke være etter siste side",
+      "page_out_from_begin": "Kan ikke være før side 1",
       "page_range_info": "%{offsetBegin}-%{offsetEnd} av %{total}",
       "page_rows_per_page": "Elementer per side:",
       "next": "Neste",
       "prev": "Forrige",
-      "skip_nav": "Hopp til innholdet"
+      "skip_nav": "Hopp til innhold"
     },
     "notification": {
-      "updated": "Element oppdatert |||| %{smart_count} elementer er oppdatert",
+      "updated": "Element oppdatert |||| %{smart_count} elementer oppdatert",
       "created": "Element opprettet",
       "deleted": "Element slettet |||| %{smart_count} elementer slettet",
       "bad_item": "Feil element",
-      "item_doesnt_exist": "Elementet eksisterer ikke",
-      "http_error": "Serverkommunikasjonsfeil",
-      "data_provider_error": "dataleverandørfeil. Sjekk konsollen for detaljer.",
-      "i18n_error": "Kan ikke laste oversettelsene for det angitte språket",
-      "canceled": "Handlingen avbrutt",
-      "logged_out": "Økten din er avsluttet. Koble til på nytt.",
-      "new_version": "Ny versjon tilgjengelig! Trykk Oppdater "
+      "item_doesnt_exist": "Element eksisterer ikke",
+      "http_error": "Kommunikasjonsfeil mot server",
+      "data_provider_error": "dataProvider feil. Sjekk konsollet for feil.",
+      "i18n_error": "Klarte ikke laste oversettelser for valgt språk.",
+      "canceled": "Handling avbrutt",
+      "logged_out": "Din sesjon er avsluttet, vennligst koble til på nytt.",
+      "new_version": "Ny versjon tilgjengelig! Vennligst last siden på nytt."
     },
     "toggleFieldsMenu": {
-      "columnsToDisplay": "Kolonner som skal vises",
-      "layout": "Oppsett",
-      "grid": "Nett",
-      "table": "Bord"
+      "columnsToDisplay": "Vis følgende kolonner",
+      "layout": "Layout",
+      "grid": "Rutenett",
+      "table": "Tabell"
     }
   },
   "message": {
-    "note": "Info",
-    "transcodingDisabled": "Endring av transkodingskonfigurasjonen gjennom webgrensesnittet er deaktivert av sikkerhetsgrunner. Hvis du ønsker å endre (redigere eller legge til) transkodingsalternativer, start serveren på nytt med %{config}-konfigurasjonsalternativet.",
-    "transcodingEnabled": "Navidrome kjører for øyeblikket med %{config}, noe som gjør det mulig å kjøre systemkommandoer fra transkodingsinnstillingene ved å bruke nettgrensesnittet. Vi anbefaler å deaktivere den av sikkerhetsgrunner og bare aktivere den når du konfigurerer alternativer for omkoding.",
+    "note": "NOTAT",
+    "transcodingDisabled": "Endringer på transkodingkonfigurasjon fra web grensesnittet er deaktivert grunnet sikkerhet. Hvis du ønsker å endre eller legge til transkodingsmuligheter, restart serveren med %{config} konfigurasjonsalternativ.",
+    "transcodingEnabled": "Navidrome kjører for øyeblikket med %{config}, som gjør det mulig å kjøre systemkommandoer fra transkodingsinstillinger i web grensesnittet. Vi anbefaler å deaktivere denne muligheten av sikkerhetsårsaker og heller kun ha det aktivert under konfigurasjon av transkodingsmuligheter.",
     "songsAddedToPlaylist": "Lagt til 1 sang i spillelisten |||| Lagt til %{smart_count} sanger i spillelisten",
     "noPlaylistsAvailable": "Ingen tilgjengelig",
-    "delete_user_title": "Slett bruker «%{name}»",
-    "delete_user_content": "Er du sikker på at du vil slette denne brukeren og alle dataene deres (inkludert spillelister og preferanser)?",
-    "notifications_blocked": "Du har blokkert varsler for dette nettstedet i nettleserens innstillinger",
-    "notifications_not_available": "Denne nettleseren støtter ikke skrivebordsvarsler, eller du har ikke tilgang til Navidrome over https",
-    "lastfmLinkSuccess": "Last.fm er vellykket koblet og scrobbling aktivert",
-    "lastfmLinkFailure": "Last.fm kunne ikke kobles til",
-    "lastfmUnlinkSuccess": "Last.fm koblet fra og scrobbling deaktivert",
-    "lastfmUnlinkFailure": "Last.fm kunne ikke kobles fra",
+    "delete_user_title": "Slett bruker '%{name}'",
+    "delete_user_content": "Er du sikker på at du vil slette denne brukeren og all tilhørlig data (inkludert spillelister og preferanser)?",
+    "remove_missing_title": "Fjern manglende filer",
+    "remove_missing_content": "Er du sikker på at du ønsker å fjerne de valgte manglende filene fra databasen? Dette vil permanent fjerne alle referanser til de, inkludert antall avspillinger og rangeringer.",
+    "notifications_blocked": "Du har blokkert notifikasjoner for denne nettsiden i din nettleser.",
+    "notifications_not_available": "Denne nettleseren støtter ikke skrivebordsnotifikasjoner, eller så er du ikke tilkoblet Navidrome via https.",
+    "lastfmLinkSuccess": "Last.fm er tilkoblet og scrobbling er aktivert",
+    "lastfmLinkFailure": "Last.fm kunne ikke koble til",
+    "lastfmUnlinkSuccess": "Last.fm er avkoblet og scrobbling er deaktivert",
+    "lastfmUnlinkFailure": "Last.fm kunne ikke avkobles",
+    "listenBrainzLinkSuccess": "ListenBrainz er koblet til og scrobbling er aktivert som bruker: %{user}",
+    "listenBrainzLinkFailure": "ListenBrainz kunne ikke koble til: %{error}",
+    "listenBrainzUnlinkSuccess": "ListenBrainz er avkoblet og scrobbling er deaktivert",
+    "listenBrainzUnlinkFailure": "ListenBrainz kunne ikke avkobles",
     "openIn": {
       "lastfm": "Åpne i Last.fm",
       "musicbrainz": "Åpne i MusicBrainz"
     },
-    "lastfmLink": "Les mer...",
-    "listenBrainzLinkSuccess": "ListenBrainz er vellykket koblet og scrobbling aktivert som bruker: %{user}",
-    "listenBrainzLinkFailure": "ListenBrainz kunne ikke kobles: %{error}",
-    "listenBrainzUnlinkSuccess": "ListenBrainz koblet fra og scrobbling deaktivert",
-    "listenBrainzUnlinkFailure": "ListenBrainz kunne ikke fjernes",
-    "downloadOriginalFormat": "",
-    "shareOriginalFormat": "",
-    "shareDialogTitle": "",
-    "shareBatchDialogTitle": "",
-    "shareSuccess": "",
-    "shareFailure": "",
-    "downloadDialogTitle": "",
-    "shareCopyToClipboard": "",
-    "remove_missing_title": "",
-    "remove_missing_content": ""
+    "lastfmLink": "Les Mer...",
+    "shareOriginalFormat": "Del i originalformat",
+    "shareDialogTitle": "Del %{resource} '%{name}'",
+    "shareBatchDialogTitle": "Del 1 %{resource} |||| Del %{smart_count} %{resource}",
+    "shareCopyToClipboard": "Kopier til utklippstavle: Ctrl+C, Enter",
+    "shareSuccess": "URL kopiert til utklippstavle: %{url}",
+    "shareFailure": "Error ved kopiering av URL %{url} til utklippstavle",
+    "downloadDialogTitle": "Last ned %{resource} '%{name}' (%{size})",
+    "downloadOriginalFormat": "Last ned i originalformat"
   },
   "menu": {
     "library": "Bibliotek",
-    "settings": "Innstillinger",
+    "settings": "Instillinger",
     "version": "Versjon",
     "theme": "Tema",
     "personal": {
@@ -434,81 +437,81 @@
         "theme": "Tema",
         "language": "Språk",
         "defaultView": "Standardvisning",
-        "desktop_notifications": "Skrivebordsvarsler",
+        "desktop_notifications": "Skrivebordsnotifikasjoner",
+        "lastfmNotConfigured": "Last.fm API-Key er ikke konfigurert",
         "lastfmScrobbling": "Scrobble til Last.fm",
         "listenBrainzScrobbling": "Scrobble til ListenBrainz",
-        "replaygain": "",
-        "preAmp": "",
+        "replaygain": "ReplayGain Mode",
+        "preAmp": "ReplayGain PreAmp (dB)",
         "gain": {
-          "none": "",
-          "album": "",
-          "track": ""
-        },
-        "lastfmNotConfigured": ""
+          "none": "Deaktivert",
+          "album": "Bruk Album Gain",
+          "track": "Bruk Track Gain"
+        }
       }
     },
     "albumList": "Album",
-    "about": "Om",
-    "playlists": "Spilleliste",
-    "sharedPlaylists": "Delte spillelister"
+    "playlists": "Spillelister",
+    "sharedPlaylists": "Delte Spillelister",
+    "about": "Om"
   },
   "player": {
-    "playListsText": "Spillekø",
+    "playListsText": "Spill Av Kø",
     "openText": "Åpne",
     "closeText": "Lukk",
     "notContentText": "Ingen musikk",
-    "clickToPlayText": "Klikk for å spille",
-    "clickToPauseText": "Klikk for å sette på pause",
+    "clickToPlayText": "Klikk for å avspille",
+    "clickToPauseText": "Klikk for å pause",
     "nextTrackText": "Neste spor",
     "previousTrackText": "Forrige spor",
-    "reloadText": "Last inn på nytt",
+    "reloadText": "Last på nytt",
     "volumeText": "Volum",
-    "toggleLyricText": "Veksle mellom tekster",
+    "toggleLyricText": "Slå på/av sangtekster",
     "toggleMiniModeText": "Minimer",
-    "destroyText": "Ødelegge",
-    "downloadText": "nedlasting",
+    "destroyText": "Ødelegg",
+    "downloadText": "Last Ned",
     "removeAudioListsText": "Slett lydlister",
     "clickToDeleteText": "Klikk for å slette %{name}",
     "emptyLyricText": "Ingen sangtekster",
     "playModeText": {
       "order": "I rekkefølge",
-      "orderLoop": "Gjenta",
-      "singleLoop": "Gjenta engang",
-      "shufflePlay": "Tilfeldig rekkefølge"
+      "orderLoop": "Repeat",
+      "singleLoop": "Repeat En",
+      "shufflePlay": "Shuffle"
     }
   },
   "about": {
     "links": {
       "homepage": "Hjemmeside",
       "source": "Kildekode",
-      "featureRequests": "Funksjonsforespørsler",
-      "lastInsightsCollection": "",
+      "featureRequests": "Funksjonsforespørseler",
+      "lastInsightsCollection": "Siste Innsamling av anonymisert forbruksdata",
       "insights": {
-        "disabled": "",
-        "waiting": ""
+        "disabled": "Deaktivert",
+        "waiting": "Venter"
       }
     }
   },
   "activity": {
     "title": "Aktivitet",
-    "totalScanned": "Totalt skannede mapper",
-    "quickScan": "Rask skanning",
-    "fullScan": "Full skanning",
-    "serverUptime": "Serveroppetid",
+    "totalScanned": "Antall mapper skannet",
+    "quickScan": "Hurtigskann",
+    "fullScan": "Full Skann",
+    "serverUptime": "Server Oppetid",
     "serverDown": "OFFLINE"
   },
   "help": {
-    "title": "Navidrome hurtigtaster",
+    "title": "Navidrome Hurtigtaster",
     "hotkeys": {
-      "show_help": "Vis denne hjelpen",
-      "toggle_menu": "Bytt menysidelinje",
-      "toggle_play": "Spill / Pause",
-      "prev_song": "Forrige sang",
-      "next_song": "Neste sang",
-      "vol_up": "Volum opp",
-      "vol_down": "Volum ned",
-      "toggle_love": "Legg til dette sporet i favoritter",
-      "current_song": ""
+      "show_help": "Vis Hjelp",
+      "toggle_menu": "Åpne/Lukke Sidepanel",
+      "toggle_play": "Avspill / Pause",
+      "prev_song": "Forrige Sang",
+      "next_song": "Neste Sang",
+      "current_song": "Gå til Nåværende Sang",
+      "vol_up": "Volum Opp",
+      "vol_down": "Volum Ned",
+      "toggle_love": "Legg til spor i favoritter"
     }
   }
-}
+}

resources/i18n/pt-br.json

@@ -1,5 +1,5 @@
 {
-  "languageName": "Português",
+  "languageName": "Português (Brasil)",
   "resources": {
     "song": {
       "name": "Música |||| Músicas",
@@ -18,7 +18,6 @@
         "size": "Tamanho",
         "updatedAt": "Últ. Atualização",
         "bitRate": "Bitrate",
-        "bitDepth": "Profundidade de bits",
         "discSubtitle": "Sub-título do disco",
         "starred": "Favorita",
         "comment": "Comentário",
@@ -33,7 +32,10 @@
         "participants": "Outros Participantes",
         "tags": "Outras Tags",
         "mappedTags": "Tags mapeadas",
-        "rawTags": "Tags originais"
+        "rawTags": "Tags originais",
+        "bitDepth": "Profundidade de bits",
+        "sampleRate": "Taxa de amostragem",
+        "missing": "Ausente"
       },
       "actions": {
         "addToQueue": "Adicionar à fila",
@@ -57,7 +59,6 @@
         "genre": "Gênero",
         "compilation": "Coletânea",
         "year": "Ano",
-        "date": "Data de Lançamento",
         "updatedAt": "Últ. Atualização",
         "comment": "Comentário",
         "rating": "Classificação",
@@ -72,7 +73,9 @@
         "releaseType": "Tipo",
         "grouping": "Agrupamento",
         "media": "Mídia",
-        "mood": "Mood"
+        "mood": "Mood",
+        "date": "Data de Lançamento",
+        "missing": "Ausente"
       },
       "actions": {
         "playAll": "Tocar",
@@ -104,7 +107,8 @@
         "rating": "Classificação",
         "genre": "Gênero",
         "size": "Tamanho",
-        "role": "Role"
+        "role": "Role",
+        "missing": "Ausente"
       },
       "roles": {
         "albumartist": "Artista do Álbum |||| Artistas do Álbum",
@@ -192,7 +196,8 @@
         "addNewPlaylist": "Criar \"%{name}\"",
         "export": "Exportar",
         "makePublic": "Pública",
-        "makePrivate": "Pessoal"
+        "makePrivate": "Pessoal",
+        "saveQueue": "Salvar fila em nova Playlist"
       },
       "message": {
         "duplicate_song": "Adicionar músicas duplicadas",
@@ -231,18 +236,19 @@
     },
     "missing": {
       "name": "Arquivo ausente |||| Arquivos ausentes",
-      "empty": "Nenhum arquivo ausente",
       "fields": {
         "path": "Caminho",
         "size": "Tamanho",
         "updatedAt": "Desaparecido em"
       },
       "actions": {
-        "remove": "Remover"
+        "remove": "Remover",
+        "remove_all": "Remover todos"
       },
       "notifications": {
         "removed": "Arquivo(s) ausente(s) removido(s)"
-      }
+      },
+      "empty": "Nenhum arquivo ausente"
     }
   },
   "ra": {
@@ -422,7 +428,9 @@
     "downloadDialogTitle": "Baixar %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Copie para o clipboard: Ctrl+C, Enter",
     "remove_missing_title": "Remover arquivos ausentes",
-    "remove_missing_content": "Você tem certeza que deseja remover os arquivos selecionados do banco de dados? Isso removerá permanentemente qualquer referência a eles, incluindo suas contagens de reprodução e classificações."
+    "remove_missing_content": "Você tem certeza que deseja remover os arquivos selecionados do banco de dados? Isso removerá permanentemente qualquer referência a eles, incluindo suas contagens de reprodução e classificações.",
+    "remove_all_missing_title": "Remover todos os arquivos ausentes",
+    "remove_all_missing_content": "Você tem certeza que deseja remover todos os arquivos ausentes do banco de dados? Isso removerá permanentemente qualquer referência a eles, incluindo suas contagens de reprodução e classificações."
   },
   "menu": {
     "library": "Biblioteca",
@@ -496,7 +504,10 @@
     "quickScan": "Scan rápido",
     "fullScan": "Scan completo",
     "serverUptime": "Uptime do servidor",
-    "serverDown": "DESCONECTADO"
+    "serverDown": "DESCONECTADO",
+    "scanType": "Tipo",
+    "status": "Erro",
+    "elapsedTime": "Duração"
   },
   "help": {
     "title": "Teclas de atalho",

resources/i18n/ru.json

@@ -33,7 +33,9 @@
         "tags": "Дополнительные теги",
         "mappedTags": "Сопоставленные теги",
         "rawTags": "Исходные теги",
-        "bitDepth": "Битовая глубина"
+        "bitDepth": "Битовая глубина (Bit)",
+        "sampleRate": "Частота дискретизации (Hz)",
+        "missing": "Поле отсутствует"
       },
       "actions": {
         "addToQueue": "В очередь",
@@ -72,7 +74,8 @@
         "grouping": "Группирование",
         "media": "Медиа",
         "mood": "Настроение",
-        "date": ""
+        "date": "Дата записи",
+        "missing": "Поле отсутствует"
       },
       "actions": {
         "playAll": "Играть",
@@ -104,7 +107,8 @@
         "rating": "Рейтинг",
         "genre": "Жанр",
         "size": "Размер",
-        "role": "Роль"
+        "role": "Роль",
+        "missing": "Поле отсутствует"
       },
       "roles": {
         "albumartist": "Исполнитель альбома |||| Исполнители альбома",
@@ -156,7 +160,7 @@
       "fields": {
         "name": "Имя",
         "transcodingId": "Транскодирование",
-        "maxBitRate": "Макс. Битрейт",
+        "maxBitRate": "Макс. битрейт",
         "client": "Клиент",
         "userName": "Пользователь",
         "lastSeen": "Был на сайте",
@@ -174,7 +178,7 @@
       }
     },
     "playlist": {
-      "name": "Плейлистов |||| Плейлисты",
+      "name": "Плейлист |||| Плейлисты",
       "fields": {
         "name": "Название",
         "duration": "Длительность",
@@ -192,7 +196,8 @@
         "addNewPlaylist": "Создать \"%{name}\"",
         "export": "Экспорт",
         "makePublic": "Опубликовать",
-        "makePrivate": "Сделать личным"
+        "makePrivate": "Сделать личным",
+        "saveQueue": "Сохранить очередь в плейлист"
       },
       "message": {
         "duplicate_song": "Повторяющиеся треки",
@@ -223,7 +228,7 @@
         "lastVisitedAt": "Последнее посещение",
         "visitCount": "Посещения",
         "format": "Формат",
-        "maxBitRate": "Макс. Битрейт",
+        "maxBitRate": "Макс. битрейт",
         "updatedAt": "Обновлено в",
         "createdAt": "Создано",
         "downloadable": "Разрешить загрузку?"
@@ -237,7 +242,8 @@
         "updatedAt": "Исчез"
       },
       "actions": {
-        "remove": "Удалить"
+        "remove": "Удалить",
+        "remove_all": "Убрать все"
       },
       "notifications": {
         "removed": "Отсутствующие файлы удалены"
@@ -273,7 +279,7 @@
       "oneOf": "Должно быть одним из: %{options}",
       "regex": "Должно быть в формате (regexp): %{pattern}",
       "unique": "Должно быть уникальным",
-      "url": "Должен быть действительным URL адрес"
+      "url": "Должен быть действительный URL"
     },
     "action": {
       "add_filter": "Фильтр",
@@ -290,7 +296,7 @@
       "export": "Экспорт",
       "list": "Список",
       "refresh": "Обновить",
-      "remove_filter": "Убрать фильтр",
+      "remove_filter": "Убрать этот фильтр",
       "remove": "Удалить",
       "save": "Сохранить",
       "search": "Поиск",
@@ -381,7 +387,7 @@
       "i18n_error": "Не удалось загрузить перевод для указанного языка",
       "canceled": "Операция отменена",
       "logged_out": "Ваша сессия завершена, попробуйте переподключиться/войти снова",
-      "new_version": "Доступна новая версия! Пожалуйста, обновите это окно"
+      "new_version": "Доступна новая версия! Пожалуйста, обновите это окно."
     },
     "toggleFieldsMenu": {
       "columnsToDisplay": "Отображение столбцов",
@@ -422,7 +428,9 @@
     "downloadDialogTitle": "Скачать %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Копировать в буфер обмена: Ctrl+C, Enter",
     "remove_missing_title": "Удалить отсутствующие файлы",
-    "remove_missing_content": "Вы уверены, что хотите удалить выбранные отсутствующие файлы из базы данных? Это навсегда удалит все ссылки на них, включая данные о прослушиваниях и рейтингах."
+    "remove_missing_content": "Вы уверены, что хотите удалить выбранные отсутствующие файлы из базы данных? Это навсегда удалит все ссылки на них, включая данные о прослушиваниях и рейтингах.",
+    "remove_all_missing_title": "Удалите все отсутствующие файлы",
+    "remove_all_missing_content": "Вы уверены, что хотите удалить все отсутствующие файлы из базы данных? Это навсегда удалит все упоминания о них, включая количество игр и рейтинг."
   },
   "menu": {
     "library": "Библиотека",
@@ -481,7 +489,7 @@
   "about": {
     "links": {
       "homepage": "Главная",
-      "source": "Код",
+      "source": "Исходный код",
       "featureRequests": "Предложения",
       "lastInsightsCollection": "Последний сбор данных",
       "insights": {
@@ -496,7 +504,10 @@
     "quickScan": "Быстрое сканирование",
     "fullScan": "Полное сканирование",
     "serverUptime": "Время работы сервера",
-    "serverDown": "Оффлайн"
+    "serverDown": "Оффлайн",
+    "scanType": "Тип",
+    "status": "Ошибка сканирования",
+    "elapsedTime": "Прошедшее время"
   },
   "help": {
     "title": "Горячие клавиши Navidrome",
@@ -509,7 +520,7 @@
       "vol_up": "Увеличить громкость",
       "vol_down": "Уменьшить громкость",
       "toggle_love": "Добавить / удалить песню из избранного",
-      "current_song": "Перейти к текущей песне"
+      "current_song": "Перейти к текущему треку"
     }
   }
 }

resources/i18n/sr.json

@@ -1,465 +1,517 @@
 {
-    "languageName": "српски",
-    "resources": {
-        "song": {
-            "name": "Песма |||| Песме",
-            "fields": {
-                "albumArtist": "Уметник албума",
-                "duration": "Трајање",
-                "trackNumber": "#",
-                "playCount": "Пуштано",
-                "title": "Наслов",
-                "artist": "Уметник",
-                "album": "Албум",
-                "path": "Путања фајла",
-                "genre": "Жанр",
-                "compilation": "Компилација",
-                "year": "Година",
-                "size": "Величина фајла",
-                "updatedAt": "Ажурирано",
-                "bitRate": "Битски проток",
-                "channels": "Канала",
-                "discSubtitle": "Поднаслов диска",
-                "starred": "Омиљено",
-                "comment": "Коментар",
-                "rating": "Рејтинг",
-                "quality": "Квалитет",
-                "bpm": "BPM",
-                "playDate": "Последње пуштано",
-                "createdAt": "Датум додавања"
-            },
-            "actions": {
-                "addToQueue": "Пусти касније",
-                "playNow": "Пусти одмах",
-                "addToPlaylist": "Додај у плејлисту",
-                "shuffleAll": "Измешај све",
-                "download": "Преузми",
-                "playNext": "Пусти наредно",
-                "info": "Прикажи инфо"
-            }
-        },
-        "album": {
-            "name": "Албум |||| Албуми",
-            "fields": {
-                "albumArtist": "Уметник албума",
-                "artist": "Уметник",
-                "duration": "Трајање",
-                "songCount": "Песме",
-                "playCount": "Пуштано",
-                "size": "Величина",
-                "name": "Назив",
-                "genre": "Жанр",
-                "compilation": "Компилација",
-                "year": "Година",
-                "originalDate": "Оригинално",
-                "releaseDate": "Објављено",
-                "releases": "Издање|||| Издања",
-                "released": "Објављено",
-                "updatedAt": "Ажурирано",
-                "comment": "Коментар",
-                "rating": "Рејтинг",
-                "createdAt": "Датум додавања"
-            },
-            "actions": {
-                "playAll": "Пусти",
-                "playNext": "Пусти наредно",
-                "addToQueue": "Пусти касније",
-                "share": "Дели",
-                "shuffle": "Измешај",
-                "addToPlaylist": "Додај у плејлисту",
-                "download": "Преузми",
-                "info": "Прикажи инфо"
-            },
-            "lists": {
-                "all": "Све",
-                "random": "Насумично",
-                "recentlyAdded": "Додато недавно",
-                "recentlyPlayed": "Пуштано недавно",
-                "mostPlayed": "Најчешће пуштано",
-                "starred": "Омиљено",
-                "topRated": "Најбоље рангирано"
-            }
-        },
-        "artist": {
-            "name": "Уметник |||| Уметници",
-            "fields": {
-                "name": "Име",
-                "albumCount": "Број албума",
-                "songCount": "Број песама",
-                "size": "Величина",
-                "playCount": "Пуштано",
-                "rating": "Рејтинг",
-                "genre": "Жанр"
-            }
-        },
-        "user": {
-            "name": "Корисник |||| Корисници",
-            "fields": {
-                "userName": "Корисничко име",
-                "isAdmin": "Да ли је Админ",
-                "lastLoginAt": "Последња пријава",
-                "lastAccessAt": "Последњи приступ",
-                "updatedAt": "Ажурирано",
-                "name": "Име",
-                "password": "Лозинка",
-                "createdAt": "Креирана",
-                "changePassword": "Измени лозинку?",
-                "currentPassword": "Текућа лозинка",
-                "newPassword": "Нова лозинка",
-                "token": "Жетон"
-            },
-            "helperTexts": {
-                "name": "Измене вашег имена ће постати видљиве након следеће пријаве"
-            },
-            "notifications": {
-                "created": "Корисник креиран",
-                "updated": "Корисник ажуриран",
-                "deleted": "Корисник обрисан"
-            },
-            "message": {
-                "listenBrainzToken": "Унесите свој ListenBrainz кориснички жетон.",
-                "clickHereForToken": "Кликните овде да преузмете свој жетон"
-            }
-        },
-        "player": {
-            "name": "Плејер |||| Плејери",
-            "fields": {
-                "name": "Назив",
-                "transcodingId": "Транскодирање",
-                "maxBitRate": "Макс. битски проток",
-                "client": "Клијент",
-                "userName": "Корисничко име",
-                "lastSeen": "последњи пут виђен",
-                "reportRealPath": "Пријављуј реалну путању",
-                "scrobbleEnabled": "Шаљи скроблове на спољне сервисе"
-            }
-        },
-        "transcoding": {
-            "name": "Транскодирање |||| Транскодирања",
-            "fields": {
-                "name": "Назив",
-                "targetFormat": "Циљни формат",
-                "defaultBitRate": "Подразумевани битски проток",
-                "command": "Команда"
-            }
-        },
-        "playlist": {
-            "name": "Плејлиста |||| Плејлисте",
-            "fields": {
-                "name": "Назив",
-                "duration": "Трајање",
-                "ownerName": "Власник",
-                "public": "Јавна",
-                "updatedAt": "Ажурирана",
-                "createdAt": "Креирана",
-                "songCount": "Песме",
-                "comment": "Коментар",
-                "sync": "Ауто-увоз",
-                "path": "Увоз из"
-            },
-            "actions": {
-                "selectPlaylist": "Изабери плејлисту",
-                "addNewPlaylist": "Креирај „%{name}”",
-                "export": "Извоз",
-                "makePublic": "Учини јавном",
-                "makePrivate": "Учини приватном"
-            },
-            "message": {
-                "duplicate_song": "Додај дуплиране песме",
-                "song_exist": "У плејлисту се додају дупликати. Желите ли да се додају, или да се прескоче?"
-            }
-        },
-        "radio": {
-            "name": "Радио |||| Радији",
-            "fields": {
-                "name": "Назив",
-                "streamUrl": "URL тока",
-                "homePageUrl": "URL почетне странице",
-                "updatedAt": "Ажурирано",
-                "createdAt": "Креирано"
-            },
-            "actions": {
-                "playNow": "Пусти одмах"
-            }
-        },
-        "share": {
-            "name": "Дељење |||| Дељења",
-            "fields": {
-                "username": "Поделио",
-                "url": "URL",
-                "description": "Опис",
-                "downloadable": "Допушта се преузимање?",
-                "contents": "Садржај",
-                "expiresAt": "Истиче",
-                "lastVisitedAt": "Последњи пут посећено",
-                "visitCount": "Број посета",
-                "format": "Формат",
-                "maxBitRate": "Макс. битски проток",
-                "updatedAt": "Ажурирано",
-                "createdAt": "Креирано"
-            },
-            "notifications": {
-            },
-            "actions": {
-            }
-        }
+  "languageName": "српски",
+  "resources": {
+    "song": {
+      "name": "Песма |||| Песме",
+      "fields": {
+        "album": "Албум",
+        "albumArtist": "Уметник албума",
+        "artist": "Уметник",
+        "bitDepth": "Битова",
+        "bitRate": "Битски проток",
+        "bpm": "BPM",
+        "channels": "Канала",
+        "comment": "Коментар",
+        "compilation": "Компилација",
+        "createdAt": "Датум додавања",
+        "discSubtitle": "Поднаслов диска",
+        "duration": "Трајање",
+        "genre": "Жанр",
+        "grouping": "Груписање",
+        "mappedTags": "Мапиране ознаке",
+        "mood": "Расположење",
+        "participants": "Додатни учесници",
+        "path": "Путања фајла",
+        "playCount": "Пуштано",
+        "playDate": "Последње пуштано",
+        "quality": "Квалитет",
+        "rating": "Рејтинг",
+        "rawTags": "Сирове ознаке",
+        "size": "Величина фајла",
+        "starred": "Омиљено",
+        "tags": "Додатне ознаке",
+        "title": "Наслов",
+        "trackNumber": "#",
+        "updatedAt": "Ажурирано",
+        "year": "Година"
+      },
+      "actions": {
+        "addToPlaylist": "Додај у плејлисту",
+        "addToQueue": "Пусти касније",
+        "download": "Преузми",
+        "info": "Прикажи инфо",
+        "playNext": "Пусти наредно",
+        "playNow": "Пусти одмах",
+        "shuffleAll": "Измешај све"
+      }
     },
-    "ra": {
-        "auth": {
-            "welcome1": "Хвала што сте инсталирали Navidrome!",
-            "welcome2": "За почетак, креирајте админ корисника",
-            "confirmPassword": "Потврдите лозинку",
-            "buttonCreateAdmin": "Креирај админа",
-            "auth_check_error": "Ако желите да наставите, молимо вас да се пријавите",
-            "user_menu": "Профил",
-            "username": "Корисничко име",
-            "password": "Лозинка",
-            "sign_in": "Пријави се",
-            "sign_in_error": "Потврда идентитета није успела, покушајте поново",
-            "logout": "Одјави се"
-        },
-        "validation": {
-            "invalidChars": "Молимо вас да користите само слова и цифре",
-            "passwordDoesNotMatch": "Лозинка се не подудара",
-            "required": "Неопходно",
-            "minLength": "Мора да буде барем %{min} карактера",
-            "maxLength": "Мора да буде %{max} карактера или мање",
-            "minValue": "Мора да буде барем %{min}",
-            "maxValue": "Мора да буде %{max} или мање",
-            "number": "Мора да буде број",
-            "email": "Мора да буде исправна и-мејл адреса",
-            "oneOf": "Мора да буде једно од: %{options}",
-            "regex": "Мора да се подудара са одређеним форматом (регуларни израз): %{pattern}",
-            "unique": "Мора да буде јединствено",
-            "url": "Мора да буде исправна URL адреса"
-        },
-        "action": {
-            "add_filter": "Додај филтер",
-            "add": "Додај",
-            "back": "Иди назад",
-            "bulk_actions": "изабрана је 1 ставка |||| изабрано је %{smart_count} ставки",
-            "bulk_actions_mobile": "1 |||| %{smart_count}",
-            "cancel": "Откажи",
-            "clear_input_value": "Обриши вредност",
-            "clone": "Клонирај",
-            "confirm": "Потврди",
-            "create": "Креирај",
-            "delete": "Обриши",
-            "edit": "Уреди",
-            "export": "Извези",
-            "list": "Листа",
-            "refresh": "Освежи",
-            "remove_filter": "Уклони овај филтер",
-            "remove": "Уклони",
-            "save": "Сачувај",
-            "search": "Тражи",
-            "show": "Прикажи",
-            "sort": "Сортирај",
-            "undo": "Поништи",
-            "expand": "Развиј",
-            "close": "Затвори",
-            "open_menu": "Отвори мени",
-            "close_menu": "Затвори мени",
-            "unselect": "Уклони избор",
-            "skip": "Прескочи",
-            "share": "Подели",
-            "download":  "Преузми"
-        },
-        "boolean": {
-            "true": "Да",
-            "false": "Не"
-        },
-        "page": {
-            "create": "Креирај %{name}",
-            "dashboard": "Контролна табла",
-            "edit": "%{name} #%{id}",
-            "error": "Нешто је пошло наопако",
-            "list": "%{name}",
-            "loading": "Учитава се",
-            "not_found": "Није пронађено",
-            "show": "%{name} #%{id}",
-            "empty": "Још увек нема %{name}.",
-            "invite": "Желите ли да се дода?"
-        },
-        "input": {
-            "file": {
-                "upload_several": "Упустите фајлове да се отпреме, или кликните да их изаберете.",
-                "upload_single": "Упустите фајл да се отпреми, или кликните да га изаберете."
-            },
-            "image": {
-                "upload_several": "Упустите слике да се отпреме, или кликните да их изаберете.",
-                "upload_single": "Упустите слику да се отпреми, или кликните да је изаберете."
-            },
-            "references": {
-                "all_missing": "Не могу да се нађу подаци референци.",
-                "many_missing": "Изгледа да барем једна од придружених референци више није доступна.",
-                "single_missing": "Изгледа да придружена референца више није доступна."
-            },
-            "password": {
-                "toggle_visible": "Сакриј лозинку",
-                "toggle_hidden": "Прикажи лозинку"
-            }
-        },
-        "message": {
-            "about": "О програму",
-            "are_you_sure": "Да ли сте сигурни?",
-            "bulk_delete_content": "Да ли заиста желите да обришете %{name}? |||| Да ли заиста желите да обришете %{smart_count} ставке?",
-            "bulk_delete_title": "Брисање %{name} |||| Брисање %{smart_count} %{name}",
-            "delete_content": "Да ли заиста желите да обришете ову ставку?",
-            "delete_title": "Брисање %{name} #%{id}",
-            "details": "Детаљи",
-            "error": "Дошло је до клијентске грешке и ваш захтев није могао да се изврши.",
-            "invalid_form": "Формулар није исправан. Молимо вас да исправите грешке",
-            "loading": "Страница се учитава, сачекајте мало",
-            "no": "Не",
-            "not_found": "Или сте откуцали погрешну URL адресу, или сте следили неисправан линк.",
-            "yes": "Да",
-            "unsaved_changes": "Неке од ваших измена нису сачуване. Да ли заиста желите да их одбаците?"
-        },
-        "navigation": {
-            "no_results": "Није пронађен ниједан резултат",
-            "no_more_results": "Број странице %{page} је ван опсега. Покушајте претходну страницу.",
-            "page_out_of_boundaries": "Број странице %{page} је ван опсега",
-            "page_out_from_end": "Не може да се иде након последње странице",
-            "page_out_from_begin": "Не може да се иде испред странице 1",
-            "page_range_info": "%{offsetBegin}-%{offsetEnd} од %{total}",
-            "page_rows_per_page": "Ставки по страници:",
-            "next": "Наредна",
-            "prev": "Претход",
-            "skip_nav": "Прескочи на садржај"
-        },
-        "notification": {
-            "updated": "Елемент је ажуриран |||| %{smart_count} елемената је ажурирано",
-            "created": "Елемент је креиран",
-            "deleted": "Елемент је обрисан |||| %{smart_count} елемената је обрисано",
-            "bad_item": "Неисправни елемент",
-            "item_doesnt_exist": "Елемент не постоји",
-            "http_error": "Грешка у комуникацији са сервером",
-            "data_provider_error": "dataProvider грешка. За више детаља погледајте конзолу.",
-            "i18n_error": "Не могу да се учитају преводи за наведени језик",
-            "canceled": "Акција је отказана",
-            "logged_out": "Ваша сесија је завршена, молимо вас да се повежите поново.",
-            "new_version": "Доступна је нова верзија! Молимо вас да освежите овај прозор."
-        },
-        "toggleFieldsMenu": {
-            "columnsToDisplay": "Колоне за приказ",
-            "layout": "Распоред",
-            "grid": "Мрежа",
-            "table": "Табела"
-        }
+    "album": {
+      "name": "Албум |||| Албуми",
+      "fields": {
+        "albumArtist": "Уметник албума",
+        "artist": "Уметник",
+        "catalogNum": "Каталошки број",
+        "comment": "Коментар",
+        "compilation": "Компилација",
+        "createdAt": "Датум додавања",
+        "date": "Датум снимања",
+        "duration": "Трајање",
+        "genre": "Жанр",
+        "grouping": "Груписање",
+        "media": "Медијум",
+        "mood": "Расположење",
+        "name": "Назив",
+        "originalDate": "Оригинално",
+        "playCount": "Пуштано",
+        "rating": "Рејтинг",
+        "recordLabel": "Издавачка кућа",
+        "releaseDate": "Објављено",
+        "releaseType": "Тип",
+        "released": "Објављено",
+        "releases": "Издање|||| Издања",
+        "size": "Величина",
+        "songCount": "Песме",
+        "updatedAt": "Ажурирано",
+        "year": "Година"
+      },
+      "actions": {
+        "addToPlaylist": "Додај у плејлисту",
+        "addToQueue": "Пусти касније",
+        "download": "Преузми",
+        "info": "Прикажи инфо",
+        "playAll": "Пусти",
+        "playNext": "Пусти наредно",
+        "share": "Дели",
+        "shuffle": "Измешај"
+      },
+      "lists": {
+        "all": "Све",
+        "mostPlayed": "Најчешће пуштано",
+        "random": "Насумично",
+        "recentlyAdded": "Додато недавно",
+        "recentlyPlayed": "Пуштано недавно",
+        "starred": "Омиљено",
+        "topRated": "Најбоље рангирано"
+      }
     },
-    "message": {
-        "note": "НАПОМЕНА",
-        "transcodingDisabled": "Измена конфигурације транскодирања кроз веб интерфејс је искључена из разлога безбедности. Ако желите да измените (уредите или додате) опције транскодирања, поново покрените сервер са %{config} конфигурационом опцијом.",
-        "transcodingEnabled": "Navidrome се тренутно извршава са %{config}, чиме је омогућено извршавање системских команди из подешавања транскодирања коришћењем веб интерфејса. Из разлога безбедности, препоручујемо да то искључите, а да омогућите само када конфигуришете опције транскодирања.",
-        "songsAddedToPlaylist": "У плејлисту је додата 1 песма |||| У плејлисту је додато %{smart_count} песама",
-        "noPlaylistsAvailable": "Није доступна ниједна",
-        "delete_user_title": "Брисање корисника ’%{name}’",
-        "delete_user_content": "Да ли заиста желите да обришете овог корисника, заједно са свим његовим подацима (плејлистама и подешавањима)?",
-        "notifications_blocked": "У подешавањима интернет прегледача за овај сајт, блокирали сте обавештења",
-        "notifications_not_available": "Овај интернет прегледач не подржава десктоп обавештења, или Navidrome серверу не приступате преко https протокола",
-        "lastfmLinkSuccess": "Last.fm је успешно повезан и укључено је скробловање",
-        "lastfmLinkFailure": "Last.fm није могао да се повеже",
-        "lastfmUnlinkSuccess": "Last.fm више није повезан и скробловање је искључено",
-        "lastfmUnlinkFailure": "Није могла да се уклони веза са Last.fm",
-        "listenBrainzLinkSuccess": "ListenBrainz је успешно повезан и скробловање је укључено као корисник: %{user}",
-        "listenBrainzLinkFailure": "ListenBrainz није могао да се повеже: %{error}",
-        "listenBrainzUnlinkSuccess": "ListenBrainz више није повезан и скробловање је искључено",
-        "listenBrainzUnlinkFailure": "Није могла да се уклони веза са ListenBrainz",
-        "openIn": {
-            "lastfm": "Отвори у Last.fm",
-            "musicbrainz": "Отвори у MusicBrainz"
-        },
-        "lastfmLink": "Прочитај још...",
-        "shareOriginalFormat": "Подели у оригиналном формату",
-        "shareDialogTitle": "Подели %{resource} ’%{name}’",
-        "shareBatchDialogTitle": "Подели 1 %{resource} |||| Подели %{smart_count} %{resource}",
-        "shareCopyToClipboard": "Копирај у клипборд: Ctrl+C, Ентер",
-        "shareSuccess": "URL је копиран у клипборд: %{url}",
-        "shareFailure": "Грешка приликом копирања URL адресе %{url} у клипборд",
-        "downloadDialogTitle": "Преузимање %{resource} ’%{name}’ (%{size})",
-        "downloadOriginalFormat": "Преузми у оригиналном формату"
+    "artist": {
+      "name": "Уметник |||| Уметници",
+      "fields": {
+        "albumCount": "Број албума",
+        "genre": "Жанр",
+        "name": "Назив",
+        "playCount": "Пуштано",
+        "rating": "Рејтинг",
+        "role": "Улога",
+        "size": "Величина",
+        "songCount": "Број песама"
+      },
+      "roles": {
+        "albumartist": "Уметник албума |||| Уметници албума",
+        "arranger": "Аранжер |||| Аранжери",
+        "artist": "Уметник |||| Уметници",
+        "composer": "Композитор |||| Композитори",
+        "conductor": "Диригент |||| Диригенти",
+        "director": "Режисер |||| Режисери",
+        "djmixer": "Ди-џеј миксер |||| Ди-џеј миксер",
+        "engineer": "Инжењер |||| Инжењери",
+        "lyricist": "Текстописац |||| Текстописци",
+        "mixer": "Миксер |||| Миксери",
+        "performer": "Извођач |||| Извођачи",
+        "producer": "Продуцент |||| Продуценти",
+        "remixer": "Ремиксер |||| Ремиксери"
+      }
     },
-    "menu": {
-        "library": "Библиотека",
-        "settings": "Подешавања",
-        "version": "Верзија",
-        "theme": "Тема",
-        "personal": {
-            "name": "Лична",
-            "options": {
-                "theme": "Тема",
-                "language": "Језик",
-                "defaultView": "Подразумевани поглед",
-                "desktop_notifications": "Десктоп обавештења",
-                "lastfmScrobbling": "Скроблуј на Last.fm",
-                "listenBrainzScrobbling": "Скроблуј на ListenBrainz",
-                "replaygain": "ReplayGain режим",
-                "preAmp": "ReplayGain претпојачање (dB)",
-                "gain": {
-                    "none": "Искључено",
-                    "album": "Користи Album појачање",
-                    "track": "Користи Track појачање"
-                }
-            }
-        },
-        "albumList": "Албуми",
-        "playlists": "Плејлисте",
-        "sharedPlaylists": "Дељене плејлисте",
-        "about": "О"
+    "user": {
+      "name": "Корисник |||| Корисници",
+      "fields": {
+        "changePassword": "Измени лозинку?",
+        "createdAt": "Креирана",
+        "currentPassword": "Текућа лозинка",
+        "isAdmin": "Да ли је Админ",
+        "lastAccessAt": "Последњи приступ",
+        "lastLoginAt": "Последња пријава",
+        "name": "Назив",
+        "newPassword": "Нова лозинка",
+        "password": "Лозинка",
+        "token": "Жетон",
+        "updatedAt": "Ажурирано",
+        "userName": "Корисничко име"
+      },
+      "helperTexts": {
+        "name": "Измене вашег имена ће постати видљиве након следеће пријаве"
+      },
+      "notifications": {
+        "created": "Корисник креиран",
+        "deleted": "Корисник обрисан",
+        "updated": "Корисник ажуриран"
+      },
+      "message": {
+        "clickHereForToken": "Кликните овде да преузмете свој жетон",
+        "listenBrainzToken": "Унесите свој ListenBrainz кориснички жетон."
+      }
     },
     "player": {
-        "playListsText": "Ред за пуштање",
-        "openText": "Отвори",
-        "closeText": "Затвори",
-        "notContentText": "Нема музике",
-        "clickToPlayText": "Кликни за пуштање",
-        "clickToPauseText": "Кликни за паузирање",
-        "nextTrackText": "Наредна нумера",
-        "previousTrackText": "Претходна нумера",
-        "reloadText": "Поново учитај",
-        "volumeText": "Јачина",
-        "toggleLyricText": "Укљ./Искљ. стихове",
-        "toggleMiniModeText": "Умањи",
-        "destroyText": "Уништи",
-        "downloadText": "Преузми",
-        "removeAudioListsText": "Обриши аудио листе",
-        "clickToDeleteText": "Кликните да обришете %{name}",
-        "emptyLyricText": "Нема стихова",
-        "playModeText": {
-            "order": "По редоследу",
-            "orderLoop": "Понови",
-            "singleLoop": "Понови једну",
-            "shufflePlay": "Промешано"
-        }
+      "name": "Плејер |||| Плејери",
+      "fields": {
+        "client": "Клијент",
+        "lastSeen": "Последњи пут виђен",
+        "maxBitRate": "Макс. битски проток",
+        "name": "Назив",
+        "reportRealPath": "Пријављуј реалну путању",
+        "scrobbleEnabled": "Шаљи скроблове на спољне сервисе",
+        "transcodingId": "Транскодирање",
+        "userName": "Корисничко име"
+      }
     },
-    "about": {
-        "links": {
-            "homepage": "Почетна страница",
-            "source": "Изворни кôд",
-            "featureRequests": "Захтеви за функцијама"
-        }
+    "transcoding": {
+      "name": "Транскодирање |||| Транскодирања",
+      "fields": {
+        "command": "Команда",
+        "defaultBitRate": "Подразумевани битски проток",
+        "name": "Назив",
+        "targetFormat": "Циљни формат"
+      }
     },
-    "activity": {
-        "title": "Активност",
-        "totalScanned": "Укупан број скенираних фолдера",
-        "quickScan": "Брзо скенирање",
-        "fullScan": "Комплетно скенирање",
-        "serverUptime": "Сервер се извршава",
-        "serverDown": "ВАН МРЕЖЕ"
+    "playlist": {
+      "name": "Плејлиста |||| Плејлисте",
+      "fields": {
+        "comment": "Коментар",
+        "createdAt": "Креирана",
+        "duration": "Трајање",
+        "name": "Назив",
+        "ownerName": "Власник",
+        "path": "Увоз из",
+        "public": "Јавна",
+        "songCount": "Песме",
+        "sync": "Ауто-увоз",
+        "updatedAt": "Ажурирано"
+      },
+      "actions": {
+        "addNewPlaylist": "Креирај „%{name}”",
+        "export": "Извези",
+        "makePrivate": "Учини приватном",
+        "makePublic": "Учини јавном",
+        "selectPlaylist": "Изабери плејлисту"
+      },
+      "message": {
+        "duplicate_song": "Додај дуплиране песме",
+        "song_exist": "У плејлисту се додају дупликати. Желите ли да се додају, или да се прескоче?"
+      }
     },
-    "help": {
-        "title": "Navidrome пречице",
-        "hotkeys": {
-            "show_help": "Прикажи ову помоћ",
-            "toggle_menu": "Укљ./Искљ. бочну траку менија",
-            "toggle_play": "Пусти / Паузирај",
-            "prev_song": "Претходна песма",
-            "next_song": "Наредна песма",
-            "current_song": "Иди на текућу песму",
-            "vol_up": "Појачај",
-            "vol_down": "Утишај",
-            "toggle_love": "Додај ову нумеру у омиљене"
-        }
+    "radio": {
+      "name": "Радио |||| Радији",
+      "fields": {
+        "createdAt": "Креирана",
+        "homePageUrl": "URL почетне странице",
+        "name": "Назив",
+        "streamUrl": "URL тока",
+        "updatedAt": "Ажурирано"
+      },
+      "actions": {
+        "playNow": "Пусти одмах"
+      }
+    },
+    "share": {
+      "name": "Дељење |||| Дељења",
+      "fields": {
+        "contents": "Садржај",
+        "createdAt": "Креирано",
+        "description": "Опис",
+        "downloadable": "Допушта се преузимање?",
+        "expiresAt": "Истиче",
+        "format": "Формат",
+        "lastVisitedAt": "Последњи пут посећено",
+        "maxBitRate": "Макс. битски проток",
+        "updatedAt": "Ажурирано",
+        "url": "URL",
+        "username": "Поделио",
+        "visitCount": "Број посета"
+      },
+      "notifications": {},
+      "actions": {}
+    },
+    "missing": {
+      "name": "Фајл који недостаје|||| Фајлови који недостају",
+      "empty": "Нема фајлова који недостају",
+      "fields": {
+        "path": "Путања",
+        "size": "Величина",
+        "updatedAt": "Нестао дана"
+      },
+      "actions": {
+        "remove": "Уклони"
+      },
+      "notifications": {
+        "removed": "Фајл који недостаје, или више њих, је уклоњен"
+      }
     }
+  },
+  "ra": {
+    "auth": {
+      "auth_check_error": "Ако желите да наставите, молимо вас да се пријавите",
+      "buttonCreateAdmin": "Креирај админа",
+      "confirmPassword": "Потврдите лозинку",
+      "insightsCollectionNote": "Navidrome прикупља анонимне податке о коришћењу\nшто олакшава унапређење пројекта. Кликните [овде] да\nсазнате више и да одустанете од прикупљања ако желите",
+      "logout": "Одјави се",
+      "password": "Лозинка",
+      "sign_in": "Пријави се",
+      "sign_in_error": "Потврда идентитета није успела, покушајте поново",
+      "user_menu": "Профил",
+      "username": "Корисничко име",
+      "welcome1": "Хвала што сте инсталирали Navidrome!",
+      "welcome2": "За почетак, креирајте админ корисника"
+    },
+    "validation": {
+      "email": "Мора да буде исправна и-мејл адреса",
+      "invalidChars": "Молимо вас да користите само слова и цифре",
+      "maxLength": "Мора да буде %{max} карактера или мање",
+      "maxValue": "Мора да буде %{max} или мање",
+      "minLength": "Мора да буде барем %{min} карактера",
+      "minValue": "Мора да буде барем %{min}",
+      "number": "Мора да буде број",
+      "oneOf": "Мора да буде једно од: %{options}",
+      "passwordDoesNotMatch": "Лозинка се не подудара",
+      "regex": "Мора да се подудара са одређеним форматом (регуларни израз): %{pattern}",
+      "required": "Неопходно",
+      "unique": "Мора да буде јединствено",
+      "url": "Мора да буде исправна URL адреса"
+    },
+    "action": {
+      "add": "Додај",
+      "add_filter": "Додај филтер",
+      "back": "Иди назад",
+      "bulk_actions": "изабрана је 1 ставка |||| изабрано је %{smart_count} ставки",
+      "bulk_actions_mobile": "1 |||| %{smart_count}",
+      "cancel": "Откажи",
+      "clear_input_value": "Обриши вредност",
+      "clone": "Клонирај",
+      "close": "Затвори",
+      "close_menu": "Затвори мени",
+      "confirm": "Потврди",
+      "create": "Креирај",
+      "delete": "Обриши",
+      "download": "Преузми",
+      "edit": "Уреди",
+      "expand": "Развиј",
+      "export": "Извези",
+      "list": "Листа",
+      "open_menu": "Отвори мени",
+      "refresh": "Освежи",
+      "remove": "Уклони",
+      "remove_filter": "Уклони овај филтер",
+      "save": "Сачувај",
+      "search": "Тражи",
+      "share": "Дели",
+      "show": "Прикажи",
+      "skip": "Прескочи",
+      "sort": "Сортирај",
+      "undo": "Поништи",
+      "unselect": "Уклони избор"
+    },
+    "boolean": {
+      "false": "Не",
+      "true": "Да"
+    },
+    "page": {
+      "create": "Креирај %{name}",
+      "dashboard": "Контролна табла",
+      "edit": "%{name} #%{id}",
+      "empty": "Још увек нема %{name}.",
+      "error": "Нешто је пошло наопако",
+      "invite": "Желите ли да се дода?",
+      "list": "%{name}",
+      "loading": "Учитава се",
+      "not_found": "Није пронађено",
+      "show": "%{name} #%{id}"
+    },
+    "input": {
+      "file": {
+        "upload_several": "Упустите фајлове да се отпреме, или кликните да их изаберете.",
+        "upload_single": "Упустите фајл да се отпреми, или кликните да га изаберете."
+      },
+      "image": {
+        "upload_several": "Упустите слике да се отпреме, или кликните да их изаберете.",
+        "upload_single": "Упустите слику да се отпреми, или кликните да је изаберете."
+      },
+      "password": {
+        "toggle_hidden": "Прикажи лозинку",
+        "toggle_visible": "Сакриј лозинку"
+      },
+      "references": {
+        "all_missing": "Не могу да се нађу подаци референци.",
+        "many_missing": "Изгледа да барем једна од придружених референци више није доступна.",
+        "single_missing": "Изгледа да придружена референца више није доступна."
+      }
+    },
+    "message": {
+      "about": "О",
+      "are_you_sure": "Да ли сте сигурни?",
+      "bulk_delete_content": "Да ли заиста желите да обришете %{name}? |||| Да ли заиста желите да обришете %{smart_count} ставке?",
+      "bulk_delete_title": "Брисање %{name} |||| Брисање %{smart_count} %{name}",
+      "delete_content": "Да ли заиста желите да обришете ову ставку?",
+      "delete_title": "Брисање %{name} #%{id}",
+      "details": "Детаљи",
+      "error": "Дошло је до клијентске грешке и ваш захтев није могао да се изврши.",
+      "invalid_form": "Формулар није исправан. Молимо вас да исправите грешке",
+      "loading": "Страница се учитава, сачекајте мало",
+      "no": "Не",
+      "not_found": "Или сте откуцали погрешну URL адресу, или сте следили неисправан линк.",
+      "unsaved_changes": "Неке од ваших измена нису сачуване. Да ли заиста желите да их одбаците?",
+      "yes": "Да"
+    },
+    "navigation": {
+      "next": "Наредна",
+      "no_more_results": "Број странице %{page} је ван опсега. Покушајте претходну страницу.",
+      "no_results": "Није пронађен ниједан резултат",
+      "page_out_from_begin": "Не може да се иде испред странице 1",
+      "page_out_from_end": "Не може да се иде након последње странице",
+      "page_out_of_boundaries": "Број странице %{page} је ван опсега",
+      "page_range_info": "%{offsetBegin}-%{offsetEnd} од %{total}",
+      "page_rows_per_page": "Ставки по страници:",
+      "prev": "Претход",
+      "skip_nav": "Прескочи на садржај"
+    },
+    "notification": {
+      "bad_item": "Неисправни елемент",
+      "canceled": "Акција је отказана",
+      "created": "Елемент је креиран",
+      "data_provider_error": "dataProvider грешка. За више детаља погледајте конзолу.",
+      "deleted": "Елемент је обрисан |||| %{smart_count} елемената је обрисано",
+      "http_error": "Грешка у комуникацији са сервером",
+      "i18n_error": "Не могу да се учитају преводи за наведени језик",
+      "item_doesnt_exist": "Елемент не постоји",
+      "logged_out": "Ваша сесија је завршена, молимо вас да се повежите поново.",
+      "new_version": "Доступна је нова верзија! Молимо вас да освежите овај прозор.",
+      "updated": "Елемент је ажуриран |||| %{smart_count} елемената је ажурирано"
+    },
+    "toggleFieldsMenu": {
+      "columnsToDisplay": "Колоне за приказ",
+      "grid": "Мрежа",
+      "layout": "Распоред",
+      "table": "Табела"
+    }
+  },
+  "message": {
+    "delete_user_content": "Да ли заиста желите да обришете овог корисника, заједно са свим његовим подацима (плејлистама и подешавањима)?",
+    "delete_user_title": "Брисање корисника ’%{name}’",
+    "downloadDialogTitle": "Преузимање %{resource} ’%{name}’ (%{size})",
+    "downloadOriginalFormat": "Преузми у оригиналном формату",
+    "lastfmLink": "Прочитај још...",
+    "lastfmLinkFailure": "Last.fm није могао да се повеже",
+    "lastfmLinkSuccess": "Last.fm је успешно повезан и укључено је скробловање",
+    "lastfmUnlinkFailure": "Није могла да се уклони веза са Last.fm",
+    "lastfmUnlinkSuccess": "Last.fm више није повезан и скробловање је искључено",
+    "listenBrainzLinkFailure": "ListenBrainz није могао да се повеже: %{error}",
+    "listenBrainzLinkSuccess": "ListenBrainz је успешно повезан и скробловање је укључено као корисник: %{user}",
+    "listenBrainzUnlinkFailure": "Није могла да се уклони веза са ListenBrainz",
+    "listenBrainzUnlinkSuccess": "ListenBrainz више није повезан и скробловање је искључено",
+    "noPlaylistsAvailable": "Није доступна ниједна",
+    "note": "НАПОМЕНА",
+    "notifications_blocked": "У подешавањима интернет прегледача за овај сајт, блокирали сте обавештења",
+    "notifications_not_available": "Овај интернет прегледач не подржава десктоп обавештења, или Navidrome серверу не приступате преко https протокола",
+    "openIn": {
+      "lastfm": "Отвори у Last.fm",
+      "musicbrainz": "Отвори у MusicBrainz"
+    },
+    "remove_missing_content": "Да ли сте сигурни да из базе података желите да уклоните фајлове који недостају? Ово ће трајно да уклони све референце на њих, укључујући број пуштања и рангирања.",
+    "remove_missing_title": "Уклони фајлове који недостају",
+    "shareBatchDialogTitle": "Подели 1 %{resource} |||| Подели %{smart_count} %{resource}",
+    "shareCopyToClipboard": "Копирај у клипборд: Ctrl+C, Ентер",
+    "shareDialogTitle": "Подели %{resource} ’%{name}’",
+    "shareFailure": "Грешка приликом копирања URL адресе %{url} у клипборд",
+    "shareOriginalFormat": "Подели у оригиналном формату",
+    "shareSuccess": "URL је копиран у клипборд: %{url}",
+    "songsAddedToPlaylist": "У плејлисту је додата 1 песма |||| У плејлисту је додато %{smart_count} песама",
+    "transcodingDisabled": "Измена конфигурације транскодирања кроз веб интерфејс је искључена из разлога безбедности. Ако желите да измените (уредите или додате) опције транскодирања, поново покрените сервер са %{config} конфигурационом опцијом.",
+    "transcodingEnabled": "Navidrome се тренутно извршава са %{config}, чиме је омогућено извршавање системских команди из подешавања транскодирања коришћењем веб интерфејса. Из разлога безбедности, препоручујемо да то искључите, а да омогућите само када конфигуришете опције транскодирања."
+  },
+  "menu": {
+    "about": "О",
+    "albumList": "Албуми",
+    "library": "Библиотека",
+    "personal": {
+      "name": "Лична",
+      "options": {
+        "defaultView": "Подразумевани поглед",
+        "desktop_notifications": "Десктоп обавештења",
+        "gain": {
+          "album": "Користи Album појачање",
+          "none": "Искључено",
+          "track": "Користи Track појачање"
+        },
+        "language": "Језик",
+        "lastfmNotConfigured": "Није подешен Last.fm API-кључ",
+        "lastfmScrobbling": "Скроблуј на Last.fm",
+        "listenBrainzScrobbling": "Скроблуј на ListenBrainz",
+        "preAmp": "ReplayGain претпојачање (dB)",
+        "replaygain": "ReplayGain режим",
+        "theme": "Тема"
+      }
+    },
+    "playlists": "Плејлисте",
+    "settings": "Подешавања",
+    "sharedPlaylists": "Дељене плејлисте",
+    "theme": "Тема",
+    "version": "Верзија"
+  },
+  "player": {
+    "clickToDeleteText": "Кликните да обришете %{name}",
+    "clickToPauseText": "Кликни за паузирање",
+    "clickToPlayText": "Кликни за пуштање",
+    "closeText": "Затвори",
+    "destroyText": "Уништи",
+    "downloadText": "Преузми",
+    "emptyLyricText": "Нема стихова",
+    "nextTrackText": "Наредна нумера",
+    "notContentText": "Нема музике",
+    "openText": "Отвори",
+    "playListsText": "Ред за пуштање",
+    "playModeText": {
+      "order": "По редоследу",
+      "orderLoop": "Понови",
+      "shufflePlay": "Измешај",
+      "singleLoop": "Понови једну"
+    },
+    "previousTrackText": "Претходна нумера",
+    "reloadText": "Поново учитај",
+    "removeAudioListsText": "Обриши аудио листе",
+    "toggleLyricText": "Укљ./Искљ. стихове",
+    "toggleMiniModeText": "Умањи",
+    "volumeText": "Јачина"
+  },
+  "about": {
+    "links": {
+      "featureRequests": "Захтеви за функцијама",
+      "homepage": "Почетна страница",
+      "insights": {
+        "disabled": "Искључено",
+        "waiting": "Чека се"
+      },
+      "lastInsightsCollection": "Последња колекција увида",
+      "source": "Изворни кôд"
+    }
+  },
+  "activity": {
+    "fullScan": "Комплетно скенирање",
+    "quickScan": "Брзо скенирање",
+    "serverDown": "ВАН МРЕЖЕ",
+    "serverUptime": "Сервер се извршава",
+    "title": "Активност",
+    "totalScanned": "Укупан број скенираних фолдера"
+  },
+  "help": {
+    "title": "Navidrome пречице",
+    "hotkeys": {
+      "current_song": "Иди на текућу песму",
+      "next_song": "Наредна песма",
+      "prev_song": "Претходна песма",
+      "show_help": "Прикажи ову помоћ",
+      "toggle_love": "Додај ову нумеру у омиљене",
+      "toggle_menu": "Укљ./Искљ. бочну траку менија",
+      "toggle_play": "Пусти / Паузирај",
+      "vol_down": "Утишај",
+      "vol_up": "Појачај"
+    }
+  }
 }

resources/i18n/sv.json

@@ -26,7 +26,16 @@
         "bpm": "BPM",
         "playDate": "Senast spelad",
         "channels": "Channels",
-        "createdAt": "Skapad"
+        "createdAt": "Skapad",
+        "grouping": "Gruppering",
+        "mood": "Stämning",
+        "participants": "Ytterligare medverkande",
+        "tags": "Ytterligare taggar",
+        "mappedTags": "Mappade taggar",
+        "rawTags": "Omodifierade taggar",
+        "bitDepth": "Bitdjup",
+        "sampleRate": "Samplingsfrekvens",
+        "missing": "Saknade"
       },
       "actions": {
         "addToQueue": "Lägg till i kön",
@@ -58,7 +67,15 @@
         "originalDate": "Originaldatum",
         "releaseDate": "Utgivningsdatum",
         "releases": "Utgåva |||| Utgåvor",
-        "released": "Utgiven"
+        "released": "Utgiven",
+        "recordLabel": "Skivbolag",
+        "catalogNum": "Katalognummer",
+        "releaseType": "Typ",
+        "grouping": "Gruppering",
+        "media": "Media",
+        "mood": "Stämning",
+        "date": "Inspelningsdatum",
+        "missing": "Saknade"
       },
       "actions": {
         "playAll": "Spela",
@@ -89,7 +106,24 @@
         "playCount": "Spelningar",
         "rating": "Betyg",
         "genre": "Genre",
-        "size": "Storlek"
+        "size": "Storlek",
+        "role": "Roll",
+        "missing": "Saknade"
+      },
+      "roles": {
+        "albumartist": "Albumartist |||| Albumartister",
+        "artist": "Artist |||| Artister",
+        "composer": "Kompositör |||| Kompositörer",
+        "conductor": "Dirigent |||| Dirigenter",
+        "lyricist": "Textförfattare |||| Textförfattare",
+        "arranger": "Arrangör |||| Arrangörer",
+        "producer": "Producent |||| Producenter",
+        "director": "Inspelningsledare |||| Inspelningsledare",
+        "engineer": "Ljudtekniker |||| Ljudtekniker",
+        "mixer": "Mixare |||| Mixare",
+        "remixer": "Remixare |||| Remixare",
+        "djmixer": "DJ-mixare |||| DJ-mixare",
+        "performer": "Utövande artist |||| Utövande artister"
       }
     },
     "user": {
@@ -162,7 +196,8 @@
         "addNewPlaylist": "Skapa \"%{name}\"",
         "export": "Exportera",
         "makePublic": "Gör offentlig",
-        "makePrivate": "Gör privat"
+        "makePrivate": "Gör privat",
+        "saveQueue": "Spara kö till spellista"
       },
       "message": {
         "duplicate_song": "Lägg till dubletter",
@@ -198,6 +233,22 @@
         "createdAt": "Skapad",
         "downloadable": "Tillåt nedladdning?"
       }
+    },
+    "missing": {
+      "name": "Saknad fil |||| Saknade filer",
+      "fields": {
+        "path": "Sökväg",
+        "size": "Storlek",
+        "updatedAt": "Försvann"
+      },
+      "actions": {
+        "remove": "Radera",
+        "remove_all": "Radera alla"
+      },
+      "notifications": {
+        "removed": "Saknade fil(er) borttagna"
+      },
+      "empty": "Inga saknade filer"
     }
   },
   "ra": {
@@ -375,7 +426,11 @@
     "shareSuccess": "URL kopierades till urklipp: %{url}",
     "shareFailure": "Fel vid kopiering av URL %{url} till urklipp",
     "downloadDialogTitle": "Ladda ner %{resource} '%{name}' (%{size})",
-    "shareCopyToClipboard": "Kopiera till urklipp: Ctrl+C, Enter"
+    "shareCopyToClipboard": "Kopiera till urklipp: Ctrl+C, Enter",
+    "remove_missing_title": "Ta bort saknade filer",
+    "remove_missing_content": "Är du säker på att du vill ta bort de valda saknade filerna från databasen? Detta kommer permanent radera alla referenser till dem, inklusive antal spelningar och betyg.",
+    "remove_all_missing_title": "Ta bort alla saknade filer",
+    "remove_all_missing_content": "Är du säker på att du vill ta bort alla saknade filer från databasen? Detta kommer permanent radera alla referenser till dem, inklusive antal spelningar och betyg."
   },
   "menu": {
     "library": "Bibliotek",
@@ -449,7 +504,10 @@
     "quickScan": "Snabbscan",
     "fullScan": "Komplett scan",
     "serverUptime": "Serverdrifttid",
-    "serverDown": "OFFLINE"
+    "serverDown": "OFFLINE",
+    "scanType": "Typ",
+    "status": "Fel vid scanning",
+    "elapsedTime": "Spelad tid"
   },
   "help": {
     "title": "Navidrome kortkommandon",

resources/i18n/tr.json

@@ -33,7 +33,9 @@
         "tags": "Ek Etiketler",
         "mappedTags": "Eşlenen etiketler",
         "rawTags": "Ham etiketler",
-        "bitDepth": "Bit derinliği"
+        "bitDepth": "Bit derinliği",
+        "sampleRate": "Örnekleme Oranı",
+        "missing": ""
       },
       "actions": {
         "addToQueue": "Oynatma Sırasına Ekle",
@@ -72,7 +74,8 @@
         "grouping": "Gruplama",
         "media": "Medya",
         "mood": "Mod",
-        "date": "Kayıt Tarihi"
+        "date": "Kayıt Tarihi",
+        "missing": ""
       },
       "actions": {
         "playAll": "Oynat",
@@ -104,7 +107,8 @@
         "rating": "Derecelendirme",
         "genre": "Tür",
         "size": "Boyut",
-        "role": "Rol"
+        "role": "Rol",
+        "missing": ""
       },
       "roles": {
         "albumartist": "Albüm Sanatçısı |||| Albüm Sanatçısı",
@@ -192,7 +196,8 @@
         "addNewPlaylist": "Oluştur  \"%{name}\"",
         "export": "Aktar",
         "makePublic": "Herkese Açık Yap",
-        "makePrivate": "Özel Yap"
+        "makePrivate": "Özel Yap",
+        "saveQueue": ""
       },
       "message": {
         "duplicate_song": "Yinelenen şarkıları ekle",
@@ -237,7 +242,8 @@
         "updatedAt": "Kaybolma"
       },
       "actions": {
-        "remove": "Kaldır"
+        "remove": "Kaldır",
+        "remove_all": "Tümünü Kaldır"
       },
       "notifications": {
         "removed": "Eksik dosya(lar) kaldırıldı"
@@ -422,7 +428,9 @@
     "downloadDialogTitle": "%{resource}: '%{name}' (%{size}) dosyasını indirin",
     "shareCopyToClipboard": "Panoya kopyala: Ctrl+C, Enter",
     "remove_missing_title": "Eksik dosyaları kaldır",
-    "remove_missing_content": "Seçili eksik dosyaları veritabanından kaldırmak istediğinizden emin misiniz? Bu, oynatma sayıları ve derecelendirmeleri dahil olmak üzere bunlara ilişkin tüm referansları kalıcı olarak kaldıracaktır."
+    "remove_missing_content": "Seçili eksik dosyaları veritabanından kaldırmak istediğinizden emin misiniz? Bu, oynatma sayıları ve derecelendirmeleri dahil olmak üzere bunlara ilişkin tüm referansları kalıcı olarak kaldıracaktır.",
+    "remove_all_missing_title": "Tüm eksik dosyaları kaldırın",
+    "remove_all_missing_content": "Veritabanından tüm eksik dosyaları kaldırmak istediğinizden emin misiniz? Bu, oynatma sayısı ve derecelendirmelerde dahil olmak üzere bunlara ilişkili tüm değerleri kalıcı olarak kaldıracaktır."
   },
   "menu": {
     "library": "Kütüphane",
@@ -496,7 +504,10 @@
     "quickScan": "Hızlı Tarama",
     "fullScan": "Tam Tarama",
     "serverUptime": "Sunucu Çalışma Süresi",
-    "serverDown": "ÇEVRİMDIŞI"
+    "serverDown": "ÇEVRİMDIŞI",
+    "scanType": "Tür",
+    "status": "Tarama Hatası",
+    "elapsedTime": "Geçen Süre"
   },
   "help": {
     "title": "Navidrome Kısayolları",

resources/i18n/uk.json

@@ -32,7 +32,10 @@
         "participants": "Додаткові вчасники",
         "tags": "Додаткові теги",
         "mappedTags": "Зіставлені теги",
-        "rawTags": "Вихідні теги"
+        "rawTags": "Вихідні теги",
+        "bitDepth": "Глибина розрядності",
+        "sampleRate": "Частота дискретизації",
+        "missing": "Поле відсутнє"
       },
       "actions": {
         "addToQueue": "Прослухати пізніше",
@@ -70,7 +73,9 @@
         "releaseType": "Тип",
         "grouping": "Групування",
         "media": "Медіа",
-        "mood": "Настрій"
+        "mood": "Настрій",
+        "date": "Дата запису",
+        "missing": "Поле відсутнє"
       },
       "actions": {
         "playAll": "Прослухати",
@@ -102,7 +107,8 @@
         "rating": "Рейтинг",
         "genre": "Жанр",
         "size": "Розмір",
-        "role": "Роль"
+        "role": "Роль",
+        "missing": "Поле відсутнє"
       },
       "roles": {
         "albumartist": "Виконавець альбому |||| Виконавці альбому",
@@ -190,7 +196,8 @@
         "addNewPlaylist": "Створити \"%{name}\"",
         "export": "Експортувати",
         "makePublic": "Зробити публічним",
-        "makePrivate": "Зробити приватним"
+        "makePrivate": "Зробити приватним",
+        "saveQueue": "Зберегти чергу до плейлиста"
       },
       "message": {
         "duplicate_song": "Додати повторювані пісні",
@@ -235,11 +242,13 @@
         "updatedAt": "Зник"
       },
       "actions": {
-        "remove": "Видалити"
+        "remove": "Видалити",
+        "remove_all": "Вилучити всі"
       },
       "notifications": {
         "removed": "Видалено зниклі файл(и)"
-      }
+      },
+      "empty": "Немає відсутніх файлів"
     }
   },
   "ra": {
@@ -419,7 +428,9 @@
     "downloadDialogTitle": "Завантаження %{resource} '%{name}' (%{size})",
     "shareCopyToClipboard": "Скопіювати в буфер: Ctrl+C, Enter",
     "remove_missing_title": "Видалити зниклі файли",
-    "remove_missing_content": "Ви впевнені, що хочете видалити вибрані відсутні файли з бази даних? Це назавжди видалить усі посилання на них, включаючи кількість прослуховувань та рейтинги."
+    "remove_missing_content": "Ви впевнені, що хочете видалити вибрані відсутні файли з бази даних? Це назавжди видалить усі посилання на них, включаючи кількість прослуховувань та рейтинги.",
+    "remove_all_missing_title": "Видалити всі відсутні файли",
+    "remove_all_missing_content": "Ви впевнені, що хочете видалити всі відсутні файли з бази даних? Це назавжди видалить будь-які посилання на них, включно з кількістю відтворень та рейтингами."
   },
   "menu": {
     "library": "Бібліотека",
@@ -493,7 +504,10 @@
     "quickScan": "Швидке сканування",
     "fullScan": "Повне сканування",
     "serverUptime": "Час роботи",
-    "serverDown": "Оффлайн"
+    "serverDown": "Оффлайн",
+    "scanType": "Тип",
+    "status": "Помилка сканування",
+    "elapsedTime": "Пройдений час"
   },
   "help": {
     "title": "Гарячі клавіші Navidrome",

resources/i18n/zh-Hans.json

@@ -12,12 +12,14 @@
                 "artist": "歌手",
                 "album": "专辑",
                 "path": "文件路径",
-                "genre": "类型",
+                "genre": "流派",
                 "compilation": "合辑",
                 "year": "发行年份",
                 "size": "文件大小",
                 "updatedAt": "更新于",
                 "bitRate": "比特率",
+                "bitDepth": "比特深度",
+                "channels": "声道",
                 "discSubtitle": "字幕",
                 "starred": "收藏",
                 "comment": "注释",
@@ -25,8 +27,13 @@
                 "quality": "品质",
                 "bpm": "BPM",
                 "playDate": "最后一次播放",
-                "channels": "声道",
-                "createdAt": "创建于"
+                "createdAt": "创建于",
+                "grouping": "分组",
+                "mood": "情绪",
+                "participants": "其他参与人员",
+                "tags": "附加标签",
+                "mappedTags": "映射标签",
+                "rawTags": "原始标签"
             },
             "actions": {
                 "addToQueue": "加入播放列表",
@@ -46,29 +53,36 @@
                 "duration": "时长",
                 "songCount": "歌曲数量",
                 "playCount": "播放次数",
+                "size": "文件大小",
                 "name": "名称",
-                "genre": "类型",
+                "genre": "流派",
                 "compilation": "合辑",
                 "year": "发行年份",
+                "date": "录制日期",
+                "originalDate": "原始日期",
+                "releaseDate": "发⾏日期",
+                "releases": "发⾏",
+                "released": "已发⾏",
                 "updatedAt": "更新于",
                 "comment": "注释",
                 "rating": "评分",
                 "createdAt": "创建于",
-                "size": "文件大小",
-                "originalDate": "原始日期",
-                "releaseDate": "发⾏日期",
-                "releases": "发⾏",
-                "released": "已发⾏"
+                "recordLabel": "厂牌",
+                "catalogNum": "目录编号",
+                "releaseType": "发行类型",
+                "grouping": "分组",
+                "media": "媒体类型",
+                "mood": "情绪"
             },
             "actions": {
                 "playAll": "立即播放",
                 "playNext": "下首播放",
                 "addToQueue": "加入播放列表",
+                "share": "分享",
                 "shuffle": "随机播放",
                 "addToPlaylist": "加入歌单",
                 "download": "下载",
-                "info": "查看信息",
-                "share": "分享"
+                "info": "查看信息"
             },
             "lists": {
                 "all": "所有",
@@ -86,10 +100,26 @@
                 "name": "名称",
                 "albumCount": "专辑数",
                 "songCount": "歌曲数",
+                "size": "文件大小",
                 "playCount": "播放次数",
                 "rating": "评分",
-                "genre": "类型",
-                "size": "文件大小"
+                "genre": "流派",
+                "role": "参与角色"
+            },
+            "roles": {
+                "albumartist": "专辑歌手",
+                "artist": "歌手",
+                "composer": "作曲",
+                "conductor": "指挥",
+                "lyricist": "作词",
+                "arranger": "编曲",
+                "producer": "制作人",
+                "director": "总监",
+                "engineer": "工程师",
+                "mixer": "混音师",
+                "remixer": "重混师",
+                "djmixer": "DJ混音师",
+                "performer": "演奏家"
             }
         },
         "user": {
@@ -98,6 +128,7 @@
                 "userName": "用户名",
                 "isAdmin": "是否管理员",
                 "lastLoginAt": "上次登录",
+                "lastAccessAt": "上次访问",
                 "updatedAt": "更新于",
                 "name": "名称",
                 "password": "密码",
@@ -108,7 +139,7 @@
                 "token": "令牌"
             },
             "helperTexts": {
-                "name": "你名字的更改将在下次登录生效"
+                "name": "名称的更改将在下次登录时生效"
             },
             "notifications": {
                 "created": "用户已创建",
@@ -187,6 +218,7 @@
                 "username": "分享者",
                 "url": "链接",
                 "description": "描述",
+                "downloadable": "是否允许下载？",
                 "contents": "目录",
                 "expiresAt": "过期于",
                 "lastVisitedAt": "上次访问于",
@@ -194,8 +226,24 @@
                 "format": "格式",
                 "maxBitRate": "最大比特率",
                 "updatedAt": "更新于",
-                "createdAt": "创建于",
-                "downloadable": "是否允许下载"
+                "createdAt": "创建于"
+            },
+            "notifications": {},
+            "actions": {}
+        },
+        "missing": {
+            "name": "丢失文件",
+            "empty": "无丢失文件",
+            "fields": {
+                "path": "路径",
+                "size": "文件大小",
+                "updatedAt": "丢失于"
+            },
+            "actions": {
+                "remove": "移除"
+            },
+            "notifications": {
+                "removed": "丢失文件已移除"
             }
         }
     },
@@ -211,7 +259,8 @@
             "password": "密码",
             "sign_in": "登录",
             "sign_in_error": "验证失败，请重试",
-            "logout": "注销"
+            "logout": "注销",
+            "insightsCollectionNote": "Navidrome 会收集匿名使用数据以协助改进项目。\n点击[此处]了解详情或选择退出。"
         },
         "validation": {
             "invalidChars": "请使用字母和数字",
@@ -233,6 +282,7 @@
             "add": "添加",
             "back": "返回",
             "bulk_actions": "选中 %{smart_count} 项",
+            "bulk_actions_mobile": "%{smart_count}",
             "cancel": "取消",
             "clear_input_value": "清除",
             "clone": "复制",
@@ -256,7 +306,6 @@
             "close_menu": "关闭菜单",
             "unselect": "未选择",
             "skip": "跳过",
-            "bulk_actions_mobile": "%{smart_count}",
             "share": "分享",
             "download": "下载"
         },
@@ -351,29 +400,31 @@
         "noPlaylistsAvailable": "没有有效的歌单",
         "delete_user_title": "删除用户 %{name}",
         "delete_user_content": "您确定要删除该用户及其相关数据（包括歌单和用户配置）吗？",
+        "remove_missing_title": "移除丢失文件",
+        "remove_missing_content": "您确定要将选中的丢失文件从数据库中永久移除吗？此操作将删除所有相关信息，包括播放次数和评分。",
         "notifications_blocked": "您已在浏览器的设置中屏蔽了此网站的通知",
         "notifications_not_available": "此浏览器不支持桌面通知",
         "lastfmLinkSuccess": "Last.fm 已关联并启用喜好记录",
         "lastfmLinkFailure": "Last.fm 无法关联",
         "lastfmUnlinkSuccess": "已成功解除与 Last.fm 的链接，且喜好记录已禁用",
         "lastfmUnlinkFailure": "Last.fm 无法取消关联",
+        "listenBrainzLinkSuccess": "ListenBrainz 已关联并启用喜好记录",
+        "listenBrainzLinkFailure": "ListenBrainz 无法关联：%{error}",
+        "listenBrainzUnlinkSuccess": "已成功解除与 ListenBrainz 的链接，且喜好记录已禁用",
+        "listenBrainzUnlinkFailure": "ListenBrainz 无法取消关联",
         "openIn": {
             "lastfm": "在 Last.fm 中打开",
             "musicbrainz": "在 MusicBrainz 中打开"
         },
         "lastfmLink": "查看更多…",
-        "listenBrainzLinkSuccess": "ListenBrainz 已关联并启用喜好记录",
-        "listenBrainzLinkFailure": "ListenBrainz 无法关联：%{error}",
-        "listenBrainzUnlinkSuccess": "已成功解除与 ListenBrainz 的链接，且喜好记录已禁用",
-        "listenBrainzUnlinkFailure": "ListenBrainz 无法取消关联",
-        "downloadOriginalFormat": "下载原始格式",
         "shareOriginalFormat": "分享原始格式",
         "shareDialogTitle": "分享 %{resource} '%{name}'",
         "shareBatchDialogTitle": "分享 %{smart_count} 个 %{resource}",
+        "shareCopyToClipboard": "复制到剪切板: Ctrl+C, Enter",
         "shareSuccess": "分享链接已复制: %{url}",
         "shareFailure": "分享链接复制失败: %{url}",
         "downloadDialogTitle": "下载 %{resource} '%{name}' (%{size})",
-        "shareCopyToClipboard": "复制到剪切板: Ctrl+C, Enter"
+        "downloadOriginalFormat": "下载原始格式"
     },
     "menu": {
         "library": "曲库",
@@ -387,6 +438,7 @@
                 "language": "语言",
                 "defaultView": "默认界面",
                 "desktop_notifications": "桌面通知",
+                "lastfmNotConfigured": "没有配置 Last.fm 的 API-Key",
                 "lastfmScrobbling": "启用 Last.fm 的喜好记录",
                 "listenBrainzScrobbling": "启用 ListenBrainz 的喜好记录",
                 "replaygain": "回放增益",
@@ -399,9 +451,9 @@
             }
         },
         "albumList": "专辑",
-        "about": "关于",
         "playlists": "歌单",
-        "sharedPlaylists": "共享的歌单"
+        "sharedPlaylists": "共享的歌单",
+        "about": "关于"
     },
     "player": {
         "playListsText": "播放列表",
@@ -432,7 +484,12 @@
         "links": {
             "homepage": "主页",
             "source": "源代码",
-            "featureRequests": "功能需求"
+            "featureRequests": "功能需求",
+            "lastInsightsCollection": " 最近的分析收集",
+            "insights": {
+                "disabled": "禁用",
+                "waiting": "等待"
+            }
         }
     },
     "activity": {
@@ -451,10 +508,10 @@
             "toggle_play": "播放/暂停",
             "prev_song": "上一首歌",
             "next_song": "下一首歌",
+            "current_song": "转到当前播放",
             "vol_up": "增大音量",
             "vol_down": "减小音量",
-            "toggle_love": "添加/移除星标",
-            "current_song": "转到当前播放"
+            "toggle_love": "添加/移除星标"
         }
     }
 }

resources/mappings.yaml

@@ -108,7 +108,7 @@ main:
   bpm:
     aliases: [ tbpm, bpm, tmpo, wm/beatsperminute ]
   lyrics:
-    aliases: [ uslt:description, lyrics, ©lyr, wm/lyrics ]
+    aliases: [ uslt:description, lyrics, ©lyr, wm/lyrics, unsyncedlyrics ]
     maxLength: 32768
     type: pair # ex: lyrics:eng, lyrics:xxx
   comment:

scanner/README.md

@@ -0,0 +1,466 @@
+# Navidrome Scanner: Technical Overview
+
+This document provides a comprehensive technical explanation of Navidrome's music library scanner system.
+
+## Architecture Overview
+
+The Navidrome scanner is built on a multi-phase pipeline architecture designed for efficient processing of music files. It systematically traverses file system directories, processes metadata, and maintains a database representation of the music library. A key performance feature is that some phases run sequentially while others execute in parallel.
+
+```mermaid
+flowchart TD
+    subgraph "Scanner Execution Flow"
+        Controller[Scanner Controller] --> Scanner[Scanner Implementation]
+        
+        Scanner --> Phase1[Phase 1: Folders Scan]
+        Phase1 --> Phase2[Phase 2: Missing Tracks]
+        
+        Phase2 --> ParallelPhases
+        
+        subgraph ParallelPhases["Parallel Execution"]
+            Phase3[Phase 3: Refresh Albums]
+            Phase4[Phase 4: Playlist Import]
+        end
+        
+        ParallelPhases --> FinalSteps[Final Steps: GC + Stats]
+    end
+    
+    %% Triggers that can initiate a scan
+    FileChanges[File System Changes] -->|Detected by| Watcher[Filesystem Watcher]
+    Watcher -->|Triggers| Controller
+    
+    ScheduledJob[Scheduled Job] -->|Based on Scanner.Schedule| Controller
+    ServerStartup[Server Startup] -->|If Scanner.ScanOnStartup=true| Controller
+    ManualTrigger[Manual Scan via UI/API] -->|Admin user action| Controller
+    CLICommand[Command Line: navidrome scan] -->|Direct invocation| Controller
+    PIDChange[PID Configuration Change] -->|Forces full scan| Controller
+    DBMigration[Database Migration] -->|May require full scan| Controller
+    
+    Scanner -.->|Alternative| External[External Scanner Process]
+```
+
+The execution flow shows that Phases 1 and 2 run sequentially, while Phases 3 and 4 execute in parallel to maximize performance before the final processing steps.
+
+## Core Components
+
+### Scanner Controller (`controller.go`)
+
+This is the entry point for all scanning operations. It provides:
+
+- Public API for initiating scans and checking scan status
+- Event broadcasting to notify clients about scan progress
+- Serialization of scan operations (prevents concurrent scans)
+- Progress tracking and monitoring
+- Error collection and reporting
+
+```go
+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)
+}
+```
+
+### Scanner Implementation (`scanner.go`)
+
+The primary implementation that orchestrates the four-phase scanning pipeline. Each phase follows the Phase interface pattern:
+
+```go
+type phase[T any] interface {
+    producer() ppl.Producer[T]
+    stages() []ppl.Stage[T]
+    finalize(error) error
+    description() string
+}
+```
+
+This design enables:
+- Type-safe pipeline construction with generics
+- Modular phase implementation
+- Separation of concerns
+- Easy measurement of performance
+
+### External Scanner (`external.go`)
+
+The External Scanner is a specialized implementation that offloads the scanning process to a separate subprocess. This is specifically designed to address memory management challenges in long-running Navidrome instances.
+
+```go
+// scannerExternal is a scanner that runs an external process to do the scanning. It is used to avoid
+// memory leaks or retention in the main process, as the scanner can consume a lot of memory. The
+// external process will be spawned with the same executable as the current process, and will run
+// the "scan" command with the "--subprocess" flag.
+//
+// The external process will send progress updates to the main process through its STDOUT, and the main
+// process will forward them to the caller.
+```
+
+```mermaid
+sequenceDiagram
+    participant MP as Main Process
+    participant ES as External Scanner
+    participant SP as Subprocess (navidrome scan --subprocess)
+    participant FS as File System
+    participant DB as Database
+    
+    Note over MP: DevExternalScanner=true
+    MP->>ES: ScanAll(ctx, fullScan)
+    activate ES
+    
+    ES->>ES: Locate executable path
+    ES->>SP: Start subprocess with args:<br>scan --subprocess --configfile ... etc.
+    activate SP
+    
+    Note over ES,SP: Create pipe for communication
+    
+    par Subprocess executes scan
+        SP->>FS: Read files & metadata
+        SP->>DB: Update database
+    and Main process monitors progress
+        loop For each progress update
+            SP->>ES: Send encoded progress info via stdout pipe
+            ES->>MP: Forward progress info
+        end
+    end
+    
+    SP-->>ES: Subprocess completes (success/error)
+    deactivate SP
+    ES-->>MP: Return aggregated warnings/errors
+    deactivate ES
+```
+
+Technical details:
+
+1. **Process Isolation**
+    - Spawns a separate process using the same executable
+    - Uses the `--subprocess` flag to indicate it's running as a child process
+    - Preserves configuration by passing required flags (`--configfile`, `--datafolder`, etc.)
+
+2. **Inter-Process Communication**
+    - Uses a pipe for bidirectional communication
+    - Encodes/decodes progress updates using Go's `gob` encoding for efficient binary transfer
+    - Properly handles process termination and error propagation
+
+3. **Memory Management Benefits**
+    - Scanning operations can be memory-intensive, especially with large music libraries
+    - Memory leaks or excessive allocations are automatically cleaned up when the process terminates
+    - Main Navidrome process remains stable even if scanner encounters memory-related issues
+
+4. **Error Handling**
+    - Detects non-zero exit codes from the subprocess
+    - Propagates error messages back to the main process
+    - Ensures resources are properly cleaned up, even in error conditions
+
+## Scanning Process Flow
+
+### Phase 1: Folder Scan (`phase_1_folders.go`)
+
+This phase handles the initial traversal and media file processing.
+
+```mermaid
+flowchart TD
+    A[Start Phase 1] --> B{Full Scan?}
+    B -- Yes --> C[Scan All Folders]
+    B -- No --> D[Scan Modified Folders]
+    C --> E[Read File Metadata]
+    D --> E
+    E --> F[Create Artists]
+    E --> G[Create Albums]
+    F --> H[Save to Database]
+    G --> H
+    H --> I[Mark Missing Folders]
+    I --> J[End Phase 1]
+```
+
+**Technical implementation details:**
+
+1. **Folder Traversal**
+    - Uses `walkDirTree` to traverse the directory structure
+    - Handles symbolic links and hidden files
+    - Processes `.ndignore` files for exclusions
+    - Maps files to appropriate types (audio, image, playlist)
+
+2. **Metadata Extraction**
+    - Processes files in batches (defined by `filesBatchSize = 200`)
+    - Extracts metadata using the configured storage backend
+    - Converts raw metadata to `MediaFile` objects
+    - Collects and normalizes tag information
+
+3. **Album and Artist Creation**
+    - Groups tracks by album ID
+    - Creates album records from track metadata
+    - Handles album ID changes by tracking previous IDs
+    - Creates artist records from track participants
+
+4. **Database Persistence**
+    - Uses transactions for atomic updates
+    - Preserves album annotations across ID changes
+    - Updates library-artist mappings
+    - Marks missing tracks for later processing
+    - Pre-caches artwork for performance
+
+### Phase 2: Missing Tracks Processing (`phase_2_missing_tracks.go`)
+
+This phase identifies tracks that have moved or been deleted.
+
+```mermaid
+flowchart TD
+    A[Start Phase 2] --> B[Load Libraries]
+    B --> C[Get Missing and Matching Tracks]
+    C --> D[Group by PID]
+    D --> E{Match Type?}
+    E -- Exact --> F[Update Path]
+    E -- Same PID --> G[Update If Only One]
+    E -- Equivalent --> H[Update If No Better Match]
+    F --> I[End Phase 2]
+    G --> I
+    H --> I
+```
+
+**Technical implementation details:**
+
+1. **Track Identification Strategy**
+    - Uses persistent identifiers (PIDs) to track tracks across scans
+    - Loads missing tracks and potential matches from the database
+    - Groups tracks by PID to limit comparison scope
+
+2. **Match Analysis**
+    - Applies three levels of matching criteria:
+        - Exact match (full metadata equivalence)
+        - Single match for a PID
+        - Equivalent match (same base path or similar metadata)
+    - Prioritizes matches in order of confidence
+
+3. **Database Update Strategy**
+    - Preserves the original track ID
+    - Updates the path to the new location
+    - Deletes the duplicate entry
+    - Uses transactions to ensure atomicity
+
+### Phase 3: Album Refresh (`phase_3_refresh_albums.go`)
+
+This phase updates album information based on the latest track metadata.
+
+```mermaid
+flowchart TD
+    A[Start Phase 3] --> B[Load Touched Albums]
+    B --> C[Filter Unmodified]
+    C --> D{Changes Detected?}
+    D -- Yes --> E[Refresh Album Data]
+    D -- No --> F[Skip]
+    E --> G[Update Database]
+    F --> H[End Phase 3]
+    G --> H
+    H --> I[Refresh Statistics]
+```
+
+**Technical implementation details:**
+
+1. **Album Selection Logic**
+    - Loads albums that have been "touched" in previous phases
+    - Uses a producer-consumer pattern for efficient processing
+    - Retrieves all media files for each album for completeness
+
+2. **Change Detection**
+    - Rebuilds album metadata from associated tracks
+    - Compares album attributes for changes
+    - Skips albums with no media files
+    - Avoids unnecessary database updates
+
+3. **Statistics Refreshing**
+    - Updates album play counts
+    - Updates artist play counts
+    - Maintains consistency between related entities
+
+### Phase 4: Playlist Import (`phase_4_playlists.go`)
+
+This phase imports and updates playlists from the file system.
+
+```mermaid
+flowchart TD
+    A[Start Phase 4] --> B{AutoImportPlaylists?}
+    B -- No --> C[Skip]
+    B -- Yes --> D{Admin User Exists?}
+    D -- No --> E[Log Warning & Skip]
+    D -- Yes --> F[Load Folders with Playlists]
+    F --> G{For Each Folder}
+    G --> H[Read Directory]
+    H --> I{For Each Playlist}
+    I --> J[Import Playlist]
+    J --> K[Pre-cache Artwork]
+    K --> L[End Phase 4]
+    C --> L
+    E --> L
+```
+
+**Technical implementation details:**
+
+1. **Playlist Discovery**
+    - Loads folders known to contain playlists
+    - Focuses on folders that have been touched in previous phases
+    - Handles both playlist formats (M3U, NSP)
+
+2. **Import Process**
+    - Uses the core.Playlists service for import
+    - Handles both regular and smart playlists
+    - Updates existing playlists when changed
+    - Pre-caches playlist cover art
+
+3. **Configuration Awareness**
+    - Respects the AutoImportPlaylists setting
+    - Requires an admin user for playlist import
+    - Logs appropriate messages for configuration issues
+
+## Final Processing Steps
+
+After the four main phases, several finalization steps occur:
+
+1. **Garbage Collection**
+    - Removes dangling tracks with no files
+    - Cleans up empty albums
+    - Removes orphaned artists
+    - Deletes orphaned annotations
+
+2. **Statistics Refresh**
+    - Updates artist song and album counts
+    - Refreshes tag usage statistics
+    - Updates aggregate metrics
+
+3. **Library Status Update**
+    - Marks scan as completed
+    - Updates last scan timestamp
+    - Stores persistent ID configuration
+
+4. **Database Optimization**
+    - Performs database maintenance
+    - Optimizes tables and indexes
+    - Reclaims space from deleted records
+
+## File System Watching
+
+The watcher system (`watcher.go`) provides real-time monitoring of file system changes:
+
+```mermaid
+flowchart TD
+    A[Start Watcher] --> B[For Each Library]
+    B --> C[Start Library Watcher]
+    C --> D[Monitor File Events]
+    D --> E{Change Detected?}
+    E -- Yes --> F[Wait for More Changes]
+    F --> G{Time Elapsed?}
+    G -- Yes --> H[Trigger Scan]
+    G -- No --> F
+    H --> I[Wait for Scan Completion]
+    I --> D
+```
+
+**Technical implementation details:**
+
+1. **Event Throttling**
+    - Uses a timer to batch changes
+    - Prevents excessive rescanning
+    - Configurable wait period
+
+2. **Library-specific Watching**
+    - Each library has its own watcher goroutine
+    - Translates paths to library-relative paths
+    - Filters irrelevant changes
+
+3. **Platform Adaptability**
+    - Uses storage-provided watcher implementation
+    - Supports different notification mechanisms per platform
+    - Graceful fallback when watching is not supported
+
+## Edge Cases and Optimizations
+
+### Handling Album ID Changes
+
+The scanner carefully manages album identity across scans:
+- Tracks previous album IDs to handle ID generation changes
+- Preserves annotations when IDs change
+- Maintains creation timestamps for consistent sorting
+
+### Detecting Moved Files
+
+A sophisticated algorithm identifies moved files:
+1. Groups missing and new files by their Persistent ID
+2. Applies multiple matching strategies in priority order
+3. Updates paths rather than creating duplicate entries
+
+### Resuming Interrupted Scans
+
+If a scan is interrupted:
+- The next scan detects this condition
+- Forces a full scan if the previous one was a full scan
+- Continues from where it left off for incremental scans
+
+### Memory Efficiency
+
+Several strategies minimize memory usage:
+- Batched file processing (200 files at a time)
+- External scanner process option
+- Database-side filtering where possible
+- Stream processing with pipelines
+
+### Concurrency Control
+
+The scanner implements a sophisticated concurrency model to optimize performance:
+
+1. **Phase-Level Parallelism**:
+    - Phases 1 and 2 run sequentially due to their dependencies
+    - Phases 3 and 4 run in parallel using the `chain.RunParallel()` function
+    - Final steps run sequentially to ensure data consistency
+
+2. **Within-Phase Concurrency**:
+    - Each phase has configurable concurrency for its stages
+    - For example, `phase_1_folders.go` processes folders concurrently: `ppl.NewStage(p.processFolder, ppl.Name("process folder"), ppl.Concurrency(conf.Server.DevScannerThreads))`
+    - Multiple stages can exist within a phase, each with its own concurrency level
+
+3. **Pipeline Architecture Benefits**:
+    - Producer-consumer pattern minimizes memory usage
+    - Work is streamed through stages rather than accumulated
+    - Back-pressure is automatically managed
+
+4. **Thread Safety Mechanisms**:
+    - Atomic counters for statistics gathering
+    - Mutex protection for shared resources
+    - Transactional database operations
+
+## Configuration Options
+
+The scanner's behavior can be customized through several configuration settings that directly affect its operation:
+
+### Core Scanner Options
+
+| Setting                 | Description                                                      | Default        | 
+|-------------------------|------------------------------------------------------------------|----------------|
+| `Scanner.Enabled`       | Whether the automatic scanner is enabled                         | true           |
+| `Scanner.Schedule`      | Cron expression or duration for scheduled scans (e.g., "@daily") | "0" (disabled) |
+| `Scanner.ScanOnStartup` | Whether to scan when the server starts                           | true           |
+| `Scanner.WatcherWait`   | Delay before triggering scan after file changes detected         | 5s             |
+| `Scanner.ArtistJoiner`  | String used to join multiple artists in track metadata           | " • "          |
+
+### Playlist Processing
+
+| Setting                     | Description                                              | Default |
+|-----------------------------|----------------------------------------------------------|---------|
+| `PlaylistsPath`             | Path(s) to search for playlists (supports glob patterns) | ""      |
+| `AutoImportPlaylists`       | Whether to import playlists during scanning              | true    |
+
+### Performance Options
+
+| Setting              | Description                                               | Default |
+|----------------------|-----------------------------------------------------------|---------|
+| `DevExternalScanner` | Use external process for scanning (reduces memory issues) | true    |
+| `DevScannerThreads`  | Number of concurrent processing threads during scanning   | 5       |
+
+### Persistent ID Options
+
+| Setting     | Description                                                         | Default                                                             |
+|-------------|---------------------------------------------------------------------|---------------------------------------------------------------------|
+| `PID.Track` | Format for track persistent IDs (critical for tracking moved files) | "musicbrainz_trackid\|albumid,discnumber,tracknumber,title"         |
+| `PID.Album` | Format for album persistent IDs (affects album grouping)            | "musicbrainz_albumid\|albumartistid,album,albumversion,releasedate" |
+
+These options can be set in the Navidrome configuration file (e.g., `navidrome.toml`) or via environment variables with the `ND_` prefix (e.g., `ND_SCANNER_ENABLED=false`). For environment variables, dots in option names are replaced with underscores.
+
+## Conclusion
+
+The Navidrome scanner represents a sophisticated system for efficiently managing music libraries. Its phase-based pipeline architecture, careful handling of edge cases, and performance optimizations allow it to handle libraries of significant size while maintaining data integrity and providing a responsive user experience.

scanner/controller.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/core/artwork"
 	"github.com/navidrome/navidrome/core/auth"
@@ -37,6 +38,9 @@ type StatusInfo struct {
 	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,
@@ -94,6 +98,7 @@ type ProgressInfo struct {
 	ChangesDetected bool
 	Warning         string
 	Error           string
+	ForceUpdate     bool
 }
 
 type scanner interface {
@@ -113,20 +118,51 @@ type controller struct {
 	changesDetected bool
 }
 
+// getScanInfo retrieves scan status from the database
+func (s *controller) getScanInfo(ctx context.Context) (scanType string, elapsed time.Duration, lastErr string) {
+	lastErr, _ = s.ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "")
+	scanType, _ = s.ds.Property(ctx).DefaultGet(consts.LastScanTypeKey, "")
+	startTimeStr, _ := s.ds.Property(ctx).DefaultGet(consts.LastScanStartTimeKey, "")
+
+	if startTimeStr != "" {
+		startTime, err := time.Parse(time.RFC3339, startTimeStr)
+		if err == nil {
+			if running.Load() {
+				elapsed = time.Since(startTime)
+			} else {
+				// If scan is not running, try to get the last scan time for the library
+				lib, err := s.ds.Library(ctx).Get(1) //TODO Multi-library
+				if err == nil {
+					elapsed = lib.LastScanAt.Sub(startTime)
+				}
+			}
+		}
+	}
+
+	return scanType, elapsed, lastErr
+}
+
 func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
 	lib, err := s.ds.Library(ctx).Get(1) //TODO Multi-library
 	if err != nil {
 		return nil, fmt.Errorf("getting library: %w", err)
 	}
+
+	scanType, elapsed, lastErr := s.getScanInfo(ctx)
+
 	if running.Load() {
 		status := &StatusInfo{
 			Scanning:    true,
 			LastScan:    lib.LastScanAt,
 			Count:       s.count.Load(),
 			FolderCount: s.folderCount.Load(),
+			LastError:   lastErr,
+			ScanType:    scanType,
+			ElapsedTime: elapsed,
 		}
 		return status, nil
 	}
+
 	count, folderCount, err := s.getCounters(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("getting library stats: %w", err)
@@ -136,6 +172,9 @@ func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
 		LastScan:    lib.LastScanAt,
 		Count:       uint32(count),
 		FolderCount: uint32(folderCount),
+		LastError:   lastErr,
+		ScanType:    scanType,
+		ElapsedTime: elapsed,
 	}, nil
 }
 
@@ -193,10 +232,14 @@ func (s *controller) ScanAll(requestCtx context.Context, fullScan bool) ([]strin
 	if count, folderCount, err := s.getCounters(ctx); err != nil {
 		return scanWarnings, err
 	} else {
+		scanType, elapsed, lastErr := s.getScanInfo(ctx)
 		s.sendMessage(ctx, &events.ScanStatus{
 			Scanning:    false,
 			Count:       count,
 			FolderCount: folderCount,
+			Error:       lastErr,
+			ScanType:    scanType,
+			ElapsedTime: elapsed,
 		})
 	}
 	return scanWarnings, scanError
@@ -240,12 +283,17 @@ func (s *controller) trackProgress(ctx context.Context, progress <-chan *Progres
 		if p.FileCount > 0 {
 			s.folderCount.Add(1)
 		}
+
+		scanType, elapsed, lastErr := s.getScanInfo(ctx)
 		status := &events.ScanStatus{
 			Scanning:    true,
 			Count:       int64(s.count.Load()),
 			FolderCount: int64(s.folderCount.Load()),
+			Error:       lastErr,
+			ScanType:    scanType,
+			ElapsedTime: elapsed,
 		}
-		if s.limiter != nil {
+		if s.limiter != nil && !p.ForceUpdate {
 			s.limiter.Do(func() { s.sendMessage(ctx, status) })
 		} else {
 			s.sendMessage(ctx, status)

scanner/controller_test.go

@@ -0,0 +1,57 @@
+package scanner_test
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core"
+	"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"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Controller", func() {
+	var ctx context.Context
+	var ds *tests.MockDataStore
+	var ctrl scanner.Scanner
+
+	Describe("Status", func() {
+		BeforeEach(func() {
+			ctx = context.Background()
+			db.Init(ctx)
+			DeferCleanup(func() { Expect(tests.ClearDB()).To(Succeed()) })
+			DeferCleanup(configtest.SetupConfig())
+			ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}
+			ds.MockedProperty = &tests.MockedPropertyRepo{}
+			ctrl = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(), core.NewPlaylists(ds), metrics.NewNoopInstance())
+			Expect(ds.Library(ctx).Put(&model.Library{ID: 1, Name: "lib", Path: "/tmp"})).To(Succeed())
+		})
+
+		It("includes last scan error", func() {
+			Expect(ds.Property(ctx).Put(consts.LastScanErrorKey, "boom")).To(Succeed())
+			status, err := ctrl.Status(ctx)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(status.LastError).To(Equal("boom"))
+		})
+
+		It("includes scan type and error in status", func() {
+			// Set up test data in property repo
+			Expect(ds.Property(ctx).Put(consts.LastScanErrorKey, "test error")).To(Succeed())
+			Expect(ds.Property(ctx).Put(consts.LastScanTypeKey, "full")).To(Succeed())
+
+			// Get status and verify basic info
+			status, err := ctrl.Status(ctx)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(status.LastError).To(Equal("test error"))
+			Expect(status.ScanType).To(Equal("full"))
+		})
+	})
+})

scanner/phase_2_missing_tracks.go

@@ -6,6 +6,8 @@ import (
 	"sync/atomic"
 
 	ppl "github.com/google/go-pipeline/pkg/pipeline"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 )
@@ -182,7 +184,35 @@ func (p *phaseMissingTracks) finalize(err error) error {
 	if matched > 0 {
 		log.Info(p.ctx, "Scanner: Found moved files", "total", matched, err)
 	}
+	if err != nil {
+		return err
+	}
+
+	// Check if we should purge missing items
+	if conf.Server.Scanner.PurgeMissing == consts.PurgeMissingAlways || (conf.Server.Scanner.PurgeMissing == consts.PurgeMissingFull && p.state.fullScan) {
+		if err = p.purgeMissing(); err != nil {
+			log.Error(p.ctx, "Scanner: Error purging missing items", err)
+		}
+	}
+
 	return err
 }
 
+func (p *phaseMissingTracks) purgeMissing() error {
+	deletedCount, err := p.ds.MediaFile(p.ctx).DeleteAllMissing()
+	if err != nil {
+		return fmt.Errorf("error deleting missing files: %w", err)
+	}
+
+	if deletedCount > 0 {
+		log.Info(p.ctx, "Scanner: Purged missing items from the database", "mediaFiles", deletedCount)
+		// Set changesDetected to true so that garbage collection will run at the end of the scan process
+		p.state.changesDetected.Store(true)
+	} else {
+		log.Debug(p.ctx, "Scanner: No missing items to purge")
+	}
+
+	return nil
+}
+
 var _ phase[*missingTracks] = (*phaseMissingTracks)(nil)

scanner/phase_2_missing_tracks_test.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"time"
 
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
@@ -222,4 +224,66 @@ var _ = Describe("phaseMissingTracks", func() {
 			Expect(state.changesDetected.Load()).To(BeFalse())
 		})
 	})
+
+	Describe("finalize", func() {
+		It("should return nil if no error", func() {
+			err := phase.finalize(nil)
+			Expect(err).To(BeNil())
+			Expect(state.changesDetected.Load()).To(BeFalse())
+		})
+
+		It("should return the error if provided", func() {
+			err := phase.finalize(context.DeadlineExceeded)
+			Expect(err).To(Equal(context.DeadlineExceeded))
+			Expect(state.changesDetected.Load()).To(BeFalse())
+		})
+
+		When("PurgeMissing is 'always'", func() {
+			BeforeEach(func() {
+				conf.Server.Scanner.PurgeMissing = consts.PurgeMissingAlways
+				mr.CountAllValue = 3
+				mr.DeleteAllMissingValue = 3
+			})
+			It("should purge missing files", func() {
+				Expect(state.changesDetected.Load()).To(BeFalse())
+				err := phase.finalize(nil)
+				Expect(err).To(BeNil())
+				Expect(state.changesDetected.Load()).To(BeTrue())
+			})
+		})
+
+		When("PurgeMissing is 'full'", func() {
+			BeforeEach(func() {
+				conf.Server.Scanner.PurgeMissing = consts.PurgeMissingFull
+				mr.CountAllValue = 2
+				mr.DeleteAllMissingValue = 2
+			})
+			It("should not purge missing files if not a full scan", func() {
+				state.fullScan = false
+				err := phase.finalize(nil)
+				Expect(err).To(BeNil())
+				Expect(state.changesDetected.Load()).To(BeFalse())
+			})
+			It("should purge missing files if full scan", func() {
+				Expect(state.changesDetected.Load()).To(BeFalse())
+				state.fullScan = true
+				err := phase.finalize(nil)
+				Expect(err).To(BeNil())
+				Expect(state.changesDetected.Load()).To(BeTrue())
+			})
+		})
+
+		When("PurgeMissing is 'never'", func() {
+			BeforeEach(func() {
+				conf.Server.Scanner.PurgeMissing = consts.PurgeMissingNever
+				mr.CountAllValue = 1
+				mr.DeleteAllMissingValue = 1
+			})
+			It("should not purge missing files", func() {
+				err := phase.finalize(nil)
+				Expect(err).To(BeNil())
+				Expect(state.changesDetected.Load()).To(BeFalse())
+			})
+		})
+	})
 })

scanner/scanner.go

@@ -57,12 +57,21 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
 	startTime := time.Now()
 	log.Info(ctx, "Scanner: Starting scan", "fullScan", state.fullScan, "numLibraries", len(libs))
 
+	// Store scan type and start time
+	scanType := "quick"
+	if state.fullScan {
+		scanType = "full"
+	}
+	_ = 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 {
 			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")
 				break
 			}
 		}
@@ -100,11 +109,14 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
 	)
 	if err != nil {
 		log.Error(ctx, "Scanner: Finished with error", "duration", time.Since(startTime), err)
+		_ = s.ds.Property(ctx).Put(consts.LastScanErrorKey, err.Error())
 		state.sendError(err)
 		s.metrics.WriteAfterScanMetrics(ctx, false)
 		return
 	}
 
+	_ = s.ds.Property(ctx).Put(consts.LastScanErrorKey, "")
+
 	if state.changesDetected.Load() {
 		state.sendProgress(&ProgressInfo{ChangesDetected: true})
 	}
@@ -115,6 +127,7 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
 
 func (s *scannerImpl) runGC(ctx context.Context, state *scanState) func() error {
 	return func() error {
+		state.sendProgress(&ProgressInfo{ForceUpdate: true})
 		return s.ds.WithTx(func(tx model.DataStore) error {
 			if state.changesDetected.Load() {
 				start := time.Now()

scanner/scanner_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/core/artwork"
 	"github.com/navidrome/navidrome/core/metrics"
@@ -17,6 +18,7 @@ import (
 	"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"
@@ -47,14 +49,15 @@ var _ = Describe("Scanner", Ordered, func() {
 	}
 
 	BeforeAll(func() {
+		ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "123", IsAdmin: true})
 		tmpDir := GinkgoT().TempDir()
 		conf.Server.DbPath = filepath.Join(tmpDir, "test-scanner.db?_journal_mode=WAL")
 		log.Warn("Using DB at " + conf.Server.DbPath)
 		//conf.Server.DbPath = ":memory:"
+		db.Db().SetMaxOpenConns(1)
 	})
 
 	BeforeEach(func() {
-		ctx = context.Background()
 		db.Init(ctx)
 		DeferCleanup(func() {
 			Expect(tests.ClearDB()).To(Succeed())
@@ -501,6 +504,113 @@ var _ = Describe("Scanner", Ordered, func() {
 			Expect(aa[0].MbzArtistID).To(Equal(beatlesMBID))
 			Expect(aa[0].SortArtistName).To(Equal("Beatles, The"))
 		})
+
+		Context("When PurgeMissing is configured", func() {
+			When("PurgeMissing is set to 'never'", func() {
+				BeforeEach(func() {
+					DeferCleanup(configtest.SetupConfig())
+					conf.Server.Scanner.PurgeMissing = consts.PurgeMissingNever
+				})
+
+				It("should mark files as missing but not delete them", func() {
+					By("Running initial scan")
+					Expect(runScanner(ctx, true)).To(Succeed())
+
+					By("Removing a file")
+					fsys.Remove("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+
+					By("Running another scan")
+					Expect(runScanner(ctx, true)).To(Succeed())
+
+					By("Checking files are marked as missing but not deleted")
+					count, err := ds.MediaFile(ctx).CountAll(model.QueryOptions{
+						Filters: squirrel.Eq{"missing": true},
+					})
+					Expect(err).ToNot(HaveOccurred())
+					Expect(count).To(Equal(int64(1)))
+
+					mf, err := findByPath("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+					Expect(err).ToNot(HaveOccurred())
+					Expect(mf.Missing).To(BeTrue())
+				})
+			})
+
+			When("PurgeMissing is set to 'always'", func() {
+				BeforeEach(func() {
+					conf.Server.Scanner.PurgeMissing = consts.PurgeMissingAlways
+				})
+
+				It("should purge missing files on any scan", func() {
+					By("Running initial scan")
+					Expect(runScanner(ctx, false)).To(Succeed())
+
+					By("Removing a file")
+					fsys.Remove("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+
+					By("Running an incremental scan")
+					Expect(runScanner(ctx, false)).To(Succeed())
+
+					By("Checking missing files are deleted")
+					count, err := ds.MediaFile(ctx).CountAll(model.QueryOptions{
+						Filters: squirrel.Eq{"missing": true},
+					})
+					Expect(err).ToNot(HaveOccurred())
+					Expect(count).To(BeZero())
+
+					_, err = findByPath("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+					Expect(err).To(MatchError(model.ErrNotFound))
+				})
+			})
+
+			When("PurgeMissing is set to 'full'", func() {
+				BeforeEach(func() {
+					conf.Server.Scanner.PurgeMissing = consts.PurgeMissingFull
+				})
+
+				It("should not purge missing files on incremental scans", func() {
+					By("Running initial scan")
+					Expect(runScanner(ctx, true)).To(Succeed())
+
+					By("Removing a file")
+					fsys.Remove("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+
+					By("Running an incremental scan")
+					Expect(runScanner(ctx, false)).To(Succeed())
+
+					By("Checking files are marked as missing but not deleted")
+					count, err := ds.MediaFile(ctx).CountAll(model.QueryOptions{
+						Filters: squirrel.Eq{"missing": true},
+					})
+					Expect(err).ToNot(HaveOccurred())
+					Expect(count).To(Equal(int64(1)))
+
+					mf, err := findByPath("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+					Expect(err).ToNot(HaveOccurred())
+					Expect(mf.Missing).To(BeTrue())
+				})
+
+				It("should purge missing files only on full scans", func() {
+					By("Running initial scan")
+					Expect(runScanner(ctx, true)).To(Succeed())
+
+					By("Removing a file")
+					fsys.Remove("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+
+					By("Running a full scan")
+					Expect(runScanner(ctx, true)).To(Succeed())
+
+					By("Checking missing files are deleted")
+					count, err := ds.MediaFile(ctx).CountAll(model.QueryOptions{
+						Filters: squirrel.Eq{"missing": true},
+					})
+					Expect(err).ToNot(HaveOccurred())
+					Expect(count).To(BeZero())
+
+					_, err = findByPath("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+					Expect(err).To(MatchError(model.ErrNotFound))
+				})
+			})
+		})
 	})
 })
 

scanner/walk_dir_tree.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/log"
@@ -266,6 +267,10 @@ func isDirOrSymlinkToDir(fsys fs.FS, baseDir string, dirEnt fs.DirEntry) (bool,
 	if dirEnt.Type()&fs.ModeSymlink == 0 {
 		return false, nil
 	}
+	// If symlinks are disabled, return false for symlinks
+	if !conf.Server.Scanner.FollowSymlinks {
+		return false, nil
+	}
 	// Does this symlink point to a directory?
 	fileInfo, err := fs.Stat(fsys, path.Join(baseDir, dirEnt.Name()))
 	if err != nil {

scanner/walk_dir_tree_test.go

@@ -8,6 +8,8 @@ import (
 	"path/filepath"
 	"testing/fstest"
 
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core/storage"
 	"github.com/navidrome/navidrome/model"
 	. "github.com/onsi/ginkgo/v2"
@@ -17,8 +19,15 @@ import (
 
 var _ = Describe("walk_dir_tree", func() {
 	Describe("walkDirTree", func() {
-		var fsys storage.MusicFS
+		var (
+			fsys storage.MusicFS
+			job  *scanJob
+			ctx  context.Context
+		)
+
 		BeforeEach(func() {
+			DeferCleanup(configtest.SetupConfig())
+			ctx = GinkgoT().Context()
 			fsys = &mockMusicFS{
 				FS: fstest.MapFS{
 					"root/a/.ndignore":       {Data: []byte("ignored/*")},
@@ -32,21 +41,22 @@ var _ = Describe("walk_dir_tree", func() {
 					"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("root/e/original")},
 				},
 			}
-		})
-
-		It("walks all directories", func() {
-			job := &scanJob{
+			job = &scanJob{
 				fs:  fsys,
 				lib: model.Library{Path: "/music"},
 			}
-			ctx := context.Background()
+		})
+
+		// 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 {
@@ -55,24 +65,42 @@ var _ = Describe("walk_dir_tree", func() {
 				return nil
 			})
 			_ = g.Wait()
+			return folders
+		}
 
-			Expect(folders).To(HaveLen(6))
-			Expect(folders["root/a/ignored"].audioFiles).To(BeEmpty())
-			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"))
-		})
+		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"))
+				}
+			},
+			Entry("with symlinks enabled", true, 7),
+			Entry("with symlinks disabled", false, 6),
+		)
 	})
 
 	Describe("helper functions", func() {
@@ -81,74 +109,88 @@ var _ = Describe("walk_dir_tree", func() {
 		baseDir := filepath.Join("tests", "fixtures")
 
 		Describe("isDirOrSymlinkToDir", func() {
-			It("returns true for normal dirs", func() {
-				dirEntry := getDirEntry("tests", "fixtures")
-				Expect(isDirOrSymlinkToDir(fsys, baseDir, dirEntry)).To(BeTrue())
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig())
 			})
-			It("returns true for symlinks to dirs", func() {
-				dirEntry := getDirEntry(baseDir, "symlink2dir")
-				Expect(isDirOrSymlinkToDir(fsys, baseDir, dirEntry)).To(BeTrue())
-			})
-			It("returns false for files", func() {
-				dirEntry := getDirEntry(baseDir, "test.mp3")
-				Expect(isDirOrSymlinkToDir(fsys, baseDir, dirEntry)).To(BeFalse())
-			})
-			It("returns false for symlinks to files", func() {
-				dirEntry := getDirEntry(baseDir, "symlink")
-				Expect(isDirOrSymlinkToDir(fsys, baseDir, dirEntry)).To(BeFalse())
-			})
-		})
-		Describe("isDirIgnored", func() {
-			It("returns false for normal dirs", func() {
-				Expect(isDirIgnored("empty_folder")).To(BeFalse())
-			})
-			It("returns true when folder name starts with a `.`", func() {
-				Expect(isDirIgnored(".hidden_folder")).To(BeTrue())
-			})
-			It("returns false when folder name starts with ellipses", func() {
-				Expect(isDirIgnored("...unhidden_folder")).To(BeFalse())
-			})
-			It("returns true when folder name is $Recycle.Bin", func() {
-				Expect(isDirIgnored("$Recycle.Bin")).To(BeTrue())
-			})
-			It("returns true when folder name is #snapshot", func() {
-				Expect(isDirIgnored("#snapshot")).To(BeTrue())
-			})
-		})
-	})
 
-	Describe("fullReadDir", func() {
-		var fsys fakeFS
-		var ctx context.Context
-		BeforeEach(func() {
-			ctx = context.Background()
-			fsys = fakeFS{MapFS: fstest.MapFS{
-				"root/a/f1": {},
-				"root/b/f2": {},
-				"root/c/f3": {},
-			}}
+			Context("with symlinks enabled", func() {
+				BeforeEach(func() {
+					conf.Server.Scanner.FollowSymlinks = true
+				})
+
+				DescribeTable("returns expected result",
+					func(dirName string, expected bool) {
+						dirEntry := getDirEntry("tests/fixtures", dirName)
+						Expect(isDirOrSymlinkToDir(fsys, baseDir, dirEntry)).To(Equal(expected))
+					},
+					Entry("normal dir", "empty_folder", true),
+					Entry("symlink to dir", "symlink2dir", true),
+					Entry("regular file", "test.mp3", false),
+					Entry("symlink to file", "symlink", false),
+				)
+			})
+
+			Context("with symlinks disabled", func() {
+				BeforeEach(func() {
+					conf.Server.Scanner.FollowSymlinks = false
+				})
+
+				DescribeTable("returns expected result",
+					func(dirName string, expected bool) {
+						dirEntry := getDirEntry("tests/fixtures", dirName)
+						Expect(isDirOrSymlinkToDir(fsys, baseDir, dirEntry)).To(Equal(expected))
+					},
+					Entry("normal dir", "empty_folder", true),
+					Entry("symlink to dir", "symlink2dir", false),
+					Entry("regular file", "test.mp3", false),
+					Entry("symlink to file", "symlink", false),
+				)
+			})
 		})
-		It("reads all entries", func() {
-			dir, _ := fsys.Open("root")
-			entries := fullReadDir(ctx, dir.(fs.ReadDirFile))
-			Expect(entries).To(HaveLen(3))
-			Expect(entries[0].Name()).To(Equal("a"))
-			Expect(entries[1].Name()).To(Equal("b"))
-			Expect(entries[2].Name()).To(Equal("c"))
+
+		Describe("isDirIgnored", func() {
+			DescribeTable("returns expected result",
+				func(dirName string, expected bool) {
+					Expect(isDirIgnored(dirName)).To(Equal(expected))
+				},
+				Entry("normal dir", "empty_folder", false),
+				Entry("hidden dir", ".hidden_folder", true),
+				Entry("dir starting with ellipsis", "...unhidden_folder", false),
+				Entry("recycle bin", "$Recycle.Bin", true),
+				Entry("snapshot dir", "#snapshot", true),
+			)
 		})
-		It("skips entries with permission error", func() {
-			fsys.failOn = "b"
-			dir, _ := fsys.Open("root")
-			entries := fullReadDir(ctx, dir.(fs.ReadDirFile))
-			Expect(entries).To(HaveLen(2))
-			Expect(entries[0].Name()).To(Equal("a"))
-			Expect(entries[1].Name()).To(Equal("c"))
-		})
-		It("aborts if it keeps getting 'readdirent: no such file or directory'", func() {
-			fsys.err = fs.ErrNotExist
-			dir, _ := fsys.Open("root")
-			entries := fullReadDir(ctx, dir.(fs.ReadDirFile))
-			Expect(entries).To(BeEmpty())
+
+		Describe("fullReadDir", func() {
+			var (
+				fsys fakeFS
+				ctx  context.Context
+			)
+
+			BeforeEach(func() {
+				ctx = GinkgoT().Context()
+				fsys = fakeFS{MapFS: fstest.MapFS{
+					"root/a/f1": {},
+					"root/b/f2": {},
+					"root/c/f3": {},
+				}}
+			})
+
+			DescribeTable("reading directory entries",
+				func(failOn string, expectedErr error, expectedNames []string) {
+					fsys.failOn = failOn
+					fsys.err = expectedErr
+					dir, _ := fsys.Open("root")
+					entries := fullReadDir(ctx, dir.(fs.ReadDirFile))
+					Expect(entries).To(HaveLen(len(expectedNames)))
+					for i, name := range expectedNames {
+						Expect(entries[i].Name()).To(Equal(name))
+					}
+				},
+				Entry("reads all entries", "", nil, []string{"a", "b", "c"}),
+				Entry("skips entries with permission error", "b", nil, []string{"a", "c"}),
+				Entry("aborts on fs.ErrNotExist", "", fs.ErrNotExist, []string{}),
+			)
 		})
 	})
 })
@@ -205,11 +247,54 @@ func getDirEntry(baseDir, name string) os.DirEntry {
 	panic(fmt.Sprintf("Could not find %s in %s", name, baseDir))
 }
 
+// mockMusicFS is a mock implementation of the MusicFS interface that supports symlinks
 type mockMusicFS struct {
 	storage.MusicFS
 	fs.FS
 }
 
+// Open resolves symlinks
 func (m *mockMusicFS) Open(name string) (fs.File, error) {
-	return m.FS.Open(name)
+	f, err := m.FS.Open(name)
+	if err != nil {
+		return nil, err
+	}
+
+	info, err := f.Stat()
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+
+	if info.Mode()&fs.ModeSymlink != 0 {
+		// For symlinks, read the target path from the Data field
+		target := string(m.FS.(fstest.MapFS)[name].Data)
+		f.Close()
+		return m.FS.Open(target)
+	}
+
+	return f, nil
+}
+
+// Stat uses Open to resolve symlinks
+func (m *mockMusicFS) Stat(name string) (fs.FileInfo, error) {
+	f, err := m.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	return f.Stat()
+}
+
+// ReadDir uses Open to resolve symlinks
+func (m *mockMusicFS) ReadDir(name string) ([]fs.DirEntry, error) {
+	f, err := m.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	if dirFile, ok := f.(fs.ReadDirFile); ok {
+		return dirFile.ReadDir(-1)
+	}
+	return nil, fmt.Errorf("not a directory")
 }

server/events/events.go

@@ -37,9 +37,12 @@ func (e *baseEvent) Data(evt Event) string {
 
 type ScanStatus struct {
 	baseEvent
-	Scanning    bool  `json:"scanning"`
-	Count       int64 `json:"count"`
-	FolderCount int64 `json:"folderCount"`
+	Scanning    bool          `json:"scanning"`
+	Count       int64         `json:"count"`
+	FolderCount int64         `json:"folderCount"`
+	Error       string        `json:"error"`
+	ScanType    string        `json:"scanType"`
+	ElapsedTime time.Duration `json:"elapsedTime"`
 }
 
 type KeepAlive struct {

server/nativeapi/missing.go

@@ -63,25 +63,29 @@ func (r *missingRepository) EntityName() string {
 }
 
 func deleteMissingFiles(ds model.DataStore, w http.ResponseWriter, r *http.Request) {
-	repo := ds.MediaFile(r.Context())
+	ctx := r.Context()
 	p := req.Params(r)
 	ids, _ := p.Strings("id")
 	err := ds.WithTx(func(tx model.DataStore) error {
-		return repo.DeleteMissing(ids)
+		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(r.Context(), "Missing file not found", "id", ids[0])
+		log.Warn(ctx, "Missing file not found", "id", ids[0])
 		http.Error(w, "not found", http.StatusNotFound)
 		return
 	}
 	if err != nil {
-		log.Error(r.Context(), "Error deleting missing tracks from DB", "ids", ids, err)
+		log.Error(ctx, "Error deleting missing tracks from DB", "ids", ids, err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	err = ds.GC(r.Context())
+	err = ds.GC(ctx)
 	if err != nil {
-		log.Error(r.Context(), "Error running GC after deleting missing tracks", err)
+		log.Error(ctx, "Error running GC after deleting missing tracks", err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}

server/public/handle_images.go

@@ -37,8 +37,9 @@ func (pub *Router) handleImages(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	size := p.IntOr("size", 0)
+	square := p.BoolOr("square", false)
 
-	imgReader, lastUpdate, err := pub.artwork.Get(ctx, artId, size, false)
+	imgReader, lastUpdate, err := pub.artwork.Get(ctx, artId, size, square)
 	switch {
 	case errors.Is(err, context.Canceled):
 		return

server/subsonic/api_suite_test.go

@@ -4,11 +4,13 @@ import (
 	"testing"
 
 	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestSubsonicApi(t *testing.T) {
+	tests.Init(t, false)
 	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Subsonic API Suite")

server/subsonic/browsing.go

@@ -38,7 +38,7 @@ func (api *Router) getArtist(r *http.Request, libId int, ifModifiedSince time.Ti
 
 	var indexes model.ArtistIndexes
 	if lib.LastScanAt.After(ifModifiedSince) {
-		indexes, err = api.ds.Artist(ctx).GetIndex(model.RoleAlbumArtist)
+		indexes, err = api.ds.Artist(ctx).GetIndex(false, model.RoleAlbumArtist)
 		if err != nil {
 			log.Error(ctx, "Error retrieving Indexes", err)
 			return nil, 0, err

server/subsonic/filter/filters.go

@@ -110,10 +110,17 @@ func SongsByRandom(genre string, fromYear, toYear int) Options {
 
 func SongWithLyrics(artist, title string) Options {
 	return addDefaultFilters(Options{
-		Sort:    "updated_at",
-		Order:   "desc",
-		Max:     1,
-		Filters: And{Eq{"artist": artist, "title": title}, NotEq{"lyrics": ""}},
+		Sort:  "updated_at",
+		Order: "desc",
+		Max:   1,
+		Filters: And{
+			Eq{"title": title},
+			NotEq{"lyrics": "[]"},
+			Or{
+				persistence.Exists("json_tree(participants, '$.albumartist')", Eq{"value": artist}),
+				persistence.Exists("json_tree(participants, '$.artist')", Eq{"value": artist}),
+			},
+		},
 	})
 }
 

server/subsonic/helpers.go

@@ -224,6 +224,7 @@ func osChildFromMediaFile(ctx context.Context, mf model.MediaFile) *responses.Op
 	child.BPM = int32(mf.BPM)
 	child.MediaType = responses.MediaTypeSong
 	child.MusicBrainzId = mf.MbzRecordingID
+	child.Isrc = mf.Tags.Values(model.TagISRC)
 	child.ReplayGain = responses.ReplayGain{
 		TrackGain: mf.RGTrackGain,
 		AlbumGain: mf.RGAlbumGain,

server/subsonic/library_scanning.go

@@ -23,6 +23,9 @@ func (api *Router) GetScanStatus(r *http.Request) (*responses.Subsonic, error) {
 		Count:       int64(status.Count),
 		FolderCount: int64(status.FolderCount),
 		LastScan:    &status.LastScan,
+		Error:       status.LastError,
+		ScanType:    status.ScanType,
+		ElapsedTime: int64(status.ElapsedTime),
 	}
 	return response, nil
 }

server/subsonic/media_retrieval.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/lyrics"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/resources"
@@ -95,8 +96,8 @@ func (api *Router) GetLyrics(r *http.Request) (*responses.Subsonic, error) {
 	artist, _ := p.String("artist")
 	title, _ := p.String("title")
 	response := newResponse()
-	lyrics := responses.Lyrics{}
-	response.Lyrics = &lyrics
+	lyricsResponse := responses.Lyrics{}
+	response.Lyrics = &lyricsResponse
 	mediaFiles, err := api.ds.MediaFile(r.Context()).GetAll(filter.SongWithLyrics(artist, title))
 
 	if err != nil {
@@ -107,7 +108,7 @@ func (api *Router) GetLyrics(r *http.Request) (*responses.Subsonic, error) {
 		return response, nil
 	}
 
-	structuredLyrics, err := mediaFiles[0].StructuredLyrics()
+	structuredLyrics, err := lyrics.GetLyrics(r.Context(), &mediaFiles[0])
 	if err != nil {
 		return nil, err
 	}
@@ -116,15 +117,15 @@ func (api *Router) GetLyrics(r *http.Request) (*responses.Subsonic, error) {
 		return response, nil
 	}
 
-	lyrics.Artist = artist
-	lyrics.Title = title
+	lyricsResponse.Artist = artist
+	lyricsResponse.Title = title
 
 	lyricsText := ""
 	for _, line := range structuredLyrics[0].Line {
 		lyricsText += line.Value + "\n"
 	}
 
-	lyrics.Value = lyricsText
+	lyricsResponse.Value = lyricsText
 
 	return response, nil
 }
@@ -140,13 +141,13 @@ func (api *Router) GetLyricsBySongId(r *http.Request) (*responses.Subsonic, erro
 		return nil, err
 	}
 
-	lyrics, err := mediaFile.StructuredLyrics()
+	structuredLyrics, err := lyrics.GetLyrics(r.Context(), mediaFile)
 	if err != nil {
 		return nil, err
 	}
 
 	response := newResponse()
-	response.LyricsList = buildLyricsList(mediaFile, lyrics)
+	response.LyricsList = buildLyricsList(mediaFile, structuredLyrics)
 
 	return response, nil
 }