Merge f0417bd9e83c65a948df3d22e757513ea8c76045 into 23f3556371321faf199866989b906f2ef06a8034

2026-05-03 06:51:16 +00:00 · 2026-04-03 06:16:41 +00:00
164 changed files with 3350 additions and 5373 deletions
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@ -13,5 +13,17 @@ RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "source /usr/local/shar
 RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
    && apt-get -y install --no-install-recommends ffmpeg

+# Install TagLib from cross-taglib releases
+ARG CROSS_TAGLIB_VERSION="2.2.0-1"
+ARG TARGETARCH
+RUN DOWNLOAD_ARCH="linux-${TARGETARCH}" \
+    && wget -q "https://github.com/navidrome/cross-taglib/releases/download/v${CROSS_TAGLIB_VERSION}/taglib-${DOWNLOAD_ARCH}.tar.gz" -O /tmp/cross-taglib.tar.gz \
+    && tar -xzf /tmp/cross-taglib.tar.gz -C /usr --strip-components=1 \
+    && mv /usr/include/taglib/* /usr/include/ \
+    && rmdir /usr/include/taglib \
+    && rm /tmp/cross-taglib.tar.gz /usr/provenance.json
+
+ENV CGO_CFLAGS_ALLOW="--define-prefix"
+
 # [Optional] Uncomment this line to install global node packages.
 # RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@ -4,10 +4,11 @@
 		"dockerfile": "Dockerfile",
 		"args": {
 			// Update the VARIANT arg to pick a version of Go: 1, 1.15, 1.14
-			"VARIANT": "1.26",
+			"VARIANT": "1.25",
 			// Options
 			"INSTALL_NODE": "true",
-			"NODE_VERSION": "v24"
+			"NODE_VERSION": "v24",
+			"CROSS_TAGLIB_VERSION": "2.2.0-1"
 		}
 	},
 	"workspaceMount": "",
--- a/.github/actions/download-taglib/action.yml
+++ b/.github/actions/download-taglib/action.yml
@ -0,0 +1,23 @@
+name: 'Download TagLib'
+description: 'Downloads and extracts the TagLib library, adding it to PKG_CONFIG_PATH'
+inputs:
+  version:
+    description: 'Version of TagLib to download'
+    required: true
+  platform:
+    description: 'Platform to download TagLib for'
+    default: 'linux-amd64'
+runs:
+  using: 'composite'
+  steps:
+    - name: Download TagLib
+      shell: bash
+      run: |
+        mkdir -p /tmp/taglib
+        cd /tmp
+        FILE=taglib-${{ inputs.platform }}.tar.gz
+        wget https://github.com/navidrome/cross-taglib/releases/download/v${{ inputs.version }}/${FILE}
+        tar -xzf ${FILE} -C taglib
+        PKG_CONFIG_PREFIX=/tmp/taglib
+        echo "PKG_CONFIG_PREFIX=${PKG_CONFIG_PREFIX}" >> $GITHUB_ENV
+        echo "PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:${PKG_CONFIG_PREFIX}/lib/pkgconfig" >> $GITHUB_ENV
--- a/.github/workflows/pipeline.yml
+++ b/.github/workflows/pipeline.yml
@ -14,6 +14,8 @@ concurrency:
  cancel-in-progress: true

 env:
+  CROSS_TAGLIB_VERSION: "2.2.0-1"
+  CGO_CFLAGS_ALLOW: "--define-prefix"
  IS_RELEASE: ${{ startsWith(github.ref, 'refs/tags/') && 'true' || 'false' }}

 jobs:
@ -64,9 +66,10 @@ jobs:
    steps:
      - uses: actions/checkout@v6

-      - uses: actions/setup-go@v6
+      - name: Download TagLib
+        uses: ./.github/actions/download-taglib
        with:
-          go-version-file: go.mod
+          version: ${{ env.CROSS_TAGLIB_VERSION }}

      - name: golangci-lint
        uses: golangci/golangci-lint-action@v9
@ -103,15 +106,18 @@ jobs:
      - name: Check out code into the Go module directory
        uses: actions/checkout@v6

-      - uses: actions/setup-go@v6
+      - name: Download TagLib
+        uses: ./.github/actions/download-taglib
        with:
-          go-version-file: go.mod
+          version: ${{ env.CROSS_TAGLIB_VERSION }}

      - name: Download dependencies
        run: go mod download

      - name: Test
-        run: go test -shuffle=on -tags netgo,sqlite_fts5 -race ./... -v
+        run: |
+          pkg-config --define-prefix --cflags --libs taglib # for debugging
+          go test -shuffle=on -tags netgo,sqlite_fts5 -race ./... -v

      - name: Test ndpgen
        run: |
@ -120,79 +126,6 @@ jobs:
          go build -o ndpgen .
          ./ndpgen --help

-  go-windows:
-    name: Test Go code (Windows)
-    runs-on: windows-2022
-    env:
-      FFMPEG_VERSION: "7.1"
-      FFMPEG_REPOSITORY: navidrome/ffmpeg-windows-builds
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-go@v6
-        with:
-          go-version-file: go.mod
-
-      - uses: msys2/setup-msys2@v2
-        with:
-          msystem: MINGW64
-          install: mingw-w64-x86_64-gcc
-          update: false
-
-      - name: Add mingw64 to PATH
-        shell: bash
-        run: echo "C:/msys64/mingw64/bin" >> $GITHUB_PATH
-
-      - name: Cache ffmpeg
-        id: ffmpeg-cache
-        uses: actions/cache@v4
-        with:
-          path: C:\ffmpeg
-          key: ffmpeg-${{ env.FFMPEG_VERSION }}-win64
-
-      - name: Download ffmpeg
-        if: steps.ffmpeg-cache.outputs.cache-hit != 'true'
-        shell: pwsh
-        run: |
-          $asset = "ffmpeg-n${env:FFMPEG_VERSION}-latest-win64-gpl-${env:FFMPEG_VERSION}"
-          $url = "https://github.com/${env:FFMPEG_REPOSITORY}/releases/download/latest/$asset.zip"
-          Invoke-WebRequest -Uri $url -OutFile ffmpeg.zip
-          Expand-Archive ffmpeg.zip -DestinationPath C:\ffmpeg-extracted
-          New-Item -ItemType Directory -Force -Path C:\ffmpeg\bin | Out-Null
-          Copy-Item "C:\ffmpeg-extracted\$asset\bin\ffmpeg.exe"  C:\ffmpeg\bin
-          Copy-Item "C:\ffmpeg-extracted\$asset\bin\ffprobe.exe" C:\ffmpeg\bin
-
-      - name: Add ffmpeg to PATH
-        shell: bash
-        run: echo "C:/ffmpeg/bin" >> $GITHUB_PATH
-
-      - name: Verify toolchain
-        shell: pwsh
-        run: |
-          go version
-          where.exe gcc
-          gcc --version
-          ffmpeg -version
-          ffprobe -version
-
-      - name: Download dependencies
-        shell: bash
-        run: go mod download
-
-      - name: Test
-        shell: bash
-        env:
-          CGO_ENABLED: "1"
-        run: go test -shuffle=on -tags netgo,sqlite_fts5 ./... -v
-
-      - name: Test ndpgen
-        shell: pwsh
-        run: |
-          cd plugins\cmd\ndpgen
-          go test -shuffle=on -v
-          go build -o ndpgen.exe .
-          .\ndpgen.exe --help
-
  js:
    name: Test JS code
    runs-on: ubuntu-latest
@ -257,7 +190,7 @@ jobs:

  build:
    name: Build
-    needs: [js, go, go-windows, go-lint, i18n-lint, git-version, check-push-enabled]
+    needs: [js, go, go-lint, i18n-lint, git-version, check-push-enabled]
    strategy:
      matrix:
        platform: [ linux/amd64, linux/arm64, linux/arm/v5, linux/arm/v6, linux/arm/v7, linux/386, linux/riscv64, darwin/amd64, darwin/arm64, windows/amd64, windows/386 ]
@ -299,6 +232,7 @@ jobs:
          build-args: |
            GIT_SHA=${{ env.GIT_SHA }}
            GIT_TAG=${{ env.GIT_TAG }}
+            CROSS_TAGLIB_VERSION=${{ env.CROSS_TAGLIB_VERSION }}

      - name: Upload Binaries
        uses: actions/upload-artifact@v7
@ -319,6 +253,7 @@ jobs:
          build-args: |
            GIT_SHA=${{ env.GIT_SHA }}
            GIT_TAG=${{ env.GIT_TAG }}
+            CROSS_TAGLIB_VERSION=${{ env.CROSS_TAGLIB_VERSION }}
          outputs: |
            type=image,name=${{ steps.docker.outputs.hub_repository }},push-by-digest=true,name-canonical=true,push=${{ steps.docker.outputs.hub_enabled }}
            type=image,name=ghcr.io/${{ github.repository }},push-by-digest=true,name-canonical=true,push=true
--- a/.golangci.yml
+++ b/.golangci.yml
@ -55,7 +55,6 @@ linters:
      - third_party$
      - builtin$
      - examples$
-      - node_modules
 formatters:
  exclusions:
    generated: lax
@ -63,4 +62,3 @@ formatters:
      - third_party$
      - builtin$
      - examples$
-      - node_modules
--- a/82
+++ b/82
@ -24,6 +24,26 @@ RUN cd /out && \
 FROM scratch AS xx
 COPY --from=xx-build /out/ /usr/bin/

+########################################################################################################################
+### Get TagLib
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/alpine:3.20 AS taglib-build
+ARG TARGETPLATFORM
+ARG CROSS_TAGLIB_VERSION=2.2.0-1
+ENV CROSS_TAGLIB_RELEASES_URL=https://github.com/navidrome/cross-taglib/releases/download/v${CROSS_TAGLIB_VERSION}/
+
+# wget in busybox can't follow redirects
+RUN <<EOT
+    apk add --no-cache wget
+    PLATFORM=$(echo ${TARGETPLATFORM} | tr '/' '-')
+    FILE=taglib-${PLATFORM}.tar.gz
+
+    DOWNLOAD_URL=${CROSS_TAGLIB_RELEASES_URL}${FILE}
+    wget ${DOWNLOAD_URL}
+
+    mkdir /taglib
+    tar -xzf ${FILE} -C /taglib
+EOT
+
 ########################################################################################################################
 ### Build Navidrome UI
 FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/node:lts-alpine AS ui
@ -42,47 +62,8 @@ FROM scratch AS ui-bundle
 COPY --from=ui /build /build

 ########################################################################################################################
-### Build Navidrome binary for Docker image (dynamic musl, enables native libwebp via dlopen)
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.26-alpine AS build-alpine
-COPY --from=xx / /
-
-ARG TARGETPLATFORM
-
-RUN apk add --no-cache clang lld file git
-RUN xx-apk add --no-cache gcc musl-dev zlib-dev
-RUN xx-verify --setup
-
-WORKDIR /workspace
-
-RUN --mount=type=bind,source=. \
-    --mount=type=cache,target=/root/.cache \
-    --mount=type=cache,target=/go/pkg/mod \
-    go mod download
-
-ARG GIT_SHA
-ARG GIT_TAG
-
-RUN --mount=type=bind,source=. \
-    --mount=from=ui,source=/build,target=./ui/build,ro \
-    --mount=type=cache,target=/root/.cache \
-    --mount=type=cache,target=/go/pkg/mod <<EOT
-    set -e
-    xx-go --wrap
-    export CGO_ENABLED=1
-    # -latomic is required on 32-bit arm (arm/v6, arm/v7) so SQLite's 64-bit atomics resolve.
-    go build -tags=netgo,sqlite_fts5 -ldflags="-w -s \
-        -linkmode=external -extldflags '-latomic' \
-        -X github.com/navidrome/navidrome/consts.gitSha=${GIT_SHA} \
-        -X github.com/navidrome/navidrome/consts.gitTag=${GIT_TAG}" \
-        -o /out/navidrome .
-    # Fail the build if the binary is accidentally statically linked: dlopen (and
-    # therefore native libwebp detection) only works with a dynamic interpreter.
-    file /out/navidrome | grep -q "dynamically linked" || { echo "ERROR: /out/navidrome is not dynamically linked"; file /out/navidrome; exit 1; }
-EOT
-
-########################################################################################################################
-### Build Navidrome binary for standalone distribution (static glibc, cross-compiled)
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.26-trixie AS base
+### Build Navidrome binary
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-trixie AS base
 RUN apt-get update && apt-get install -y clang lld
 COPY --from=xx / /
 WORKDIR /workspace
@ -107,11 +88,14 @@ RUN --mount=type=bind,source=. \
    --mount=from=ui,source=/build,target=./ui/build,ro \
    --mount=from=osxcross,src=/osxcross/SDK,target=/xx-sdk,ro \
    --mount=type=cache,target=/root/.cache \
-    --mount=type=cache,target=/go/pkg/mod <<EOT
+    --mount=type=cache,target=/go/pkg/mod \
+    --mount=from=taglib-build,target=/taglib,src=/taglib,ro <<EOT

    # Setup CGO cross-compilation environment
    xx-go --wrap
    export CGO_ENABLED=1
+    export CGO_CFLAGS_ALLOW="--define-prefix"
+    export PKG_CONFIG_PATH=/taglib/lib/pkgconfig
    cat $(go env GOENV)

    # Only Darwin (macOS) requires clang (default), Windows requires gcc, everything else can use any compiler.
@ -143,23 +127,17 @@ FROM public.ecr.aws/docker/library/alpine:3.20 AS final
 LABEL maintainer="deluan@navidrome.org"
 LABEL org.opencontainers.image.source="https://github.com/navidrome/navidrome"

-# Install runtime dependencies
-# - libwebp + symlinks: enables native WebP encoding via purego/dlopen
-RUN apk add -U --no-cache ffmpeg mpv sqlite libwebp libwebpdemux libwebpmux && \
-    for lib in libwebp libwebpdemux libwebpmux; do \
-        target=$(ls /usr/lib/$lib.so.* 2>/dev/null | head -1) && \
-        [ -n "$target" ] && ln -sf "$target" /usr/lib/$lib.so; \
-    done
+# Install ffmpeg and mpv
+RUN apk add -U --no-cache ffmpeg mpv sqlite

-# Copy navidrome binary (musl build for Docker, enables native libwebp)
-COPY --from=build-alpine /out/navidrome /app/
+# Copy navidrome binary
+COPY --from=build /out/navidrome /app/

 VOLUME ["/data", "/music"]
 ENV ND_MUSICFOLDER=/music
 ENV ND_DATAFOLDER=/data
 ENV ND_CONFIGFILE=/data/navidrome.toml
 ENV ND_PORT=4533
-ENV ND_ENABLEWEBPENCODING=true
 RUN touch /.nddockerenv

 EXPOSE ${ND_PORT}
--- a/9
+++ b/9
@ -1,10 +1,9 @@
 GO_VERSION=$(shell grep "^go " go.mod | cut -f 2 -d ' ')
 NODE_VERSION=$(shell cat .nvmrc)
-
-comma:=,
-GO_BUILD_TAGS=netgo,sqlite_fts5$(if $(EXTRA_BUILD_TAGS),$(comma)$(EXTRA_BUILD_TAGS))
+GO_BUILD_TAGS=netgo,sqlite_fts5

 # Set global environment variables, required for most targets
+export CGO_CFLAGS_ALLOW=--define-prefix
 export ND_ENABLEINSIGHTSCOLLECTOR=false

 ifneq ("$(wildcard .git/HEAD)","")
@ -20,6 +19,8 @@ IMAGE_PLATFORMS ?= $(shell echo $(SUPPORTED_PLATFORMS) | tr ',' '\n' | grep "lin
 PLATFORMS ?= $(SUPPORTED_PLATFORMS)
 DOCKER_TAG ?= deluan/navidrome:develop

+# Taglib version to use in cross-compilation, from https://github.com/navidrome/cross-taglib
+CROSS_TAGLIB_VERSION ?= 2.2.1-1
 GOLANGCI_LINT_VERSION ?= v2.11.1

 UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")
@ -176,6 +177,7 @@ docker-build: ##@Cross_Compilation Cross-compile for any supported platform (che
 		--platform $(PLATFORMS) \
 		--build-arg GIT_TAG=${GIT_TAG} \
 		--build-arg GIT_SHA=${GIT_SHA} \
+		--build-arg CROSS_TAGLIB_VERSION=${CROSS_TAGLIB_VERSION} \
 		--output "./binaries" --target binary .
 .PHONY: docker-build

@ -187,6 +189,7 @@ docker-image: ##@Cross_Compilation Build Docker image, tagged as `deluan/navidro
 		--platform $(IMAGE_PLATFORMS) \
 		--build-arg GIT_TAG=${GIT_TAG} \
 		--build-arg GIT_SHA=${GIT_SHA} \
+		--build-arg CROSS_TAGLIB_VERSION=${CROSS_TAGLIB_VERSION} \
 		--tag $(DOCKER_TAG) .
 .PHONY: docker-image

--- a/adapters/gotaglib/gotaglib_test.go
+++ b/adapters/gotaglib/gotaglib_test.go
@ -5,7 +5,6 @@ import (
 	"os"
 	"strings"

-	"github.com/navidrome/navidrome/tests"
 	"github.com/navidrome/navidrome/utils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@ -128,17 +127,6 @@ var _ = Describe("Extractor", func() {
 				Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
 				Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
 				Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014"}))
-				// Still as of TagLib v2.2.1, TagLib only maps values in ID3, MP4, and ASF tags
-				// to `originaldate`.
-				if strings.HasSuffix(file, ".mp3") || strings.HasSuffix(file, ".wav") || strings.HasSuffix(file, ".aiff") || strings.HasSuffix(file, ".m4a") || strings.HasSuffix(file, ".wma") {
-					Expect(m.Tags).To(HaveKeyWithValue("originaldate", []string{"1996-11-21"}))
-				}
-				// MP3Tag sets `ORIGYEAR` in several formats for which it has no built-in mapping
-				// for original release dates.
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("origyear", []string{"1998-07-28"}),
-					HaveKeyWithValue("----:com.apple.itunes:origyear", []string{"1998-07-28"}),
-				))

 				Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
 				Expect(m.Tags).To(Or(
@ -214,7 +202,6 @@ var _ = Describe("Extractor", func() {
 			// Only run permission tests if we are not root
 			RegularUserContext("when run without root privileges", func() {
 				BeforeEach(func() {
-					tests.SkipOnWindows("uses Unix file permission bits")
 					// Use root fs for absolute paths in temp directory
 					e = &extractor{fs: os.DirFS("/")}
 					accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")
--- a/adapters/taglib/end_to_end_test.go
+++ b/adapters/taglib/end_to_end_test.go
@ -0,0 +1,274 @@
+package taglib
+
+import (
+	"io/fs"
+	"os"
+	"time"
+
+	"github.com/djherbis/times"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/metadata"
+	"github.com/navidrome/navidrome/utils/gg"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+type testFileInfo struct {
+	fs.FileInfo
+}
+
+func (t testFileInfo) BirthTime() time.Time {
+	if ts := times.Get(t.FileInfo); ts.HasBirthTime() {
+		return ts.BirthTime()
+	}
+	return t.FileInfo.ModTime()
+}
+
+var _ = Describe("Extractor", func() {
+	toP := func(name, sortName, mbid string) model.Participant {
+		return model.Participant{
+			Artist: model.Artist{Name: name, SortArtistName: sortName, MbzArtistID: mbid},
+		}
+	}
+
+	roles := []struct {
+		model.Role
+		model.ParticipantList
+	}{
+		{model.RoleComposer, model.ParticipantList{
+			toP("coma a", "a, coma", "bf13b584-f27c-43db-8f42-32898d33d4e2"),
+			toP("comb", "comb", "924039a2-09c6-4d29-9b4f-50cc54447d36"),
+		}},
+		{model.RoleLyricist, model.ParticipantList{
+			toP("la a", "a, la", "c84f648f-68a6-40a2-a0cb-d135b25da3c2"),
+			toP("lb", "lb", "0a7c582d-143a-4540-b4e9-77200835af65"),
+		}},
+		{model.RoleArranger, model.ParticipantList{
+			toP("aa", "", "4605a1d4-8d15-42a3-bd00-9c20e42f71e6"),
+			toP("ab", "", "002f0ff8-77bf-42cc-8216-61a9c43dc145"),
+		}},
+		{model.RoleConductor, model.ParticipantList{
+			toP("cona", "", "af86879b-2141-42af-bad2-389a4dc91489"),
+			toP("conb", "", "3dfa3c70-d7d3-4b97-b953-c298dd305e12"),
+		}},
+		{model.RoleDirector, model.ParticipantList{
+			toP("dia", "", "f943187f-73de-4794-be47-88c66f0fd0f4"),
+			toP("dib", "", "bceb75da-1853-4b3d-b399-b27f0cafc389"),
+		}},
+		{model.RoleEngineer, model.ParticipantList{
+			toP("ea", "", "f634bf6d-d66a-425d-888a-28ad39392759"),
+			toP("eb", "", "243d64ae-d514-44e1-901a-b918d692baee"),
+		}},
+		{model.RoleProducer, model.ParticipantList{
+			toP("pra", "", "d971c8d7-999c-4a5f-ac31-719721ab35d6"),
+			toP("prb", "", "f0a09070-9324-434f-a599-6d25ded87b69"),
+		}},
+		{model.RoleRemixer, model.ParticipantList{
+			toP("ra", "", "c7dc6095-9534-4c72-87cc-aea0103462cf"),
+			toP("rb", "", "8ebeef51-c08c-4736-992f-c37870becedd"),
+		}},
+		{model.RoleDJMixer, model.ParticipantList{
+			toP("dja", "", "d063f13b-7589-4efc-ab7f-c60e6db17247"),
+			toP("djb", "", "3636670c-385f-4212-89c8-0ff51d6bc456"),
+		}},
+		{model.RoleMixer, model.ParticipantList{
+			toP("ma", "", "53fb5a2d-7016-427e-a563-d91819a5f35a"),
+			toP("mb", "", "64c13e65-f0da-4ab9-a300-71ee53b0376a"),
+		}},
+	}
+
+	var e *extractor
+
+	parseTestFile := func(path string) *model.MediaFile {
+		mds, err := e.Parse(path)
+		Expect(err).ToNot(HaveOccurred())
+
+		info, ok := mds[path]
+		Expect(ok).To(BeTrue())
+
+		fileInfo, err := os.Stat(path)
+		Expect(err).ToNot(HaveOccurred())
+		info.FileInfo = testFileInfo{FileInfo: fileInfo}
+
+		metadata := metadata.New(path, info)
+		mf := metadata.ToMediaFile(1, "folderID")
+		return &mf
+	}
+
+	BeforeEach(func() {
+		e = &extractor{}
+	})
+
+	Describe("ReplayGain", func() {
+		DescribeTable("test replaygain end-to-end", func(file string, trackGain, trackPeak, albumGain, albumPeak *float64) {
+			mf := parseTestFile("tests/fixtures/" + file)
+
+			Expect(mf.RGTrackGain).To(Equal(trackGain))
+			Expect(mf.RGTrackPeak).To(Equal(trackPeak))
+			Expect(mf.RGAlbumGain).To(Equal(albumGain))
+			Expect(mf.RGAlbumPeak).To(Equal(albumPeak))
+		},
+			Entry("mp3 with no replaygain", "no_replaygain.mp3", nil, nil, nil, nil),
+			Entry("mp3 with no zero replaygain", "zero_replaygain.mp3", gg.P(0.0), gg.P(1.0), gg.P(0.0), gg.P(1.0)),
+		)
+	})
+
+	Describe("lyrics", func() {
+		makeLyrics := func(code, secondLine string) model.Lyrics {
+			return model.Lyrics{
+				DisplayArtist: "",
+				DisplayTitle:  "",
+				Lang:          code,
+				Line: []model.Line{
+					{Start: gg.P(int64(0)), Value: "This is"},
+					{Start: gg.P(int64(2500)), Value: secondLine},
+				},
+				Offset: nil,
+				Synced: true,
+			}
+		}
+
+		It("should fetch both synced and unsynced lyrics in mixed flac", func() {
+			mf := parseTestFile("tests/fixtures/mixed-lyrics.flac")
+
+			lyrics, err := mf.StructuredLyrics()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(lyrics).To(HaveLen(2))
+
+			Expect(lyrics[0].Synced).To(BeTrue())
+			Expect(lyrics[1].Synced).To(BeFalse())
+		})
+
+		It("should handle mp3 with uslt and sylt", func() {
+			mf := parseTestFile("tests/fixtures/test.mp3")
+
+			lyrics, err := mf.StructuredLyrics()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(lyrics).To(HaveLen(4))
+
+			engSylt := makeLyrics("eng", "English SYLT")
+			engUslt := makeLyrics("eng", "English")
+			unsSylt := makeLyrics("xxx", "unspecified SYLT")
+			unsUslt := makeLyrics("xxx", "unspecified")
+
+			Expect(lyrics).To(ConsistOf(engSylt, engUslt, unsSylt, unsUslt))
+		})
+
+		DescribeTable("format-specific lyrics", func(file string, isId3 bool) {
+			mf := parseTestFile("tests/fixtures/" + file)
+
+			lyrics, err := mf.StructuredLyrics()
+			Expect(err).To(Not(HaveOccurred()))
+			Expect(lyrics).To(HaveLen(2))
+
+			unspec := makeLyrics("xxx", "unspecified")
+			eng := makeLyrics("xxx", "English")
+
+			if isId3 {
+				eng.Lang = "eng"
+			}
+
+			Expect(lyrics).To(Or(
+				Equal(model.LyricList{unspec, eng}),
+				Equal(model.LyricList{eng, unspec})))
+		},
+			Entry("flac", "test.flac", false),
+			Entry("m4a", "test.m4a", false),
+			Entry("ogg", "test.ogg", false),
+			Entry("wma", "test.wma", false),
+			Entry("wv", "test.wv", false),
+			Entry("wav", "test.wav", true),
+			Entry("aiff", "test.aiff", true),
+		)
+	})
+
+	Describe("Participants", func() {
+		DescribeTable("test tags consistent across formats", func(format string) {
+			mf := parseTestFile("tests/fixtures/test." + format)
+
+			for _, data := range roles {
+				role := data.Role
+				artists := data.ParticipantList
+
+				actual := mf.Participants[role]
+				Expect(actual).To(HaveLen(len(artists)))
+
+				for i := range artists {
+					actualArtist := actual[i]
+					expectedArtist := artists[i]
+
+					Expect(actualArtist.Name).To(Equal(expectedArtist.Name))
+					Expect(actualArtist.SortArtistName).To(Equal(expectedArtist.SortArtistName))
+					Expect(actualArtist.MbzArtistID).To(Equal(expectedArtist.MbzArtistID))
+				}
+			}
+
+			if format != "m4a" {
+				performers := mf.Participants[model.RolePerformer]
+				Expect(performers).To(HaveLen(8))
+
+				rules := map[string][]string{
+					"pgaa": {"2fd0b311-9fa8-4ff9-be5d-f6f3d16b835e", "Guitar"},
+					"pgbb": {"223d030b-bf97-4c2a-ad26-b7f7bbe25c93", "Guitar", ""},
+					"pvaa": {"cb195f72-448f-41c8-b962-3f3c13d09d38", "Vocals"},
+					"pvbb": {"60a1f832-8ca2-49f6-8660-84d57f07b520", "Vocals", "Flute"},
+					"pfaa": {"51fb40c-0305-4bf9-a11b-2ee615277725", "", "Flute"},
+				}
+
+				for name, rule := range rules {
+					mbid := rule[0]
+					for i := 1; i < len(rule); i++ {
+						found := false
+
+						for _, mapped := range performers {
+							if mapped.Name == name && mapped.MbzArtistID == mbid && mapped.SubRole == rule[i] {
+								found = true
+								break
+							}
+						}
+
+						Expect(found).To(BeTrue(), "Could not find matching artist")
+					}
+				}
+			}
+		},
+			Entry("FLAC format", "flac"),
+			Entry("M4a format", "m4a"),
+			Entry("OGG format", "ogg"),
+			Entry("WV format", "wv"),
+
+			Entry("MP3 format", "mp3"),
+			Entry("WAV format", "wav"),
+			Entry("AIFF format", "aiff"),
+		)
+
+		It("should parse wma", func() {
+			mf := parseTestFile("tests/fixtures/test.wma")
+
+			for _, data := range roles {
+				role := data.Role
+				artists := data.ParticipantList
+				actual := mf.Participants[role]
+
+				// WMA has no Arranger role
+				if role == model.RoleArranger {
+					Expect(actual).To(HaveLen(0))
+					continue
+				}
+
+				Expect(actual).To(HaveLen(len(artists)), role.String())
+
+				// For some bizarre reason, the order is inverted. We also don't get
+				// sort names or MBIDs
+				for i := range artists {
+					idx := len(artists) - 1 - i
+
+					actualArtist := actual[i]
+					expectedArtist := artists[idx]
+
+					Expect(actualArtist.Name).To(Equal(expectedArtist.Name))
+				}
+			}
+		})
+	})
+})
--- a/adapters/taglib/get_filename.go
+++ b/adapters/taglib/get_filename.go
@ -0,0 +1,9 @@
+//go:build !windows
+
+package taglib
+
+import "C"
+
+func getFilename(s string) *C.char {
+	return C.CString(s)
+}
--- a/adapters/taglib/get_filename_win.go
+++ b/adapters/taglib/get_filename_win.go
@ -0,0 +1,96 @@
+//go:build windows
+
+package taglib
+
+// From https://github.com/orofarne/gowchar
+
+/*
+#include <wchar.h>
+
+const size_t SIZEOF_WCHAR_T = sizeof(wchar_t);
+
+void gowchar_set (wchar_t *arr, int pos, wchar_t val)
+{
+	arr[pos] = val;
+}
+
+wchar_t gowchar_get (wchar_t *arr, int pos)
+{
+	return arr[pos];
+}
+*/
+import "C"
+
+import (
+	"fmt"
+	"unicode/utf16"
+	"unicode/utf8"
+)
+
+var SIZEOF_WCHAR_T C.size_t = C.size_t(C.SIZEOF_WCHAR_T)
+
+func getFilename(s string) *C.wchar_t {
+	wstr, _ := StringToWcharT(s)
+	return wstr
+}
+
+func StringToWcharT(s string) (*C.wchar_t, C.size_t) {
+	switch SIZEOF_WCHAR_T {
+	case 2:
+		return stringToWchar2(s) // Windows
+	case 4:
+		return stringToWchar4(s) // Unix
+	default:
+		panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", SIZEOF_WCHAR_T))
+	}
+	panic("?!!")
+}
+
+// Windows
+func stringToWchar2(s string) (*C.wchar_t, C.size_t) {
+	var slen int
+	s1 := s
+	for len(s1) > 0 {
+		r, size := utf8.DecodeRuneInString(s1)
+		if er, _ := utf16.EncodeRune(r); er == '\uFFFD' {
+			slen += 1
+		} else {
+			slen += 2
+		}
+		s1 = s1[size:]
+	}
+	slen++ // \0
+	res := C.malloc(C.size_t(slen) * SIZEOF_WCHAR_T)
+	var i int
+	for len(s) > 0 {
+		r, size := utf8.DecodeRuneInString(s)
+		if r1, r2 := utf16.EncodeRune(r); r1 != '\uFFFD' {
+			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r1))
+			i++
+			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r2))
+			i++
+		} else {
+			C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r))
+			i++
+		}
+		s = s[size:]
+	}
+	C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
+	return (*C.wchar_t)(res), C.size_t(slen)
+}
+
+// Unix
+func stringToWchar4(s string) (*C.wchar_t, C.size_t) {
+	slen := utf8.RuneCountInString(s)
+	slen++ // \0
+	res := C.malloc(C.size_t(slen) * SIZEOF_WCHAR_T)
+	var i int
+	for len(s) > 0 {
+		r, size := utf8.DecodeRuneInString(s)
+		C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r))
+		s = s[size:]
+		i++
+	}
+	C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
+	return (*C.wchar_t)(res), C.size_t(slen)
+}
--- a/adapters/taglib/taglib.go
+++ b/adapters/taglib/taglib.go
@ -0,0 +1,178 @@
+package taglib
+
+import (
+	"io/fs"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/core/storage/local"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model/metadata"
+)
+
+type extractor struct {
+	baseDir string
+}
+
+func (e extractor) Parse(files ...string) (map[string]metadata.Info, error) {
+	results := make(map[string]metadata.Info)
+	for _, path := range files {
+		props, err := e.extractMetadata(path)
+		if err != nil {
+			continue
+		}
+		results[path] = *props
+	}
+	return results, nil
+}
+
+func (e extractor) Version() string {
+	return Version()
+}
+
+func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
+	fullPath := filepath.Join(e.baseDir, filePath)
+	tags, err := Read(fullPath)
+	if err != nil {
+		log.Warn("extractor: Error reading metadata from file. Skipping", "filePath", fullPath, err)
+		return nil, err
+	}
+
+	// Parse audio properties
+	ap := metadata.AudioProperties{}
+	ap.BitRate = parseProp(tags, "__bitrate")
+	ap.Channels = parseProp(tags, "__channels")
+	ap.SampleRate = parseProp(tags, "__samplerate")
+	ap.BitDepth = parseProp(tags, "__bitspersample")
+	length := parseProp(tags, "__lengthinmilliseconds")
+	ap.Duration = (time.Millisecond * time.Duration(length)).Round(time.Millisecond * 10)
+
+	// Extract basic tags
+	parseBasicTag(tags, "__title", "title")
+	parseBasicTag(tags, "__artist", "artist")
+	parseBasicTag(tags, "__album", "album")
+	parseBasicTag(tags, "__comment", "comment")
+	parseBasicTag(tags, "__genre", "genre")
+	parseBasicTag(tags, "__year", "year")
+	parseBasicTag(tags, "__track", "tracknumber")
+
+	// Parse track/disc totals
+	parseTuple := func(prop string) {
+		tagName := prop + "number"
+		tagTotal := prop + "total"
+		if value, ok := tags[tagName]; ok && len(value) > 0 {
+			parts := strings.Split(value[0], "/")
+			tags[tagName] = []string{parts[0]}
+			if len(parts) == 2 {
+				tags[tagTotal] = []string{parts[1]}
+			}
+		}
+	}
+	parseTuple("track")
+	parseTuple("disc")
+
+	// Adjust some ID3 tags
+	parseLyrics(tags)
+	parseTIPL(tags)
+	delete(tags, "tmcl") // TMCL is already parsed by TagLib
+
+	return &metadata.Info{
+		Tags:            tags,
+		AudioProperties: ap,
+		HasPicture:      tags["has_picture"] != nil && len(tags["has_picture"]) > 0 && tags["has_picture"][0] == "true",
+	}, nil
+}
+
+// parseLyrics make sure lyrics tags have language
+func parseLyrics(tags map[string][]string) {
+	lyrics := tags["lyrics"]
+	if len(lyrics) > 0 {
+		tags["lyrics:xxx"] = lyrics
+		delete(tags, "lyrics")
+	}
+}
+
+// These are the only roles we support, based on Picard's tag map:
+// https://picard-docs.musicbrainz.org/downloads/MusicBrainz_Picard_Tag_Map.html
+var tiplMapping = map[string]string{
+	"arranger": "arranger",
+	"engineer": "engineer",
+	"producer": "producer",
+	"mix":      "mixer",
+	"DJ-mix":   "djmixer",
+}
+
+// parseProp parses a property from the tags map and sets it to the target integer.
+// It also deletes the property from the tags map after parsing.
+func parseProp(tags map[string][]string, prop string) int {
+	if value, ok := tags[prop]; ok && len(value) > 0 {
+		v, _ := strconv.Atoi(value[0])
+		delete(tags, prop)
+		return v
+	}
+	return 0
+}
+
+// parseBasicTag checks if a basic tag (like __title, __artist, etc.) exists in the tags map.
+// If it does, it moves the value to a more appropriate tag name (like title, artist, etc.),
+// and deletes the basic tag from the map. If the target tag already exists, it ignores the basic tag.
+func parseBasicTag(tags map[string][]string, basicName string, tagName string) {
+	basicValue := tags[basicName]
+	if len(basicValue) == 0 {
+		return
+	}
+	delete(tags, basicName)
+	if len(tags[tagName]) == 0 {
+		tags[tagName] = basicValue
+	}
+}
+
+// parseTIPL parses the ID3v2.4 TIPL frame string, which is received from TagLib in the format:
+//
+//	"arranger Andrew Powell engineer Chris Blair engineer Pat Stapley producer Eric Woolfson".
+//
+// and breaks it down into a map of roles and names, e.g.:
+//
+//	{"arranger": ["Andrew Powell"], "engineer": ["Chris Blair", "Pat Stapley"], "producer": ["Eric Woolfson"]}.
+func parseTIPL(tags map[string][]string) {
+	tipl := tags["tipl"]
+	if len(tipl) == 0 {
+		return
+	}
+
+	addRole := func(currentRole string, currentValue []string) {
+		if currentRole != "" && len(currentValue) > 0 {
+			role := tiplMapping[currentRole]
+			tags[role] = append(tags[role], strings.Join(currentValue, " "))
+		}
+	}
+
+	var currentRole string
+	var currentValue []string
+	for _, part := range strings.Split(tipl[0], " ") {
+		if _, ok := tiplMapping[part]; ok {
+			addRole(currentRole, currentValue)
+			currentRole = part
+			currentValue = nil
+			continue
+		}
+		currentValue = append(currentValue, part)
+	}
+	addRole(currentRole, currentValue)
+	delete(tags, "tipl")
+}
+
+var _ local.Extractor = (*extractor)(nil)
+
+func init() {
+	local.RegisterExtractor("legacy-taglib", func(_ fs.FS, baseDir string) local.Extractor {
+		// ignores fs, as taglib extractor only works with local files
+		return &extractor{baseDir}
+	})
+	conf.AddHook(func() {
+		log.Debug("TagLib version", "version", Version())
+	})
+}
--- a/adapters/taglib/taglib_suite_test.go
+++ b/adapters/taglib/taglib_suite_test.go
@ -1,4 +1,4 @@
-package matcher_test
+package taglib

 import (
 	"testing"
@ -9,9 +9,9 @@ import (
 	. "github.com/onsi/gomega"
 )

-func TestMatcher(t *testing.T) {
-	tests.Init(t, false)
+func TestTagLib(t *testing.T) {
+	tests.Init(t, true)
 	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "Matcher Suite")
+	RunSpecs(t, "TagLib Suite")
 }
--- a/adapters/taglib/taglib_test.go
+++ b/adapters/taglib/taglib_test.go
@ -0,0 +1,295 @@
+package taglib
+
+import (
+	"io/fs"
+	"os"
+	"strings"
+
+	"github.com/navidrome/navidrome/utils"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Extractor", func() {
+	var e *extractor
+
+	BeforeEach(func() {
+		e = &extractor{}
+	})
+
+	Describe("Parse", func() {
+		It("correctly parses metadata from all files in folder", func() {
+			mds, err := e.Parse(
+				"tests/fixtures/test.mp3",
+				"tests/fixtures/test.ogg",
+			)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(mds).To(HaveLen(2))
+
+			// Test MP3
+			m := mds["tests/fixtures/test.mp3"]
+			Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Song"}))
+			Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
+			Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
+			Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
+
+			Expect(m.HasPicture).To(BeTrue())
+			Expect(m.AudioProperties.Duration.String()).To(Equal("1.02s"))
+			Expect(m.AudioProperties.BitRate).To(Equal(192))
+			Expect(m.AudioProperties.Channels).To(Equal(2))
+			Expect(m.AudioProperties.SampleRate).To(Equal(44100))
+
+			Expect(m.Tags).To(Or(
+				HaveKeyWithValue("compilation", []string{"1"}),
+				HaveKeyWithValue("tcmp", []string{"1"})),
+			)
+			Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
+			Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014-05-21"}))
+			Expect(m.Tags).To(HaveKeyWithValue("originaldate", []string{"1996-11-21"}))
+			Expect(m.Tags).To(HaveKeyWithValue("releasedate", []string{"2020-12-31"}))
+			Expect(m.Tags).To(HaveKeyWithValue("discnumber", []string{"1"}))
+			Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
+			Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
+			Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
+			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_gain", []string{"+3.21518 dB"}))
+			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_peak", []string{"0.9125"}))
+			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_gain", []string{"-1.48 dB"}))
+			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_peak", []string{"0.4512"}))
+
+			Expect(m.Tags).To(HaveKeyWithValue("tracknumber", []string{"2"}))
+			Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
+
+			Expect(m.Tags).ToNot(HaveKey("lyrics"))
+			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:eng", []string{
+				"[00:00.00]This is\n[00:02.50]English SYLT\n",
+				"[00:00.00]This is\n[00:02.50]English",
+			}), HaveKeyWithValue("lyrics:eng", []string{
+				"[00:00.00]This is\n[00:02.50]English",
+				"[00:00.00]This is\n[00:02.50]English SYLT\n",
+			})))
+			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:xxx", []string{
+				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
+				"[00:00.00]This is\n[00:02.50]unspecified",
+			}), HaveKeyWithValue("lyrics:xxx", []string{
+				"[00:00.00]This is\n[00:02.50]unspecified",
+				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
+			})))
+
+			// Test OGG
+			m = mds["tests/fixtures/test.ogg"]
+			Expect(err).To(BeNil())
+			Expect(m.Tags).To(HaveKeyWithValue("fbpm", []string{"141.7"}))
+
+			// TagLib 1.12 returns 18, previous versions return 39.
+			// See https://github.com/taglib/taglib/commit/2f238921824741b2cfe6fbfbfc9701d9827ab06b
+			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.HasPicture).To(BeTrue())
+		})
+
+		DescribeTable("Format-Specific tests",
+			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())
+				Expect(mds).To(HaveLen(1))
+
+				m := mds[file]
+
+				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))
+				Expect(m.AudioProperties.BitDepth).To(Equal(bitdepth))
+
+				Expect(m.Tags).To(Or(
+					HaveKeyWithValue("replaygain_album_gain", []string{albumGain}),
+					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_gain", []string{albumGain}),
+				))
+
+				Expect(m.Tags).To(Or(
+					HaveKeyWithValue("replaygain_album_peak", []string{albumPeak}),
+					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_peak", []string{albumPeak}),
+				))
+				Expect(m.Tags).To(Or(
+					HaveKeyWithValue("replaygain_track_gain", []string{trackGain}),
+					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_gain", []string{trackGain}),
+				))
+				Expect(m.Tags).To(Or(
+					HaveKeyWithValue("replaygain_track_peak", []string{trackPeak}),
+					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_peak", []string{trackPeak}),
+				))
+
+				Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Title"}))
+				Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
+				Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
+				Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
+				Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
+				Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014"}))
+
+				Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
+				Expect(m.Tags).To(Or(
+					HaveKeyWithValue("tracknumber", []string{"3"}),
+					HaveKeyWithValue("tracknumber", []string{"3/10"}),
+				))
+				if !strings.HasSuffix(file, "test.wma") {
+					// TODO Not sure why this is not working for WMA
+					Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
+				}
+				Expect(m.Tags).To(Or(
+					HaveKeyWithValue("discnumber", []string{"1"}),
+					HaveKeyWithValue("discnumber", []string{"1/2"}),
+				))
+				Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
+
+				// WMA does not have a "compilation" tag, but "wm/iscompilation"
+				Expect(m.Tags).To(Or(
+					HaveKeyWithValue("compilation", []string{"1"}),
+					HaveKeyWithValue("wm/iscompilation", []string{"1"})),
+				)
+
+				if id3Lyrics {
+					Expect(m.Tags).To(HaveKeyWithValue("lyrics:eng", []string{
+						"[00:00.00]This is\n[00:02.50]English",
+					}))
+					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
+						"[00:00.00]This is\n[00:02.50]unspecified",
+					}))
+				} else {
+					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
+						"[00:00.00]This is\n[00:02.50]unspecified",
+						"[00:00.00]This is\n[00:02.50]English",
+					}))
+				}
+
+				Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
+			},
+
+			// 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, 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, 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, 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, true),
+
+			// 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, 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, true),
+		)
+
+		// Skip these tests when running as root
+		Context("Access Forbidden", func() {
+			var accessForbiddenFile string
+			var RegularUserContext = XContext
+			var isRegularUser = os.Getuid() != 0
+			if isRegularUser {
+				RegularUserContext = Context
+			}
+
+			// Only run permission tests if we are not root
+			RegularUserContext("when run without root privileges", func() {
+				BeforeEach(func() {
+					accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")
+
+					f, err := os.OpenFile(accessForbiddenFile, os.O_WRONLY|os.O_CREATE, 0222)
+					Expect(err).ToNot(HaveOccurred())
+
+					DeferCleanup(func() {
+						Expect(f.Close()).To(Succeed())
+						Expect(os.Remove(accessForbiddenFile)).To(Succeed())
+					})
+				})
+
+				It("correctly handle unreadable file due to insufficient read permission", func() {
+					_, err := e.extractMetadata(accessForbiddenFile)
+					Expect(err).To(MatchError(os.ErrPermission))
+				})
+
+				It("skips the file if it cannot be read", func() {
+					files := []string{
+						"tests/fixtures/test.mp3",
+						"tests/fixtures/test.ogg",
+						accessForbiddenFile,
+					}
+					mds, err := e.Parse(files...)
+					Expect(err).NotTo(HaveOccurred())
+					Expect(mds).To(HaveLen(2))
+					Expect(mds).ToNot(HaveKey(accessForbiddenFile))
+				})
+			})
+		})
+
+	})
+
+	Describe("Error Checking", func() {
+		It("returns a generic ErrPath if file does not exist", func() {
+			testFilePath := "tests/fixtures/NON_EXISTENT.ogg"
+			_, err := e.extractMetadata(testFilePath)
+			Expect(err).To(MatchError(fs.ErrNotExist))
+		})
+		It("does not throw a SIGSEGV error when reading a file with an invalid frame", func() {
+			// File has an empty TDAT frame
+			md, err := e.extractMetadata("tests/fixtures/invalid-files/test-invalid-frame.mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(md.Tags).To(HaveKeyWithValue("albumartist", []string{"Elvis Presley"}))
+		})
+	})
+
+	Describe("parseTIPL", func() {
+		var tags map[string][]string
+
+		BeforeEach(func() {
+			tags = make(map[string][]string)
+		})
+
+		Context("when the TIPL string is populated", func() {
+			It("correctly parses roles and names", func() {
+				tags["tipl"] = []string{"arranger Andrew Powell DJ-mix François Kevorkian DJ-mix Jane Doe engineer Chris Blair"}
+				parseTIPL(tags)
+				Expect(tags["arranger"]).To(ConsistOf("Andrew Powell"))
+				Expect(tags["engineer"]).To(ConsistOf("Chris Blair"))
+				Expect(tags["djmixer"]).To(ConsistOf("François Kevorkian", "Jane Doe"))
+			})
+
+			It("handles multiple names for a single role", func() {
+				tags["tipl"] = []string{"engineer Pat Stapley producer Eric Woolfson engineer Chris Blair"}
+				parseTIPL(tags)
+				Expect(tags["producer"]).To(ConsistOf("Eric Woolfson"))
+				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
+			})
+
+			It("discards roles without names", func() {
+				tags["tipl"] = []string{"engineer Pat Stapley producer engineer Chris Blair"}
+				parseTIPL(tags)
+				Expect(tags).ToNot(HaveKey("producer"))
+				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
+			})
+		})
+
+		Context("when the TIPL string is empty", func() {
+			It("does nothing", func() {
+				tags["tipl"] = []string{""}
+				parseTIPL(tags)
+				Expect(tags).To(BeEmpty())
+			})
+		})
+
+		Context("when the TIPL is not present", func() {
+			It("does nothing", func() {
+				parseTIPL(tags)
+				Expect(tags).To(BeEmpty())
+			})
+		})
+	})
+
+})
--- a/adapters/taglib/taglib_wrapper.cpp
+++ b/adapters/taglib/taglib_wrapper.cpp
@ -0,0 +1,299 @@
+#include <stdlib.h>
+#include <string.h>
+
+#define TAGLIB_STATIC
+#include <apeproperties.h>
+#include <apetag.h>
+#include <aifffile.h>
+#include <asffile.h>
+#include <dsffile.h>
+#include <fileref.h>
+#include <flacfile.h>
+#include <id3v2tag.h>
+#include <unsynchronizedlyricsframe.h>
+#include <synchronizedlyricsframe.h>
+#include <mp4file.h>
+#include <mpegfile.h>
+#include <opusfile.h>
+#include <tpropertymap.h>
+#include <vorbisfile.h>
+#include <wavfile.h>
+#include <wavfile.h>
+#include <wavpackfile.h>
+
+#include "taglib_wrapper.h"
+
+char has_cover(const TagLib::FileRef f);
+
+static char TAGLIB_VERSION[16];
+
+char* taglib_version() {
+    snprintf((char *)TAGLIB_VERSION, 16, "%d.%d.%d", TAGLIB_MAJOR_VERSION, TAGLIB_MINOR_VERSION, TAGLIB_PATCH_VERSION);
+    return (char *)TAGLIB_VERSION;
+}
+
+int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id) {
+  TagLib::FileRef f(filename, true, TagLib::AudioProperties::Fast);
+
+  if (f.isNull()) {
+    return TAGLIB_ERR_PARSE;
+  }
+
+  if (!f.audioProperties()) {
+    return TAGLIB_ERR_AUDIO_PROPS;
+  }
+
+  // Add audio properties to the tags
+  const TagLib::AudioProperties *props(f.audioProperties());
+  goPutInt(id, (char *)"__lengthinmilliseconds", props->lengthInMilliseconds());
+  goPutInt(id, (char *)"__bitrate", props->bitrate());
+  goPutInt(id, (char *)"__channels", props->channels());
+  goPutInt(id, (char *)"__samplerate", props->sampleRate());
+
+  // Extract bits per sample for supported formats
+  int bitsPerSample = 0;
+  if (const auto* apeProperties{ dynamic_cast<const TagLib::APE::Properties*>(props) })
+      bitsPerSample = apeProperties->bitsPerSample();
+  else if (const auto* asfProperties{ dynamic_cast<const TagLib::ASF::Properties*>(props) })
+      bitsPerSample = asfProperties->bitsPerSample();
+  else if (const auto* flacProperties{ dynamic_cast<const TagLib::FLAC::Properties*>(props) })
+      bitsPerSample = flacProperties->bitsPerSample();
+  else if (const auto* mp4Properties{ dynamic_cast<const TagLib::MP4::Properties*>(props) })
+      bitsPerSample = mp4Properties->bitsPerSample();
+  else if (const auto* wavePackProperties{ dynamic_cast<const TagLib::WavPack::Properties*>(props) })
+      bitsPerSample = wavePackProperties->bitsPerSample();
+  else if (const auto* aiffProperties{ dynamic_cast<const TagLib::RIFF::AIFF::Properties*>(props) })
+      bitsPerSample = aiffProperties->bitsPerSample();
+  else if (const auto* wavProperties{ dynamic_cast<const TagLib::RIFF::WAV::Properties*>(props) })
+      bitsPerSample = wavProperties->bitsPerSample();
+  else if (const auto* dsfProperties{ dynamic_cast<const TagLib::DSF::Properties*>(props) })
+      bitsPerSample = dsfProperties->bitsPerSample();
+  
+  if (bitsPerSample > 0) {
+      goPutInt(id, (char *)"__bitspersample", bitsPerSample);
+  }
+
+  // Send all properties to the Go map
+  TagLib::PropertyMap tags = f.file()->properties();
+
+  // Make sure at least the basic properties are extracted
+  TagLib::Tag *basic = f.file()->tag();
+  if (!basic->isEmpty()) {
+    if (!basic->title().isEmpty()) {
+      tags.insert("__title", basic->title());
+    }
+    if (!basic->artist().isEmpty()) {
+      tags.insert("__artist", basic->artist());
+    }
+    if (!basic->album().isEmpty()) {
+      tags.insert("__album", basic->album());
+    }
+    if (!basic->comment().isEmpty()) {
+      tags.insert("__comment", basic->comment());
+    }
+    if (!basic->genre().isEmpty()) {
+      tags.insert("__genre", basic->genre());
+    }
+    if (basic->year() > 0) {
+      tags.insert("__year", TagLib::String::number(basic->year()));
+    }
+    if (basic->track() > 0) {
+      tags.insert("__track", TagLib::String::number(basic->track()));
+    }
+  }
+
+  TagLib::ID3v2::Tag *id3Tags = NULL;
+
+  // Get some extended/non-standard ID3-only tags (ex: iTunes extended frames)
+  TagLib::MPEG::File *mp3File(dynamic_cast<TagLib::MPEG::File *>(f.file()));
+  if (mp3File != NULL) {
+    id3Tags = mp3File->ID3v2Tag();
+  }
+
+  if (id3Tags == NULL) {
+    TagLib::RIFF::WAV::File *wavFile(dynamic_cast<TagLib::RIFF::WAV::File *>(f.file()));
+    if (wavFile != NULL && wavFile->hasID3v2Tag()) {
+      id3Tags = wavFile->ID3v2Tag();
+    }
+  }
+
+  if (id3Tags == NULL) {
+    TagLib::RIFF::AIFF::File *aiffFile(dynamic_cast<TagLib::RIFF::AIFF::File *>(f.file()));
+    if (aiffFile && aiffFile->hasID3v2Tag()) {
+      id3Tags = aiffFile->tag();
+    }
+  }
+
+  // Yes, it is possible to have ID3v2 tags in FLAC. However, that can cause problems
+  // with many players, so they will not be parsed
+
+  if (id3Tags != NULL) {
+    const auto &frames = id3Tags->frameListMap();
+
+    for (const auto &kv: frames) {
+      if (kv.first == "USLT") {
+        for (const auto &tag: kv.second) {
+          TagLib::ID3v2::UnsynchronizedLyricsFrame *frame = dynamic_cast<TagLib::ID3v2::UnsynchronizedLyricsFrame *>(tag);
+          if (frame == NULL) continue;
+
+          tags.erase("LYRICS");
+
+          const auto bv = frame->language();
+          char language[4] = {'x', 'x', 'x', '\0'};
+          if (bv.size() == 3) {
+            strncpy(language, bv.data(), 3);
+          }
+
+          char *val = const_cast<char*>(frame->text().toCString(true));
+
+          goPutLyrics(id, language, val);
+        }
+      } else if (kv.first == "SYLT") {
+        for (const auto &tag: kv.second) {
+          TagLib::ID3v2::SynchronizedLyricsFrame *frame = dynamic_cast<TagLib::ID3v2::SynchronizedLyricsFrame *>(tag);
+          if (frame == NULL) continue;
+
+          const auto bv = frame->language();
+          char language[4] = {'x', 'x', 'x', '\0'};
+          if (bv.size() == 3) {
+            strncpy(language, bv.data(), 3);
+          }
+
+          const auto format = frame->timestampFormat();
+          if (format == TagLib::ID3v2::SynchronizedLyricsFrame::AbsoluteMilliseconds) {
+
+            for (const auto &line: frame->synchedText()) {
+              char *text = const_cast<char*>(line.text.toCString(true));
+              goPutLyricLine(id, language, text, line.time);
+            }
+          } else if (format == TagLib::ID3v2::SynchronizedLyricsFrame::AbsoluteMpegFrames) {
+            const int sampleRate = props->sampleRate();
+
+            if (sampleRate != 0) {
+              for (const auto &line: frame->synchedText()) {
+                const int timeInMs = (line.time * 1000) / sampleRate;
+                char *text = const_cast<char*>(line.text.toCString(true));
+                goPutLyricLine(id, language, text, timeInMs);
+              }
+            }
+          }
+        }
+      } else if (kv.first == "TIPL"){
+        if (!kv.second.isEmpty()) {
+          tags.insert(kv.first, kv.second.front()->toString());
+        }
+      }
+    }
+  }
+
+  // M4A may have some iTunes specific tags not captured by the PropertyMap interface
+  TagLib::MP4::File *m4afile(dynamic_cast<TagLib::MP4::File *>(f.file()));
+  if (m4afile != NULL) {
+    const auto itemListMap = m4afile->tag()->itemMap();
+    for (const auto item: itemListMap) {
+      char *key = const_cast<char*>(item.first.toCString(true));
+      for (const auto value: item.second.toStringList()) {
+        char *val = const_cast<char*>(value.toCString(true));
+        goPutM4AStr(id, key, val);
+      }
+    }
+  }
+
+  // WMA/ASF files may have additional tags not captured by the PropertyMap interface
+  TagLib::ASF::File *asfFile(dynamic_cast<TagLib::ASF::File *>(f.file()));
+  if (asfFile != NULL) {
+    const TagLib::ASF::Tag *asfTags{asfFile->tag()};
+    const auto itemListMap = asfTags->attributeListMap();
+    for (const auto item : itemListMap) {
+      char *key = const_cast<char*>(item.first.toCString(true));
+
+      for (auto j = item.second.begin();
+           j != item.second.end(); ++j) {
+
+        char *val = const_cast<char*>(j->toString().toCString(true));
+        goPutStr(id, key, val);
+      }
+    }
+  }
+
+  // Send all collected tags to the Go map
+  for (TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end();
+       ++i) {
+    char *key = const_cast<char*>(i->first.toCString(true));
+    for (TagLib::StringList::ConstIterator j = i->second.begin();
+         j != i->second.end(); ++j) {
+      char *val = const_cast<char*>((*j).toCString(true));
+      goPutStr(id, key, val);
+    }
+  }
+
+  // Cover art has to be handled separately
+  if (has_cover(f)) {
+    goPutStr(id, (char *)"has_picture", (char *)"true");
+  }
+
+  return 0;
+}
+
+// Detect if the file has cover art. Returns 1 if the file has cover art, 0 otherwise.
+char has_cover(const TagLib::FileRef f) {
+  char hasCover = 0;
+  // ----- MP3
+  if (TagLib::MPEG::File * mp3File{dynamic_cast<TagLib::MPEG::File *>(f.file())}) {
+    if (mp3File->ID3v2Tag()) {
+      const auto &frameListMap{mp3File->ID3v2Tag()->frameListMap()};
+      hasCover = !frameListMap["APIC"].isEmpty();
+    }
+  }
+  // ----- FLAC
+  else if (TagLib::FLAC::File * flacFile{dynamic_cast<TagLib::FLAC::File *>(f.file())}) {
+    hasCover = !flacFile->pictureList().isEmpty();
+  }
+  // ----- MP4
+  else if (TagLib::MP4::File * mp4File{dynamic_cast<TagLib::MP4::File *>(f.file())}) {
+    auto &coverItem{mp4File->tag()->itemMap()["covr"]};
+    TagLib::MP4::CoverArtList coverArtList{coverItem.toCoverArtList()};
+    hasCover = !coverArtList.isEmpty();
+  }
+  // ----- Ogg
+  else if (TagLib::Ogg::Vorbis::File * vorbisFile{dynamic_cast<TagLib::Ogg::Vorbis::File *>(f.file())}) {
+    hasCover = !vorbisFile->tag()->pictureList().isEmpty();
+  }
+  // ----- Opus
+  else if (TagLib::Ogg::Opus::File * opusFile{dynamic_cast<TagLib::Ogg::Opus::File *>(f.file())}) {
+    hasCover = !opusFile->tag()->pictureList().isEmpty();
+  }
+  // ----- 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();
+    }
+  }
+  // ----- 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 && tag->attributeListMap().contains("WM/Picture");
+  }
+  // ----- DSF
+  else if (TagLib::DSF::File * dsffile{ dynamic_cast<TagLib::DSF::File *>(f.file())}) {
+    const TagLib::ID3v2::Tag *tag { dsffile->tag() };
+    hasCover = tag && !tag->frameListMap()["APIC"].isEmpty();
+  }
+  // ----- WAVPAK (APE tag)
+  else if (TagLib::WavPack::File * wvFile{dynamic_cast<TagLib::WavPack::File *>(f.file())}) {
+    if (wvFile->hasAPETag()) {
+      // This is the particular string that Picard uses
+      hasCover = !wvFile->APETag()->itemListMap()["COVER ART (FRONT)"].isEmpty();
+    }
+  }
+
+  return hasCover;
+}
--- a/adapters/taglib/taglib_wrapper.go
+++ b/adapters/taglib/taglib_wrapper.go
@ -0,0 +1,157 @@
+package taglib
+
+/*
+#cgo !windows pkg-config: --define-prefix taglib
+#cgo windows pkg-config: taglib
+#cgo illumos LDFLAGS: -lstdc++ -lsendfile
+#cgo linux darwin CXXFLAGS: -std=c++11
+#cgo darwin LDFLAGS: -L/opt/homebrew/opt/taglib/lib
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "taglib_wrapper.h"
+*/
+import "C"
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"runtime/debug"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"unsafe"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+const iTunesKeyPrefix = "----:com.apple.itunes:"
+
+func Version() string {
+	return C.GoString(C.taglib_version())
+}
+
+func Read(filename string) (tags map[string][]string, err error) {
+	// Do not crash on failures in the C code/library
+	debug.SetPanicOnFault(true)
+	defer func() {
+		if r := recover(); r != nil {
+			log.Error("extractor: recovered from panic when reading tags", "file", filename, "error", r)
+			err = fmt.Errorf("extractor: recovered from panic: %s", r)
+		}
+	}()
+
+	fp := getFilename(filename)
+	defer C.free(unsafe.Pointer(fp))
+	id, m, release := newMap()
+	defer release()
+
+	log.Trace("extractor: reading tags", "filename", filename, "map_id", id)
+	res := C.taglib_read(fp, C.ulong(id))
+	switch res {
+	case C.TAGLIB_ERR_PARSE:
+		// Check additional case whether the file is unreadable due to permission
+		file, fileErr := os.OpenFile(filename, os.O_RDONLY, 0600)
+		defer file.Close()
+
+		if os.IsPermission(fileErr) {
+			return nil, fmt.Errorf("navidrome does not have permission: %w", fileErr)
+		} else if fileErr != nil {
+			return nil, fmt.Errorf("cannot parse file media file: %w", fileErr)
+		} else {
+			return nil, fmt.Errorf("cannot parse file media file")
+		}
+	case C.TAGLIB_ERR_AUDIO_PROPS:
+		return nil, fmt.Errorf("can't get audio properties from file")
+	}
+	if log.IsGreaterOrEqualTo(log.LevelDebug) {
+		j, _ := json.Marshal(m)
+		log.Trace("extractor: read tags", "tags", string(j), "filename", filename, "id", id)
+	} else {
+		log.Trace("extractor: read tags", "tags", m, "filename", filename, "id", id)
+	}
+
+	return m, nil
+}
+
+type tagMap map[string][]string
+
+var allMaps sync.Map
+var mapsNextID atomic.Uint32
+
+func newMap() (uint32, tagMap, func()) {
+	id := mapsNextID.Add(1)
+
+	m := tagMap{}
+	allMaps.Store(id, m)
+
+	return id, m, func() {
+		allMaps.Delete(id)
+	}
+}
+
+func doPutTag(id C.ulong, key string, val *C.char) {
+	if key == "" {
+		return
+	}
+
+	r, _ := allMaps.Load(uint32(id))
+	m := r.(tagMap)
+	k := strings.ToLower(key)
+	v := strings.TrimSpace(C.GoString(val))
+	m[k] = append(m[k], v)
+}
+
+//export goPutM4AStr
+func goPutM4AStr(id C.ulong, key *C.char, val *C.char) {
+	k := C.GoString(key)
+
+	// Special for M4A, do not catch keys that have no actual name
+	k = strings.TrimPrefix(k, iTunesKeyPrefix)
+	doPutTag(id, k, val)
+}
+
+//export goPutStr
+func goPutStr(id C.ulong, key *C.char, val *C.char) {
+	doPutTag(id, C.GoString(key), val)
+}
+
+//export goPutInt
+func goPutInt(id C.ulong, key *C.char, val C.int) {
+	valStr := strconv.Itoa(int(val))
+	vp := C.CString(valStr)
+	defer C.free(unsafe.Pointer(vp))
+	goPutStr(id, key, vp)
+}
+
+//export goPutLyrics
+func goPutLyrics(id C.ulong, lang *C.char, val *C.char) {
+	doPutTag(id, "lyrics:"+C.GoString(lang), val)
+}
+
+//export goPutLyricLine
+func goPutLyricLine(id C.ulong, lang *C.char, text *C.char, time C.int) {
+	language := C.GoString(lang)
+	line := C.GoString(text)
+	timeGo := int64(time)
+
+	ms := timeGo % 1000
+	timeGo /= 1000
+	sec := timeGo % 60
+	timeGo /= 60
+	minimum := timeGo % 60
+	formattedLine := fmt.Sprintf("[%02d:%02d.%02d]%s\n", minimum, sec, ms/10, line)
+
+	key := "lyrics:" + language
+
+	r, _ := allMaps.Load(uint32(id))
+	m := r.(tagMap)
+	k := strings.ToLower(key)
+	existing, ok := m[k]
+	if ok {
+		existing[0] += formattedLine
+	} else {
+		m[k] = []string{formattedLine}
+	}
+}
--- a/adapters/taglib/taglib_wrapper.h
+++ b/adapters/taglib/taglib_wrapper.h
@ -0,0 +1,24 @@
+#define TAGLIB_ERR_PARSE -1
+#define TAGLIB_ERR_AUDIO_PROPS -2
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WIN32
+#define FILENAME_CHAR_T wchar_t
+#else
+#define FILENAME_CHAR_T char
+#endif
+
+extern void goPutM4AStr(unsigned long id, char *key, char *val);
+extern void goPutStr(unsigned long id, char *key, char *val);
+extern void goPutInt(unsigned long id, char *key, int val);
+extern void goPutLyrics(unsigned long id, char *lang, char *val);
+extern void goPutLyricLine(unsigned long id, char *lang, char *text, int time);
+int taglib_read(const FILENAME_CHAR_T *filename, unsigned long id);
+char* taglib_version();
+
+#ifdef __cplusplus
+}
+#endif
--- a/cmd/root.go
+++ b/cmd/root.go
@ -27,6 +27,7 @@ import (
 	_ "github.com/navidrome/navidrome/adapters/gotaglib"
 	_ "github.com/navidrome/navidrome/adapters/lastfm"
 	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
+	_ "github.com/navidrome/navidrome/adapters/taglib"
 )

 var (
--- a/cmd/wire_gen.go
+++ b/cmd/wire_gen.go
@ -17,7 +17,6 @@ import (
 	"github.com/navidrome/navidrome/core/external"
 	"github.com/navidrome/navidrome/core/ffmpeg"
 	"github.com/navidrome/navidrome/core/lyrics"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/playlists"
@ -40,6 +39,7 @@ import (
 	_ "github.com/navidrome/navidrome/adapters/gotaglib"
 	_ "github.com/navidrome/navidrome/adapters/lastfm"
 	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
+	_ "github.com/navidrome/navidrome/adapters/taglib"
 )

 // Injectors from wire_injectors.go:
@ -72,8 +72,7 @@ func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
 	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
-	matcherMatcher := matcher.New(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
+	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)
@ -94,8 +93,7 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
 	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
-	matcherMatcher := matcher.New(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
+	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	transcodingCache := stream.GetTranscodingCache()
 	mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
@ -123,8 +121,7 @@ func CreatePublicRouter() *public.Router {
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
 	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
-	matcherMatcher := matcher.New(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
+	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	transcodingCache := stream.GetTranscodingCache()
 	mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
@ -171,8 +168,7 @@ func CreateScanner(ctx context.Context) model.Scanner {
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
 	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
-	matcherMatcher := matcher.New(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
+	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	imageUploadService := core.NewImageUploadService()
@ -190,8 +186,7 @@ func CreateScanWatcher(ctx context.Context) scanner.Watcher {
 	metricsMetrics := metrics.GetPrometheusInstance(dataStore)
 	manager := plugins.GetManager(dataStore, broker, metricsMetrics)
 	agentsAgents := agents.GetAgents(dataStore, manager)
-	matcherMatcher := matcher.New(dataStore)
-	provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
+	provider := external.NewProvider(dataStore, agentsAgents)
 	artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
 	cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
 	imageUploadService := core.NewImageUploadService()
--- a/conf/configuration.go
+++ b/conf/configuration.go
@ -12,7 +12,6 @@ import (
 	"time"

 	"github.com/bmatcuk/doublestar/v4"
-	"github.com/dustin/go-humanize"
 	"github.com/go-viper/encoding/ini"
 	"github.com/kr/pretty"
 	"github.com/navidrome/navidrome/consts"
@ -27,7 +26,6 @@ type configOptions struct {
 	Address                         string
 	Port                            int
 	UnixSocketPerm                  string
-	EnforceNonRootUser              bool
 	MusicFolder                     string
 	DataFolder                      string
 	CacheFolder                     string
@ -61,8 +59,8 @@ type configOptions struct {
 	SmartPlaylistRefreshDelay       time.Duration
 	AutoTranscodeDownload           bool
 	DefaultDownsamplingFormat       string
-	Search                          searchOptions  `json:",omitzero"`
-	Matcher                         matcherOptions `json:",omitzero"`
+	Search                          searchOptions `json:",omitzero"`
+	SimilarSongsMatchThreshold      int
 	RecentlyAddedByModTime          bool
 	PreferSortTags                  bool
 	IgnoredArticles                 string
@ -72,7 +70,6 @@ type configOptions struct {
 	MPVCmdTemplate                  string
 	CoverArtPriority                string
 	CoverArtQuality                 int
-	EnableWebPEncoding              bool
 	ArtistArtPriority               string
 	ArtistImageFolder               string
 	DiscArtPriority                 string
@ -82,7 +79,6 @@ type configOptions struct {
 	EnableStarRating                bool
 	EnableUserEditing               bool
 	EnableArtworkUpload             bool
-	MaxImageUploadSize              string
 	EnableSharing                   bool
 	ShareURL                        string
 	DefaultShareExpiration          time.Duration
@ -91,7 +87,6 @@ type configOptions struct {
 	DefaultLanguage                 string
 	DefaultUIVolume                 int
 	UISearchDebounceMs              int
-	UICoverArtSize                  int
 	EnableReplayGain                bool
 	EnableCoverAnimation            bool
 	EnableNowPlaying                bool
@ -146,6 +141,7 @@ type configOptions struct {
 	DevOptimizeDB                     bool
 	DevPreserveUnicodeInExternalCalls bool
 	DevEnableMediaFileProbe           bool
+	DevJpegCoverArt                   bool
 }

 type scannerOptions struct {
@ -262,11 +258,6 @@ type searchOptions struct {
 	FullString bool
 }

-type matcherOptions struct {
-	PreferStarred  bool
-	FuzzyThreshold int
-}
-
 // logFatal prints a fatal error message to stderr and exits.
 // Overridden in tests to allow testing fatal paths.
 var logFatal = func(args ...any) {
@ -274,12 +265,6 @@ var logFatal = func(args ...any) {
 	os.Exit(1)
 }

-var getEUID = os.Geteuid
-
-var currentGOOS = func() string {
-	return runtime.GOOS
-}
-
 var (
 	Server = &configOptions{}
 	hooks  []func()
@ -303,18 +288,12 @@ func Load(noConfigDump bool) {
 	mapDeprecatedOption("ReverseProxyUserHeader", "ExtAuth.UserHeader")
 	mapDeprecatedOption("HTTPSecurityHeaders.CustomFrameOptionsValue", "HTTPHeaders.FrameOptions")
 	mapDeprecatedOption("CoverJpegQuality", "CoverArtQuality")
-	mapDeprecatedOption("SimilarSongsMatchThreshold", "Matcher.FuzzyThreshold")

 	err := viper.Unmarshal(&Server)
 	if err != nil {
 		logFatal("Error parsing config:", err)
 	}

-	// Validate non-root user early, before any filesystem operations
-	if err := validateEnforceNonRootUser(); err != nil {
-		logFatal(err)
-	}
-
 	err = os.MkdirAll(Server.DataFolder, os.ModePerm)
 	if err != nil {
 		logFatal("Error creating data path:", err)
@ -380,11 +359,10 @@ func Load(noConfigDump bool) {
 		validateBackupSchedule,
 		validatePlaylistsPath,
 		validatePurgeMissingOption,
-		validateMaxImageUploadSize,
 		validateURL("ExtAuth.LogoutURL", Server.ExtAuth.LogoutURL),
 	)
 	if err != nil {
-		logFatal(err)
+		os.Exit(1)
 	}

 	Server.Search.Backend = normalizeSearchBackend(Server.Search.Backend)
@ -442,18 +420,10 @@ func Load(noConfigDump bool) {
 	logDeprecatedOptions("ReverseProxyUserHeader", "ExtAuth.UserHeader")
 	logDeprecatedOptions("HTTPSecurityHeaders.CustomFrameOptionsValue", "HTTPHeaders.FrameOptions")
 	logDeprecatedOptions("CoverJpegQuality", "CoverArtQuality")
-	logDeprecatedOptions("SimilarSongsMatchThreshold", "Matcher.FuzzyThreshold")

 	// Removed options
 	logRemovedOptions("Spotify.ID", "Spotify.Secret")

-	// Validate other options
-	if Server.UICoverArtSize < 200 || Server.UICoverArtSize > 1200 {
-		newValue := max(200, min(1200, Server.UICoverArtSize))
-		log.Warn("UICoverArtSize must be between 200 and 1200, clamping", "value", Server.UICoverArtSize, "newValue", newValue)
-		Server.UICoverArtSize = newValue
-	}
-
 	// Call init hooks
 	for _, hook := range hooks {
 		hook()
@ -571,7 +541,8 @@ func validatePlaylistsPath() error {
 	for path := range strings.SplitSeq(Server.PlaylistsPath, string(filepath.ListSeparator)) {
 		_, err := doublestar.Match(path, "")
 		if err != nil {
-			return fmt.Errorf("invalid PlaylistsPath %q: %w", path, err)
+			log.Error("Invalid PlaylistsPath", "path", path, err)
+			return err
 		}
 	}
 	return nil
@ -598,31 +569,13 @@ func validatePurgeMissingOption() error {
 	valid := slices.Contains(allowedValues, Server.Scanner.PurgeMissing)
 	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 validateMaxImageUploadSize() error {
-	if _, err := humanize.ParseBytes(Server.MaxImageUploadSize); err != nil {
-		return fmt.Errorf("invalid MaxImageUploadSize %q: use values like '10MB', '1GB', or raw bytes like '10485760': %w", Server.MaxImageUploadSize, err)
-	}
-	return nil
-}
-
-func validateEnforceNonRootUser() error {
-	if !Server.EnforceNonRootUser || currentGOOS() == "windows" {
-		return nil
-	}
-
-	if getEUID() == 0 {
-		return fmt.Errorf("EnforceNonRootUser is enabled but Navidrome is running as root")
-	}
-
-	return nil
-}
-
 func validateScanSchedule() error {
 	if Server.Scanner.Schedule == "0" || Server.Scanner.Schedule == "" {
 		Server.Scanner.Schedule = ""
@ -646,9 +599,9 @@ func validateBackupSchedule() error {
 func validateSchedule(schedule, field string) (string, error) {
 	_, err := scheduler.ParseCrontab(schedule)
 	if err != nil {
-		return schedule, fmt.Errorf("invalid %s %q (see https://pkg.go.dev/github.com/robfig/cron#hdr-CRON_Expression_Format): %w", field, schedule, err)
+		log.Error(fmt.Sprintf("Invalid %s. Please read format spec at https://pkg.go.dev/github.com/robfig/cron#hdr-CRON_Expression_Format", field), "schedule", schedule, err)
 	}
-	return schedule, nil
+	return schedule, err
 }

 // validateURL checks if the provided URL is valid and has either http or https scheme.
@ -660,13 +613,19 @@ func validateURL(optionName, optionURL string) func() error {
 		}
 		u, err := url.Parse(optionURL)
 		if err != nil {
-			return fmt.Errorf("invalid %s %q: %w", optionName, optionURL, err)
+			log.Error(fmt.Sprintf("Invalid %s: it could not be parsed", optionName), "url", optionURL, "err", err)
+			return err
 		}
 		if u.Scheme != "http" && u.Scheme != "https" {
-			return fmt.Errorf("invalid scheme for %s: '%s'. Only 'http' and 'https' are allowed", optionName, u.Scheme)
+			err := fmt.Errorf("invalid scheme for %s: '%s'. Only 'http' and 'https' are allowed", optionName, u.Scheme)
+			log.Error(err.Error())
+			return err
 		}
+		// Require an absolute URL with a non-empty host and no opaque component.
 		if u.Host == "" || u.Opaque != "" {
-			return fmt.Errorf("invalid %s: '%s'. A full http(s) URL with a non-empty host is required", optionName, optionURL)
+			err := fmt.Errorf("invalid %s: '%s'. A full http(s) URL with a non-empty host is required", optionName, optionURL)
+			log.Error(err.Error())
+			return err
 		}
 		return nil
 	}
@ -722,7 +681,6 @@ func setViperDefaults() {
 	viper.SetDefault("address", "0.0.0.0")
 	viper.SetDefault("port", 4533)
 	viper.SetDefault("unixsocketperm", "0660")
-	viper.SetDefault("enforcenonrootuser", false)
 	viper.SetDefault("sessiontimeout", consts.DefaultSessionTimeout)
 	viper.SetDefault("baseurl", "")
 	viper.SetDefault("tlscert", "")
@ -748,8 +706,7 @@ func setViperDefaults() {
 	viper.SetDefault("defaultdownsamplingformat", consts.DefaultDownsamplingFormat)
 	viper.SetDefault("search.fullstring", false)
 	viper.SetDefault("search.backend", "fts")
-	viper.SetDefault("matcher.preferstarred", true)
-	viper.SetDefault("matcher.fuzzythreshold", 85)
+	viper.SetDefault("similarsongsmatchthreshold", 85)
 	viper.SetDefault("recentlyaddedbymodtime", false)
 	viper.SetDefault("prefersorttags", false)
 	viper.SetDefault("ignoredarticles", "The El La Los Las Le Les Os As O A")
@ -759,7 +716,6 @@ func setViperDefaults() {
 	viper.SetDefault("mpvcmdtemplate", "mpv --audio-device=%d --no-audio-display %f --input-ipc-server=%s")
 	viper.SetDefault("coverartpriority", "cover.*, folder.*, front.*, embedded, external")
 	viper.SetDefault("coverartquality", 75)
-	viper.SetDefault("enablewebpencoding", false)
 	viper.SetDefault("artistartpriority", "artist.*, album/artist.*, external")
 	viper.SetDefault("artistimagefolder", "")
 	viper.SetDefault("discartpriority", "disc*.*, cd*.*, cover.*, folder.*, front.*, discsubtitle, embedded")
@ -772,12 +728,10 @@ func setViperDefaults() {
 	viper.SetDefault("defaultlanguage", "")
 	viper.SetDefault("defaultuivolume", consts.DefaultUIVolume)
 	viper.SetDefault("uisearchdebouncems", consts.DefaultUISearchDebounceMs)
-	viper.SetDefault("uicoverartsize", consts.DefaultUICoverArtSize)
 	viper.SetDefault("enablereplaygain", true)
 	viper.SetDefault("enablecoveranimation", true)
 	viper.SetDefault("enablenowplaying", true)
 	viper.SetDefault("enableartworkupload", true)
-	viper.SetDefault("maximageuploadsize", consts.DefaultMaxImageUploadSize)
 	viper.SetDefault("enablesharing", false)
 	viper.SetDefault("shareurl", "")
 	viper.SetDefault("defaultshareexpiration", 8760*time.Hour)
@ -856,7 +810,7 @@ func setViperDefaults() {
 	viper.SetDefault("devuishowconfig", true)
 	viper.SetDefault("devneweventstream", true)
 	viper.SetDefault("devoffsetoptimize", 50000)
-	viper.SetDefault("devartworkmaxrequests", max(2, runtime.NumCPU()/2))
+	viper.SetDefault("devartworkmaxrequests", max(4, runtime.NumCPU()))
 	viper.SetDefault("devartworkthrottlebackloglimit", consts.RequestThrottleBacklogLimit)
 	viper.SetDefault("devartworkthrottlebacklogtimeout", consts.RequestThrottleBacklogTimeout)
 	viper.SetDefault("devartistinfotimetolive", consts.ArtistInfoTimeToLive)
@ -872,6 +826,7 @@ func setViperDefaults() {
 	viper.SetDefault("devoptimizedb", true)
 	viper.SetDefault("devpreserveunicodeinexternalcalls", false)
 	viper.SetDefault("devenablemediafileprobe", true)
+	viper.SetDefault("devjpegcoverart", false)
 }

 func init() {
--- a/conf/configuration_test.go
+++ b/conf/configuration_test.go
@ -219,80 +219,6 @@ var _ = Describe("Configuration", func() {

 	})

-	Describe("ValidateMaxImageUploadSize", func() {
-		BeforeEach(func() {
-			viper.Reset()
-			conf.SetViperDefaults()
-			viper.SetDefault("datafolder", GinkgoT().TempDir())
-			viper.SetDefault("loglevel", "error")
-			conf.ResetConf()
-		})
-
-		DescribeTable("accepts valid size values",
-			func(input string) {
-				conf.Server.MaxImageUploadSize = input
-				Expect(conf.ValidateMaxImageUploadSize()).To(Succeed())
-			},
-			Entry("megabytes", "10MB"),
-			Entry("gigabytes", "1GB"),
-			Entry("raw bytes", "10485760"),
-			Entry("mebibytes", "10MiB"),
-			Entry("lower case", "50mb"),
-		)
-
-		DescribeTable("rejects invalid size values",
-			func(input string) {
-				conf.Server.MaxImageUploadSize = input
-				Expect(conf.ValidateMaxImageUploadSize()).To(MatchError(ContainSubstring("invalid MaxImageUploadSize")))
-			},
-			Entry("garbage string", "not-a-size"),
-			Entry("negative-looking", "-10MB"),
-		)
-	})
-
-	Describe("EnforceNonRootUser", func() {
-		It("defaults to false", func() {
-			conf.Load(true)
-
-			Expect(conf.Server.EnforceNonRootUser).To(BeFalse())
-		})
-
-		It("allows startup for non-root users when enabled", func() {
-			DeferCleanup(conf.SetRuntimeInfoForTest("linux", 1000))
-			viper.Set("enforcenonrootuser", true)
-
-			conf.Load(true)
-
-			Expect(conf.Server.EnforceNonRootUser).To(BeTrue())
-		})
-
-		It("exits when enabled and running as root without having created a data folder", func() {
-			// Create a path that doesn't exist yet
-			tempBase := GinkgoT().TempDir()
-			nonExistentDataFolder := filepath.Join(tempBase, "nonexistent", "data")
-			DeferCleanup(conf.SetRuntimeInfoForTest("linux", 0))
-			viper.Set("enforcenonrootuser", true)
-			viper.Set("datafolder", nonExistentDataFolder)
-
-			// Attempt to load config as root user - should fail before creating directories
-			Expect(func() {
-				conf.Load(true)
-			}).To(PanicWith(ContainSubstring("EnforceNonRootUser is enabled but Navidrome is running as root")))
-
-			// Verify that the data folder was NOT created
-			Expect(nonExistentDataFolder).ToNot(BeAnExistingFile())
-		})
-
-		It("is a no-op on non-unix platforms", func() {
-			DeferCleanup(conf.SetRuntimeInfoForTest("windows", 0))
-			viper.Set("enforcenonrootuser", true)
-
-			conf.Load(true)
-
-			Expect(conf.Server.EnforceNonRootUser).To(BeTrue())
-		})
-	})
-
 	DescribeTable("should load configuration from",
 		func(format string) {
 			filename := filepath.Join("testdata", "cfg."+format)
--- a/conf/export_test.go
+++ b/conf/export_test.go
@ -14,19 +14,6 @@ var NormalizeSearchBackend = normalizeSearchBackend

 var ToPascalCase = toPascalCase

-var ValidateMaxImageUploadSize = validateMaxImageUploadSize
-
-func SetRuntimeInfoForTest(goos string, euid int) func() {
-	oldGOOS := currentGOOS
-	oldEUID := getEUID
-	currentGOOS = func() string { return goos }
-	getEUID = func() int { return euid }
-	return func() {
-		currentGOOS = oldGOOS
-		getEUID = oldEUID
-	}
-}
-
 func SetLogFatal(f func(...any)) func() {
 	old := logFatal
 	logFatal = f
--- a/consts/consts.go
+++ b/consts/consts.go
@ -85,10 +85,11 @@ const (
 )

 const (
-	DefaultUICoverArtSize     = 300
-	DefaultMaxImageUploadSize = "10MB"
+	UICoverArtSize = 600
 )

+var CacheWarmerImageSizes = []int{UICoverArtSize}
+
 // Prometheus options
 const (
 	PrometheusDefaultPath = "/metrics"
--- a/context7.json
+++ b/context7.json
@ -1,4 +0,0 @@
-{
-  "url": "https://context7.com/navidrome/navidrome",
-  "public_key": "pk_WqzhKScNKWQ84J4n0oG0J"
-}
--- a/core/artwork/artwork_internal_test.go
+++ b/core/artwork/artwork_internal_test.go
@ -7,11 +7,12 @@ import (
 	"image/jpeg"
 	"image/png"
 	"io"
+
 	"os"
 	"path/filepath"
-	"time"

 	_ "github.com/gen2brain/webp"
+
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/log"
@ -80,7 +81,6 @@ var _ = Describe("Artwork", func() {
 				})
 			})
 			It("returns embed cover", func() {
-				tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 				aw, err := newAlbumArtworkReader(ctx, aw, alOnlyEmbed.CoverArtID(), nil)
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
@ -104,7 +104,6 @@ var _ = Describe("Artwork", func() {
 				})
 			})
 			It("returns external cover", func() {
-				tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 				folderRepo.result = []model.Folder{{
 					Path:       "tests/fixtures/artist/an-album",
 					ImageFiles: []string{"front.png"},
@ -135,7 +134,6 @@ var _ = Describe("Artwork", func() {
 			})
 			DescribeTable("CoverArtPriority",
 				func(priority string, expected string) {
-					tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 					conf.Server.CoverArtPriority = priority
 					aw, err := newAlbumArtworkReader(ctx, aw, alMultipleCovers.CoverArtID(), nil)
 					Expect(err).ToNot(HaveOccurred())
@ -148,51 +146,6 @@ var _ = Describe("Artwork", func() {
 				Entry(nil, " embedded , front.* , cover.*,folder.*", "tests/fixtures/artist/an-album/test.mp3"),
 			)
 		})
-		Context("LastUpdated", func() {
-			// Regression test for #5377: LastUpdated feeds the HTTP Last-Modified header.
-			// It must return max(album.UpdatedAt, ImagesUpdatedAt) so browsers revalidate
-			// cached cover art when only the image file changes.
-			now := time.Now().Truncate(time.Second)
-			DescribeTable("returns the max of album.UpdatedAt and ImagesUpdatedAt",
-				func(albumUpdatedAt, imagesUpdatedAt, expected time.Time) {
-					album := model.Album{ID: "al1", UpdatedAt: albumUpdatedAt}
-					folderRepo.result = []model.Folder{{ImagesUpdatedAt: imagesUpdatedAt}}
-					ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{album})
-
-					ar, err := newAlbumArtworkReader(ctx, aw, album.CoverArtID(), nil)
-					Expect(err).ToNot(HaveOccurred())
-					Expect(ar.LastUpdated()).To(Equal(expected))
-				},
-				Entry("album newer than images", now, now.Add(-1*time.Hour), now),
-				Entry("images newer than album", now.Add(-24*time.Hour), now.Add(-1*time.Hour), now.Add(-1*time.Hour)),
-				Entry("equal timestamps", now, now, now),
-			)
-		})
-	})
-	Describe("discArtworkReader", func() {
-		Context("LastUpdated", func() {
-			// Regression test for #5377: same bug as albumArtworkReader — disc covers
-			// must also revalidate when the image file changes, not only when media files do.
-			now := time.Now().Truncate(time.Second)
-			DescribeTable("returns the max of album.UpdatedAt and ImagesUpdatedAt",
-				func(albumUpdatedAt, imagesUpdatedAt, expected time.Time) {
-					album := model.Album{ID: "al1", UpdatedAt: albumUpdatedAt}
-					folderRepo.result = []model.Folder{{ImagesUpdatedAt: imagesUpdatedAt}}
-					ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{album})
-					ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
-						{ID: "mf1", AlbumID: "al1", DiscNumber: 1, Path: "tests/fixtures/test.mp3"},
-					})
-
-					artID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("al1", 1), nil)
-					dr, err := newDiscArtworkReader(ctx, aw, artID)
-					Expect(err).ToNot(HaveOccurred())
-					Expect(dr.LastUpdated()).To(Equal(expected))
-				},
-				Entry("album newer than images", now, now.Add(-1*time.Hour), now),
-				Entry("images newer than album", now.Add(-24*time.Hour), now.Add(-1*time.Hour), now.Add(-1*time.Hour)),
-				Entry("equal timestamps", now, now, now),
-			)
-		})
 	})
 	Describe("artistArtworkReader", func() {
 		Context("Multiple covers", func() {
@ -213,7 +166,6 @@ var _ = Describe("Artwork", func() {
 			})
 			DescribeTable("ArtistArtPriority",
 				func(priority string, expected string) {
-					tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 					conf.Server.ArtistArtPriority = priority
 					aw, err := newArtistArtworkReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)
 					Expect(err).ToNot(HaveOccurred())
@ -251,7 +203,6 @@ var _ = Describe("Artwork", func() {
 				})
 			})
 			It("returns embed cover", func() {
-				tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 				aw, err := newMediafileArtworkReader(ctx, aw, mfWithEmbed.CoverArtID())
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
@ -259,7 +210,6 @@ var _ = Describe("Artwork", func() {
 				Expect(path).To(Equal("tests/fixtures/test.mp3"))
 			})
 			It("returns embed cover if successfully extracted by ffmpeg", func() {
-				tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 				aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())
 				Expect(err).ToNot(HaveOccurred())
 				r, path, err := aw.Reader(ctx)
@ -430,24 +380,24 @@ var _ = Describe("Artwork", func() {
 			})
 		})
 		When("Square is false", func() {
-			It("returns PNG if original image is a PNG", func() {
+			It("returns WebP even if original image is a PNG", func() {
 				conf.Server.CoverArtPriority = "front.png"
 				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)
 				Expect(err).ToNot(HaveOccurred())

 				img, format, err := image.Decode(r)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(format).To(Equal("png"))
+				Expect(format).To(Equal("webp"))
 				Expect(img.Bounds().Size().X).To(Equal(15))
 				Expect(img.Bounds().Size().Y).To(Equal(15))
 			})
-			It("returns JPEG if original image is not a PNG", func() {
+			It("returns WebP if original image is not a PNG", func() {
 				conf.Server.CoverArtPriority = "cover.jpg"
 				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)
 				Expect(err).ToNot(HaveOccurred())

 				img, format, err := image.Decode(r)
-				Expect(format).To(Equal("jpeg"))
+				Expect(format).To(Equal("webp"))
 				Expect(err).ToNot(HaveOccurred())
 				Expect(img.Bounds().Size().X).To(Equal(200))
 				Expect(img.Bounds().Size().Y).To(Equal(200))
@ -480,51 +430,24 @@ var _ = Describe("Artwork", func() {
 					Expect(img.Bounds().Size().X).To(Equal(size))
 					Expect(img.Bounds().Size().Y).To(Equal(size))
 				},
-				Entry("portrait png image", "png", "png", false, 200),
-				Entry("landscape png image", "png", "png", true, 200),
-				Entry("portrait jpg image", "jpg", "png", false, 200),
-				Entry("landscape jpg image", "jpg", "png", true, 200),
+				Entry("portrait png image", "png", "webp", false, 200),
+				Entry("landscape png image", "png", "webp", true, 200),
+				Entry("portrait jpg image", "jpg", "webp", false, 200),
+				Entry("landscape jpg image", "jpg", "webp", true, 200),
 			)
 		})
-		When("EnableWebPEncoding is true and square is false", func() {
+		When("DevJpegCoverArt is true and square is false", func() {
 			BeforeEach(func() {
-				conf.Server.EnableWebPEncoding = true
+				conf.Server.DevJpegCoverArt = true
 			})
-			It("returns WebP even if original image is a PNG", func() {
+			It("returns JPEG even if original image is a PNG", func() {
 				conf.Server.CoverArtPriority = "front.png"
 				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)
 				Expect(err).ToNot(HaveOccurred())

 				img, format, err := image.Decode(r)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(format).To(Equal("webp"))
-				Expect(img.Bounds().Size().X).To(Equal(15))
-				Expect(img.Bounds().Size().Y).To(Equal(15))
-			})
-			It("returns WebP if original image is not a PNG", func() {
-				conf.Server.CoverArtPriority = "cover.jpg"
-				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)
-				Expect(err).ToNot(HaveOccurred())
-
-				img, format, err := image.Decode(r)
-				Expect(format).To(Equal("webp"))
-				Expect(err).ToNot(HaveOccurred())
-				Expect(img.Bounds().Size().X).To(Equal(200))
-				Expect(img.Bounds().Size().Y).To(Equal(200))
-			})
-		})
-		When("EnableWebPEncoding is false and square is false", func() {
-			BeforeEach(func() {
-				conf.Server.EnableWebPEncoding = false
-			})
-			It("returns PNG if original image is a PNG", func() {
-				conf.Server.CoverArtPriority = "front.png"
-				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)
-				Expect(err).ToNot(HaveOccurred())
-
-				img, format, err := image.Decode(r)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(format).To(Equal("png"))
+				Expect(format).To(Equal("jpeg"))
 				Expect(img.Bounds().Size().X).To(Equal(15))
 				Expect(img.Bounds().Size().Y).To(Equal(15))
 			})
@ -540,11 +463,11 @@ var _ = Describe("Artwork", func() {
 				Expect(img.Bounds().Size().Y).To(Equal(200))
 			})
 		})
-		When("EnableWebPEncoding is false and square is true", func() {
+		When("DevJpegCoverArt is true and square is true", func() {
 			var alCover model.Album

 			BeforeEach(func() {
-				conf.Server.EnableWebPEncoding = false
+				conf.Server.DevJpegCoverArt = true
 			})
 			It("returns PNG for square mode", func() {
 				dirName := createImage("png", false, 200)
--- a/core/artwork/cache_warmer.go
+++ b/core/artwork/cache_warmer.go
@ -10,6 +10,7 @@ import (
 	"time"

 	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/request"
@ -23,7 +24,7 @@ type CacheWarmer interface {

 // NewCacheWarmer creates a new CacheWarmer instance. The CacheWarmer will pre-cache Artwork images in the background
 // to speed up the response time when the image is requested by the UI. The cache is pre-populated with the original
-// image size, as well as the size defined by the UICoverArtSize config option.
+// image size, as well as the size defined in the UICoverArtSize constant.
 func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {
 	// If image cache is disabled, return a NOOP implementation
 	if conf.Server.ImageCacheSize == "0" || !conf.Server.EnableArtworkPrecache {
@ -37,11 +38,10 @@ func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {
 	}

 	a := &cacheWarmer{
-		artwork:      artwork,
-		cache:        cache,
-		buffer:       make(map[model.ArtworkID]struct{}),
-		wakeSignal:   make(chan struct{}, 1),
-		coverArtSize: conf.Server.UICoverArtSize,
+		artwork:    artwork,
+		cache:      cache,
+		buffer:     make(map[model.ArtworkID]struct{}),
+		wakeSignal: make(chan struct{}, 1),
 	}

 	// Create a context with a fake admin user, to be able to pre-cache Playlist CoverArts
@ -51,12 +51,11 @@ func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {
 }

 type cacheWarmer struct {
-	artwork      Artwork
-	buffer       map[model.ArtworkID]struct{}
-	mutex        sync.Mutex
-	cache        cache.FileCache
-	wakeSignal   chan struct{}
-	coverArtSize int
+	artwork    Artwork
+	buffer     map[model.ArtworkID]struct{}
+	mutex      sync.Mutex
+	cache      cache.FileCache
+	wakeSignal chan struct{}
 }

 func (a *cacheWarmer) PreCache(artID model.ArtworkID) {
@ -143,14 +142,16 @@ func (a *cacheWarmer) doCacheImage(ctx context.Context, id model.ArtworkID) erro
 	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()

-	size := a.coverArtSize
-	r, _, err := a.artwork.Get(ctx, id, size, true)
-	if err != nil {
-		return fmt.Errorf("caching id='%s', size=%d: %w", id, size, err)
+	for _, size := range consts.CacheWarmerImageSizes {
+		r, _, err := a.artwork.Get(ctx, id, size, true)
+		if err != nil {
+			return fmt.Errorf("caching id='%s', size=%d: %w", id, size, err)
+		}
+		_, err = io.Copy(io.Discard, r)
+		r.Close()
+		return err
 	}
-	_, err = io.Copy(io.Discard, r)
-	r.Close()
-	return err
+	return nil
 }

 func NoopCacheWarmer() CacheWarmer {
--- a/core/artwork/cache_warmer_test.go
+++ b/core/artwork/cache_warmer_test.go
@ -12,6 +12,7 @@ import (

 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils/cache"
 	. "github.com/onsi/ginkgo/v2"
@ -181,7 +182,7 @@ var _ = Describe("CacheWarmer", func() {

 			Eventually(func() []int {
 				return aw.getCachedSizes()
-			}).Should(ContainElements(conf.Server.UICoverArtSize))
+			}).Should(ContainElements(consts.UICoverArtSize))
 		})
 	})
 })
--- a/core/artwork/reader_album.go
+++ b/core/artwork/reader_album.go
@ -61,7 +61,7 @@ func newAlbumArtworkReader(ctx context.Context, artwork *artwork, artID model.Ar
 func (a *albumArtworkReader) Key() string {
 	hashInput := conf.Server.CoverArtPriority
 	if conf.Server.EnableExternalServices {
-		hashInput = conf.Server.Agents + hashInput
+		hashInput += conf.Server.Agents
 	}
 	hash := md5.Sum([]byte(hashInput))
 	return fmt.Sprintf(
@ -72,7 +72,7 @@ func (a *albumArtworkReader) Key() string {
 	)
 }
 func (a *albumArtworkReader) LastUpdated() time.Time {
-	return a.lastUpdate
+	return a.album.UpdatedAt
 }

 func (a *albumArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
--- a/core/artwork/reader_artist_test.go
+++ b/core/artwork/reader_artist_test.go
@ -12,7 +12,6 @@ import (
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@ -62,7 +61,6 @@ var _ = Describe("artistArtworkReader", func() {

 		When("artist has only one album", func() {
 			It("returns the parent folder", func() {
-				tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 				paths = []string{
 					filepath.FromSlash("/music/artist/album1"),
 				}
@ -88,7 +86,6 @@ var _ = Describe("artistArtworkReader", func() {

 		When("the album paths contain same prefix", func() {
 			It("returns the common prefix", func() {
-				tests.SkipOnWindows("artwork path handling (#TBD-path-sep-artwork)")
 				paths = []string{
 					filepath.FromSlash("/music/artist/album1"),
 					filepath.FromSlash("/music/artist/album2"),
--- a/core/artwork/reader_disc.go
+++ b/core/artwork/reader_disc.go
@ -116,7 +116,7 @@ func (d *discArtworkReader) Key() string {
 }

 func (d *discArtworkReader) LastUpdated() time.Time {
-	return d.lastUpdate
+	return d.album.UpdatedAt
 }

 func (d *discArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
@ -168,38 +168,47 @@ func (d *discArtworkReader) fromDiscSubtitle(ctx context.Context, subtitle strin
 	}
 }

-// globMetaChars holds the substitution metacharacters understood by
-// filepath.Match. The '\' escape character is intentionally excluded:
-// disc art patterns come from user config and never include escaped
-// metachars in practice, and treating '\' as a metachar would misalign
-// the literal-prefix extraction in extractDiscNumber.
-const globMetaChars = "*?["
-
-// extractDiscNumber parses the disc number from a filename matched by a
-// filepath.Match-style glob pattern.
-//
-// Both pattern and filename must already be lowercased by the caller, which
-// is also expected to have verified that filepath.Match(pattern, filename)
-// is true before calling this function.
+// extractDiscNumber extracts a disc number from a filename based on a glob pattern.
+// It finds the portion of the filename that the wildcard matched and parses leading
+// digits as the disc number. Returns (0, false) if the pattern doesn't match or
+// no leading digits are found in the wildcard portion.
 func extractDiscNumber(pattern, filename string) (int, bool) {
-	metaIdx := strings.IndexAny(pattern, globMetaChars)
-	if metaIdx < 0 {
+	filename = strings.ToLower(filename)
+	pattern = strings.ToLower(pattern)
+
+	matched, err := filepath.Match(pattern, filename)
+	if err != nil || !matched {
 		return 0, false
 	}
-	prefix := pattern[:metaIdx]
+
+	// Find the prefix before the first '*' in the pattern
+	starIdx := strings.IndexByte(pattern, '*')
+	if starIdx < 0 {
+		return 0, false
+	}
+	prefix := pattern[:starIdx]
+
+	// Strip the prefix from the filename to get the wildcard-matched portion
 	if !strings.HasPrefix(filename, prefix) {
 		return 0, false
 	}
+	remainder := filename[len(prefix):]

-	start := len(prefix)
-	end := start
-	for end < len(filename) && filename[end] >= '0' && filename[end] <= '9' {
-		end++
+	// Extract leading ASCII digits from the remainder
+	var digits []byte
+	for _, r := range remainder {
+		if r >= '0' && r <= '9' {
+			digits = append(digits, byte(r))
+		} else {
+			break
+		}
 	}
-	if end == start {
+
+	if len(digits) == 0 {
 		return 0, false
 	}
-	num, err := strconv.Atoi(filename[start:end])
+
+	num, err := strconv.Atoi(string(digits))
 	if err != nil {
 		return 0, false
 	}
@ -207,16 +216,20 @@ func extractDiscNumber(pattern, filename string) (int, bool) {
 }

 // fromExternalFile returns a sourceFunc that matches image files against a glob
-// pattern. A numbered filename whose number equals the target disc wins over
-// any unnumbered candidate; callers must pass a lowercase pattern.
+// pattern with disc-number-aware filtering.
+//
+// Matching rules:
+//   - If a disc number can be extracted from the filename, the file matches only if
+//     the number equals the target disc number.
+//   - If no number is found and this is a multi-folder album, the file matches if
+//     it's in a folder containing tracks for this disc.
+//   - If no number is found and this is a single-folder album, the file is skipped
+//     (ambiguous).
 func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string) sourceFunc {
-	isLiteral := !strings.ContainsAny(pattern, globMetaChars)
 	return func() (io.ReadCloser, string, error) {
-		var fallbacks []string
 		for _, file := range d.imgFiles {
 			_, name := filepath.Split(file)
-			name = strings.ToLower(name)
-			match, err := filepath.Match(pattern, name)
+			match, err := filepath.Match(pattern, strings.ToLower(name))
 			if err != nil {
 				log.Warn(ctx, "Error matching disc art file to pattern", "pattern", pattern, "file", file)
 				continue
@ -225,27 +238,24 @@ func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string
 				continue
 			}

-			if !isLiteral {
-				if num, hasNum := extractDiscNumber(pattern, name); hasNum {
-					if num != d.discNumber {
-						continue
-					}
-					f, err := os.Open(file)
-					if err != nil {
-						log.Warn(ctx, "Could not open disc art file", "file", file, err)
-						continue
-					}
-					return f, file, nil
+			// Try to extract disc number from filename
+			num, hasNum := extractDiscNumber(pattern, name)
+			if hasNum {
+				// File has a disc number — must match target disc
+				if num != d.discNumber {
+					continue
 				}
-			}
-
-			if d.isMultiFolder && !d.discFolders[filepath.Dir(file)] {
+			} else if d.isMultiFolder {
+				// No number, multi-folder: match by folder association
+				dir := filepath.Dir(file)
+				if !d.discFolders[dir] {
+					continue
+				}
+			} else {
+				// No number, single-folder: ambiguous, skip
 				continue
 			}
-			fallbacks = append(fallbacks, file)
-		}

-		for _, file := range fallbacks {
 			f, err := os.Open(file)
 			if err != nil {
 				log.Warn(ctx, "Could not open disc art file", "file", file, err)
--- a/core/artwork/reader_disc_test.go
+++ b/core/artwork/reader_disc_test.go
@ -42,24 +42,11 @@ var _ = Describe("Disc Artwork Reader", func() {
 			// Case insensitive (filename already lowered by caller)
 			Entry("Disc1.jpg lowered", "disc*.*", "disc1.jpg", 1, true),

-			// HasPrefix guard: filename doesn't share the pattern's literal prefix
-			Entry("cover.jpg with disc*.* (no prefix match)", "disc*.*", "cover.jpg", 0, false),
+			// Pattern doesn't match
+			Entry("cover.jpg doesn't match disc*.*", "disc*.*", "cover.jpg", 0, false),

 			// Pattern with no wildcard before dot
 			Entry("front1.jpg with front*.*", "front*.*", "front1.jpg", 1, true),
-
-			// '?' single-char wildcard
-			Entry("disc?.jpg with disc1.jpg", "disc?.jpg", "disc1.jpg", 1, true),
-			Entry("disc?.jpg with disc2.jpg", "disc?.jpg", "disc2.jpg", 2, true),
-			Entry("cd??.jpg with cd07.jpg", "cd??.jpg", "cd07.jpg", 7, true),
-
-			// '[...]' character class wildcard
-			Entry("cd[12].jpg with cd1.jpg", "cd[12].jpg", "cd1.jpg", 1, true),
-			Entry("cd[12].jpg with cd2.jpg", "cd[12].jpg", "cd2.jpg", 2, true),
-			Entry("disc[0-9].jpg with disc5.jpg", "disc[0-9].jpg", "disc5.jpg", 5, true),
-
-			// Literal pattern (no wildcard) returns false
-			Entry("shellac.png literal", "shellac.png", "shellac.png", 0, false),
 		)
 	})

@ -98,186 +85,19 @@ var _ = Describe("Disc Artwork Reader", func() {
 			Expect(path).To(Equal(f1))
 		})

-		It("matches file without number in single-folder album (shared disc art)", func() {
-			f1 := createFile("album/cover.png")
+		It("skips file without number in single-folder album", func() {
+			f1 := createFile("album/disc.jpg")
 			reader := &discArtworkReader{
 				discNumber:  1,
 				imgFiles:    []string{f1},
 				discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},
 			}

-			sf := reader.fromExternalFile(ctx, "cover.*")
-			r, path, err := sf()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(r).ToNot(BeNil())
-			r.Close()
-			Expect(path).To(Equal(f1))
-		})
-
-		It("returns shared disc art for every disc number in single-folder album", func() {
-			f1 := createFile("album/shellac.png")
-			makeReader := func(discNum int) *discArtworkReader {
-				return &discArtworkReader{
-					discNumber:  discNum,
-					imgFiles:    []string{f1},
-					discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},
-				}
-			}
-
-			for _, disc := range []int{1, 2, 5} {
-				sf := makeReader(disc).fromExternalFile(ctx, "shellac.png")
-				r, path, err := sf()
-				Expect(err).ToNot(HaveOccurred(), "disc %d", disc)
-				Expect(r).ToNot(BeNil())
-				r.Close()
-				Expect(path).To(Equal(f1), "disc %d", disc)
-			}
-		})
-
-		It("numbered and unnumbered patterns both resolve against the same reader", func() {
-			f1 := createFile("album/cover.png")
-			f2 := createFile("album/disc1.jpg")
-			f3 := createFile("album/disc2.jpg")
-			reader := &discArtworkReader{
-				discNumber:  2,
-				imgFiles:    []string{f1, f2, f3},
-				discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},
-			}
-
 			sf := reader.fromExternalFile(ctx, "disc*.*")
-			r, path, err := sf()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(r).ToNot(BeNil())
-			r.Close()
-			Expect(path).To(Equal(f3))
-
-			sf = reader.fromExternalFile(ctx, "cover.*")
-			r, path, err = sf()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(r).ToNot(BeNil())
-			r.Close()
-			Expect(path).To(Equal(f1))
+			r, _, _ := sf()
+			Expect(r).To(BeNil())
 		})

-		It("respects DiscArtPriority order when both numbered and unnumbered patterns match", func() {
-			f1 := createFile("album/cover.png")
-			f2 := createFile("album/disc1.jpg")
-			reader := &discArtworkReader{
-				discNumber:  1,
-				imgFiles:    []string{f1, f2},
-				discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},
-			}
-
-			ff := reader.fromDiscArtPriority(ctx, nil, "disc*.*, cover.*")
-			Expect(ff).To(HaveLen(2))
-			r, path, err := ff[0]()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(path).To(Equal(f2))
-			r.Close()
-
-			ff = reader.fromDiscArtPriority(ctx, nil, "cover.*, disc*.*")
-			Expect(ff).To(HaveLen(2))
-			r, path, err = ff[0]()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(path).To(Equal(f1))
-			r.Close()
-		})
-
-		DescribeTable("numbered match wins over shared fallback within a pattern",
-			func(discNumber, expectedIdx int) {
-				files := []string{
-					createFile("album/disc.jpg"),
-					createFile("album/disc1.jpg"),
-					createFile("album/disc2.jpg"),
-				}
-				reader := &discArtworkReader{
-					discNumber:  discNumber,
-					imgFiles:    files,
-					discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},
-				}
-
-				sf := reader.fromExternalFile(ctx, "disc*.*")
-				r, path, err := sf()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(r).ToNot(BeNil())
-				r.Close()
-				Expect(path).To(Equal(files[expectedIdx]))
-			},
-			Entry("disc 2 picks disc2.jpg over the shared disc.jpg", 2, 2),
-			Entry("disc 3 falls back to disc.jpg when no numbered match exists", 3, 0),
-		)
-
-		It("tries the next fallback candidate when the first one cannot be opened", func() {
-			f1 := createFile("album/cover.jpg")
-			f2 := createFile("album/cover.png")
-			// Remove f1 so os.Open will fail on it; f2 should still win.
-			Expect(os.Remove(f1)).To(Succeed())
-			reader := &discArtworkReader{
-				discNumber:  1,
-				imgFiles:    []string{f1, f2},
-				discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},
-			}
-
-			sf := reader.fromExternalFile(ctx, "cover.*")
-			r, path, err := sf()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(r).ToNot(BeNil())
-			r.Close()
-			Expect(path).To(Equal(f2))
-		})
-
-		It("keeps scanning literal-pattern matches so fallback retry still works", func() {
-			// Guards against an 'early break on first literal match' optimization.
-			// Multiple imgFiles entries can share a basename (symlinks, case-variant
-			// duplicates on case-sensitive filesystems). If the loop breaks after
-			// recording just the first, the fallback retry cannot recover when
-			// that first file is unreadable.
-			f1 := createFile("album/stale/cover.png")
-			f2 := createFile("album/cover.png")
-			Expect(os.Remove(f1)).To(Succeed())
-			reader := &discArtworkReader{
-				discNumber: 1,
-				imgFiles:   []string{f1, f2},
-				discFolders: map[string]bool{
-					filepath.Join(tmpDir, "album"):       true,
-					filepath.Join(tmpDir, "album/stale"): true,
-				},
-				isMultiFolder: true,
-			}
-
-			sf := reader.fromExternalFile(ctx, "cover.png")
-			r, path, err := sf()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(r).ToNot(BeNil())
-			r.Close()
-			Expect(path).To(Equal(f2))
-		})
-
-		DescribeTable("filters by disc number for non-'*' wildcard patterns",
-			func(pattern string, discNumber, expectedIdx int) {
-				files := []string{
-					createFile("album/disc1.jpg"),
-					createFile("album/disc2.jpg"),
-				}
-				reader := &discArtworkReader{
-					discNumber:  discNumber,
-					imgFiles:    files,
-					discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},
-				}
-
-				sf := reader.fromExternalFile(ctx, pattern)
-				r, path, err := sf()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(r).ToNot(BeNil())
-				r.Close()
-				Expect(path).To(Equal(files[expectedIdx]))
-			},
-			Entry("disc?.jpg, target disc 1 → disc1.jpg", "disc?.jpg", 1, 0),
-			Entry("disc?.jpg, target disc 2 → disc2.jpg", "disc?.jpg", 2, 1),
-			Entry("disc[0-9].jpg, target disc 1 → disc1.jpg", "disc[0-9].jpg", 1, 0),
-			Entry("disc[0-9].jpg, target disc 2 → disc2.jpg", "disc[0-9].jpg", 2, 1),
-		)
-
 		It("matches file without number in multi-folder album by folder", func() {
 			f1 := createFile("album/cd1/disc.jpg")
 			f2 := createFile("album/cd2/disc.jpg")
--- a/core/artwork/reader_resized.go
+++ b/core/artwork/reader_resized.go
@ -19,16 +19,6 @@ import (
 	xdraw "golang.org/x/image/draw"
 )

-func init() {
-	conf.AddHook(func() {
-		if err := webp.Dynamic(); err != nil {
-			log.Debug("Using WASM WebP encoder/decoder", "reason", err)
-		} else {
-			log.Debug("Using native libwebp for WebP encoding/decoding")
-		}
-	})
-}
-
 var bufPool = sync.Pool{
 	New: func() any {
 		return new(bytes.Buffer)
@ -127,7 +117,7 @@ func (a *resizedArtworkReader) resizeImage(ctx context.Context, reader io.Reader
 }

 func resizeStaticImage(data []byte, size int, square bool) (io.Reader, int, error) {
-	original, format, err := image.Decode(bytes.NewReader(data))
+	original, _, err := image.Decode(bytes.NewReader(data))
 	if err != nil {
 		return nil, 0, err
 	}
@ -167,12 +157,14 @@ func resizeStaticImage(data []byte, size int, square bool) (io.Reader, int, erro

 	buf := bufPool.Get().(*bytes.Buffer)
 	buf.Reset()
-	if conf.Server.EnableWebPEncoding {
-		err = webp.Encode(buf, dst, webp.Options{Quality: conf.Server.CoverArtQuality})
-	} else if format == "png" || square {
-		err = png.Encode(buf, dst)
+	if conf.Server.DevJpegCoverArt {
+		if square {
+			err = png.Encode(buf, dst)
+		} else {
+			err = jpeg.Encode(buf, dst, &jpeg.Options{Quality: conf.Server.CoverArtQuality})
+		}
 	} else {
-		err = jpeg.Encode(buf, dst, &jpeg.Options{Quality: conf.Server.CoverArtQuality})
+		err = webp.Encode(buf, dst, webp.Options{Quality: conf.Server.CoverArtQuality})
 	}
 	if err != nil {
 		bufPool.Put(buf)
--- a/core/common_test.go
+++ b/core/common_test.go
@ -41,7 +41,6 @@ var _ = Describe("common.go", func() {
 		})

 		It("returns the absolute path when library exists", func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-core)")
 			ctx := context.Background()
 			abs := AbsolutePath(ctx, ds, libId, path)
 			Expect(abs).To(Equal("/library/root/music/file.mp3"))
--- a/core/external/provider.go
+++ b/core/external/provider.go
@ -12,7 +12,6 @@ import (
 	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/utils"
@ -42,7 +41,6 @@ type Provider interface {
 type provider struct {
 	ds          model.DataStore
 	ag          Agents
-	matcher     *matcher.Matcher
 	artistQueue refreshQueue[auxArtist]
 	albumQueue  refreshQueue[auxAlbum]
 }
@ -87,8 +85,8 @@ type Agents interface {
 	agents.SimilarSongsByArtistRetriever
 }

-func NewProvider(ds model.DataStore, agents Agents, m *matcher.Matcher) Provider {
-	e := &provider{ds: ds, ag: agents, matcher: m}
+func NewProvider(ds model.DataStore, agents Agents) Provider {
+	e := &provider{ds: ds, ag: agents}
 	e.artistQueue = newRefreshQueue(context.TODO(), e.populateArtistInfo)
 	e.albumQueue = newRefreshQueue(context.TODO(), e.populateAlbumInfo)
 	return e
@ -302,7 +300,7 @@ func (e *provider) SimilarSongs(ctx context.Context, id string, count int) (mode
 	}

 	if err == nil && len(songs) > 0 {
-		return e.matcher.MatchSongsToLibrary(ctx, songs, count)
+		return e.matchSongsToLibrary(ctx, songs, count)
 	}

 	// Fallback to existing similar artists + top songs algorithm
@ -481,7 +479,7 @@ func (e *provider) getMatchingTopSongs(ctx context.Context, agent agents.ArtistT
 		}
 	}

-	mfs, err := e.matcher.MatchSongsToLibrary(ctx, songs, count)
+	mfs, err := e.matchSongsToLibrary(ctx, songs, count)
 	if err != nil {
 		return nil, err
 	}
--- a/core/external/provider_albumimage_test.go
+++ b/core/external/provider_albumimage_test.go
@ -9,7 +9,6 @@ import (
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core/agents"
 	. "github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
@ -44,7 +43,7 @@ var _ = Describe("Provider - AlbumImage", func() {
 		mockAlbumAgent = newMockAlbumInfoAgent()

 		agentsCombined := &mockAgents{albumInfoAgent: mockAlbumAgent}
-		provider = NewProvider(ds, agentsCombined, matcher.New(ds))
+		provider = NewProvider(ds, agentsCombined)

 		// Default mocks
 		// Mocks for GetEntityByID sequence (initial failed lookups)
--- a/core/external/provider_artistimage_test.go
+++ b/core/external/provider_artistimage_test.go
@ -11,7 +11,6 @@ import (
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core/agents"
 	. "github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
@ -52,7 +51,7 @@ var _ = Describe("Provider - ArtistImage", func() {
 			imageAgent: mockImageAgent,
 		}

-		provider = NewProvider(ds, agentsCombined, matcher.New(ds))
+		provider = NewProvider(ds, agentsCombined)

 		// Default mocks for successful Get calls
 		mockArtistRepo.On("Get", "artist-1").Return(&model.Artist{ID: "artist-1", Name: "Artist One"}, nil).Maybe()
--- a/core/external/provider_matching.go
+++ b/core/external/provider_matching.go
@ -1,4 +1,4 @@
-package matcher
+package external

 import (
 	"context"
@ -13,17 +13,7 @@ import (
 	"github.com/xrash/smetrics"
 )

-// Matcher matches agent song results to local library tracks.
-type Matcher struct {
-	ds model.DataStore
-}
-
-// New creates a new Matcher with the given DataStore.
-func New(ds model.DataStore) *Matcher {
-	return &Matcher{ds: ds}
-}
-
-// MatchSongsToLibrary matches agent song results to local library tracks using a multi-phase
+// matchSongsToLibrary matches agent song results to local library tracks using a multi-phase
 // matching algorithm that prioritizes accuracy over recall.
 //
 // # Algorithm Overview
@ -46,20 +36,18 @@ func New(ds model.DataStore) *Matcher {
 // # Fuzzy Matching Details
 //
 // For title+artist matching, the algorithm uses Jaro-Winkler similarity (threshold configurable
-// via Matcher.FuzzyThreshold, default 85%). Matches are ranked by:
+// via SimilarSongsMatchThreshold, default 85%). Matches are ranked by:
 //
 //  1. Title similarity (Jaro-Winkler score, 0.0-1.0)
 //  2. Duration proximity (closer duration = higher score, 1.0 if unknown)
-//  3. Preferred track flag (enabled by Matcher.PreferStarred; prioritized when the track is
-//     starred or has rating >= 4)
-//  4. Specificity level (0-5, based on metadata precision):
+//  3. Specificity level (0-5, based on metadata precision):
 //     - Level 5: Title + Artist MBID + Album MBID (most specific)
 //     - Level 4: Title + Artist MBID + Album name (fuzzy)
 //     - Level 3: Title + Artist name + Album name (fuzzy)
 //     - Level 2: Title + Artist MBID
 //     - Level 1: Title + Artist name
 //     - Level 0: Title only
-//  5. Album similarity (Jaro-Winkler, as final tiebreaker)
+//  4. Album similarity (Jaro-Winkler, as final tiebreaker)
 //
 // # Examples
 //
@ -107,34 +95,36 @@ func New(ds model.DataStore) *Matcher {
 //
 // Returns up to 'count' MediaFiles from the library that best match the input songs,
 // preserving the original order from the agent. Songs that cannot be matched are skipped.
-func (m *Matcher) MatchSongsToLibrary(ctx context.Context, songs []agents.Song, count int) (model.MediaFiles, error) {
-	idMatches, err := m.loadTracksByID(ctx, songs)
+func (e *provider) matchSongsToLibrary(ctx context.Context, songs []agents.Song, count int) (model.MediaFiles, error) {
+	idMatches, err := e.loadTracksByID(ctx, songs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load tracks by ID: %w", err)
 	}
-	mbidMatches, err := m.loadTracksByMBID(ctx, songs, idMatches)
+	mbidMatches, err := e.loadTracksByMBID(ctx, songs, idMatches)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
 	}
-	isrcMatches, err := m.loadTracksByISRC(ctx, songs, idMatches, mbidMatches)
+	isrcMatches, err := e.loadTracksByISRC(ctx, songs, idMatches, mbidMatches)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load tracks by ISRC: %w", err)
 	}
-	titleMatches, err := m.loadTracksByTitleAndArtist(ctx, songs, idMatches, mbidMatches, isrcMatches)
+	titleMatches, err := e.loadTracksByTitleAndArtist(ctx, songs, idMatches, mbidMatches, isrcMatches)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
 	}

-	return m.selectBestMatchingSongs(songs, idMatches, mbidMatches, isrcMatches, titleMatches, count), nil
+	return e.selectBestMatchingSongs(songs, idMatches, mbidMatches, isrcMatches, titleMatches, count), nil
 }

 // songMatchedIn checks if a song has already been matched in any of the provided match maps.
+// It checks the song's ID, MBID, and ISRC fields against the corresponding map keys.
 func songMatchedIn(s agents.Song, priorMatches ...map[string]model.MediaFile) bool {
 	_, found := lookupByIdentifiers(s, priorMatches...)
 	return found
 }

 // lookupByIdentifiers searches for a song's identifiers (ID, MBID, ISRC) in the provided maps.
+// Returns the first matching MediaFile found and true, or an empty MediaFile and false if no match.
 func lookupByIdentifiers(s agents.Song, maps ...map[string]model.MediaFile) (model.MediaFile, bool) {
 	keys := []string{s.ID, s.MBID, s.ISRC}
 	for _, m := range maps {
@ -150,7 +140,10 @@ func lookupByIdentifiers(s agents.Song, maps ...map[string]model.MediaFile) (mod
 }

 // loadTracksByID fetches MediaFiles from the library using direct ID matching.
-func (m *Matcher) loadTracksByID(ctx context.Context, songs []agents.Song) (map[string]model.MediaFile, error) {
+// It extracts all non-empty ID fields from the input songs and performs a single
+// batch query to the database. Returns a map keyed by MediaFile ID for O(1) lookup.
+// Only non-missing files are returned.
+func (e *provider) loadTracksByID(ctx context.Context, songs []agents.Song) (map[string]model.MediaFile, error) {
 	var ids []string
 	for _, s := range songs {
 		if s.ID != "" {
@ -161,7 +154,7 @@ func (m *Matcher) loadTracksByID(ctx context.Context, songs []agents.Song) (map[
 	if len(ids) == 0 {
 		return matches, nil
 	}
-	res, err := m.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
 		Filters: squirrel.And{
 			squirrel.Eq{"media_file.id": ids},
 			squirrel.Eq{"missing": false},
@ -179,7 +172,10 @@ func (m *Matcher) loadTracksByID(ctx context.Context, songs []agents.Song) (map[
 }

 // loadTracksByMBID fetches MediaFiles from the library using MusicBrainz Recording IDs.
-func (m *Matcher) loadTracksByMBID(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
+// It extracts all non-empty MBID fields from the input songs and performs a single
+// batch query against the mbz_recording_id column. Returns a map keyed by MBID for
+// O(1) lookup. Only non-missing files are returned.
+func (e *provider) loadTracksByMBID(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
 	var mbids []string
 	for _, s := range songs {
 		if s.MBID != "" && !songMatchedIn(s, priorMatches...) {
@ -190,7 +186,7 @@ func (m *Matcher) loadTracksByMBID(ctx context.Context, songs []agents.Song, pri
 	if len(mbids) == 0 {
 		return matches, nil
 	}
-	res, err := m.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
 		Filters: squirrel.And{
 			squirrel.Eq{"mbz_recording_id": mbids},
 			squirrel.Eq{"missing": false},
@ -209,8 +205,11 @@ func (m *Matcher) loadTracksByMBID(ctx context.Context, songs []agents.Song, pri
 	return matches, nil
 }

-// loadTracksByISRC fetches MediaFiles from the library using ISRC matching.
-func (m *Matcher) loadTracksByISRC(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
+// loadTracksByISRC fetches MediaFiles from the library using ISRC (International Standard
+// Recording Code) matching. It extracts all non-empty ISRC fields from the input songs and
+// queries the tags JSON column for matching ISRC values. Returns a map keyed by ISRC for
+// O(1) lookup. Only non-missing files are returned.
+func (e *provider) loadTracksByISRC(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
 	var isrcs []string
 	for _, s := range songs {
 		if s.ISRC != "" && !songMatchedIn(s, priorMatches...) {
@ -221,9 +220,8 @@ func (m *Matcher) loadTracksByISRC(ctx context.Context, songs []agents.Song, pri
 	if len(isrcs) == 0 {
 		return matches, nil
 	}
-	res, err := m.ds.MediaFile(ctx).GetAllByTags(model.TagISRC, isrcs, model.QueryOptions{
+	res, err := e.ds.MediaFile(ctx).GetAllByTags(model.TagISRC, isrcs, model.QueryOptions{
 		Filters: squirrel.Eq{"missing": false},
-		Sort:    "starred desc, rating desc, year asc, compilation asc",
 	})
 	if err != nil {
 		return matches, err
@ -239,25 +237,27 @@ func (m *Matcher) loadTracksByISRC(ctx context.Context, songs []agents.Song, pri
 }

 // songQuery represents a normalized query for matching a song to library tracks.
+// All string fields are sanitized (lowercased, diacritics removed) for comparison.
+// This struct is used internally by loadTracksByTitleAndArtist to group queries by artist.
 type songQuery struct {
-	title      string
-	artist     string
-	artistMBID string
-	album      string
-	albumMBID  string
-	durationMs uint32
+	title      string // Sanitized song title
+	artist     string // Sanitized artist name (without articles like "The")
+	artistMBID string // MusicBrainz Artist ID (optional, for higher specificity matching)
+	album      string // Sanitized album name (optional, for specificity scoring)
+	albumMBID  string // MusicBrainz Album ID (optional, for highest specificity matching)
+	durationMs uint32 // Duration in milliseconds (0 means unknown, skip duration filtering)
 }

-// matchScore combines title/album similarity with metadata specificity for ranking matches.
+// matchScore combines title/album similarity with metadata specificity for ranking matches
 type matchScore struct {
-	titleSimilarity   float64
-	durationProximity float64
-	preferredMatch    bool
-	albumSimilarity   float64
-	specificityLevel  int
+	titleSimilarity   float64 // 0.0-1.0 (Jaro-Winkler)
+	durationProximity float64 // 0.0-1.0 (closer duration = higher, 1.0 if unknown)
+	albumSimilarity   float64 // 0.0-1.0 (Jaro-Winkler), used as tiebreaker
+	specificityLevel  int     // 0-5 (higher = more specific metadata match)
 }

 // betterThan returns true if this score beats another.
+// Comparison order: title similarity > duration proximity > specificity level > album similarity
 func (s matchScore) betterThan(other matchScore) bool {
 	if s.titleSimilarity != other.titleSimilarity {
 		return s.titleSimilarity > other.titleSimilarity
@ -265,71 +265,64 @@ func (s matchScore) betterThan(other matchScore) bool {
 	if s.durationProximity != other.durationProximity {
 		return s.durationProximity > other.durationProximity
 	}
-	if s.preferredMatch != other.preferredMatch {
-		return s.preferredMatch
-	}
 	if s.specificityLevel != other.specificityLevel {
 		return s.specificityLevel > other.specificityLevel
 	}
 	return s.albumSimilarity > other.albumSimilarity
 }

-// sanitizedTrack holds pre-sanitized fields for a media file, avoiding redundant sanitization
-// when the same track is scored against multiple queries in the inner loop. The `mf` field
-// is a pointer to avoid copying the large MediaFile struct into each entry of the per-artist
-// sanitized slice.
-type sanitizedTrack struct {
-	mf     *model.MediaFile
-	title  string
-	artist string
-	album  string
-}
-
-func newSanitizedTrack(mf *model.MediaFile) sanitizedTrack {
-	return sanitizedTrack{
-		mf:     mf,
-		title:  str.SanitizeFieldForSorting(mf.Title),
-		artist: str.SanitizeFieldForSortingNoArticle(mf.Artist),
-		album:  str.SanitizeFieldForSorting(mf.Album),
-	}
-}
-
 // computeSpecificityLevel determines how well query metadata matches a track (0-5).
-// The track's title, artist, and album fields must be pre-sanitized.
-func computeSpecificityLevel(q songQuery, t sanitizedTrack, albumThreshold float64) int {
+// Higher values indicate more specific matches (MBIDs > names > title only).
+// Uses fuzzy matching for album names with the same threshold as title matching.
+func computeSpecificityLevel(q songQuery, mf model.MediaFile, albumThreshold float64) int {
+	title := str.SanitizeFieldForSorting(mf.Title)
+	artist := str.SanitizeFieldForSortingNoArticle(mf.Artist)
+	album := str.SanitizeFieldForSorting(mf.Album)
+
+	// Level 5: Title + Artist MBID + Album MBID (most specific)
 	if q.artistMBID != "" && q.albumMBID != "" &&
-		t.mf.MbzArtistID == q.artistMBID && t.mf.MbzAlbumID == q.albumMBID {
+		mf.MbzArtistID == q.artistMBID && mf.MbzAlbumID == q.albumMBID {
 		return 5
 	}
+	// Level 4: Title + Artist MBID + Album name (fuzzy)
 	if q.artistMBID != "" && q.album != "" &&
-		t.mf.MbzArtistID == q.artistMBID && similarityRatio(t.album, q.album) >= albumThreshold {
+		mf.MbzArtistID == q.artistMBID && similarityRatio(album, q.album) >= albumThreshold {
 		return 4
 	}
+	// Level 3: Title + Artist name + Album name (fuzzy)
 	if q.artist != "" && q.album != "" &&
-		t.artist == q.artist && similarityRatio(t.album, q.album) >= albumThreshold {
+		artist == q.artist && similarityRatio(album, q.album) >= albumThreshold {
 		return 3
 	}
-	if q.artistMBID != "" && t.mf.MbzArtistID == q.artistMBID {
+	// Level 2: Title + Artist MBID
+	if q.artistMBID != "" && mf.MbzArtistID == q.artistMBID {
 		return 2
 	}
-	if q.artist != "" && t.artist == q.artist {
+	// Level 1: Title + Artist name
+	if q.artist != "" && artist == q.artist {
 		return 1
 	}
-	if t.title == q.title {
+	// Level 0: Title only match (but for fuzzy, title matched via similarity)
+	// Check if at least the title matches exactly
+	if title == q.title {
 		return 0
 	}
-	return -1
+	return -1 // No exact title match, but could still be a fuzzy match
 }

 // loadTracksByTitleAndArtist loads tracks matching by title with optional artist/album filtering.
-func (m *Matcher) loadTracksByTitleAndArtist(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
-	queries := m.buildTitleQueries(songs, priorMatches...)
+// Uses a unified scoring approach that combines title similarity (Jaro-Winkler) with
+// metadata specificity (MBIDs, album names) for both exact and fuzzy matches.
+// Returns a map keyed by "title|artist" for compatibility with selectBestMatchingSongs.
+func (e *provider) loadTracksByTitleAndArtist(ctx context.Context, songs []agents.Song, priorMatches ...map[string]model.MediaFile) (map[string]model.MediaFile, error) {
+	queries := e.buildTitleQueries(songs, priorMatches...)
 	if len(queries) == 0 {
 		return map[string]model.MediaFile{}, nil
 	}

-	threshold := float64(conf.Server.Matcher.FuzzyThreshold) / 100.0
+	threshold := float64(conf.Server.SimilarSongsMatchThreshold) / 100.0

+	// Group queries by artist for efficient DB access
 	byArtist := map[string][]songQuery{}
 	for _, q := range queries {
 		if q.artist != "" {
@ -339,7 +332,8 @@ func (m *Matcher) loadTracksByTitleAndArtist(ctx context.Context, songs []agents

 	matches := map[string]model.MediaFile{}
 	for artist, artistQueries := range byArtist {
-		tracks, err := m.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		// Single DB query per artist - get all their tracks
+		tracks, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
 			Filters: squirrel.And{
 				squirrel.Eq{"order_artist_name": artist},
 				squirrel.Eq{"missing": false},
@ -350,13 +344,9 @@ func (m *Matcher) loadTracksByTitleAndArtist(ctx context.Context, songs []agents
 			continue
 		}

-		sanitized := make([]sanitizedTrack, len(tracks))
-		for i := range tracks {
-			sanitized[i] = newSanitizedTrack(&tracks[i])
-		}
-
+		// Find best match for each query using unified scoring
 		for _, q := range artistQueries {
-			if mf, found := m.findBestMatch(q, sanitized, threshold); found {
+			if mf, found := e.findBestMatch(q, tracks, threshold); found {
 				key := q.title + "|" + q.artist
 				if _, exists := matches[key]; !exists {
 					matches[key] = mf
@ -367,11 +357,13 @@ func (m *Matcher) loadTracksByTitleAndArtist(ctx context.Context, songs []agents
 	return matches, nil
 }

-// durationProximity returns a score from 0.0 to 1.0 indicating how close the track's duration
-// is to the target. Returns 1.0 if durationMs is 0 (unknown).
+// durationProximity returns a score from 0.0 to 1.0 indicating how close
+// the track's duration is to the target. A perfect match returns 1.0, and the
+// score decreases as the difference grows (using 1 / (1 + diff)). Returns 1.0
+// if durationMs is 0 (unknown), so duration does not influence scoring.
 func durationProximity(durationMs uint32, mediaFileDurationSec float32) float64 {
-	if durationMs == 0 {
-		return 1.0
+	if durationMs <= 0 {
+		return 1.0 // Unknown duration — don't penalise
 	}
 	durationSec := float64(durationMs) / 1000.0
 	diff := math.Abs(durationSec - float64(mediaFileDurationSec))
@ -379,46 +371,51 @@ func durationProximity(durationMs uint32, mediaFileDurationSec float32) float64
 }

 // findBestMatch finds the best matching track using combined title/album similarity and specificity scoring.
-func (m *Matcher) findBestMatch(q songQuery, sanitizedTracks []sanitizedTrack, threshold float64) (model.MediaFile, bool) {
+// A track must meet the threshold for title similarity, then the best match is chosen by:
+// 1. Highest title similarity
+// 2. Duration proximity (closer duration = higher score, 1.0 if unknown)
+// 3. Highest specificity level
+// 4. Highest album similarity (as final tiebreaker)
+func (e *provider) findBestMatch(q songQuery, tracks model.MediaFiles, threshold float64) (model.MediaFile, bool) {
 	var bestMatch model.MediaFile
 	bestScore := matchScore{titleSimilarity: -1}
 	found := false

-	for _, t := range sanitizedTracks {
-		titleSim := similarityRatio(q.title, t.title)
+	for _, mf := range tracks {
+		trackTitle := str.SanitizeFieldForSorting(mf.Title)
+		titleSim := similarityRatio(q.title, trackTitle)

 		if titleSim < threshold {
 			continue
 		}

+		// Compute album similarity for tiebreaking (0.0 if no album in query)
 		var albumSim float64
 		if q.album != "" {
-			albumSim = similarityRatio(q.album, t.album)
+			trackAlbum := str.SanitizeFieldForSorting(mf.Album)
+			albumSim = similarityRatio(q.album, trackAlbum)
 		}

 		score := matchScore{
 			titleSimilarity:   titleSim,
-			durationProximity: durationProximity(q.durationMs, t.mf.Duration),
-			preferredMatch:    conf.Server.Matcher.PreferStarred && isPreferredTrack(t.mf),
+			durationProximity: durationProximity(q.durationMs, mf.Duration),
 			albumSimilarity:   albumSim,
-			specificityLevel:  computeSpecificityLevel(q, t, threshold),
+			specificityLevel:  computeSpecificityLevel(q, mf, threshold),
 		}

 		if score.betterThan(bestScore) {
 			bestScore = score
-			bestMatch = *t.mf
+			bestMatch = mf
 			found = true
 		}
 	}
 	return bestMatch, found
 }

-func isPreferredTrack(mf *model.MediaFile) bool {
-	return mf.Starred || mf.Rating >= 4
-}
-
 // buildTitleQueries converts agent songs into normalized songQuery structs for title+artist matching.
-func (m *Matcher) buildTitleQueries(songs []agents.Song, priorMatches ...map[string]model.MediaFile) []songQuery {
+// It skips songs that have already been matched in prior phases (by ID, MBID, or ISRC) and sanitizes
+// all string fields for consistent comparison (lowercase, diacritics removed, articles stripped from artist names).
+func (e *provider) buildTitleQueries(songs []agents.Song, priorMatches ...map[string]model.MediaFile) []songQuery {
 	var queries []songQuery
 	for _, s := range songs {
 		if songMatchedIn(s, priorMatches...) {
@ -437,9 +434,18 @@ func (m *Matcher) buildTitleQueries(songs []agents.Song, priorMatches ...map[str
 }

 // selectBestMatchingSongs assembles the final result by mapping input songs to their best matching
-// library tracks using priority order: ID > MBID > ISRC > title+artist.
-func (m *Matcher) selectBestMatchingSongs(songs []agents.Song, byID, byMBID, byISRC, byTitleArtist map[string]model.MediaFile, count int) model.MediaFiles {
+// library tracks. It iterates through the input songs in order and selects the first available match
+// using priority order: ID > MBID > ISRC > title+artist.
+//
+// The function also handles deduplication: when multiple different input songs would match the same
+// library track (e.g., "Song (Live)" and "Song (Remastered)" both matching "Song (Live)" in the library),
+// only the first match is kept. However, if the same input song appears multiple times (intentional
+// repetition), duplicates are preserved in the output.
+//
+// Returns up to 'count' MediaFiles, preserving the input order. Songs that cannot be matched are skipped.
+func (e *provider) selectBestMatchingSongs(songs []agents.Song, byID, byMBID, byISRC, byTitleArtist map[string]model.MediaFile, count int) model.MediaFiles {
 	mfs := make(model.MediaFiles, 0, len(songs))
+	// Track MediaFile.ID -> input song that added it, for deduplication
 	addedBy := make(map[string]agents.Song, len(songs))

 	for _, t := range songs {
@ -452,9 +458,11 @@ func (m *Matcher) selectBestMatchingSongs(songs []agents.Song, byID, byMBID, byI
 			continue
 		}

+		// Check for duplicate library track
 		if prevSong, alreadyAdded := addedBy[mf.ID]; alreadyAdded {
+			// Only add duplicate if input songs are identical
 			if t != prevSong {
-				continue
+				continue // Different input songs → skip mismatch-induced duplicate
 			}
 		} else {
 			addedBy[mf.ID] = t
@ -465,11 +473,14 @@ func (m *Matcher) selectBestMatchingSongs(songs []agents.Song, byID, byMBID, byI
 	return mfs
 }

-// findMatchingTrack looks up a song in the match maps using priority order.
+// findMatchingTrack looks up a song in the match maps using priority order: ID > MBID > ISRC > title+artist.
+// Returns the matched MediaFile and true if found, or an empty MediaFile and false if no match exists.
 func findMatchingTrack(t agents.Song, byID, byMBID, byISRC, byTitleArtist map[string]model.MediaFile) (model.MediaFile, bool) {
+	// Try identifier-based matches first (ID, MBID, ISRC)
 	if mf, found := lookupByIdentifiers(t, byID, byMBID, byISRC); found {
 		return mf, true
 	}
+	// Fall back to title+artist fuzzy match
 	key := str.SanitizeFieldForSorting(t.Name) + "|" + str.SanitizeFieldForSortingNoArticle(t.Artist)
 	if mf, ok := byTitleArtist[key]; ok {
 		return mf, true
@ -478,6 +489,9 @@ func findMatchingTrack(t agents.Song, byID, byMBID, byISRC, byTitleArtist map[st
 }

 // similarityRatio calculates the similarity between two strings using Jaro-Winkler algorithm.
+// Returns a value between 0.0 (completely different) and 1.0 (identical).
+// Jaro-Winkler is well-suited for matching song titles because it gives higher scores
+// when strings share a common prefix (e.g., "Song Title" vs "Song Title - Remastered").
 func similarityRatio(a, b string) float64 {
 	if a == b {
 		return 1.0
@ -485,5 +499,6 @@ func similarityRatio(a, b string) float64 {
 	if len(a) == 0 || len(b) == 0 {
 		return 0.0
 	}
+	// JaroWinkler params: boostThreshold=0.7, prefixSize=4
 	return smetrics.JaroWinkler(a, b, 0.7, 4)
 }
--- a/core/external/provider_matching_internal_test.go
+++ b/core/external/provider_matching_internal_test.go
@ -1,4 +1,4 @@
-package matcher
+package external

 import (
 	. "github.com/onsi/ginkgo/v2"
@ -16,21 +16,25 @@ var _ = Describe("similarityRatio", func() {
 	})

 	It("returns high similarity for remastered suffix", func() {
+		// Jaro-Winkler gives ~0.92 for this case
 		ratio := similarityRatio("paranoid android", "paranoid android remastered")
 		Expect(ratio).To(BeNumerically(">=", 0.85))
 	})

 	It("returns high similarity for suffix additions like (Live)", func() {
+		// Jaro-Winkler gives ~0.96 for this case
 		ratio := similarityRatio("bohemian rhapsody", "bohemian rhapsody live")
 		Expect(ratio).To(BeNumerically(">=", 0.90))
 	})

 	It("returns high similarity for 'yesterday' variants (common prefix)", func() {
+		// Jaro-Winkler gives ~0.90 because of common prefix
 		ratio := similarityRatio("yesterday", "yesterday once more")
 		Expect(ratio).To(BeNumerically(">=", 0.85))
 	})

 	It("returns low similarity for same suffix", func() {
+		// Jaro-Winkler gives ~0.70 for this case
 		ratio := similarityRatio("postman (live)", "taxman (live)")
 		Expect(ratio).To(BeNumerically("<", 0.85))
 	})
--- a/core/external/provider_matching_test.go
+++ b/core/external/provider_matching_test.go
@ -0,0 +1,762 @@
+package external_test
+
+import (
+	"context"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/core/agents"
+	. "github.com/navidrome/navidrome/core/external"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/stretchr/testify/mock"
+)
+
+var _ = Describe("Provider - Song Matching", func() {
+	var ds model.DataStore
+	var provider Provider
+	var agentsCombined *mockAgents
+	var artistRepo *mockArtistRepo
+	var mediaFileRepo *mockMediaFileRepo
+	var albumRepo *mockAlbumRepo
+	var ctx context.Context
+
+	BeforeEach(func() {
+		ctx = GinkgoT().Context()
+
+		artistRepo = newMockArtistRepo()
+		mediaFileRepo = newMockMediaFileRepo()
+		albumRepo = newMockAlbumRepo()
+
+		ds = &tests.MockDataStore{
+			MockedArtist:    artistRepo,
+			MockedMediaFile: mediaFileRepo,
+			MockedAlbum:     albumRepo,
+		}
+
+		agentsCombined = &mockAgents{}
+		provider = NewProvider(ds, agentsCombined)
+	})
+
+	// Shared helper for tests that only need artist track queries (no ID/MBID matching)
+	setupSimilarSongsExpectations := func(returnedSongs []agents.Song, artistTracks model.MediaFiles) {
+		agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+			Return(returnedSongs, nil).Once()
+
+		// loadTracksByTitleAndArtist - queries by artist name
+		mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			and, ok := opt.Filters.(squirrel.And)
+			if !ok || len(and) < 2 {
+				return false
+			}
+			eq, hasEq := and[0].(squirrel.Eq)
+			if !hasEq {
+				return false
+			}
+			_, hasArtist := eq["order_artist_name"]
+			return hasArtist
+		})).Return(artistTracks, nil).Maybe()
+	}
+
+	Describe("matchSongsToLibrary priority matching", func() {
+		var track model.MediaFile
+
+		BeforeEach(func() {
+			DeferCleanup(configtest.SetupConfig())
+			// Disable fuzzy matching for these tests to avoid unexpected GetAll calls
+			conf.Server.SimilarSongsMatchThreshold = 100
+
+			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist", MbzRecordingID: ""}
+
+			// Setup for GetEntityByID to return the track
+			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
+		})
+
+		setupExpectations := func(returnedSongs []agents.Song, idMatches, mbidMatches, artistTracks model.MediaFiles) {
+			agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+				Return(returnedSongs, nil).Once()
+
+			// loadTracksByID
+			mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+				_, ok := opt.Filters.(squirrel.Eq)
+				return ok
+			})).Return(idMatches, nil).Once()
+
+			// loadTracksByMBID
+			mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+				and, ok := opt.Filters.(squirrel.And)
+				if !ok || len(and) < 1 {
+					return false
+				}
+				eq, hasEq := and[0].(squirrel.Eq)
+				if !hasEq {
+					return false
+				}
+				_, hasMBID := eq["mbz_recording_id"]
+				return hasMBID
+			})).Return(mbidMatches, nil).Once()
+
+			// loadTracksByTitleAndArtist - now queries by artist name
+			mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+				and, ok := opt.Filters.(squirrel.And)
+				if !ok || len(and) < 2 {
+					return false
+				}
+				eq, hasEq := and[0].(squirrel.Eq)
+				if !hasEq {
+					return false
+				}
+				_, hasArtist := eq["order_artist_name"]
+				return hasArtist
+			})).Return(artistTracks, nil).Maybe()
+		}
+
+		Context("when agent returns artist and album metadata", func() {
+			It("matches by title + artist MBID + album MBID (highest priority)", func() {
+				// Song in library with all MBIDs
+				correctMatch := model.MediaFile{
+					ID: "correct-match", Title: "Similar Song", Artist: "Depeche Mode", Album: "Violator",
+					MbzArtistID: "artist-mbid-123", MbzAlbumID: "album-mbid-456",
+				}
+				// Another song with same title but different MBIDs (should NOT match)
+				wrongMatch := model.MediaFile{
+					ID: "wrong-match", Title: "Similar Song", Artist: "Depeche Mode", Album: "Some Other Album",
+					MbzArtistID: "artist-mbid-123", MbzAlbumID: "different-album-mbid",
+				}
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Depeche Mode", ArtistMBID: "artist-mbid-123", Album: "Violator", AlbumMBID: "album-mbid-456"},
+				}
+
+				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{wrongMatch, correctMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("correct-match"))
+			})
+
+			It("matches by title + artist name + album name when MBIDs unavailable", func() {
+				// Song in library without MBIDs but with matching artist/album names
+				correctMatch := model.MediaFile{
+					ID: "correct-match", Title: "Similar Song", Artist: "depeche mode", Album: "violator",
+				}
+				// Another song with same title but different artist (should NOT match)
+				wrongMatch := model.MediaFile{
+					ID: "wrong-match", Title: "Similar Song", Artist: "Other Artist", Album: "Other Album",
+				}
+
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Depeche Mode", Album: "Violator"}, // No MBIDs
+				}
+
+				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{wrongMatch, correctMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("correct-match"))
+			})
+
+			It("matches by title + artist only when album info unavailable", func() {
+				// Song in library with matching artist
+				correctMatch := model.MediaFile{
+					ID: "correct-match", Title: "Similar Song", Artist: "depeche mode", Album: "Some Album",
+				}
+				// Another song with same title but different artist
+				wrongMatch := model.MediaFile{
+					ID: "wrong-match", Title: "Similar Song", Artist: "Other Artist", Album: "Other Album",
+				}
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Depeche Mode"}, // No album info
+				}
+
+				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{wrongMatch, correctMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("correct-match"))
+			})
+
+			It("does not match songs without artist info", func() {
+				// Songs without artist info cannot be matched since we query by artist
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song"}, // No artist/album info at all
+				}
+
+				// No artist to query, so no GetAll calls for title matching
+				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(BeEmpty())
+			})
+		})
+
+		Context("when matching multiple songs with the same title but different artists", func() {
+			It("returns distinct matches for each artist's version (covers scenario)", func() {
+				// Multiple covers of the same song by different artists
+				cover1 := model.MediaFile{
+					ID: "cover-1", Title: "Yesterday", Artist: "The Beatles", Album: "Help!",
+				}
+				cover2 := model.MediaFile{
+					ID: "cover-2", Title: "Yesterday", Artist: "Ray Charles", Album: "Greatest Hits",
+				}
+				cover3 := model.MediaFile{
+					ID: "cover-3", Title: "Yesterday", Artist: "Frank Sinatra", Album: "My Way",
+				}
+
+				returnedSongs := []agents.Song{
+					{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},
+					{Name: "Yesterday", Artist: "Ray Charles", Album: "Greatest Hits"},
+					{Name: "Yesterday", Artist: "Frank Sinatra", Album: "My Way"},
+				}
+
+				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{cover1, cover2, cover3})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				// All three covers should be returned, not just the first one
+				Expect(songs).To(HaveLen(3))
+				// Verify all three different versions are included
+				ids := []string{songs[0].ID, songs[1].ID, songs[2].ID}
+				Expect(ids).To(ContainElements("cover-1", "cover-2", "cover-3"))
+			})
+		})
+
+		Context("when matching multiple songs with different precision levels", func() {
+			It("prefers more precise matches for each song", func() {
+				// Library has multiple versions of same song
+				preciseMatch := model.MediaFile{
+					ID: "precise", Title: "Song A", Artist: "Artist One", Album: "Album One",
+					MbzArtistID: "mbid-1", MbzAlbumID: "album-mbid-1",
+				}
+				lessAccurateMatch := model.MediaFile{
+					ID: "less-accurate", Title: "Song A", Artist: "Artist One", Album: "Compilation",
+					MbzArtistID: "mbid-1",
+				}
+				artistTwoMatch := model.MediaFile{
+					ID: "artist-two", Title: "Song B", Artist: "Artist Two",
+				}
+
+				returnedSongs := []agents.Song{
+					{Name: "Song A", Artist: "Artist One", ArtistMBID: "mbid-1", Album: "Album One", AlbumMBID: "album-mbid-1"},
+					{Name: "Song B", Artist: "Artist Two"}, // Different artist
+				}
+
+				setupExpectations(returnedSongs, model.MediaFiles{}, model.MediaFiles{}, model.MediaFiles{lessAccurateMatch, preciseMatch, artistTwoMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(2))
+				// First song should be the precise match (has all MBIDs)
+				Expect(songs[0].ID).To(Equal("precise"))
+				// Second song matches by title + artist
+				Expect(songs[1].ID).To(Equal("artist-two"))
+			})
+		})
+	})
+
+	Describe("Fuzzy matching fallback", func() {
+		var track model.MediaFile
+
+		BeforeEach(func() {
+			DeferCleanup(configtest.SetupConfig())
+			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist"}
+
+			// Setup for GetEntityByID to return the track
+			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
+		})
+
+		Context("with default threshold (85%)", func() {
+			It("matches songs with remastered suffix", func() {
+				conf.Server.SimilarSongsMatchThreshold = 85
+
+				// Agent returns "Paranoid Android" but library has "Paranoid Android - Remastered"
+				returnedSongs := []agents.Song{
+					{Name: "Paranoid Android", Artist: "Radiohead"},
+				}
+				// Artist catalog has the remastered version (fuzzy match will find it)
+				artistTracks := model.MediaFiles{
+					{ID: "remastered", Title: "Paranoid Android - Remastered", Artist: "Radiohead"},
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, artistTracks)
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("remastered"))
+			})
+
+			It("matches songs with live suffix", func() {
+				conf.Server.SimilarSongsMatchThreshold = 85
+
+				returnedSongs := []agents.Song{
+					{Name: "Bohemian Rhapsody", Artist: "Queen"},
+				}
+				artistTracks := model.MediaFiles{
+					{ID: "live", Title: "Bohemian Rhapsody (Live)", Artist: "Queen"},
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, artistTracks)
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("live"))
+			})
+
+			It("does not match completely different songs", func() {
+				conf.Server.SimilarSongsMatchThreshold = 85
+
+				returnedSongs := []agents.Song{
+					{Name: "Yesterday", Artist: "The Beatles"},
+				}
+				// Artist catalog has completely different songs
+				artistTracks := model.MediaFiles{
+					{ID: "different", Title: "Tomorrow Never Knows", Artist: "The Beatles"},
+					{ID: "different2", Title: "Here Comes The Sun", Artist: "The Beatles"},
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, artistTracks)
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(BeEmpty())
+			})
+		})
+
+		Context("with threshold set to 100 (exact match only)", func() {
+			It("only matches exact titles", func() {
+				conf.Server.SimilarSongsMatchThreshold = 100
+
+				returnedSongs := []agents.Song{
+					{Name: "Paranoid Android", Artist: "Radiohead"},
+				}
+				// Artist catalog has only remastered version - no exact match
+				artistTracks := model.MediaFiles{
+					{ID: "remastered", Title: "Paranoid Android - Remastered", Artist: "Radiohead"},
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, artistTracks)
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(BeEmpty())
+			})
+		})
+
+		Context("with lower threshold (75%)", func() {
+			It("matches more aggressively", func() {
+				conf.Server.SimilarSongsMatchThreshold = 75
+
+				returnedSongs := []agents.Song{
+					{Name: "Song", Artist: "Artist"},
+				}
+				artistTracks := model.MediaFiles{
+					{ID: "extended", Title: "Song (Extended Mix)", Artist: "Artist"},
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, artistTracks)
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("extended"))
+			})
+		})
+
+		Context("with fuzzy album matching", func() {
+			It("matches album with (Remaster) suffix", func() {
+				conf.Server.SimilarSongsMatchThreshold = 85
+
+				// Agent returns "A Night at the Opera" but library has remastered version
+				returnedSongs := []agents.Song{
+					{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
+				}
+				// Library has same album with remaster suffix
+				correctMatch := model.MediaFile{
+					ID: "correct", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera (2011 Remaster)",
+				}
+				wrongMatch := model.MediaFile{
+					ID: "wrong", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "Greatest Hits",
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{wrongMatch, correctMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				// Should prefer the fuzzy album match (Level 3) over title+artist only (Level 1)
+				Expect(songs[0].ID).To(Equal("correct"))
+			})
+
+			It("matches album with (Deluxe Edition) suffix", func() {
+				conf.Server.SimilarSongsMatchThreshold = 85
+
+				returnedSongs := []agents.Song{
+					{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
+				}
+				correctMatch := model.MediaFile{
+					ID: "correct", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator (Deluxe Edition)",
+				}
+				wrongMatch := model.MediaFile{
+					ID: "wrong", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "101",
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{wrongMatch, correctMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("correct"))
+			})
+
+			It("prefers exact album match over fuzzy album match", func() {
+				conf.Server.SimilarSongsMatchThreshold = 85
+
+				returnedSongs := []agents.Song{
+					{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
+				}
+				exactMatch := model.MediaFile{
+					ID: "exact", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator",
+				}
+				fuzzyMatch := model.MediaFile{
+					ID: "fuzzy", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator (Deluxe Edition)",
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{fuzzyMatch, exactMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				// Both have same title similarity (1.0), so should prefer exact album match (higher specificity via higher album similarity)
+				Expect(songs[0].ID).To(Equal("exact"))
+			})
+		})
+	})
+
+	Describe("Duration matching", func() {
+		var track model.MediaFile
+
+		BeforeEach(func() {
+			DeferCleanup(configtest.SetupConfig())
+			conf.Server.SimilarSongsMatchThreshold = 100 // Exact title match for predictable tests
+
+			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist"}
+
+			// Setup for GetEntityByID to return the track
+			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
+		})
+
+		Context("when agent provides duration", func() {
+			It("prefers tracks with matching duration", func() {
+				// Agent returns song with duration 180000ms (180 seconds)
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
+				}
+				// Library has two versions: one matching duration, one not
+				correctMatch := model.MediaFile{
+					ID: "correct", Title: "Similar Song", Artist: "Test Artist", Duration: 180.0,
+				}
+				wrongDuration := model.MediaFile{
+					ID: "wrong", Title: "Similar Song", Artist: "Test Artist", Duration: 240.0,
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{wrongDuration, correctMatch})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("correct"))
+			})
+
+			It("matches tracks with close duration", func() {
+				// Agent returns song with duration 180000ms (180 seconds)
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
+				}
+				// Library has track with 182.5 seconds (close to target)
+				closeDuration := model.MediaFile{
+					ID: "close-duration", Title: "Similar Song", Artist: "Test Artist", Duration: 182.5,
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{closeDuration})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("close-duration"))
+			})
+
+			It("prefers closer duration over farther duration", func() {
+				// Agent returns song with duration 180000ms (180 seconds)
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
+				}
+				// Library has one close, one far
+				closeDuration := model.MediaFile{
+					ID: "close", Title: "Similar Song", Artist: "Test Artist", Duration: 181.0,
+				}
+				farDuration := model.MediaFile{
+					ID: "far", Title: "Similar Song", Artist: "Test Artist", Duration: 190.0,
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{farDuration, closeDuration})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("close"))
+			})
+
+			It("still matches when no tracks have matching duration", func() {
+				// Agent returns song with duration 180000ms
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
+				}
+				// Library only has tracks with very different duration
+				differentDuration := model.MediaFile{
+					ID: "different", Title: "Similar Song", Artist: "Test Artist", Duration: 300.0,
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{differentDuration})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				// Duration mismatch doesn't exclude the track; it's just scored lower
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("different"))
+			})
+
+			It("prefers title match over duration match when titles differ", func() {
+				// Agent returns "Similar Song" with duration 180000ms
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
+				}
+				// Library has:
+				// - differentTitle: matches duration but has different title (won't pass title threshold)
+				// - correctTitle: doesn't match duration but has correct title (wins on title similarity)
+				differentTitle := model.MediaFile{
+					ID: "wrong-title", Title: "Different Song", Artist: "Test Artist", Duration: 180.0,
+				}
+				correctTitle := model.MediaFile{
+					ID: "correct-title", Title: "Similar Song", Artist: "Test Artist", Duration: 300.0,
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{differentTitle, correctTitle})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				// Title similarity is the top priority, so the correct title wins despite duration mismatch
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("correct-title"))
+			})
+		})
+
+		Context("when agent does not provide duration", func() {
+			It("matches without duration filtering (duration=0)", func() {
+				// Agent returns song without duration
+				returnedSongs := []agents.Song{
+					{Name: "Similar Song", Artist: "Test Artist", Duration: 0},
+				}
+				// Library tracks with various durations should all be candidates
+				anyTrack := model.MediaFile{
+					ID: "any", Title: "Similar Song", Artist: "Test Artist", Duration: 999.0,
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{anyTrack})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("any"))
+			})
+		})
+
+		Context("edge cases", func() {
+			It("handles very short songs with close duration", func() {
+				// 30-second song with 1-second difference
+				returnedSongs := []agents.Song{
+					{Name: "Short Song", Artist: "Test Artist", Duration: 30000},
+				}
+				shortTrack := model.MediaFile{
+					ID: "short", Title: "Short Song", Artist: "Test Artist", Duration: 31.0,
+				}
+
+				setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{shortTrack})
+
+				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(songs).To(HaveLen(1))
+				Expect(songs[0].ID).To(Equal("short"))
+			})
+		})
+	})
+
+	Describe("Deduplication of mismatched songs", func() {
+		var track model.MediaFile
+
+		BeforeEach(func() {
+			DeferCleanup(configtest.SetupConfig())
+			conf.Server.SimilarSongsMatchThreshold = 85 // Allow fuzzy matching
+
+			track = model.MediaFile{ID: "track-1", Title: "Test Track", Artist: "Test Artist"}
+
+			// Setup for GetEntityByID to return the track
+			artistRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			albumRepo.On("Get", "track-1").Return(nil, model.ErrNotFound).Once()
+			mediaFileRepo.On("Get", "track-1").Return(&track, nil).Once()
+		})
+
+		It("removes duplicates when different input songs match the same library track", func() {
+			// Agent returns two different versions that will both fuzzy-match to the same library track
+			returnedSongs := []agents.Song{
+				{Name: "Bohemian Rhapsody (Live)", Artist: "Queen"},
+				{Name: "Bohemian Rhapsody (Original Mix)", Artist: "Queen"},
+			}
+			// Library only has one version
+			libraryTrack := model.MediaFile{
+				ID: "br-live", Title: "Bohemian Rhapsody (Live)", Artist: "Queen",
+			}
+
+			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{libraryTrack})
+
+			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+			Expect(err).ToNot(HaveOccurred())
+			// Should only return one track, not two duplicates
+			Expect(songs).To(HaveLen(1))
+			Expect(songs[0].ID).To(Equal("br-live"))
+		})
+
+		It("preserves duplicates when identical input songs match the same library track", func() {
+			// Agent returns the exact same song twice (intentional repetition)
+			returnedSongs := []agents.Song{
+				{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
+				{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
+			}
+			// Library has matching track
+			libraryTrack := model.MediaFile{
+				ID: "br", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera",
+			}
+
+			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{libraryTrack})
+
+			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+			Expect(err).ToNot(HaveOccurred())
+			// Should return two tracks since input songs were identical
+			Expect(songs).To(HaveLen(2))
+			Expect(songs[0].ID).To(Equal("br"))
+			Expect(songs[1].ID).To(Equal("br"))
+		})
+
+		It("handles mixed scenario with both identical and different input songs", func() {
+			// Agent returns: Song A, Song B (different from A), Song A again (same as first)
+			// All three match to the same library track
+			returnedSongs := []agents.Song{
+				{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},
+				{Name: "Yesterday (Remastered)", Artist: "The Beatles", Album: "1"},        // Different version
+				{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},                 // Same as first
+				{Name: "Yesterday (Anthology)", Artist: "The Beatles", Album: "Anthology"}, // Another different version
+			}
+			// Library only has one version
+			libraryTrack := model.MediaFile{
+				ID: "yesterday", Title: "Yesterday", Artist: "The Beatles", Album: "Help!",
+			}
+
+			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{libraryTrack})
+
+			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+			Expect(err).ToNot(HaveOccurred())
+			// Should return 2 tracks:
+			// 1. First "Yesterday" (original)
+			// 2. Third "Yesterday" (same as first, so kept)
+			// Skip: Second "Yesterday (Remastered)" (different input, same library track)
+			// Skip: Fourth "Yesterday (Anthology)" (different input, same library track)
+			Expect(songs).To(HaveLen(2))
+			Expect(songs[0].ID).To(Equal("yesterday"))
+			Expect(songs[1].ID).To(Equal("yesterday"))
+		})
+
+		It("does not deduplicate songs that match different library tracks", func() {
+			// Agent returns different songs that match different library tracks
+			returnedSongs := []agents.Song{
+				{Name: "Song A", Artist: "Artist"},
+				{Name: "Song B", Artist: "Artist"},
+				{Name: "Song C", Artist: "Artist"},
+			}
+			// Library has all three songs
+			trackA := model.MediaFile{ID: "track-a", Title: "Song A", Artist: "Artist"}
+			trackB := model.MediaFile{ID: "track-b", Title: "Song B", Artist: "Artist"}
+			trackC := model.MediaFile{ID: "track-c", Title: "Song C", Artist: "Artist"}
+
+			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{trackA, trackB, trackC})
+
+			songs, err := provider.SimilarSongs(ctx, "track-1", 5)
+
+			Expect(err).ToNot(HaveOccurred())
+			// All three should be returned since they match different library tracks
+			Expect(songs).To(HaveLen(3))
+			Expect(songs[0].ID).To(Equal("track-a"))
+			Expect(songs[1].ID).To(Equal("track-b"))
+			Expect(songs[2].ID).To(Equal("track-c"))
+		})
+
+		It("respects count limit after deduplication", func() {
+			// Agent returns 4 songs: 2 unique + 2 that would create duplicates
+			returnedSongs := []agents.Song{
+				{Name: "Song A", Artist: "Artist"},
+				{Name: "Song A (Live)", Artist: "Artist"}, // Different, matches same track
+				{Name: "Song B", Artist: "Artist"},
+				{Name: "Song B (Remix)", Artist: "Artist"}, // Different, matches same track
+			}
+			trackA := model.MediaFile{ID: "track-a", Title: "Song A", Artist: "Artist"}
+			trackB := model.MediaFile{ID: "track-b", Title: "Song B", Artist: "Artist"}
+
+			setupSimilarSongsExpectations(returnedSongs, model.MediaFiles{trackA, trackB})
+
+			// Request only 2 songs
+			songs, err := provider.SimilarSongs(ctx, "track-1", 2)
+
+			Expect(err).ToNot(HaveOccurred())
+			// Should return exactly 2: Song A and Song B (skipping duplicates)
+			Expect(songs).To(HaveLen(2))
+			Expect(songs[0].ID).To(Equal("track-a"))
+			Expect(songs[1].ID).To(Equal("track-b"))
+		})
+	})
+})
--- a/core/external/provider_similarsongs_test.go
+++ b/core/external/provider_similarsongs_test.go
@ -7,7 +7,6 @@ import (
 	"github.com/Masterminds/squirrel"
 	"github.com/navidrome/navidrome/core/agents"
 	. "github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
@ -49,7 +48,7 @@ var _ = Describe("Provider - SimilarSongs", func() {
 			similarAgent:  mockSimilarAgent,
 		}

-		provider = NewProvider(ds, agentsCombined, matcher.New(ds))
+		provider = NewProvider(ds, agentsCombined)
 	})

 	Describe("dispatch by entity type", func() {
--- a/core/external/provider_topsongs_test.go
+++ b/core/external/provider_topsongs_test.go
@ -10,7 +10,6 @@ import (
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core/agents"
 	. "github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
@ -30,7 +29,7 @@ var _ = Describe("Provider - TopSongs", func() {
 	BeforeEach(func() {
 		DeferCleanup(configtest.SetupConfig())
 		// Disable fuzzy matching for these tests to avoid unexpected GetAll calls
-		conf.Server.Matcher.FuzzyThreshold = 100
+		conf.Server.SimilarSongsMatchThreshold = 100

 		ctx = GinkgoT().Context()

@ -45,7 +44,7 @@ var _ = Describe("Provider - TopSongs", func() {

 		ag = new(mockAgents)

-		p = NewProvider(ds, ag, matcher.New(ds))
+		p = NewProvider(ds, ag)
 	})

 	It("returns top songs for a known artist", func() {
--- a/core/external/provider_updatealbuminfo_test.go
+++ b/core/external/provider_updatealbuminfo_test.go
@ -8,7 +8,6 @@ import (
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core/agents"
 	"github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
@ -35,7 +34,7 @@ var _ = Describe("Provider - UpdateAlbumInfo", func() {
 		ctx = GinkgoT().Context()
 		ds = new(tests.MockDataStore)
 		ag = new(mockAgents)
-		p = external.NewProvider(ds, ag, matcher.New(ds))
+		p = external.NewProvider(ds, ag)
 		mockAlbumRepo = ds.Album(ctx).(*tests.MockAlbumRepo)
 		conf.Server.DevAlbumInfoTimeToLive = 1 * time.Hour
 	})
--- a/core/external/provider_updateartistinfo_test.go
+++ b/core/external/provider_updateartistinfo_test.go
@ -9,7 +9,6 @@ import (
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core/agents"
 	"github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
@ -38,7 +37,7 @@ var _ = Describe("Provider - UpdateArtistInfo", func() {
 		ctx = GinkgoT().Context()
 		ds = new(tests.MockDataStore)
 		ag = new(mockAgents)
-		p = external.NewProvider(ds, ag, matcher.New(ds))
+		p = external.NewProvider(ds, ag)
 		mockArtistRepo = ds.Artist(ctx).(*tests.MockArtistRepo)
 	})

--- a/core/ffmpeg/ffmpeg.go
+++ b/core/ffmpeg/ffmpeg.go
@ -49,7 +49,6 @@ type FFmpeg interface {
 	ProbeAudioStream(ctx context.Context, filePath string) (*AudioProbeResult, error)
 	CmdPath() (string, error)
 	IsAvailable() bool
-	IsProbeAvailable() bool
 	Version() string
 }

@ -225,19 +224,6 @@ func (e *ffmpeg) IsAvailable() bool {
 	return err == nil
 }

-func (e *ffmpeg) IsProbeAvailable() bool {
-	if _, err := ffmpegCmd(); err != nil {
-		return false
-	}
-	probeOnce.Do(func() {
-		probePath := ffprobePath(ffmpegPath)
-		if _, err := exec.LookPath(probePath); err == nil {
-			probeAvail = true
-		}
-	})
-	return probeAvail
-}
-
 // Version executes ffmpeg -version and extracts the version from the output.
 // Sample output: ffmpeg version 6.0 Copyright (c) 2000-2023 the FFmpeg developers
 func (e *ffmpeg) Version() string {
@ -387,7 +373,18 @@ func buildDynamicArgs(opts TranscodeOptions) []string {
 	if opts.BitRate > 0 {
 		args = append(args, "-b:a", strconv.Itoa(opts.BitRate)+"k")
 	}
-	args = injectDynamicAudioFlags(args, opts)
+	if opts.SampleRate > 0 {
+		args = append(args, "-ar", strconv.Itoa(opts.SampleRate))
+	}
+	if opts.Channels > 0 {
+		args = append(args, "-ac", strconv.Itoa(opts.Channels))
+	}
+	// Only pass -sample_fmt for lossless output formats where bit depth matters.
+	// Lossy codecs (mp3, aac, opus) handle sample format conversion internally,
+	// and passing interleaved formats like "s16" causes silent failures.
+	if opts.BitDepth >= 16 && isLosslessOutputFormat(opts.Format) {
+		args = append(args, "-sample_fmt", bitDepthToSampleFmt(opts.BitDepth))
+	}

 	args = append(args, "-v", "0")

@ -401,19 +398,12 @@ func buildDynamicArgs(opts TranscodeOptions) []string {

 // buildTemplateArgs handles user-customized command templates, with dynamic injection
 // of sample rate, channels, and bit depth when requested by the transcode decision.
-// Values in opts have already been clamped to codec limits upstream (see
-// core/stream/codec.go codecMax* helpers), so injecting them unconditionally is safe —
-// ffmpeg honors the last occurrence of a duplicate flag.
+// Note: these flags are injected unconditionally when non-zero, even if the template
+// already includes them. FFmpeg uses the last occurrence of duplicate flags.
 func buildTemplateArgs(opts TranscodeOptions) []string {
 	args := createFFmpegCommand(opts.Command, opts.FilePath, opts.BitRate, opts.Offset)
-	return injectDynamicAudioFlags(args, opts)
-}

-// injectDynamicAudioFlags appends -ar, -ac, and -sample_fmt flags based on opts.
-// Only passes -sample_fmt for lossless output formats where bit depth matters:
-// lossy codecs (mp3, aac, opus) handle sample format conversion internally, and
-// passing interleaved formats like "s16" causes silent failures.
-func injectDynamicAudioFlags(args []string, opts TranscodeOptions) []string {
+	// Dynamically inject -ar, -ac, and -sample_fmt before the output target
 	if opts.SampleRate > 0 {
 		args = injectBeforeOutput(args, "-ar", strconv.Itoa(opts.SampleRate))
 	}
@ -543,6 +533,4 @@ var (
 	ffOnce     sync.Once
 	ffmpegPath string
 	ffmpegErr  error
-	probeOnce  sync.Once
-	probeAvail bool
 )
--- a/core/lyrics/lyrics_test.go
+++ b/core/lyrics/lyrics_test.go
@ -10,7 +10,6 @@ import (
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core/lyrics"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
 	"github.com/navidrome/navidrome/utils"
 	"github.com/navidrome/navidrome/utils/gg"
 	. "github.com/onsi/ginkgo/v2"
@ -94,7 +93,6 @@ var _ = Describe("sources", func() {
 			var accessForbiddenFile string

 			BeforeEach(func() {
-				tests.SkipOnWindows("uses Unix file permission bits")
 				accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")

 				f, err := os.OpenFile(accessForbiddenFile, os.O_WRONLY|os.O_CREATE, 0222)
--- a/core/matcher/matcher_test.go
+++ b/core/matcher/matcher_test.go
@ -1,850 +0,0 @@
-package matcher_test
-
-import (
-	"context"
-	"errors"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/core/matcher"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"github.com/stretchr/testify/mock"
-)
-
-var _ = Describe("Matcher", func() {
-	var ds model.DataStore
-	var mediaFileRepo *mockMediaFileRepo
-	var ctx context.Context
-	var m *matcher.Matcher
-
-	BeforeEach(func() {
-		ctx = GinkgoT().Context()
-		DeferCleanup(configtest.SetupConfig())
-		mediaFileRepo = newMockMediaFileRepo()
-		DeferCleanup(func() {
-			mediaFileRepo.AssertExpectations(GinkgoT())
-		})
-		ds = &tests.MockDataStore{
-			MockedMediaFile: mediaFileRepo,
-		}
-		m = matcher.New(ds)
-	})
-
-	// Per-phase expectation helpers. Each `expect*Phase` registers a .Once() expectation
-	// that will fail the suite via AssertExpectations if the phase is NOT called. Tests
-	// use these to deterministically verify which matching phases fire. Phases that may
-	// or may not fire should use the `allow*Phase` variants instead, which register
-	// .Maybe() fallbacks.
-	expectIDPhase := func(matches model.MediaFiles) {
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInAnd("media_file.id"))).
-			Return(matches, nil).Once()
-	}
-	expectMBIDPhase := func(matches model.MediaFiles) {
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInAnd("mbz_recording_id"))).
-			Return(matches, nil).Once()
-	}
-	expectISRCPhase := func(matches model.MediaFiles) {
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInEq("missing"))).
-			Return(matches, nil).Once()
-	}
-
-	// allowOtherPhases installs .Maybe() catch-alls so phases that short-circuit (return
-	// early without hitting the DB) don't cause test failures for unexpected calls. Call
-	// this after expect*Phase for the phases the test actually wants to verify.
-	allowOtherPhases := func() {
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInAnd("media_file.id"))).
-			Return(model.MediaFiles{}, nil).Maybe()
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInAnd("mbz_recording_id"))).
-			Return(model.MediaFiles{}, nil).Maybe()
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInEq("missing"))).
-			Return(model.MediaFiles{}, nil).Maybe()
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInAnd("order_artist_name"))).
-			Return(model.MediaFiles{}, nil).Maybe()
-	}
-
-	// setupTitleOnlyExpectations is a convenience for fuzzy-match tests that only exercise
-	// the title+artist phase. The title phase uses .Maybe() because it may short-circuit
-	// when no songs have an artist.
-	setupTitleOnlyExpectations := func(artistTracks model.MediaFiles) {
-		mediaFileRepo.On("GetAll", mock.MatchedBy(matchFieldInAnd("order_artist_name"))).
-			Return(artistTracks, nil).Maybe()
-	}
-
-	Describe("MatchSongsToLibrary", func() {
-		Context("matching by direct ID", func() {
-			It("matches songs with an ID field to MediaFiles by ID", func() {
-				conf.Server.Matcher.FuzzyThreshold = 100
-				songs := []agents.Song{
-					{ID: "track-1", Name: "Some Song", Artist: "Some Artist"},
-				}
-				idMatch := model.MediaFile{
-					ID: "track-1", Title: "Some Song", Artist: "Some Artist",
-				}
-				expectIDPhase(model.MediaFiles{idMatch})
-				allowOtherPhases()
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("track-1"))
-			})
-		})
-
-		Context("matching by MBID", func() {
-			It("matches songs with MBID to tracks with matching mbz_recording_id", func() {
-				conf.Server.Matcher.FuzzyThreshold = 100
-				songs := []agents.Song{
-					{Name: "Paranoid Android", MBID: "abc-123", Artist: "Radiohead"},
-				}
-				mbidMatch := model.MediaFile{
-					ID: "track-mbid", Title: "Paranoid Android", Artist: "Radiohead",
-					MbzRecordingID: "abc-123",
-				}
-				expectMBIDPhase(model.MediaFiles{mbidMatch})
-				allowOtherPhases()
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("track-mbid"))
-			})
-		})
-
-		Context("matching by ISRC", func() {
-			It("matches songs with ISRC to tracks with matching ISRC tag", func() {
-				conf.Server.Matcher.FuzzyThreshold = 100
-				songs := []agents.Song{
-					{Name: "Paranoid Android", ISRC: "GBAYE0000351", Artist: "Radiohead"},
-				}
-				isrcMatch := model.MediaFile{
-					ID: "track-isrc", Title: "Paranoid Android", Artist: "Radiohead",
-					Tags: model.Tags{model.TagISRC: []string{"GBAYE0000351"}},
-				}
-				expectISRCPhase(model.MediaFiles{isrcMatch})
-				allowOtherPhases()
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("track-isrc"))
-			})
-		})
-
-		Context("fuzzy title+artist matching", func() {
-			It("matches songs by title and artist name", func() {
-				conf.Server.Matcher.FuzzyThreshold = 100
-				songs := []agents.Song{
-					{Name: "Enjoy the Silence", Artist: "Depeche Mode"},
-				}
-				titleMatch := model.MediaFile{
-					ID: "track-title", Title: "Enjoy the Silence", Artist: "Depeche Mode",
-				}
-				setupTitleOnlyExpectations(model.MediaFiles{titleMatch})
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("track-title"))
-			})
-
-			It("matches songs with fuzzy title similarity", func() {
-				conf.Server.Matcher.FuzzyThreshold = 85
-				songs := []agents.Song{
-					{Name: "Bohemian Rhapsody", Artist: "Queen"},
-				}
-				fuzzyMatch := model.MediaFile{
-					ID: "track-fuzzy", Title: "Bohemian Rhapsody (Live)", Artist: "Queen",
-				}
-				setupTitleOnlyExpectations(model.MediaFiles{fuzzyMatch})
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("track-fuzzy"))
-			})
-
-			It("does not match completely different titles", func() {
-				conf.Server.Matcher.FuzzyThreshold = 85
-				songs := []agents.Song{
-					{Name: "Yesterday", Artist: "The Beatles"},
-				}
-				differentTracks := model.MediaFiles{
-					{ID: "different", Title: "Tomorrow Never Knows", Artist: "The Beatles"},
-				}
-				setupTitleOnlyExpectations(differentTracks)
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(BeEmpty())
-			})
-		})
-
-		Context("deduplication", func() {
-			It("removes duplicates when different input songs match the same library track", func() {
-				conf.Server.Matcher.FuzzyThreshold = 85
-				songs := []agents.Song{
-					{Name: "Bohemian Rhapsody (Live)", Artist: "Queen"},
-					{Name: "Bohemian Rhapsody (Original Mix)", Artist: "Queen"},
-				}
-				libraryTrack := model.MediaFile{
-					ID: "br-live", Title: "Bohemian Rhapsody (Live)", Artist: "Queen",
-				}
-				setupTitleOnlyExpectations(model.MediaFiles{libraryTrack})
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("br-live"))
-			})
-
-			It("preserves duplicates when identical input songs match the same library track", func() {
-				conf.Server.Matcher.FuzzyThreshold = 85
-				songs := []agents.Song{
-					{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
-					{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
-				}
-				libraryTrack := model.MediaFile{
-					ID: "br", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera",
-				}
-				setupTitleOnlyExpectations(model.MediaFiles{libraryTrack})
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(2))
-				Expect(result[0].ID).To(Equal("br"))
-				Expect(result[1].ID).To(Equal("br"))
-			})
-		})
-
-		Context("priority ordering", func() {
-			It("prefers ID match over MBID match", func() {
-				conf.Server.Matcher.FuzzyThreshold = 100
-				// Song has both ID and MBID set. The matcher should resolve via ID
-				// and short-circuit the MBID phase entirely, so no MBID fetch should
-				// occur even though an mbz_recording_id exists in the input.
-				songs := []agents.Song{
-					{ID: "track-id", Name: "Song", MBID: "mbid-1", Artist: "Artist"},
-				}
-				idMatch := model.MediaFile{
-					ID: "track-id", Title: "Song", Artist: "Artist",
-				}
-				expectIDPhase(model.MediaFiles{idMatch})
-				allowOtherPhases()
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("track-id"))
-			})
-		})
-
-		Context("count limit", func() {
-			It("returns at most 'count' results", func() {
-				conf.Server.Matcher.FuzzyThreshold = 100
-				songs := []agents.Song{
-					{Name: "Song A", Artist: "Artist"},
-					{Name: "Song B", Artist: "Artist"},
-					{Name: "Song C", Artist: "Artist"},
-				}
-				tracks := model.MediaFiles{
-					{ID: "a", Title: "Song A", Artist: "Artist"},
-					{ID: "b", Title: "Song B", Artist: "Artist"},
-					{ID: "c", Title: "Song C", Artist: "Artist"},
-				}
-				setupTitleOnlyExpectations(tracks)
-				result, err := m.MatchSongsToLibrary(ctx, songs, 2)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(2))
-			})
-		})
-
-		Context("empty input", func() {
-			It("returns empty results for no songs", func() {
-				result, err := m.MatchSongsToLibrary(ctx, []agents.Song{}, 5)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(BeEmpty())
-			})
-		})
-	})
-
-	Describe("specificity level matching", func() {
-		BeforeEach(func() {
-			conf.Server.Matcher.FuzzyThreshold = 100
-		})
-
-		It("matches by title + artist MBID + album MBID (highest priority)", func() {
-			correctMatch := model.MediaFile{
-				ID: "correct-match", Title: "Similar Song", Artist: "Depeche Mode", Album: "Violator",
-				MbzArtistID: "artist-mbid-123", MbzAlbumID: "album-mbid-456",
-			}
-			wrongMatch := model.MediaFile{
-				ID: "wrong-match", Title: "Similar Song", Artist: "Depeche Mode", Album: "Some Other Album",
-				MbzArtistID: "artist-mbid-123", MbzAlbumID: "different-album-mbid",
-			}
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Depeche Mode", ArtistMBID: "artist-mbid-123", Album: "Violator", AlbumMBID: "album-mbid-456"},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{wrongMatch, correctMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("correct-match"))
-		})
-
-		It("matches by title + artist name + album name when MBIDs unavailable", func() {
-			correctMatch := model.MediaFile{
-				ID: "correct-match", Title: "Similar Song", Artist: "depeche mode", Album: "violator",
-			}
-			wrongMatch := model.MediaFile{
-				ID: "wrong-match", Title: "Similar Song", Artist: "Other Artist", Album: "Other Album",
-			}
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Depeche Mode", Album: "Violator"},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{wrongMatch, correctMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("correct-match"))
-		})
-
-		It("matches by title + artist only when album info unavailable", func() {
-			correctMatch := model.MediaFile{
-				ID: "correct-match", Title: "Similar Song", Artist: "depeche mode", Album: "Some Album",
-			}
-			wrongMatch := model.MediaFile{
-				ID: "wrong-match", Title: "Similar Song", Artist: "Other Artist", Album: "Other Album",
-			}
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Depeche Mode"},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{wrongMatch, correctMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("correct-match"))
-		})
-
-		It("does not match songs without artist info", func() {
-			songs := []agents.Song{
-				{Name: "Similar Song"},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(BeEmpty())
-		})
-
-		It("returns distinct matches for each artist's version (covers scenario)", func() {
-			cover1 := model.MediaFile{ID: "cover-1", Title: "Yesterday", Artist: "The Beatles", Album: "Help!"}
-			cover2 := model.MediaFile{ID: "cover-2", Title: "Yesterday", Artist: "Ray Charles", Album: "Greatest Hits"}
-			cover3 := model.MediaFile{ID: "cover-3", Title: "Yesterday", Artist: "Frank Sinatra", Album: "My Way"}
-
-			songs := []agents.Song{
-				{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},
-				{Name: "Yesterday", Artist: "Ray Charles", Album: "Greatest Hits"},
-				{Name: "Yesterday", Artist: "Frank Sinatra", Album: "My Way"},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{cover1, cover2, cover3})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(3))
-			ids := []string{result[0].ID, result[1].ID, result[2].ID}
-			Expect(ids).To(ContainElements("cover-1", "cover-2", "cover-3"))
-		})
-
-		It("prefers more precise matches for each song", func() {
-			preciseMatch := model.MediaFile{
-				ID: "precise", Title: "Song A", Artist: "Artist One", Album: "Album One",
-				MbzArtistID: "mbid-1", MbzAlbumID: "album-mbid-1",
-			}
-			lessAccurateMatch := model.MediaFile{
-				ID: "less-accurate", Title: "Song A", Artist: "Artist One", Album: "Compilation",
-				MbzArtistID: "mbid-1",
-			}
-			artistTwoMatch := model.MediaFile{
-				ID: "artist-two", Title: "Song B", Artist: "Artist Two",
-			}
-
-			songs := []agents.Song{
-				{Name: "Song A", Artist: "Artist One", ArtistMBID: "mbid-1", Album: "Album One", AlbumMBID: "album-mbid-1"},
-				{Name: "Song B", Artist: "Artist Two"},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{lessAccurateMatch, preciseMatch, artistTwoMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(2))
-			Expect(result[0].ID).To(Equal("precise"))
-			Expect(result[1].ID).To(Equal("artist-two"))
-		})
-	})
-
-	Describe("fuzzy matching thresholds", func() {
-		Context("with default threshold (85%)", func() {
-			It("matches songs with remastered suffix", func() {
-				conf.Server.Matcher.FuzzyThreshold = 85
-
-				songs := []agents.Song{
-					{Name: "Paranoid Android", Artist: "Radiohead"},
-				}
-				artistTracks := model.MediaFiles{
-					{ID: "remastered", Title: "Paranoid Android - Remastered", Artist: "Radiohead"},
-				}
-
-				setupTitleOnlyExpectations(artistTracks)
-
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("remastered"))
-			})
-
-			It("matches songs with live suffix", func() {
-				conf.Server.Matcher.FuzzyThreshold = 85
-
-				songs := []agents.Song{
-					{Name: "Bohemian Rhapsody", Artist: "Queen"},
-				}
-				artistTracks := model.MediaFiles{
-					{ID: "live", Title: "Bohemian Rhapsody (Live)", Artist: "Queen"},
-				}
-
-				setupTitleOnlyExpectations(artistTracks)
-
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("live"))
-			})
-		})
-
-		Context("with threshold set to 100 (exact match only)", func() {
-			It("only matches exact titles", func() {
-				conf.Server.Matcher.FuzzyThreshold = 100
-
-				songs := []agents.Song{
-					{Name: "Paranoid Android", Artist: "Radiohead"},
-				}
-				artistTracks := model.MediaFiles{
-					{ID: "remastered", Title: "Paranoid Android - Remastered", Artist: "Radiohead"},
-				}
-
-				setupTitleOnlyExpectations(artistTracks)
-
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(BeEmpty())
-			})
-		})
-
-		Context("with lower threshold (75%)", func() {
-			It("matches more aggressively", func() {
-				conf.Server.Matcher.FuzzyThreshold = 75
-
-				songs := []agents.Song{
-					{Name: "Song", Artist: "Artist"},
-				}
-				artistTracks := model.MediaFiles{
-					{ID: "extended", Title: "Song (Extended Mix)", Artist: "Artist"},
-				}
-
-				setupTitleOnlyExpectations(artistTracks)
-
-				result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(HaveLen(1))
-				Expect(result[0].ID).To(Equal("extended"))
-			})
-		})
-	})
-
-	Describe("fuzzy album matching", func() {
-		BeforeEach(func() {
-			conf.Server.Matcher.FuzzyThreshold = 85
-			conf.Server.Matcher.PreferStarred = false
-		})
-
-		It("matches album with (Remaster) suffix", func() {
-			songs := []agents.Song{
-				{Name: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera"},
-			}
-			correctMatch := model.MediaFile{
-				ID: "correct", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "A Night at the Opera (2011 Remaster)",
-			}
-			wrongMatch := model.MediaFile{
-				ID: "wrong", Title: "Bohemian Rhapsody", Artist: "Queen", Album: "Greatest Hits",
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{wrongMatch, correctMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("correct"))
-		})
-
-		It("matches album with (Deluxe Edition) suffix", func() {
-			songs := []agents.Song{
-				{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
-			}
-			correctMatch := model.MediaFile{
-				ID: "correct", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator (Deluxe Edition)",
-			}
-			wrongMatch := model.MediaFile{
-				ID: "wrong", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "101",
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{wrongMatch, correctMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("correct"))
-		})
-
-		It("prefers exact album match over fuzzy album match", func() {
-			songs := []agents.Song{
-				{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
-			}
-			exactMatch := model.MediaFile{
-				ID: "exact", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator",
-			}
-			fuzzyMatch := model.MediaFile{
-				ID: "fuzzy", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator (Deluxe Edition)",
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{fuzzyMatch, exactMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("exact"))
-		})
-
-		It("prefers starred songs over better album match when enabled", func() {
-			conf.Server.Matcher.PreferStarred = true
-			songs := []agents.Song{
-				{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
-			}
-			albumMatch := model.MediaFile{
-				ID: "album-match", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator",
-			}
-			starredTrack := model.MediaFile{
-				ID: "starred", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Singles", Annotations: model.Annotations{Starred: true},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{albumMatch, starredTrack})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("starred"))
-		})
-
-		It("prefers 4-star songs over better album match when enabled", func() {
-			conf.Server.Matcher.PreferStarred = true
-			songs := []agents.Song{
-				{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
-			}
-			albumMatch := model.MediaFile{
-				ID: "album-match", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator",
-			}
-			ratedTrack := model.MediaFile{
-				ID: "rated", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Singles", Annotations: model.Annotations{Rating: 4},
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{albumMatch, ratedTrack})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("rated"))
-		})
-	})
-
-	Describe("duration matching", func() {
-		BeforeEach(func() {
-			conf.Server.Matcher.FuzzyThreshold = 100
-		})
-
-		It("prefers tracks with matching duration", func() {
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-			}
-			correctMatch := model.MediaFile{
-				ID: "correct", Title: "Similar Song", Artist: "Test Artist", Duration: 180.0,
-			}
-			wrongDuration := model.MediaFile{
-				ID: "wrong", Title: "Similar Song", Artist: "Test Artist", Duration: 240.0,
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{wrongDuration, correctMatch})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("correct"))
-		})
-
-		It("matches tracks with close duration", func() {
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-			}
-			closeDuration := model.MediaFile{
-				ID: "close-duration", Title: "Similar Song", Artist: "Test Artist", Duration: 182.5,
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{closeDuration})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("close-duration"))
-		})
-
-		It("prefers closer duration over farther duration", func() {
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-			}
-			closeDuration := model.MediaFile{
-				ID: "close", Title: "Similar Song", Artist: "Test Artist", Duration: 181.0,
-			}
-			farDuration := model.MediaFile{
-				ID: "far", Title: "Similar Song", Artist: "Test Artist", Duration: 190.0,
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{farDuration, closeDuration})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("close"))
-		})
-
-		It("still matches when no tracks have matching duration", func() {
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-			}
-			differentDuration := model.MediaFile{
-				ID: "different", Title: "Similar Song", Artist: "Test Artist", Duration: 300.0,
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{differentDuration})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("different"))
-		})
-
-		It("prefers title match over duration match when titles differ", func() {
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Test Artist", Duration: 180000},
-			}
-			differentTitle := model.MediaFile{
-				ID: "wrong-title", Title: "Different Song", Artist: "Test Artist", Duration: 180.0,
-			}
-			correctTitle := model.MediaFile{
-				ID: "correct-title", Title: "Similar Song", Artist: "Test Artist", Duration: 300.0,
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{differentTitle, correctTitle})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("correct-title"))
-		})
-
-		It("matches without duration filtering when agent duration is 0", func() {
-			songs := []agents.Song{
-				{Name: "Similar Song", Artist: "Test Artist", Duration: 0},
-			}
-			anyTrack := model.MediaFile{
-				ID: "any", Title: "Similar Song", Artist: "Test Artist", Duration: 999.0,
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{anyTrack})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("any"))
-		})
-
-		It("handles very short songs with close duration", func() {
-			songs := []agents.Song{
-				{Name: "Short Song", Artist: "Test Artist", Duration: 30000},
-			}
-			shortTrack := model.MediaFile{
-				ID: "short", Title: "Short Song", Artist: "Test Artist", Duration: 31.0,
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{shortTrack})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(1))
-			Expect(result[0].ID).To(Equal("short"))
-		})
-	})
-
-	Describe("deduplication edge cases", func() {
-		BeforeEach(func() {
-			conf.Server.Matcher.FuzzyThreshold = 85
-		})
-
-		It("handles mixed scenario with both identical and different input songs", func() {
-			songs := []agents.Song{
-				{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},
-				{Name: "Yesterday (Remastered)", Artist: "The Beatles", Album: "1"},
-				{Name: "Yesterday", Artist: "The Beatles", Album: "Help!"},
-				{Name: "Yesterday (Anthology)", Artist: "The Beatles", Album: "Anthology"},
-			}
-			libraryTrack := model.MediaFile{
-				ID: "yesterday", Title: "Yesterday", Artist: "The Beatles", Album: "Help!",
-			}
-
-			setupTitleOnlyExpectations(model.MediaFiles{libraryTrack})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(2))
-			Expect(result[0].ID).To(Equal("yesterday"))
-			Expect(result[1].ID).To(Equal("yesterday"))
-		})
-
-		It("does not deduplicate songs that match different library tracks", func() {
-			songs := []agents.Song{
-				{Name: "Song A", Artist: "Artist"},
-				{Name: "Song B", Artist: "Artist"},
-				{Name: "Song C", Artist: "Artist"},
-			}
-			trackA := model.MediaFile{ID: "track-a", Title: "Song A", Artist: "Artist"}
-			trackB := model.MediaFile{ID: "track-b", Title: "Song B", Artist: "Artist"}
-			trackC := model.MediaFile{ID: "track-c", Title: "Song C", Artist: "Artist"}
-
-			setupTitleOnlyExpectations(model.MediaFiles{trackA, trackB, trackC})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 5)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(3))
-			Expect(result[0].ID).To(Equal("track-a"))
-			Expect(result[1].ID).To(Equal("track-b"))
-			Expect(result[2].ID).To(Equal("track-c"))
-		})
-
-		It("respects count limit after deduplication", func() {
-			songs := []agents.Song{
-				{Name: "Song A", Artist: "Artist"},
-				{Name: "Song A (Live)", Artist: "Artist"},
-				{Name: "Song B", Artist: "Artist"},
-				{Name: "Song B (Remix)", Artist: "Artist"},
-			}
-			trackA := model.MediaFile{ID: "track-a", Title: "Song A", Artist: "Artist"}
-			trackB := model.MediaFile{ID: "track-b", Title: "Song B", Artist: "Artist"}
-
-			setupTitleOnlyExpectations(model.MediaFiles{trackA, trackB})
-
-			result, err := m.MatchSongsToLibrary(ctx, songs, 2)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(result).To(HaveLen(2))
-			Expect(result[0].ID).To(Equal("track-a"))
-			Expect(result[1].ID).To(Equal("track-b"))
-		})
-	})
-})
-
-type mockMediaFileRepo struct {
-	mock.Mock
-	model.MediaFileRepository
-}
-
-func newMockMediaFileRepo() *mockMediaFileRepo {
-	return &mockMediaFileRepo{}
-}
-
-func (m *mockMediaFileRepo) GetAll(options ...model.QueryOptions) (model.MediaFiles, error) {
-	argsSlice := make([]any, len(options))
-	for i, v := range options {
-		argsSlice[i] = v
-	}
-	args := m.Called(argsSlice...)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(model.MediaFiles), args.Error(1)
-}
-
-func (m *mockMediaFileRepo) GetAllByTags(_ model.TagName, _ []string, options ...model.QueryOptions) (model.MediaFiles, error) {
-	return m.GetAll(options...)
-}
-
-func (m *mockMediaFileRepo) SetError(hasError bool) {
-	if hasError {
-		m.On("GetAll", mock.Anything).Return(nil, errors.New("mock repo error"))
-	}
-}
-
-// matchFieldInAnd returns a matcher that checks whether QueryOptions.Filters is a
-// squirrel.And whose first element is a squirrel.Eq containing the given field name.
-func matchFieldInAnd(fieldName string) func(opt model.QueryOptions) bool {
-	return func(opt model.QueryOptions) bool {
-		and, ok := opt.Filters.(squirrel.And)
-		if !ok || len(and) < 2 {
-			return false
-		}
-		eq, hasEq := and[0].(squirrel.Eq)
-		if !hasEq {
-			return false
-		}
-		_, hasField := eq[fieldName]
-		return hasField
-	}
-}
-
-// matchFieldInEq returns a matcher that checks whether QueryOptions.Filters is a
-// squirrel.Eq containing the given field name.
-func matchFieldInEq(fieldName string) func(opt model.QueryOptions) bool {
-	return func(opt model.QueryOptions) bool {
-		eq, ok := opt.Filters.(squirrel.Eq)
-		if !ok {
-			return false
-		}
-		_, hasField := eq[fieldName]
-		return hasField
-	}
-}
--- a/core/metrics/insights.go
+++ b/core/metrics/insights.go
@ -195,8 +195,6 @@ var staticData = sync.OnceValue(func() insights.Data {
 	data.Config.EnableArtworkPrecache = conf.Server.EnableArtworkPrecache
 	data.Config.EnableArtworkUpload = conf.Server.EnableArtworkUpload
 	data.Config.CoverArtQuality = conf.Server.CoverArtQuality
-	data.Config.EnableWebPEncoding = conf.Server.EnableWebPEncoding
-	data.Config.UICoverArtSize = conf.Server.UICoverArtSize
 	data.Config.EnableCoverAnimation = conf.Server.EnableCoverAnimation
 	data.Config.EnableNowPlaying = conf.Server.EnableNowPlaying
 	data.Config.EnableDownloads = conf.Server.EnableDownloads
--- a/core/metrics/insights/data.go
+++ b/core/metrics/insights/data.go
@ -65,8 +65,6 @@ type Data struct {
 		EnablePrometheus        bool   `json:"enablePrometheus,omitempty"`
 		EnableArtworkUpload     bool   `json:"enableArtworkUpload,omitempty"`
 		CoverArtQuality         int    `json:"coverArtQuality,omitempty"`
-		EnableWebPEncoding      bool   `json:"enableWebPEncoding,omitempty"`
-		UICoverArtSize          int    `json:"uiCoverArtSize,omitempty"`
 		EnableCoverAnimation    bool   `json:"enableCoverAnimation,omitempty"`
 		EnableNowPlaying        bool   `json:"enableNowPlaying,omitempty"`
 		SessionTimeout          uint64 `json:"sessionTimeout,omitempty"`
--- a/core/playback/mpv/mpv_test.go
+++ b/core/playback/mpv/mpv_test.go
@ -14,7 +14,6 @@ import (
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@ -200,7 +199,6 @@ var _ = Describe("MPV", func() {
 		})

 		It("executes MPV command and captures arguments correctly", func() {
-			tests.SkipOnWindows("mpv binary not available in CI (#TBD-mpv-windows)")
 			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 			defer cancel()

@ -228,7 +226,6 @@ var _ = Describe("MPV", func() {
 		})

 		It("handles file paths with spaces", func() {
-			tests.SkipOnWindows("mpv binary not available in CI (#TBD-mpv-windows)")
 			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 			defer cancel()

@ -256,7 +253,6 @@ var _ = Describe("MPV", func() {
 			})

 			It("passes all snapcast arguments correctly", func() {
-				tests.SkipOnWindows("mpv binary not available in CI (#TBD-mpv-windows)")
 				ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 				defer cancel()

--- a/core/playlists/import_test.go
+++ b/core/playlists/import_test.go
@ -183,7 +183,6 @@ var _ = Describe("Playlists - Import", func() {
 			})

 			It("rejects #EXTALBUMARTURL with absolute path outside library boundaries", func() {
-				tests.SkipOnWindows("relies on Unix /etc filesystem")
 				tmpDir := GinkgoT().TempDir()

 				m3u := "#EXTALBUMARTURL:/etc/passwd\ntest.mp3\n"
@ -321,7 +320,6 @@ var _ = Describe("Playlists - Import", func() {
 				Expect(pls.Rules.Expression).To(BeAssignableToTypeOf(criteria.All{}))
 			})
 			It("returns an error if the playlist is not well-formed", func() {
-				tests.SkipOnWindows("line-ending differences affect JSON error offset")
 				_, err := ps.ImportFile(ctx, folder, "invalid_json.nsp")
 				Expect(err.Error()).To(ContainSubstring("line 19, column 1: invalid character '\\n'"))
 			})
@ -349,7 +347,6 @@ var _ = Describe("Playlists - Import", func() {

 		DescribeTable("Playlist filename Unicode normalization (regression fix-playlist-filename-normalization)",
 			func(storedForm, filesystemForm string) {
-				tests.SkipOnWindows("/tmp hardcoded in test")
 				// Use Polish characters that decompose: ó (U+00F3) -> o + combining acute (U+006F + U+0301)
 				plsNameNFC := "Piosenki_Polskie_zółć" // NFC form (composed)
 				plsNameNFD := norm.NFD.String(plsNameNFC)
@ -824,7 +821,6 @@ var _ = Describe("Playlists - Import", func() {
 		})

 		It("returns true if folder is in PlaylistsPath", func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-playlists)")
 			conf.Server.PlaylistsPath = "other/**:playlists/**"
 			Expect(playlists.InPath(folder)).To(BeTrue())
 		})
--- a/core/playlists/parse_m3u_test.go
+++ b/core/playlists/parse_m3u_test.go
@ -15,7 +15,6 @@ var _ = Describe("libraryMatcher", func() {
 	ctx := context.Background()

 	BeforeEach(func() {
-		tests.SkipOnWindows("path separator bug (#TBD-path-sep-playlists)")
 		mockLibRepo = &tests.MockLibraryRepo{}
 		ds = &tests.MockDataStore{
 			MockedLibrary: mockLibRepo,
@ -197,7 +196,6 @@ var _ = Describe("pathResolver", func() {
 	ctx := context.Background()

 	BeforeEach(func() {
-		tests.SkipOnWindows("path separator bug (#TBD-path-sep-playlists)")
 		mockLibRepo = &tests.MockLibraryRepo{}
 		ds = &tests.MockDataStore{
 			MockedLibrary: mockLibRepo,
--- a/core/publicurl/publicurl.go
+++ b/core/publicurl/publicurl.go
@ -45,9 +45,6 @@ func PublicURL(req *http.Request, u string, params url.Values) string {
 	}
 	buildUrl.Scheme = shareUrl.Scheme
 	buildUrl.Host = shareUrl.Host
-	if basePath := strings.TrimRight(shareUrl.Path, "/"); basePath != "" {
-		buildUrl.Path = path.Join(basePath, buildUrl.Path)
-	}
 	if len(params) > 0 {
 		buildUrl.RawQuery = params.Encode()
 	}
--- a/core/publicurl/publicurl_test.go
+++ b/core/publicurl/publicurl_test.go
@ -56,31 +56,6 @@ var _ = Describe("Public URL Utilities", func() {
 			})
 		})

-		When("ShareURL includes a path", func() {
-			BeforeEach(func() {
-				conf.Server.ShareURL = "https://example.com/navi"
-			})
-
-			It("prepends the ShareURL path to the resource", func() {
-				r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-				result := publicurl.PublicURL(r, "/share/img/hash", nil)
-				Expect(result).To(Equal("https://example.com/navi/share/img/hash"))
-			})
-
-			It("prepends the ShareURL path and includes query parameters", func() {
-				r, _ := http.NewRequest("GET", "http://localhost/test", nil)
-				params := url.Values{"size": []string{"600"}}
-				result := publicurl.PublicURL(r, "/share/img/hash", params)
-				Expect(result).To(Equal("https://example.com/navi/share/img/hash?size=600"))
-			})
-
-			It("handles trailing slash in ShareURL path", func() {
-				conf.Server.ShareURL = "https://example.com/navi/"
-				result := publicurl.PublicURL(nil, "/share/img/hash", nil)
-				Expect(result).To(Equal("https://example.com/navi/share/img/hash"))
-			})
-		})
-
 		When("ShareURL is not set", func() {
 			BeforeEach(func() {
 				conf.Server.ShareURL = ""
--- a/core/storage/local/local.go
+++ b/core/storage/local/local.go
@ -11,7 +11,6 @@ import (

 	"github.com/djherbis/times"
 	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core/storage"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model/metadata"
@ -29,13 +28,7 @@ type localStorage struct {
 func newLocalStorage(u url.URL) storage.Storage {
 	newExtractor, ok := extractors[conf.Server.Scanner.Extractor]
 	if !ok || newExtractor == nil {
-		if conf.Server.Scanner.Extractor != consts.DefaultScannerExtractor {
-			log.Warn("Extractor not found, using default", "extractor", conf.Server.Scanner.Extractor, "default", consts.DefaultScannerExtractor)
-		}
-		newExtractor = extractors[consts.DefaultScannerExtractor]
-		if newExtractor == nil {
-			log.Fatal("Default extractor not registered", "extractor", consts.DefaultScannerExtractor)
-		}
+		log.Fatal("Extractor not found", "path", conf.Server.Scanner.Extractor)
 	}
 	isWindowsPath := filepath.VolumeName(u.Host) != ""
 	if u.Scheme == storage.LocalSchemaID && isWindowsPath {
--- a/core/storage/local/local_test.go
+++ b/core/storage/local/local_test.go
@ -10,10 +10,8 @@ import (

 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core/storage"
 	"github.com/navidrome/navidrome/model/metadata"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@ -45,10 +43,6 @@ var _ = Describe("LocalStorage", func() {
 	})

 	Describe("newLocalStorage", func() {
-		BeforeEach(func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-storage-local)")
-		})
-
 		Context("with valid path", func() {
 			It("should create a localStorage instance with correct path", func() {
 				u, err := url.Parse("file://" + tempDir)
@ -141,40 +135,21 @@ var _ = Describe("LocalStorage", func() {
 			})
 		})

-		Context("when the configured extractor is not registered", func() {
-			var defaultExtractor *mockTestExtractor
-
-			BeforeEach(func() {
-				defaultExtractor = &mockTestExtractor{results: make(map[string]metadata.Info)}
-				RegisterExtractor(consts.DefaultScannerExtractor, func(fs.FS, string) Extractor {
-					return defaultExtractor
-				})
-				DeferCleanup(func() {
-					lock.Lock()
-					delete(extractors, consts.DefaultScannerExtractor)
-					lock.Unlock()
-				})
-			})
-
-			It("falls back to the default extractor instead of crashing", func() {
-				conf.Server.Scanner.Extractor = "nonexistent-extractor"
+		Context("with invalid extractor", func() {
+			It("should handle extractor validation correctly", func() {
+				// Note: The actual implementation uses log.Fatal which exits the process,
+				// so we test the normal path where extractors exist

 				u, err := url.Parse("file://" + tempDir)
 				Expect(err).ToNot(HaveOccurred())

 				storage := newLocalStorage(*u)
-				ls, ok := storage.(*localStorage)
-				Expect(ok).To(BeTrue())
-				Expect(ls.extractor).To(BeIdenticalTo(defaultExtractor))
+				Expect(storage).ToNot(BeNil())
 			})
 		})
 	})

 	Describe("localStorage.FS", func() {
-		BeforeEach(func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-storage-local)")
-		})
-
 		Context("with existing directory", func() {
 			It("should return a localFS instance", func() {
 				u, err := url.Parse("file://" + tempDir)
@ -208,7 +183,6 @@ var _ = Describe("LocalStorage", func() {
 		var testFile string

 		BeforeEach(func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-storage-local)")
 			// Create a test file
 			testFile = filepath.Join(tempDir, "test.mp3")
 			err := os.WriteFile(testFile, []byte("test data"), 0600)
@ -390,7 +364,6 @@ var _ = Describe("LocalStorage", func() {

 	Describe("Storage registration", func() {
 		It("should register localStorage for file scheme", func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-storage-local)")
 			// This tests the init() function indirectly
 			storage, err := storage.For("file://" + tempDir)
 			Expect(err).ToNot(HaveOccurred())
--- a/core/storage/storage_test.go
+++ b/core/storage/storage_test.go
@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"testing"

-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@ -55,7 +54,6 @@ var _ = Describe("Storage", func() {
 			Expect(s.(*fakeLocalStorage).u.Path).To(Equal("/tmp"))
 		})
 		It("should return a file implementation for a relative folder", func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-storage)")
 			s, err := For("tmp")
 			Expect(err).ToNot(HaveOccurred())
 			cwd, _ := os.Getwd()
--- a/core/stream/codec.go
+++ b/core/stream/codec.go
@ -75,16 +75,3 @@ func codecMaxSampleRate(codec string) int {
 	}
 	return 0
 }
-
-// codecMaxChannels returns the hard maximum number of audio channels a codec
-// supports. Returns 0 if the codec has no hard limit (or is unknown), in which
-// case the source/profile constraints applied upstream are authoritative.
-func codecMaxChannels(codec string) int {
-	switch strings.ToLower(codec) {
-	case "mp3":
-		return 2
-	case "opus":
-		return 8
-	}
-	return 0
-}
--- a/core/stream/codec_test.go
+++ b/core/stream/codec_test.go
@ -66,26 +66,4 @@ var _ = Describe("Codec", func() {
 			Expect(normalizeProbeCodec("DSD_LSBF_PLANAR")).To(Equal("dsd"))
 		})
 	})
-
-	Describe("codecMaxChannels", func() {
-		It("returns 2 for mp3", func() {
-			Expect(codecMaxChannels("mp3")).To(Equal(2))
-		})
-
-		It("returns 8 for opus", func() {
-			Expect(codecMaxChannels("opus")).To(Equal(8))
-		})
-
-		It("is case-insensitive", func() {
-			Expect(codecMaxChannels("MP3")).To(Equal(2))
-			Expect(codecMaxChannels("Opus")).To(Equal(8))
-		})
-
-		It("returns 0 for codecs with no hard limit", func() {
-			Expect(codecMaxChannels("aac")).To(Equal(0))
-			Expect(codecMaxChannels("flac")).To(Equal(0))
-			Expect(codecMaxChannels("vorbis")).To(Equal(0))
-			Expect(codecMaxChannels("")).To(Equal(0))
-		})
-	})
 })
--- a/core/stream/decider.go
+++ b/core/stream/decider.go
@ -44,14 +44,10 @@ func (s *deciderService) MakeDecision(ctx context.Context, mf *model.MediaFile,

 	var probe *ffmpeg.AudioProbeResult
 	if !opts.SkipProbe {
-		if !s.ff.IsProbeAvailable() {
-			log.Debug(ctx, "ffprobe not available, using tag metadata for transcode decision", "mediaID", mf.ID)
-		} else {
-			var err error
-			probe, err = s.ensureProbed(ctx, mf)
-			if err != nil {
-				return nil, err
-			}
+		var err error
+		probe, err = s.ensureProbed(ctx, mf)
+		if err != nil {
+			return nil, err
 		}
 	}

@ -199,17 +195,6 @@ func parseProbeData(data string) (*ffmpeg.AudioProbeResult, error) {
 	return &result, nil
 }

-// matchesPCMWAVBridge bridges Navidrome's internal "pcm" codec name with the
-// "wav" codec name that browsers use to advertise audio/wav support. The match
-// is scoped to WAV-container sources so AIFF files (which also normalize to
-// codec "pcm" but use a different container) cannot false-match a codec-only
-// ["wav"] profile.
-func matchesPCMWAVBridge(src *Details, profile *DirectPlayProfile) bool {
-	return strings.EqualFold(src.Codec, "pcm") &&
-		strings.EqualFold(src.Container, "wav") &&
-		containsIgnoreCase(profile.AudioCodecs, "wav")
-}
-
 // checkDirectPlayProfile returns "" if the profile matches (direct play OK),
 // or a typed reason string if it doesn't match.
 func (s *deciderService) checkDirectPlayProfile(src *Details, profile *DirectPlayProfile, clientInfo *ClientInfo) string {
@ -220,17 +205,17 @@ func (s *deciderService) checkDirectPlayProfile(src *Details, profile *DirectPla

 	// Check container
 	if len(profile.Containers) > 0 && !matchesContainer(src.Container, profile.Containers) {
-		return fmt.Sprintf("container '%s' not supported by profile %s", src.Container, profile)
+		return "container not supported"
 	}

 	// Check codec
-	if len(profile.AudioCodecs) > 0 && !matchesCodec(src.Codec, profile.AudioCodecs) && !matchesPCMWAVBridge(src, profile) {
-		return fmt.Sprintf("audio codec '%s' not supported by profile %s", src.Codec, profile)
+	if len(profile.AudioCodecs) > 0 && !matchesCodec(src.Codec, profile.AudioCodecs) {
+		return "audio codec not supported"
 	}

 	// Check channels
 	if profile.MaxAudioChannels > 0 && src.Channels > profile.MaxAudioChannels {
-		return fmt.Sprintf("audio channels %d not supported by profile %s (max %d)", src.Channels, profile, profile.MaxAudioChannels)
+		return "audio channels not supported"
 	}

 	// Check codec-specific limitations
@ -294,19 +279,14 @@ func (s *deciderService) computeTranscodedStream(ctx context.Context, src *Detai
 	if maxRate := codecMaxSampleRate(ts.Codec); maxRate > 0 && ts.SampleRate > maxRate {
 		ts.SampleRate = maxRate
 	}
-	if maxCh := codecMaxChannels(ts.Codec); maxCh > 0 && ts.Channels > maxCh {
-		ts.Channels = maxCh
-	}

 	// Determine target bitrate (all in kbps)
 	if ok := s.computeBitrate(ctx, src, targetFormat, targetIsLossless, clientInfo, ts); !ok {
 		return nil, ""
 	}

-	// Apply MaxAudioChannels from the transcoding profile. Compare against the
-	// already-clamped ts.Channels (not src.Channels) so the codec hard limit
-	// applied above is never raised by a looser profile setting.
-	if profile.MaxAudioChannels > 0 && ts.Channels > profile.MaxAudioChannels {
+	// Apply MaxAudioChannels from the transcoding profile
+	if profile.MaxAudioChannels > 0 && src.Channels > profile.MaxAudioChannels {
 		ts.Channels = profile.MaxAudioChannels
 	}

--- a/core/stream/decider_test.go
+++ b/core/stream/decider_test.go
@ -76,10 +76,7 @@ var _ = Describe("Decider", func() {
 				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
 				Expect(err).ToNot(HaveOccurred())
 				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement(And(
-					ContainSubstring("container 'flac' not supported"),
-					ContainSubstring("[mp3]"),
-				)))
+				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
 			})

 			It("rejects direct play when codec doesn't match", func() {
@ -92,10 +89,7 @@ var _ = Describe("Decider", func() {
 				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
 				Expect(err).ToNot(HaveOccurred())
 				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement(And(
-					ContainSubstring("audio codec 'alac' not supported"),
-					ContainSubstring("[m4a/aac]"),
-				)))
+				Expect(decision.TranscodeReasons).To(ContainElement("audio codec not supported"))
 			})

 			It("rejects direct play when channels exceed limit", func() {
@ -108,44 +102,7 @@ var _ = Describe("Decider", func() {
 				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
 				Expect(err).ToNot(HaveOccurred())
 				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement(And(
-					ContainSubstring("audio channels 6 not supported"),
-					ContainSubstring("[flac]"),
-					ContainSubstring("(max 2)"),
-				)))
-			})
-
-			It("accepts WAV source against a wav codec profile (pcm->wav bridge)", func() {
-				// ffprobe normalizes PCM variants (pcm_s16le etc) to codec "pcm", but
-				// browsers advertise WAV support as audioCodecs:["wav"] via audio/wav MIME.
-				mf := withProbe(&model.MediaFile{ID: "1", Suffix: "wav", Codec: "pcm", BitRate: 1411, Channels: 2})
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"wav"}, AudioCodecs: []string{"wav"}, Protocols: []string{ProtocolHTTP}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("does not accept AIFF (pcm in non-wav container) against a wav codec profile", func() {
-				// AIFF files also normalize to codec="pcm" but use container="aiff".
-				// Without the container guard they would falsely match a codec-only
-				// ["wav"] profile and be direct-played as if they were WAV.
-				mf := withProbe(&model.MediaFile{ID: "1", Suffix: "aiff", Codec: "pcm", BitRate: 1411, Channels: 2})
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{AudioCodecs: []string{"wav"}, Protocols: []string{ProtocolHTTP}},
-					},
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: ProtocolHTTP},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement(ContainSubstring("audio codec 'pcm'")))
+				Expect(decision.TranscodeReasons).To(ContainElement("audio channels not supported"))
 			})

 			It("handles container aliases (aac -> m4a)", func() {
@ -259,10 +216,7 @@ var _ = Describe("Decider", func() {
 				Expect(decision.CanTranscode).To(BeTrue())
 				Expect(decision.TargetFormat).To(Equal("mp3"))
 				Expect(decision.TargetBitrate).To(Equal(256)) // kbps
-				Expect(decision.TranscodeReasons).To(ContainElement(And(
-					ContainSubstring("container 'flac' not supported"),
-					ContainSubstring("[mp3]"),
-				)))
+				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
 			})

 			It("rejects lossy to lossless transcoding", func() {
@ -770,73 +724,6 @@ var _ = Describe("Decider", func() {
 			})
 		})

-		Context("Codec channel limits", func() {
-			It("clamps 6-channel FLAC to 2 channels when transcoding to MP3", func() {
-				// Regression test for #5336: ffmpeg's mp3 encoder rejects >2 channels.
-				// The decider must clamp to the codec's hard limit even when no
-				// transcoding profile MaxAudioChannels is configured.
-				mf := withProbe(&model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 44100, BitDepth: 16})
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: ProtocolHTTP},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetFormat).To(Equal("mp3"))
-				Expect(decision.TranscodeStream.Channels).To(Equal(2))
-				Expect(decision.TargetChannels).To(Equal(2))
-			})
-
-			It("honors a stricter profile MaxAudioChannels over the codec clamp", func() {
-				mf := withProbe(&model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 44100, BitDepth: 16})
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: ProtocolHTTP, MaxAudioChannels: 1},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TranscodeStream.Channels).To(Equal(1))
-				Expect(decision.TargetChannels).To(Equal(1))
-			})
-
-			It("applies the codec clamp when the profile limit is looser", func() {
-				mf := withProbe(&model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 44100, BitDepth: 16})
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: ProtocolHTTP, MaxAudioChannels: 4},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TranscodeStream.Channels).To(Equal(2))
-				Expect(decision.TargetChannels).To(Equal(2))
-			})
-
-			It("passes channels through unchanged for codecs with no hard limit", func() {
-				mf := withProbe(&model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 44100, BitDepth: 16})
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "m4a", AudioCodec: "aac", Protocol: ProtocolHTTP},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci, TranscodeOptions{})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetFormat).To(Equal("aac"))
-				Expect(decision.TranscodeStream.Channels).To(Equal(6))
-				Expect(decision.TargetChannels).To(Equal(6))
-			})
-		})
-
 		Context("Probe-based lossless detection", func() {
 			It("uses probe codec name for lossless detection", func() {
 				// WavPack files: ffprobe reports codec as "wavpack", suffix is ".wv"
@ -1014,12 +901,9 @@ var _ = Describe("Decider", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(decision.CanDirectPlay).To(BeFalse())
 				Expect(decision.TranscodeReasons).To(HaveLen(3))
-				Expect(decision.TranscodeReasons[0]).To(ContainSubstring("container 'ogg' not supported"))
-				Expect(decision.TranscodeReasons[0]).To(ContainSubstring("[flac]"))
-				Expect(decision.TranscodeReasons[1]).To(ContainSubstring("container 'ogg' not supported"))
-				Expect(decision.TranscodeReasons[1]).To(ContainSubstring("[mp3/mp3]"))
-				Expect(decision.TranscodeReasons[2]).To(ContainSubstring("container 'ogg' not supported"))
-				Expect(decision.TranscodeReasons[2]).To(ContainSubstring("[m4a,mp4/aac]"))
+				Expect(decision.TranscodeReasons[0]).To(Equal("container not supported"))
+				Expect(decision.TranscodeReasons[1]).To(Equal("container not supported"))
+				Expect(decision.TranscodeReasons[2]).To(Equal("container not supported"))
 			})
 		})

@ -1231,7 +1115,6 @@ var _ = Describe("Decider", func() {
 				Expect(bitrate).To(Equal(fallbackBitrate))
 			})
 		})
-
 	})

 	Describe("ensureProbed", func() {
--- a/core/stream/types.go
+++ b/core/stream/types.go
@ -2,7 +2,6 @@ package stream

 import (
 	"errors"
-	"strings"
 	"time"
 )

@ -48,18 +47,6 @@ type DirectPlayProfile struct {
 	MaxAudioChannels int
 }

-func (p DirectPlayProfile) String() string {
-	containers := strings.Join(p.Containers, ",")
-	if containers == "" {
-		containers = "*"
-	}
-	codecs := strings.Join(p.AudioCodecs, ",")
-	if codecs == "" {
-		return "[" + containers + "]"
-	}
-	return "[" + containers + "/" + codecs + "]"
-}
-
 // Profile describes a transcoding target the client supports
 type Profile struct {
 	Container        string
--- a/core/wire_providers.go
+++ b/core/wire_providers.go
@ -6,7 +6,6 @@ import (
 	"github.com/navidrome/navidrome/core/external"
 	"github.com/navidrome/navidrome/core/ffmpeg"
 	"github.com/navidrome/navidrome/core/lyrics"
-	"github.com/navidrome/navidrome/core/matcher"
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/playlists"
@ -29,7 +28,6 @@ var Set = wire.NewSet(
 	stream.NewTranscodeDecider,
 	agents.GetAgents,
 	external.NewProvider,
-	matcher.New,
 	wire.Bind(new(external.Agents), new(*agents.Agents)),
 	ffmpeg.New,
 	scrobbler.GetPlayTracker,
--- a/db/backup.go
+++ b/db/backup.go
@ -81,12 +81,12 @@ func backupOrRestore(ctx context.Context, isBackup bool, path string) error {
 			// Caution: -1 means that sqlite will hold a read lock until the operation finishes
 			// This will lock out other writes that could happen at the same time
 			done, err := backupOp.Step(-1)
-			if err != nil {
-				return fmt.Errorf("error during backup step: %w", err)
-			}
 			if !done {
 				return fmt.Errorf("backup not done with step -1")
 			}
+			if err != nil {
+				return fmt.Errorf("error during backup step: %w", err)
+			}

 			err = backupOp.Finish()
 			if err != nil {
--- a/db/migrations/20260405124200_fix_schema_inconsistencies.sql
+++ b/db/migrations/20260405124200_fix_schema_inconsistencies.sql
@ -1,55 +0,0 @@
-- +goose Up
-
-- NOTE: This migration recreates two tables to fix schema inconsistencies.
-- On large production databases, the data copy may take some time as tables are locked during the transaction.
-- This is necessary because SQLite does not support altering table constraints directly.
-- Consider applying this migration during a maintenance window if the tables are large.
-
-- Fix library_artist table: Remove contradictory 'default null' from 'not null' column
-- This is a cosmetic fix (NOT NULL takes precedence), but improves schema consistency
-CREATE TABLE library_artist_new
-(
-    library_id integer NOT NULL DEFAULT 1
-        REFERENCES library(id) ON DELETE CASCADE,
-    artist_id varchar NOT NULL
-        REFERENCES artist(id) ON DELETE CASCADE,
-    stats text DEFAULT '{}',
-    CONSTRAINT library_artist_ux UNIQUE (library_id, artist_id)
-);
-
-INSERT INTO library_artist_new (library_id, artist_id, stats)
-SELECT library_id, artist_id, stats FROM library_artist;
-
-DROP TABLE library_artist;
-
-ALTER TABLE library_artist_new RENAME TO library_artist;
-
-- Fix scrobble_buffer table: Remove duplicate user_id from unique constraint
-- Original constraint had: UNIQUE (user_id, service, media_file_id, play_time, user_id)
-- Fixed constraint is: UNIQUE (user_id, service, media_file_id, play_time)
-CREATE TABLE scrobble_buffer_new
-(
-    user_id varchar NOT NULL
-        CONSTRAINT scrobble_buffer_user_id_fk
-            REFERENCES user ON UPDATE CASCADE ON DELETE CASCADE,
-    service varchar NOT NULL,
-    media_file_id varchar NOT NULL
-        CONSTRAINT scrobble_buffer_media_file_id_fk
-            REFERENCES media_file ON UPDATE CASCADE ON DELETE CASCADE,
-    play_time datetime NOT NULL,
-    enqueue_time datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    id varchar NOT NULL DEFAULT '',
-    CONSTRAINT scrobble_buffer_pk UNIQUE (user_id, service, media_file_id, play_time)
-);
-
-INSERT INTO scrobble_buffer_new (user_id, service, media_file_id, play_time, enqueue_time, id)
-SELECT user_id, service, media_file_id, play_time, enqueue_time, id FROM scrobble_buffer;
-
-DROP TABLE scrobble_buffer;
-
-ALTER TABLE scrobble_buffer_new RENAME TO scrobble_buffer;
-
-CREATE UNIQUE INDEX scrobble_buffer_id_ix ON scrobble_buffer (id);
-
-- +goose Down
-- Down migration is intentionally a no-op: Navidrome does not run down migrations.
--- a/db/migrations/20260410201914_fix_zero_album_created_at.sql
+++ b/db/migrations/20260410201914_fix_zero_album_created_at.sql
@ -1,22 +0,0 @@
-- +goose Up
-
-- Backfill album.created_at for rows poisoned by early scanner versions or
-- propagated via CopyAttributes during metadata-driven ID changes. Prefer the
-- oldest valid birth_time from the album's media files, fall back to updated_at.
-UPDATE album
-SET created_at = COALESCE(
-    (SELECT MIN(birth_time)
-     FROM media_file
-     WHERE media_file.album_id = album.id
-       AND birth_time IS NOT NULL
-       AND birth_time != ''
-       AND birth_time NOT LIKE '0001-%'),
-    updated_at
-)
-WHERE created_at IS NULL
-   OR created_at = ''
-   OR created_at LIKE '0001-%';
-
-- +goose Down
-
-SELECT 1;
--- a/go.mod
+++ b/go.mod
@ -1,9 +1,9 @@
 module github.com/navidrome/navidrome

-go 1.26.0
+go 1.25.0

 // Fork to implement raw tags support
-replace go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260407173416-cf47afbaa67a
+replace go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260307161927-168f6e74ada7

 require (
 	github.com/Masterminds/squirrel v1.5.4
@ -36,7 +36,7 @@ require (
 	github.com/kardianos/service v1.2.4
 	github.com/kr/pretty v0.3.1
 	github.com/lestrrat-go/jwx/v3 v3.0.13
-	github.com/mattn/go-sqlite3 v1.14.42
+	github.com/mattn/go-sqlite3 v1.14.38
 	github.com/microcosm-cc/bluemonday v1.0.27
 	github.com/mileusna/useragent v1.3.5
 	github.com/onsi/ginkgo/v2 v2.28.1
@ -58,12 +58,12 @@ require (
 	github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342
 	go.senan.xyz/taglib v0.11.1
 	go.uber.org/goleak v1.3.0
-	golang.org/x/image v0.39.0
-	golang.org/x/net v0.53.0
+	golang.org/x/image v0.38.0
+	golang.org/x/net v0.52.0
 	golang.org/x/sync v0.20.0
-	golang.org/x/sys v0.43.0
-	golang.org/x/term v0.42.0
-	golang.org/x/text v0.36.0
+	golang.org/x/sys v0.42.0
+	golang.org/x/term v0.41.0
+	golang.org/x/text v0.35.0
 	golang.org/x/time v0.15.0
 	gopkg.in/yaml.v3 v3.0.1
 )
@ -89,7 +89,7 @@ require (
 	github.com/goccy/go-json v0.10.6 // indirect
 	github.com/goccy/go-yaml v1.19.2 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
-	github.com/google/pprof v0.0.0-20260402051712-545e8a4df936 // indirect
+	github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc // 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
@ -101,7 +101,7 @@ require (
 	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.4 // indirect
-	github.com/lestrrat-go/dsig v1.3.0 // indirect
+	github.com/lestrrat-go/dsig v1.0.0 // indirect
 	github.com/lestrrat-go/dsig-secp256k1 v1.0.0 // indirect
 	github.com/lestrrat-go/httpcc v1.0.1 // indirect
 	github.com/lestrrat-go/httprc/v3 v3.0.5 // indirect
@ -134,10 +134,10 @@ require (
 	go.uber.org/multierr v1.11.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/crypto v0.50.0 // indirect
-	golang.org/x/mod v0.35.0 // indirect
-	golang.org/x/telemetry v0.0.0-20260409153401-be6f6cb8b1fa // indirect
-	golang.org/x/tools v0.44.0 // indirect
+	golang.org/x/crypto v0.49.0 // indirect
+	golang.org/x/mod v0.34.0 // indirect
+	golang.org/x/telemetry v0.0.0-20260311193753-579e4da9a98c // indirect
+	golang.org/x/tools v0.43.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
 	gopkg.in/ini.v1 v1.67.1 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
--- a/go.sum
+++ b/go.sum
@ -34,8 +34,8 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1 h1:5RVFMOWjMyRy8cARdy79nAmgYw3hK/4HUq48LQ6Wwqo=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
-github.com/deluan/go-taglib v0.0.0-20260407173416-cf47afbaa67a h1:ZPwh87Xa08FCg5MU5e0Did5WgapEWGxb5d4Je0pLjJw=
-github.com/deluan/go-taglib v0.0.0-20260407173416-cf47afbaa67a/go.mod h1:sKDN0U4qXDlq6LFK+aOAkDH4Me5nDV1V/A4B+B69xBA=
+github.com/deluan/go-taglib v0.0.0-20260307161927-168f6e74ada7 h1:RpRSTEsAdLHx3Ci0d3M5wtpjcBZiKzhnGfnNAxGXrAE=
+github.com/deluan/go-taglib v0.0.0-20260307161927-168f6e74ada7/go.mod h1:sKDN0U4qXDlq6LFK+aOAkDH4Me5nDV1V/A4B+B69xBA=
 github.com/deluan/rest v0.0.0-20211102003136-6260bc399cbf h1:tb246l2Zmpt/GpF9EcHCKTtwzrd0HGfEmoODFA/qnk4=
 github.com/deluan/rest v0.0.0-20211102003136-6260bc399cbf/go.mod h1:tSgDythFsl0QgS/PFWfIZqcJKnkADWneY80jaVRlqK8=
 github.com/deluan/sanitize v0.0.0-20241120162836-fdfd8fdfaa55 h1:wSCnggTs2f2ji6nFwQmfwgINcmSMj0xF0oHnoyRSPe4=
@ -108,8 +108,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-20260402051712-545e8a4df936 h1:EwtI+Al+DeppwYX2oXJCETMO23COyaKGP6fHVpkpWpg=
-github.com/google/pprof v0.0.0-20260402051712-545e8a4df936/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
+github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc h1:VBbFa1lDYWEeV5FZKUiYKYT0VxCp9twUmmaq9eb8sXw=
+github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
 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=
@ -161,8 +161,8 @@ github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 h1:P6pPBnrTSX3DEVR4fDembhR
 github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0/go.mod h1:vmVJ0l/dxyfGW6FmdpVm2joNMFikkuWg0EoCKLGUMNw=
 github.com/lestrrat-go/blackmagic v1.0.4 h1:IwQibdnf8l2KoO+qC3uT4OaTWsW7tuRQXy9TRN9QanA=
 github.com/lestrrat-go/blackmagic v1.0.4/go.mod h1:6AWFyKNNj0zEXQYfTMPfZrAXUWUfTIZ5ECEUEJaijtw=
-github.com/lestrrat-go/dsig v1.3.0 h1:phjMOCXvYzhuIgn7Voe2rex8z166vGfxRxmqM25P9/Q=
-github.com/lestrrat-go/dsig v1.3.0/go.mod h1:RD2eOaidyPvpc7IJQoO3Qq52RWdy8ZcJs8lrOnoa1Kc=
+github.com/lestrrat-go/dsig v1.0.0 h1:OE09s2r9Z81kxzJYRn07TFM9XA4akrUdoMwr0L8xj38=
+github.com/lestrrat-go/dsig v1.0.0/go.mod h1:dEgoOYYEJvW6XGbLasr8TFcAxoWrKlbQvmJgCR0qkDo=
 github.com/lestrrat-go/dsig-secp256k1 v1.0.0 h1:JpDe4Aybfl0soBvoVwjqDbp+9S1Y2OM7gcrVVMFPOzY=
 github.com/lestrrat-go/dsig-secp256k1 v1.0.0/go.mod h1:CxUgAhssb8FToqbL8NjSPoGQlnO4w3LG1P0qPWQm/NU=
 github.com/lestrrat-go/httpcc v1.0.1 h1:ydWCStUeJLkpYyjLDHihupbn2tYmZ7m22BGkcvZZrIE=
@ -177,8 +177,8 @@ github.com/maruel/natural v1.3.0 h1:VsmCsBmEyrR46RomtgHs5hbKADGRVtliHTyCOLFBpsg=
 github.com/maruel/natural v1.3.0/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
 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.42 h1:MigqEP4ZmHw3aIdIT7T+9TLa90Z6smwcthx+Azv4Cgo=
-github.com/mattn/go-sqlite3 v1.14.42/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
+github.com/mattn/go-sqlite3 v1.14.38 h1:tDUzL85kMvOrvpCt8P64SbGgVFtJB11GPi2AdmITgb4=
+github.com/mattn/go-sqlite3 v1.14.38/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/mfridman/tparse v0.18.0 h1:wh6dzOKaIwkUGyKgOntDW4liXSo37qg5AXbIhkMV3vE=
@ -319,19 +319,19 @@ golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliY
 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.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
-golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
+golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
+golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
 golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa h1:Zt3DZoOFFYkKhDT3v7Lm9FDMEV06GpzjG2jrqW+QTE0=
 golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA=
-golang.org/x/image v0.39.0 h1:skVYidAEVKgn8lZ602XO75asgXBgLj9G/FE3RbuPFww=
-golang.org/x/image v0.39.0/go.mod h1:sIbmppfU+xFLPIG0FoVUTvyBMmgng1/XAMhQ2ft0hpA=
+golang.org/x/image v0.38.0 h1:5l+q+Y9JDC7mBOMjo4/aPhMDcxEptsX+Tt3GgRQRPuE=
+golang.org/x/image v0.38.0/go.mod h1:/3f6vaXC+6CEanU4KJxbcUZyEePbyKbaLoDOe4ehFYY=
 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=
 golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
-golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
+golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
+golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@ -343,8 +343,8 @@ golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
 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.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
-golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
+golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
+golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
 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=
@ -369,11 +369,11 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
-golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
-golang.org/x/telemetry v0.0.0-20260409153401-be6f6cb8b1fa h1:efT73AJZfAAUV7SOip6pWGkwJDzIGiKBZGVzHYa+ve4=
-golang.org/x/telemetry v0.0.0-20260409153401-be6f6cb8b1fa/go.mod h1:kHjTxDEnAu6/Nl9lDkzjWpR+bmKfxeiRuSDlsMb70gE=
+golang.org/x/telemetry v0.0.0-20260311193753-579e4da9a98c h1:6a8FdnNk6bTXBjR4AGKFgUKuo+7GnR3FX5L7CbveeZc=
+golang.org/x/telemetry v0.0.0-20260311193753-579e4da9a98c/go.mod h1:TpUTTEp9frx7rTdLpC9gFG9kdI7zVLFTFFlqaH2Cncw=
 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=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
@ -382,8 +382,8 @@ golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
-golang.org/x/term v0.42.0 h1:UiKe+zDFmJobeJ5ggPwOshJIVt6/Ft0rcfrXZDLWAWY=
-golang.org/x/term v0.42.0/go.mod h1:Dq/D+snpsbazcBG5+F9Q1n2rXV8Ma+71xEjTRufARgY=
+golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
+golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@ -394,8 +394,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.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
-golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
+golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
 golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
 golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@ -405,8 +405,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 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.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/tools v0.44.0 h1:UP4ajHPIcuMjT1GqzDWRlalUEoY+uzoZKnhOjbIPD2c=
-golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI=
+golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
+golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
 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.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
--- a/model/criteria/fields.go
+++ b/model/criteria/fields.go
@ -35,7 +35,6 @@ var fieldMap = map[string]*mappedField{
 	"releasedate":     {field: "media_file.release_date"},
 	"size":            {field: "media_file.size"},
 	"compilation":     {field: "media_file.compilation"},
-	"missing":         {field: "media_file.missing"},
 	"explicitstatus":  {field: "media_file.explicit_status"},
 	"dateadded":       {field: "media_file.created_at"},
 	"datemodified":    {field: "media_file.updated_at"},
@ -50,11 +49,9 @@ var fieldMap = map[string]*mappedField{
 	"catalognumber":   {field: "media_file.catalog_num"},
 	"filepath":        {field: "media_file.path"},
 	"filetype":        {field: "media_file.suffix"},
-	"codec":           {field: "media_file.codec"},
 	"duration":        {field: "media_file.duration"},
 	"bitrate":         {field: "media_file.bit_rate"},
 	"bitdepth":        {field: "media_file.bit_depth"},
-	"samplerate":      {field: "media_file.sample_rate"},
 	"bpm":             {field: "media_file.bpm"},
 	"channels":        {field: "media_file.channels"},
 	"loved":           {field: "COALESCE(annotation.starred, false)"},
--- a/model/folder_test.go
+++ b/model/folder_test.go
@ -7,7 +7,6 @@ import (

 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/id"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@ -67,7 +66,6 @@ var _ = Describe("Folder", func() {

 		When("the folder has multiple subdirs", func() {
 			It("should return the correct folder ID", func() {
-				tests.SkipOnWindows("path separator bug (#TBD-path-sep-model)")
 				folderPath := filepath.FromSlash("/music/rock/metal")
 				expectedID := id.NewHash("1:rock/metal")
 				Expect(model.FolderID(lib, folderPath)).To(Equal(expectedID))
@ -77,7 +75,6 @@ var _ = Describe("Folder", func() {

 	Describe("NewFolder", func() {
 		It("should create a new SubFolder with the correct attributes", func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-model)")
 			folderPath := filepath.FromSlash("rock/metal")
 			folder := model.NewFolder(lib, folderPath)

--- a/model/mediafile.go
+++ b/model/mediafile.go
@ -361,9 +361,6 @@ func older(t1, t2 time.Time) time.Time {
 	if t1.IsZero() {
 		return t2
 	}
-	if t2.IsZero() {
-		return t1
-	}
 	if t1.After(t2) {
 		return t2
 	}
--- a/model/mediafile_test.go
+++ b/model/mediafile_test.go
@ -6,7 +6,6 @@ import (
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
 	. "github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@ -23,7 +22,7 @@ var _ = Describe("MediaFiles", func() {
 						SortAlbumName: "SortAlbumName", SortArtistName: "SortArtistName", SortAlbumArtistName: "SortAlbumArtistName",
 						OrderAlbumName: "OrderAlbumName", OrderAlbumArtistName: "OrderAlbumArtistName",
 						MbzAlbumArtistID: "MbzAlbumArtistID", MbzAlbumType: "MbzAlbumType", MbzAlbumComment: "MbzAlbumComment",
-						MbzReleaseGroupID: "MbzReleaseGroupID", Compilation: false, CatalogNum: "", Path: "music1/file1.mp3", FolderID: "Folder1",
+						MbzReleaseGroupID: "MbzReleaseGroupID", Compilation: false, CatalogNum: "", Path: "/music1/file1.mp3", FolderID: "Folder1",
 					},
 					{
 						ID: "2", Album: "Album", ArtistID: "ArtistID", Artist: "Artist", AlbumArtistID: "AlbumArtistID", AlbumArtist: "AlbumArtist", AlbumID: "AlbumID",
@ -31,7 +30,7 @@ var _ = Describe("MediaFiles", func() {
 						OrderAlbumName: "OrderAlbumName", OrderArtistName: "OrderArtistName", OrderAlbumArtistName: "OrderAlbumArtistName",
 						MbzAlbumArtistID: "MbzAlbumArtistID", MbzAlbumType: "MbzAlbumType", MbzAlbumComment: "MbzAlbumComment",
 						MbzReleaseGroupID: "MbzReleaseGroupID",
-						Compilation:       true, CatalogNum: "CatalogNum", HasCoverArt: true, Path: "music2/file2.mp3", FolderID: "Folder2",
+						Compilation:       true, CatalogNum: "CatalogNum", HasCoverArt: true, Path: "/music2/file2.mp3", FolderID: "Folder2",
 					},
 				}
 			})
@ -52,7 +51,7 @@ var _ = Describe("MediaFiles", func() {
 				Expect(album.MbzReleaseGroupID).To(Equal("MbzReleaseGroupID"))
 				Expect(album.CatalogNum).To(Equal("CatalogNum"))
 				Expect(album.Compilation).To(BeTrue())
-				Expect(album.EmbedArtPath).To(Equal("music2/file2.mp3"))
+				Expect(album.EmbedArtPath).To(Equal("/music2/file2.mp3"))
 				Expect(album.FolderIDs).To(ConsistOf("Folder1", "Folder2"))
 			})
 		})
@ -120,20 +119,6 @@ var _ = Describe("MediaFiles", func() {
 						Expect(a.MinYear).To(Equal(1999))
 					})
 				})
-				Context("CreatedAt aggregation", func() {
-					It("ignores zero BirthTime values when computing the oldest", func() {
-						mfs = MediaFiles{
-							{BirthTime: t("2022-12-19 08:30")},
-							{BirthTime: time.Time{}},
-							{BirthTime: t("2022-12-18 10:00")},
-						}
-						Expect(mfs.ToAlbum().CreatedAt).To(Equal(t("2022-12-18 10:00")))
-					})
-					It("returns zero when all BirthTime values are zero", func() {
-						mfs = MediaFiles{{BirthTime: time.Time{}}, {BirthTime: time.Time{}}}
-						Expect(mfs.ToAlbum().CreatedAt).To(BeZero())
-					})
-				})
 			})
 			When("we have multiple songs with same dates", func() {
 				BeforeEach(func() {
@ -448,9 +433,6 @@ var _ = Describe("MediaFiles", func() {

 			DescribeTable("generates correct output",
 				func(absolutePaths bool, expectedContent string) {
-					if absolutePaths {
-						tests.SkipOnWindows("path separator bug (#TBD-path-sep-model)")
-					}
 					result := mfs.ToM3U8("Multi Track", absolutePaths)
 					Expect(result).To(Equal(expectedContent))
 				},
@ -471,7 +453,6 @@ var _ = Describe("MediaFiles", func() {

 		Context("path variations", func() {
 			It("handles different path structures", func() {
-				tests.SkipOnWindows("path separator bug (#TBD-path-sep-model)")
 				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"},
--- a/model/metadata/persistent_ids.go
+++ b/model/metadata/persistent_ids.go
@ -12,85 +12,88 @@ import (
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/id"
 	"github.com/navidrome/navidrome/utils"
+	"github.com/navidrome/navidrome/utils/slice"
 	"github.com/navidrome/navidrome/utils/str"
 )

 type hashFunc = func(...string) string

-// computePID calculates the persistent ID for a given spec. The spec is a
-// pipe-separated list of fields, where each field is a comma-separated list of
-// attributes. Attributes can be either tags or processed values like folder,
-// albumid, albumartistid, etc. For each field, it gets all its attribute values
-// and concatenates them, then hashes the result. If a field is empty, it is
-// skipped and the function looks for the next field.
-//
-// Taking hash as a parameter (instead of closing over it in a factory) keeps
-// mf on the stack: closing over mf would force the whole ~1KB MediaFile to the
-// heap on every call.
-func computePID(mf model.MediaFile, md Metadata, spec string, prependLibId bool, hash hashFunc) string {
-	switch spec {
-	case "track_legacy":
-		return legacyTrackID(mf, prependLibId)
-	case "album_legacy":
-		return legacyAlbumID(mf, md, prependLibId)
-	}
-	pid := ""
-	fields := strings.SplitSeq(spec, "|")
-	for field := range fields {
-		attributes := strings.Split(field, ",")
-		values := make([]string, len(attributes))
-		hasValue := false
-		for i, attr := range attributes {
-			v := getPIDAttr(mf, md, attr, prependLibId, spec, hash)
-			if v != "" {
-				hasValue = true
-			}
-			values[i] = v
-		}
-		if hasValue {
-			pid += strings.Join(values, "\\")
-			break
-		}
-	}
-	if prependLibId {
-		pid = fmt.Sprintf("%d\\%s", mf.LibraryID, pid)
-	}
-	return hash(pid)
-}
+// createGetPID returns a function that calculates the persistent ID for a given spec, getting the referenced values from the metadata
+// The spec is a pipe-separated list of fields, where each field is a comma-separated list of attributes
+// Attributes can be either tags or some processed values like folder, albumid, albumartistid, etc.
+// For each field, it gets all its attributes values and concatenates them, then hashes the result.
+// If a field is empty, it is skipped and the function looks for the next field.
+type getPIDFunc = func(mf model.MediaFile, md Metadata, spec string, prependLibId bool) string

-func getPIDAttr(mf model.MediaFile, md Metadata, attr string, prependLibId bool, spec string, hash hashFunc) string {
-	attr = strings.TrimSpace(strings.ToLower(attr))
-	switch attr {
-	case "albumid":
-		if spec == conf.Server.PID.Album {
-			log.Error("Recursive PID definition detected, ignoring `albumid`", "spec", spec)
-			return ""
+func createGetPID(hash hashFunc) getPIDFunc {
+	var getPID getPIDFunc
+	getAttr := func(mf model.MediaFile, md Metadata, attr string, prependLibId bool, spec string) string {
+		attr = strings.TrimSpace(strings.ToLower(attr))
+		switch attr {
+		case "albumid":
+			if spec == conf.Server.PID.Album {
+				log.Error("Recursive PID definition detected, ignoring `albumid`", "spec", spec)
+				return ""
+			}
+			return getPID(mf, md, conf.Server.PID.Album, prependLibId)
+		case "folder":
+			return filepath.Dir(mf.Path)
+		case "albumartistid":
+			return hash(str.Clear(strings.ToLower(mf.AlbumArtist)))
+		case "title":
+			return mf.Title
+		case "album":
+			return str.Clear(strings.ToLower(md.String(model.TagAlbum)))
 		}
-		return computePID(mf, md, conf.Server.PID.Album, prependLibId, hash)
-	case "folder":
-		return filepath.Dir(mf.Path)
-	case "albumartistid":
-		return hash(str.Clear(strings.ToLower(mf.AlbumArtist)))
-	case "title":
-		return mf.Title
-	case "album":
-		return str.Clear(strings.ToLower(md.String(model.TagAlbum)))
+		return md.String(model.TagName(attr))
+	}
+	getPID = func(mf model.MediaFile, md Metadata, spec string, prependLibId bool) string {
+		pid := ""
+		fields := strings.SplitSeq(spec, "|")
+		for field := range fields {
+			attributes := strings.Split(field, ",")
+			hasValue := false
+			values := slice.Map(attributes, func(attr string) string {
+				v := getAttr(mf, md, attr, prependLibId, spec)
+				if v != "" {
+					hasValue = true
+				}
+				return v
+			})
+			if hasValue {
+				pid += strings.Join(values, "\\")
+				break
+			}
+		}
+		if prependLibId {
+			pid = fmt.Sprintf("%d\\%s", mf.LibraryID, pid)
+		}
+		return hash(pid)
+	}
+
+	return func(mf model.MediaFile, md Metadata, spec string, prependLibId bool) string {
+		switch spec {
+		case "track_legacy":
+			return legacyTrackID(mf, prependLibId)
+		case "album_legacy":
+			return legacyAlbumID(mf, md, prependLibId)
+		}
+		return getPID(mf, md, spec, prependLibId)
 	}
-	return md.String(model.TagName(attr))
 }

 func (md Metadata) trackPID(mf model.MediaFile) string {
-	return computePID(mf, md, conf.Server.PID.Track, true, id.NewHash)
+	return createGetPID(id.NewHash)(mf, md, conf.Server.PID.Track, true)
 }

 func (md Metadata) albumID(mf model.MediaFile, pidConf string) string {
-	return computePID(mf, md, pidConf, true, id.NewHash)
+	return createGetPID(id.NewHash)(mf, md, pidConf, true)
 }

 // BFR Must be configurable?
 func (md Metadata) artistID(name string) string {
 	mf := model.MediaFile{AlbumArtist: name}
-	return computePID(mf, md, "albumartistid", false, id.NewHash)
+	return createGetPID(id.NewHash)(mf, md, "albumartistid", false)
 }

 func (md Metadata) mapTrackTitle() string {
--- a/model/metadata/persistent_ids_test.go
+++ b/model/metadata/persistent_ids_test.go
@ -6,23 +6,21 @@ import (
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )

 var _ = Describe("getPID", func() {
 	var (
-		md  Metadata
-		mf  model.MediaFile
-		sum hashFunc
+		md     Metadata
+		mf     model.MediaFile
+		sum    hashFunc
+		getPID getPIDFunc
 	)
-	getPID := func(mf model.MediaFile, md Metadata, spec string, prependLibId bool) string {
-		return computePID(mf, md, spec, prependLibId, sum)
-	}

 	BeforeEach(func() {
 		sum = func(s ...string) string { return "(" + strings.Join(s, ",") + ")" }
+		getPID = createGetPID(sum)
 	})

 	Context("attributes are tags", func() {
@ -80,7 +78,6 @@ var _ = Describe("getPID", func() {
 		})
 		When("field is folder", func() {
 			It("should return the pid", func() {
-				tests.SkipOnWindows("path separator bug (#TBD-path-sep-metadata)")
 				spec := "folder|title"
 				md.tags = map[model.TagName][]string{"title": {"title"}}
 				mf.Path = "/path/to/file.mp3"
--- a/model/playlist_test.go
+++ b/model/playlist_test.go
@ -2,7 +2,6 @@ package model_test

 import (
 	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
@ -28,7 +27,6 @@ var _ = Describe("Playlist", func() {
 			}
 		})
 		It("generates the correct M3U format", func() {
-			tests.SkipOnWindows("path separator bug (#TBD-path-sep-model)")
 			expected := `#EXTM3U
 #PLAYLIST:Mellow sunset
 #EXTINF:378,Morcheeba feat. Kurt Wagner - What New York Couples Fight About
--- a/persistence/album_repository.go
+++ b/persistence/album_repository.go
@ -252,17 +252,7 @@ func (r *albumRepository) CopyAttributes(fromID, toID string, columns ...string)
 	}
 	to := make(map[string]any)
 	for _, col := range columns {
-		v := from[col]
-		// created_at is aggregated from song birth_times and must never be
-		// overwritten with a zero/poisoned value, or it propagates forward on
-		// every metadata-driven album ID change.
-		if col == "created_at" && (!v.Valid || v.String == "" || strings.HasPrefix(v.String, "0001-")) {
-			continue
-		}
-		to[col] = v
-	}
-	if len(to) == 0 {
-		return nil
+		to[col] = from[col]
 	}
 	_, err = r.executeSQL(Update(r.tableName).SetMap(to).Where(Eq{"id": toID}))
 	return err
--- a/persistence/album_repository_test.go
+++ b/persistence/album_repository_test.go
@ -41,32 +41,6 @@ var _ = Describe("AlbumRepository", func() {
 		})
 	})

-	Describe("CopyAttributes", func() {
-		var srcTime, dstTime time.Time
-		BeforeEach(func() {
-			srcTime = time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC)
-			dstTime = time.Date(2024, 6, 7, 8, 9, 10, 0, time.UTC)
-			Expect(albumRepo.Put(&model.Album{ID: "copy-src", Name: "src", LibraryID: 1, CreatedAt: srcTime})).To(Succeed())
-			Expect(albumRepo.Put(&model.Album{ID: "copy-dst", Name: "dst", LibraryID: 1, CreatedAt: dstTime})).To(Succeed())
-			Expect(albumRepo.Put(&model.Album{ID: "copy-zero", Name: "zero", LibraryID: 1})).To(Succeed())
-			DeferCleanup(func() {
-				_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": []string{"copy-src", "copy-dst", "copy-zero"}}))
-			})
-		})
-		It("copies a valid created_at from source to destination", func() {
-			Expect(albumRepo.CopyAttributes("copy-src", "copy-dst", "created_at")).To(Succeed())
-			got, err := albumRepo.Get("copy-dst")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(got.CreatedAt).To(BeTemporally("~", srcTime, time.Second))
-		})
-		It("leaves destination untouched when source created_at is zero", func() {
-			Expect(albumRepo.CopyAttributes("copy-zero", "copy-dst", "created_at")).To(Succeed())
-			got, err := albumRepo.Get("copy-dst")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(got.CreatedAt).To(BeTemporally("~", dstTime, time.Second))
-		})
-	})
-
 	Describe("GetAll", func() {
 		var GetAll = func(opts ...model.QueryOptions) (model.Albums, error) {
 			albums, err := albumRepo.GetAll(opts...)
--- a/persistence/folder_repository_test.go
+++ b/persistence/folder_repository_test.go
@ -8,7 +8,6 @@ import (
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/request"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	"github.com/pocketbase/dbx"
@ -100,7 +99,6 @@ var _ = Describe("FolderRepository", func() {
 			})

 			It("includes all child folders when querying parent", func() {
-				tests.SkipOnWindows("path storage (#TBD-path-sep-persistence)")
 				// Create a parent folder with multiple children
 				parent := model.NewFolder(testLib, "TestParent/Music")
 				child1 := model.NewFolder(testLib, "TestParent/Music/Rock/Queen")
@ -122,7 +120,6 @@ var _ = Describe("FolderRepository", func() {
 			})

 			It("excludes children from other libraries", func() {
-				tests.SkipOnWindows("path storage (#TBD-path-sep-persistence)")
 				// Create parent in testLib
 				parent := model.NewFolder(testLib, "TestIsolation/Parent")
 				child := model.NewFolder(testLib, "TestIsolation/Parent/Child")
@ -148,7 +145,6 @@ var _ = Describe("FolderRepository", func() {
 			})

 			It("excludes missing children when querying parent", func() {
-				tests.SkipOnWindows("path storage (#TBD-path-sep-persistence)")
 				// Create parent and children, mark one as missing
 				parent := model.NewFolder(testLib, "TestMissingChild/Parent")
 				child1 := model.NewFolder(testLib, "TestMissingChild/Parent/Child1")
@ -169,7 +165,6 @@ var _ = Describe("FolderRepository", func() {
 			})

 			It("handles mix of existing and non-existing target paths", func() {
-				tests.SkipOnWindows("path storage (#TBD-path-sep-persistence)")
 				// Create folders for one path but not the other
 				existingParent := model.NewFolder(testLib, "TestMixed/Exists")
 				existingChild := model.NewFolder(testLib, "TestMixed/Exists/Child")
--- a/persistence/library_repository_test.go
+++ b/persistence/library_repository_test.go
@ -2,7 +2,6 @@ package persistence

 import (
 	"context"
-	"time"

 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
@ -65,11 +64,6 @@ var _ = Describe("LibraryRepository", func() {
 				originalID := lib.ID
 				originalCreatedAt := lib.CreatedAt

-				// Ensure the update's timestamp is strictly greater than the
-				// create's timestamp on platforms with coarse clock resolution
-				// (Windows' time.Now() is millisecond-granular).
-				time.Sleep(2 * time.Millisecond)
-
 				// Now update it
 				lib.Name = "Updated Library"
 				lib.Path = "/music/updated"
--- a/persistence/mediafile_repository_test.go
+++ b/persistence/mediafile_repository_test.go
@ -48,10 +48,10 @@ var _ = Describe("MediaRepository", func() {
 		var mp3File, flacFile1, flacFile2, flacUpperFile model.MediaFile

 		BeforeEach(func() {
-			mp3File = model.MediaFile{ID: "suffix-mp3", LibraryID: 1, Suffix: "mp3", Path: "test/file.mp3"}
-			flacFile1 = model.MediaFile{ID: "suffix-flac1", LibraryID: 1, Suffix: "flac", Path: "test/file1.flac"}
-			flacFile2 = model.MediaFile{ID: "suffix-flac2", LibraryID: 1, Suffix: "flac", Path: "test/file2.flac"}
-			flacUpperFile = model.MediaFile{ID: "suffix-FLAC", LibraryID: 1, Suffix: "FLAC", Path: "test/file.FLAC"}
+			mp3File = model.MediaFile{ID: "suffix-mp3", LibraryID: 1, Suffix: "mp3", Path: "/test/file.mp3"}
+			flacFile1 = model.MediaFile{ID: "suffix-flac1", LibraryID: 1, Suffix: "flac", Path: "/test/file1.flac"}
+			flacFile2 = model.MediaFile{ID: "suffix-flac2", LibraryID: 1, Suffix: "flac", Path: "/test/file2.flac"}
+			flacUpperFile = model.MediaFile{ID: "suffix-FLAC", LibraryID: 1, Suffix: "FLAC", Path: "/test/file.FLAC"}

 			Expect(mr.Put(&mp3File)).To(Succeed())
 			Expect(mr.Put(&flacFile1)).To(Succeed())
@ -109,7 +109,7 @@ var _ = Describe("MediaRepository", func() {
 	Describe("Put CreatedAt behavior (#5050)", func() {
 		It("sets CreatedAt to now when inserting a new file with zero CreatedAt", func() {
 			before := time.Now().Add(-time.Second)
-			newFile := model.MediaFile{ID: id.NewRandom(), LibraryID: 1, Path: "test/created-at-zero.mp3"}
+			newFile := model.MediaFile{ID: id.NewRandom(), LibraryID: 1, Path: "/test/created-at-zero.mp3"}
 			Expect(mr.Put(&newFile)).To(Succeed())

 			retrieved, err := mr.Get(newFile.ID)
@ -124,7 +124,7 @@ var _ = Describe("MediaRepository", func() {
 			newFile := model.MediaFile{
 				ID:        id.NewRandom(),
 				LibraryID: 1,
-				Path:      "test/created-at-preserved.mp3",
+				Path:      "/test/created-at-preserved.mp3",
 				CreatedAt: originalTime,
 			}
 			Expect(mr.Put(&newFile)).To(Succeed())
@ -142,7 +142,7 @@ var _ = Describe("MediaRepository", func() {
 			newFile := model.MediaFile{
 				ID:        fileID,
 				LibraryID: 1,
-				Path:      "test/created-at-update.mp3",
+				Path:      "/test/created-at-update.mp3",
 				Title:     "Original Title",
 				CreatedAt: originalTime,
 			}
@ -152,7 +152,7 @@ var _ = Describe("MediaRepository", func() {
 			updatedFile := model.MediaFile{
 				ID:        fileID,
 				LibraryID: 1,
-				Path:      "test/created-at-update.mp3",
+				Path:      "/test/created-at-update.mp3",
 				Title:     "Updated Title",
 				// CreatedAt is zero - should NOT overwrite the stored value
 			}
@ -231,7 +231,7 @@ var _ = Describe("MediaRepository", func() {

 			It("returns 0 when no ratings exist", func() {
 				newID := id.NewRandom()
-				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "test/no-rating.mp3"})).To(Succeed())
+				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "/test/no-rating.mp3"})).To(Succeed())

 				mf, err := mr.Get(newID)
 				Expect(err).ToNot(HaveOccurred())
@ -242,7 +242,7 @@ var _ = Describe("MediaRepository", func() {

 			It("returns the user's rating as average when only one user rated", func() {
 				newID := id.NewRandom()
-				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "test/single-rating.mp3"})).To(Succeed())
+				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "/test/single-rating.mp3"})).To(Succeed())
 				Expect(mr.SetRating(5, newID)).To(Succeed())

 				mf, err := mr.Get(newID)
@ -255,7 +255,7 @@ var _ = Describe("MediaRepository", func() {

 			It("calculates average across multiple users", func() {
 				newID := id.NewRandom()
-				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "test/multi-rating.mp3"})).To(Succeed())
+				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "/test/multi-rating.mp3"})).To(Succeed())

 				Expect(mr.SetRating(3, newID)).To(Succeed())

@ -273,7 +273,7 @@ var _ = Describe("MediaRepository", func() {

 			It("excludes zero ratings from average calculation", func() {
 				newID := id.NewRandom()
-				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "test/zero-excluded.mp3"})).To(Succeed())
+				Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: newID, Path: "/test/zero-excluded.mp3"})).To(Succeed())

 				Expect(mr.SetRating(4, newID)).To(Succeed())

@ -343,19 +343,19 @@ var _ = Describe("MediaRepository", func() {
 						ID:        id.NewRandom(),
 						LibraryID: 1,
 						Title:     "Old Song",
-						Path:      "test/old.mp3",
+						Path:      "/test/old.mp3",
 					},
 					{
 						ID:        id.NewRandom(),
 						LibraryID: 1,
 						Title:     "Middle Song",
-						Path:      "test/middle.mp3",
+						Path:      "/test/middle.mp3",
 					},
 					{
 						ID:        id.NewRandom(),
 						LibraryID: 1,
 						Title:     "New Song",
-						Path:      "test/new.mp3",
+						Path:      "/test/new.mp3",
 					},
 				}

@ -486,7 +486,7 @@ var _ = Describe("MediaRepository", func() {
 		var mfWithoutAnnotation model.MediaFile

 		BeforeEach(func() {
-			mfWithoutAnnotation = model.MediaFile{ID: "no-annotation-file", LibraryID: 1, Path: "test/no-annotation.mp3", Title: "No Annotation"}
+			mfWithoutAnnotation = model.MediaFile{ID: "no-annotation-file", LibraryID: 1, Path: "/test/no-annotation.mp3", Title: "No Annotation"}
 			Expect(mr.Put(&mfWithoutAnnotation)).To(Succeed())
 		})

@ -566,7 +566,7 @@ var _ = Describe("MediaRepository", func() {
 					MbzRecordingID:    "550e8400-e29b-41d4-a716-446655440020", // Valid UUID v4
 					MbzReleaseTrackID: "550e8400-e29b-41d4-a716-446655440021", // Valid UUID v4
 					LibraryID:         1,
-					Path:              "test/path/test.mp3",
+					Path:              "/test/path/test.mp3",
 				}

 				// Insert the test media file into the database
@ -608,7 +608,7 @@ var _ = Describe("MediaRepository", func() {
 					Title:          "Test Missing MBID MediaFile",
 					MbzRecordingID: "550e8400-e29b-41d4-a716-446655440022",
 					LibraryID:      1,
-					Path:           "test/path/missing.mp3",
+					Path:           "/test/path/missing.mp3",
 					Missing:        true,
 				}

--- a/persistence/persistence_suite_test.go
+++ b/persistence/persistence_suite_test.go
@ -77,14 +77,14 @@ var (
 )

 var (
-	albumSgtPeppers    = al(model.Album{ID: "101", Name: "Sgt Peppers", AlbumArtist: "The Beatles", OrderAlbumName: "sgt peppers", AlbumArtistID: "3", EmbedArtPath: p("beatles/1/sgt/a day.mp3"), SongCount: 1, MaxYear: 1967})
-	albumAbbeyRoad     = al(model.Album{ID: "102", Name: "Abbey Road", AlbumArtist: "The Beatles", OrderAlbumName: "abbey road", AlbumArtistID: "3", EmbedArtPath: p("beatles/1/come together.mp3"), SongCount: 1, MaxYear: 1969})
-	albumRadioactivity = al(model.Album{ID: "103", Name: "Radioactivity", AlbumArtist: "Kraftwerk", OrderAlbumName: "radioactivity", AlbumArtistID: "2", EmbedArtPath: p("kraft/radio/radio.mp3"), SongCount: 2})
-	albumMultiDisc     = al(model.Album{ID: "104", Name: "Multi Disc Album", AlbumArtist: "Test Artist", OrderAlbumName: "multi disc album", AlbumArtistID: "1", EmbedArtPath: p("test/multi/disc1/track1.mp3"), SongCount: 4})
-	albumCJK           = al(model.Album{ID: "105", Name: "COWBOY BEBOP", AlbumArtist: "シートベルツ", OrderAlbumName: "cowboy bebop", AlbumArtistID: "4", EmbedArtPath: p("seatbelts/cowboy-bebop/track1.mp3"), SongCount: 1})
-	albumWithVersion   = alWithTags(model.Album{ID: "106", Name: "Abbey Road", AlbumArtist: "The Beatles", OrderAlbumName: "abbey road", AlbumArtistID: "3", EmbedArtPath: p("beatles/2/come together.mp3"), SongCount: 1, MaxYear: 2019},
+	albumSgtPeppers    = al(model.Album{ID: "101", Name: "Sgt Peppers", AlbumArtist: "The Beatles", OrderAlbumName: "sgt peppers", AlbumArtistID: "3", EmbedArtPath: p("/beatles/1/sgt/a day.mp3"), SongCount: 1, MaxYear: 1967})
+	albumAbbeyRoad     = al(model.Album{ID: "102", Name: "Abbey Road", AlbumArtist: "The Beatles", OrderAlbumName: "abbey road", AlbumArtistID: "3", EmbedArtPath: p("/beatles/1/come together.mp3"), SongCount: 1, MaxYear: 1969})
+	albumRadioactivity = al(model.Album{ID: "103", Name: "Radioactivity", AlbumArtist: "Kraftwerk", OrderAlbumName: "radioactivity", AlbumArtistID: "2", EmbedArtPath: p("/kraft/radio/radio.mp3"), SongCount: 2})
+	albumMultiDisc     = al(model.Album{ID: "104", Name: "Multi Disc Album", AlbumArtist: "Test Artist", OrderAlbumName: "multi disc album", AlbumArtistID: "1", EmbedArtPath: p("/test/multi/disc1/track1.mp3"), SongCount: 4})
+	albumCJK           = al(model.Album{ID: "105", Name: "COWBOY BEBOP", AlbumArtist: "シートベルツ", OrderAlbumName: "cowboy bebop", AlbumArtistID: "4", EmbedArtPath: p("/seatbelts/cowboy-bebop/track1.mp3"), SongCount: 1})
+	albumWithVersion   = alWithTags(model.Album{ID: "106", Name: "Abbey Road", AlbumArtist: "The Beatles", OrderAlbumName: "abbey road", AlbumArtistID: "3", EmbedArtPath: p("/beatles/2/come together.mp3"), SongCount: 1, MaxYear: 2019},
 		model.Tags{model.TagAlbumVersion: {"Deluxe Edition"}})
-	albumPunctuation = al(model.Album{ID: "107", Name: "Things Fall Apart", AlbumArtist: "The Roots", OrderAlbumName: "things fall apart", AlbumArtistID: "5", EmbedArtPath: p("roots/things/track1.mp3"), SongCount: 1})
+	albumPunctuation = al(model.Album{ID: "107", Name: "Things Fall Apart", AlbumArtist: "The Roots", OrderAlbumName: "things fall apart", AlbumArtistID: "5", EmbedArtPath: p("/roots/things/track1.mp3"), SongCount: 1})
 	testAlbums       = model.Albums{
 		albumSgtPeppers,
 		albumAbbeyRoad,
@ -97,12 +97,12 @@ var (
 )

 var (
-	songDayInALife    = mf(model.MediaFile{ID: "1001", Title: "A Day In A Life", ArtistID: "3", Artist: "The Beatles", AlbumID: "101", Album: "Sgt Peppers", Path: p("beatles/1/sgt/a day.mp3")})
-	songComeTogether  = mf(model.MediaFile{ID: "1002", Title: "Come Together", ArtistID: "3", Artist: "The Beatles", AlbumID: "102", Album: "Abbey Road", Path: p("beatles/1/come together.mp3")})
-	songRadioactivity = mf(model.MediaFile{ID: "1003", Title: "Radioactivity", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "103", Album: "Radioactivity", Path: p("kraft/radio/radio.mp3")})
+	songDayInALife    = mf(model.MediaFile{ID: "1001", Title: "A Day In A Life", ArtistID: "3", Artist: "The Beatles", AlbumID: "101", Album: "Sgt Peppers", Path: p("/beatles/1/sgt/a day.mp3")})
+	songComeTogether  = mf(model.MediaFile{ID: "1002", Title: "Come Together", ArtistID: "3", Artist: "The Beatles", AlbumID: "102", Album: "Abbey Road", Path: p("/beatles/1/come together.mp3")})
+	songRadioactivity = mf(model.MediaFile{ID: "1003", Title: "Radioactivity", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "103", Album: "Radioactivity", Path: p("/kraft/radio/radio.mp3")})
 	songAntenna       = mf(model.MediaFile{ID: "1004", Title: "Antenna", ArtistID: "2", Artist: "Kraftwerk",
 		AlbumID:     "103",
-		Path:        p("kraft/radio/antenna.mp3"),
+		Path:        p("/kraft/radio/antenna.mp3"),
 		RGAlbumGain: gg.P(1.0), RGAlbumPeak: gg.P(2.0), RGTrackGain: gg.P(3.0), RGTrackPeak: gg.P(4.0),
 	})
 	songAntennaWithLyrics = mf(model.MediaFile{
@ -115,13 +115,13 @@ var (
 	})
 	songAntenna2 = mf(model.MediaFile{ID: "1006", Title: "Antenna", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "103"})
 	// Multi-disc album tracks (intentionally out of order to test sorting)
-	songDisc2Track11 = mf(model.MediaFile{ID: "2001", Title: "Disc 2 Track 11", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 2, TrackNumber: 11, Path: p("test/multi/disc2/track11.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
-	songDisc1Track01 = mf(model.MediaFile{ID: "2002", Title: "Disc 1 Track 1", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 1, TrackNumber: 1, Path: p("test/multi/disc1/track1.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
-	songDisc2Track01 = mf(model.MediaFile{ID: "2003", Title: "Disc 2 Track 1", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 2, TrackNumber: 1, Path: p("test/multi/disc2/track1.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
-	songDisc1Track02 = mf(model.MediaFile{ID: "2004", Title: "Disc 1 Track 2", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 1, TrackNumber: 2, Path: p("test/multi/disc1/track2.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
-	songCJK          = mf(model.MediaFile{ID: "3001", Title: "プラチナ・ジェット", ArtistID: "4", Artist: "シートベルツ", AlbumID: "105", Album: "COWBOY BEBOP", Path: p("seatbelts/cowboy-bebop/track1.mp3")})
-	songVersioned    = mf(model.MediaFile{ID: "3002", Title: "Come Together", ArtistID: "3", Artist: "The Beatles", AlbumID: "106", Album: "Abbey Road", Path: p("beatles/2/come together.mp3")})
-	songPunctuation  = mf(model.MediaFile{ID: "3003", Title: "!!!!!!!", ArtistID: "5", Artist: "The Roots", AlbumID: "107", Album: "Things Fall Apart", Path: p("roots/things/track1.mp3")})
+	songDisc2Track11 = mf(model.MediaFile{ID: "2001", Title: "Disc 2 Track 11", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 2, TrackNumber: 11, Path: p("/test/multi/disc2/track11.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+	songDisc1Track01 = mf(model.MediaFile{ID: "2002", Title: "Disc 1 Track 1", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 1, TrackNumber: 1, Path: p("/test/multi/disc1/track1.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+	songDisc2Track01 = mf(model.MediaFile{ID: "2003", Title: "Disc 2 Track 1", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 2, TrackNumber: 1, Path: p("/test/multi/disc2/track1.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+	songDisc1Track02 = mf(model.MediaFile{ID: "2004", Title: "Disc 1 Track 2", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 1, TrackNumber: 2, Path: p("/test/multi/disc1/track2.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+	songCJK          = mf(model.MediaFile{ID: "3001", Title: "プラチナ・ジェット", ArtistID: "4", Artist: "シートベルツ", AlbumID: "105", Album: "COWBOY BEBOP", Path: p("/seatbelts/cowboy-bebop/track1.mp3")})
+	songVersioned    = mf(model.MediaFile{ID: "3002", Title: "Come Together", ArtistID: "3", Artist: "The Beatles", AlbumID: "106", Album: "Abbey Road", Path: p("/beatles/2/come together.mp3")})
+	songPunctuation  = mf(model.MediaFile{ID: "3003", Title: "!!!!!!!", ArtistID: "5", Artist: "The Roots", AlbumID: "107", Album: "Things Fall Apart", Path: p("/roots/things/track1.mp3")})
 	testSongs        = model.MediaFiles{
 		songDayInALife,
 		songComeTogether,
--- a/persistence/playlist_repository_test.go
+++ b/persistence/playlist_repository_test.go
@ -408,7 +408,7 @@ var _ = Describe("PlaylistRepository", func() {
 				ArtistID: "1",
 				Album:    "Test Album",
 				AlbumID:  "101",
-				Path:     "test/grouping/song1.mp3",
+				Path:     "/test/grouping/song1.mp3",
 				Tags: model.Tags{
 					"grouping": []string{"My Crate"},
 				},
@ -426,7 +426,7 @@ var _ = Describe("PlaylistRepository", func() {
 				ArtistID:     "1",
 				Album:        "Test Album",
 				AlbumID:      "101",
-				Path:         "test/grouping/song2.mp3",
+				Path:         "/test/grouping/song2.mp3",
 				Tags:         model.Tags{},
 				Participants: model.Participants{},
 				LibraryID:    1,
@ -614,7 +614,7 @@ var _ = Describe("PlaylistRepository", func() {
 				ArtistID:     "1",
 				Album:        "Test Album",
 				AlbumID:      "101",
-				Path:         "lib1/song.mp3",
+				Path:         "/music/lib1/song.mp3",
 				LibraryID:    1,
 				Participants: model.Participants{},
 				Tags:         model.Tags{},
@ -630,7 +630,7 @@ var _ = Describe("PlaylistRepository", func() {
 				ArtistID:     "1",
 				Album:        "Test Album",
 				AlbumID:      "101",
-				Path:         "lib2/song.mp3",
+				Path:         uniqueLibPath + "/song.mp3",
 				LibraryID:    lib2ID,
 				Participants: model.Participants{},
 				Tags:         model.Tags{},
--- a/plugins/capabilities/lyrics.yaml
+++ b/plugins/capabilities/lyrics.yaml
@ -102,11 +102,6 @@ components:
                mbzReleaseTrackId:
                    type: string
                    description: MBZReleaseTrackID is the MusicBrainz release track ID.
-                path:
-                    type: string
-                    description: |-
-                        Path is the full path to the track file, relative to the library root.
-                        Only included if the plugin has library permission with filesystem access for the track's library.
            required:
                - id
                - title
--- a/plugins/capabilities/scrobbler.go
+++ b/plugins/capabilities/scrobbler.go
@ -68,9 +68,6 @@ type TrackInfo struct {
 	MBZReleaseGroupID string `json:"mbzReleaseGroupId,omitempty"`
 	// MBZReleaseTrackID is the MusicBrainz release track ID.
 	MBZReleaseTrackID string `json:"mbzReleaseTrackId,omitempty"`
-	// Path is the full path to the track file, relative to the library root.
-	// Only included if the plugin has library permission with filesystem access for the track's library.
-	Path string `json:"path,omitempty"`
 }

 // NowPlayingRequest is the request for now playing notification.
--- a/plugins/capabilities/scrobbler.yaml
+++ b/plugins/capabilities/scrobbler.yaml
@ -128,11 +128,6 @@ components:
                mbzReleaseTrackId:
                    type: string
                    description: MBZReleaseTrackID is the MusicBrainz release track ID.
-                path:
-                    type: string
-                    description: |-
-                        Path is the full path to the track file, relative to the library root.
-                        Only included if the plugin has library permission with filesystem access for the track's library.
            required:
                - id
                - title
--- a/plugins/config_validation_test.go
+++ b/plugins/config_validation_test.go
@ -1,3 +1,5 @@
+//go:build !windows
+
 package plugins

 import (
--- a/plugins/host_kvstore.go
+++ b/plugins/host_kvstore.go
@ -9,7 +9,6 @@ import (
 	"path/filepath"
 	"slices"
 	"strings"
-	"sync"
 	"time"

 	"github.com/dustin/go-humanize"
@ -36,8 +35,6 @@ type kvstoreServiceImpl struct {
 	pluginName string
 	db         *sql.DB
 	maxSize    int64
-	cancel     context.CancelFunc
-	wg         sync.WaitGroup
 }

 // newKVStoreService creates a new kvstoreServiceImpl instance with its own SQLite database.
@ -77,15 +74,12 @@ func newKVStoreService(ctx context.Context, pluginName string, perm *KVStorePerm

 	log.Debug("Initialized plugin kvstore", "plugin", pluginName, "path", dbPath, "maxSize", humanize.Bytes(uint64(maxSize)))

-	cleanupCtx, cancel := context.WithCancel(ctx)
 	svc := &kvstoreServiceImpl{
 		pluginName: pluginName,
 		db:         db,
 		maxSize:    maxSize,
-		cancel:     cancel,
 	}
-	svc.wg.Add(1)
-	go svc.cleanupLoop(cleanupCtx)
+	go svc.cleanupLoop(ctx)
 	return svc, nil
 }

@ -341,7 +335,6 @@ func (s *kvstoreServiceImpl) GetMany(ctx context.Context, keys []string) (map[st
 // cleanupLoop periodically removes expired keys from the database.
 // It stops when the provided context is cancelled.
 func (s *kvstoreServiceImpl) cleanupLoop(ctx context.Context) {
-	defer s.wg.Done()
 	ticker := time.NewTicker(cleanupInterval)
 	defer ticker.Stop()
 	for {
@ -366,12 +359,17 @@ func (s *kvstoreServiceImpl) cleanupExpired(ctx context.Context) {
 	}
 }

-// Close stops the cleanup goroutine and closes the SQLite database connection.
+// Close runs a final cleanup and closes the SQLite database connection.
+// The cleanup goroutine is stopped by the context passed to newKVStoreService.
 func (s *kvstoreServiceImpl) Close() error {
-	log.Debug("Closing plugin kvstore", "plugin", s.pluginName)
-	s.cancel()
-	s.wg.Wait()
-	return s.db.Close()
+	if s.db != nil {
+		log.Debug("Closing plugin kvstore", "plugin", s.pluginName)
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		s.cleanupExpired(ctx)
+		return s.db.Close()
+	}
+	return nil
 }

 // Compile-time verification
--- a/plugins/host_kvstore_test.go
+++ b/plugins/host_kvstore_test.go
@ -445,36 +445,6 @@ var _ = Describe("KVStoreService", func() {
 		})
 	})

-	Describe("Close", func() {
-		It("does not race with cleanupLoop goroutine", func() {
-			// Create a service with a dedicated context so we can verify
-			// that Close() properly waits for the cleanup goroutine.
-			closeCtx, closeCancel := context.WithCancel(ctx)
-			defer closeCancel()
-
-			maxSize := "1KB"
-			svc, err := newKVStoreService(closeCtx, "test_close_race", &KVStorePermission{MaxSize: &maxSize})
-			Expect(err).ToNot(HaveOccurred())
-
-			// Insert an expired key so cleanup has work to do
-			_, err = svc.db.Exec(`
-				INSERT INTO kvstore (key, value, size, expires_at)
-				VALUES ('cleanup_race', 'old', 3, datetime('now', '-1 seconds'))
-			`)
-			Expect(err).ToNot(HaveOccurred())
-
-			// Close should not panic or produce "database is closed" errors.
-			// Before the fix, the cleanup goroutine could race with db.Close().
-			err = svc.Close()
-			Expect(err).ToNot(HaveOccurred())
-
-			// Verify the database is actually closed (further queries should fail)
-			_, err = svc.db.Exec(`SELECT 1`)
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("database is closed"))
-		})
-	})
-
 	Describe("SetWithTTL", func() {
 		It("stores value that is retrievable before expiry", func() {
 			err := service.SetWithTTL(ctx, "ttl_key", []byte("ttl_value"), 3600)
--- a/plugins/lyrics_adapter.go
+++ b/plugins/lyrics_adapter.go
@ -31,7 +31,7 @@ type LyricsPlugin struct {
 // using model.ToLyrics.
 func (l *LyricsPlugin) GetLyrics(ctx context.Context, mf *model.MediaFile) (model.LyricList, error) {
 	req := capabilities.GetLyricsRequest{
-		Track: mediaFileToTrackInfo(l.plugin, mf),
+		Track: mediaFileToTrackInfo(mf),
 	}
 	resp, err := callPluginFunction[capabilities.GetLyricsRequest, capabilities.GetLyricsResponse](
 		ctx, l.plugin, FuncLyricsGetLyrics, req,
--- a/plugins/manager_loader.go
+++ b/plugins/manager_loader.go
@ -301,7 +301,7 @@ func (m *Manager) loadPluginWithConfig(p *model.Plugin) error {
 	}

 	// Configure filesystem access for library permission
-	if pkg.Manifest.HasLibraryFilesystemPermission() {
+	if pkg.Manifest.Permissions != nil && pkg.Manifest.Permissions.Library != nil && pkg.Manifest.Permissions.Library.Filesystem {
 		adminCtx := adminContext(ctx)
 		libraries, err := m.ds.Library(adminCtx).GetAll()
 		if err != nil {
@ -384,7 +384,6 @@ func (m *Manager) loadPluginWithConfig(p *model.Plugin) error {
 		metrics:        m.metrics,
 		allowedUserIDs: allowedUsers,
 		allUsers:       p.AllUsers,
-		libraries:      newLibraryAccess(allowedLibraries, p.AllLibraries),
 	}
 	m.mu.Unlock()

--- a/plugins/manager_loader_test.go
+++ b/plugins/manager_loader_test.go
@ -1,3 +1,5 @@
+//go:build !windows
+
 package plugins

 import (
--- a/plugins/manager_plugin.go
+++ b/plugins/manager_plugin.go
@ -21,7 +21,6 @@ type plugin struct {
 	metrics        PluginMetricsRecorder
 	allowedUserIDs []string // User IDs this plugin can access (from DB configuration)
 	allUsers       bool     // If true, plugin can access all users
-	libraries      libraryAccess
 }

 // instance creates a new plugin instance for the given context.
@ -48,30 +47,3 @@ func (p *plugin) Close() error {
 	}
 	return errors.Join(errs...)
 }
-
-func (p *plugin) hasLibraryFilesystemAccess(libID int) bool {
-	return p.manifest.HasLibraryFilesystemPermission() && p.libraries.contains(libID)
-}
-
-// libraryAccess captures the set of libraries a plugin is permitted to see,
-// precomputed at load time for O(1) lookup.
-type libraryAccess struct {
-	allLibraries bool
-	libraryIDSet map[int]struct{}
-}
-
-func newLibraryAccess(allowedLibraryIDs []int, allLibraries bool) libraryAccess {
-	set := make(map[int]struct{}, len(allowedLibraryIDs))
-	for _, id := range allowedLibraryIDs {
-		set[id] = struct{}{}
-	}
-	return libraryAccess{allLibraries: allLibraries, libraryIDSet: set}
-}
-
-func (a libraryAccess) contains(libID int) bool {
-	if a.allLibraries {
-		return true
-	}
-	_, ok := a.libraryIDSet[libID]
-	return ok
-}
--- a/plugins/manager_plugin_test.go
+++ b/plugins/manager_plugin_test.go
@ -1,34 +0,0 @@
-package plugins
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("plugin", func() {
-	Describe("hasLibraryFilesystemAccess", func() {
-		fsManifest := &Manifest{
-			Permissions: &Permissions{
-				Library: &LibraryPermission{Filesystem: true},
-			},
-		}
-
-		It("returns false when the manifest does not grant filesystem permission", func() {
-			p := &plugin{manifest: &Manifest{}, libraries: newLibraryAccess(nil, true)}
-			Expect(p.hasLibraryFilesystemAccess(1)).To(BeFalse())
-		})
-
-		It("returns true for any library when allLibraries is set", func() {
-			p := &plugin{manifest: fsManifest, libraries: newLibraryAccess(nil, true)}
-			Expect(p.hasLibraryFilesystemAccess(1)).To(BeTrue())
-			Expect(p.hasLibraryFilesystemAccess(42)).To(BeTrue())
-		})
-
-		It("returns true only for libraries in the allowed list", func() {
-			p := &plugin{manifest: fsManifest, libraries: newLibraryAccess([]int{1, 3}, false)}
-			Expect(p.hasLibraryFilesystemAccess(1)).To(BeTrue())
-			Expect(p.hasLibraryFilesystemAccess(3)).To(BeTrue())
-			Expect(p.hasLibraryFilesystemAccess(2)).To(BeFalse())
-		})
-	})
-})
--- a/plugins/manager_test.go
+++ b/plugins/manager_test.go
@ -1,5 +1,3 @@
-//go:build !windows
-
 package plugins

 import (
--- a/plugins/manager_watcher_test.go
+++ b/plugins/manager_watcher_test.go
@ -1,5 +1,3 @@
-//go:build !windows
-
 package plugins

 import (
--- a/plugins/manifest.go
+++ b/plugins/manifest.go
@ -86,10 +86,3 @@ func ValidateWithCapabilities(m *Manifest, capabilities []Capability) error {
 func (m *Manifest) HasExperimentalThreads() bool {
 	return m.Experimental != nil && m.Experimental.Threads != nil
 }
-
-// HasLibraryFilesystemPermission checks if the manifest grants filesystem permission for libraries.
-func (m *Manifest) HasLibraryFilesystemPermission() bool {
-	return m.Permissions != nil &&
-		m.Permissions.Library != nil &&
-		m.Permissions.Library.Filesystem
-}
--- a/plugins/metadata_agent_test.go
+++ b/plugins/metadata_agent_test.go
@ -1,5 +1,3 @@
-//go:build !windows
-
 package plugins

 import (
--- a/plugins/migrate_test.go
+++ b/plugins/migrate_test.go
@ -1,3 +1,5 @@
+//go:build !windows
+
 package plugins

 import (
--- a/plugins/pdk/go/lyrics/lyrics.go
+++ b/plugins/pdk/go/lyrics/lyrics.go
@ -68,9 +68,6 @@ type TrackInfo struct {
 	MBZReleaseGroupID string `json:"mbzReleaseGroupId,omitempty"`
 	// MBZReleaseTrackID is the MusicBrainz release track ID.
 	MBZReleaseTrackID string `json:"mbzReleaseTrackId,omitempty"`
-	// Path is the full path to the track file, relative to the library root.
-	// Only included if the plugin has library permission with filesystem access for the track's library.
-	Path string `json:"path,omitempty"`
 }

 // Lyrics requires all methods to be implemented.
--- a/plugins/pdk/go/lyrics/lyrics_stub.go
+++ b/plugins/pdk/go/lyrics/lyrics_stub.go
@ -65,9 +65,6 @@ type TrackInfo struct {
 	MBZReleaseGroupID string `json:"mbzReleaseGroupId,omitempty"`
 	// MBZReleaseTrackID is the MusicBrainz release track ID.
 	MBZReleaseTrackID string `json:"mbzReleaseTrackId,omitempty"`
-	// Path is the full path to the track file, relative to the library root.
-	// Only included if the plugin has library permission with filesystem access for the track's library.
-	Path string `json:"path,omitempty"`
 }

 // Lyrics requires all methods to be implemented.
--- a/plugins/pdk/go/scrobbler/scrobbler.go
+++ b/plugins/pdk/go/scrobbler/scrobbler.go
@ -92,9 +92,6 @@ type TrackInfo struct {
 	MBZReleaseGroupID string `json:"mbzReleaseGroupId,omitempty"`
 	// MBZReleaseTrackID is the MusicBrainz release track ID.
 	MBZReleaseTrackID string `json:"mbzReleaseTrackId,omitempty"`
-	// Path is the full path to the track file, relative to the library root.
-	// Only included if the plugin has library permission with filesystem access for the track's library.
-	Path string `json:"path,omitempty"`
 }

 // Scrobbler requires all methods to be implemented.
--- a/Show More
+++ b/Show More