Update persistence/playlist_repository.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/pipeline.yml

@@ -14,7 +14,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  CROSS_TAGLIB_VERSION: "2.1.1-2"
+  CROSS_TAGLIB_VERSION: "2.1.1-1"
   CGO_CFLAGS_ALLOW: "--define-prefix"
   IS_RELEASE: ${{ startsWith(github.ref, 'refs/tags/') && 'true' || 'false' }}
 
@@ -193,7 +193,7 @@ jobs:
     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 ]
+        platform: [ linux/amd64, linux/arm64, linux/arm/v5, linux/arm/v6, linux/arm/v7, linux/386, darwin/amd64, darwin/arm64, windows/amd64, windows/386 ]
     runs-on: ubuntu-latest
     env:
       IS_LINUX: ${{ startsWith(matrix.platform, 'linux/') && 'true' || 'false' }}

.gitignore

@@ -35,5 +35,4 @@ AGENTS.md
 *.test
 *.wasm
 *.ndp
-openspec/
-go.work*
+openspec/

Dockerfile

@@ -28,7 +28,7 @@ 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.1.1-2
+ARG CROSS_TAGLIB_VERSION=2.1.1-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
@@ -63,7 +63,7 @@ COPY --from=ui /build /build
 
 ########################################################################################################################
 ### Build Navidrome binary
-FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-trixie AS base
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.25-bookworm AS base
 RUN apt-get update && apt-get install -y clang lld
 COPY --from=xx / /
 WORKDIR /workspace

Makefile

@@ -13,13 +13,13 @@ GIT_SHA=source_archive
 GIT_TAG=$(patsubst navidrome-%,v%,$(notdir $(PWD)))-SNAPSHOT
 endif
 
-SUPPORTED_PLATFORMS ?= 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
+SUPPORTED_PLATFORMS ?= linux/amd64,linux/arm64,linux/arm/v5,linux/arm/v6,linux/arm/v7,linux/386,darwin/amd64,darwin/arm64,windows/amd64,windows/386
 IMAGE_PLATFORMS ?= $(shell echo $(SUPPORTED_PLATFORMS) | tr ',' '\n' | grep "linux" | grep -v "arm/v5" | tr '\n' ',' | sed 's/,$$//')
 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.1.1-2
+CROSS_TAGLIB_VERSION ?= 2.1.1-1
 GOLANGCI_LINT_VERSION ?= v2.8.0
 
 UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")

adapters/deezer/client.go

@@ -29,12 +29,14 @@ type httpDoer interface {
 
 type client struct {
 	httpDoer httpDoer
+	language string
 	jwt      jwtToken
 }
 
-func newClient(hc httpDoer) *client {
+func newClient(hc httpDoer, language string) *client {
 	return &client{
 		httpDoer: hc,
+		language: language,
 	}
 }
 
@@ -127,7 +129,7 @@ const pipeAPIURL = "https://pipe.deezer.com/api"
 
 var strictPolicy = bluemonday.StrictPolicy()
 
-func (c *client) getArtistBio(ctx context.Context, artistID int, lang string) (string, error) {
+func (c *client) getArtistBio(ctx context.Context, artistID int) (string, error) {
 	jwt, err := c.getJWT(ctx)
 	if err != nil {
 		return "", fmt.Errorf("deezer: failed to get JWT: %w", err)
@@ -158,10 +160,10 @@ func (c *client) getArtistBio(ctx context.Context, artistID int, lang string) (s
 	}
 
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Accept-Language", lang)
+	req.Header.Set("Accept-Language", c.language)
 	req.Header.Set("Authorization", "Bearer "+jwt)
 
-	log.Trace(ctx, "Fetching Deezer artist biography via GraphQL", "artistId", artistID, "language", lang)
+	log.Trace(ctx, "Fetching Deezer artist biography via GraphQL", "artistId", artistID, "language", c.language)
 	resp, err := c.httpDoer.Do(req)
 	if err != nil {
 		return "", err

adapters/deezer/client_auth_test.go

@@ -21,7 +21,7 @@ var _ = Describe("JWT Authentication", func() {
 
 	BeforeEach(func() {
 		httpClient = &fakeHttpClient{}
-		client = newClient(httpClient)
+		client = newClient(httpClient, "en")
 		ctx = context.Background()
 	})
 

adapters/deezer/client_test.go

@@ -18,7 +18,7 @@ var _ = Describe("client", func() {
 
 	BeforeEach(func() {
 		httpClient = &fakeHttpClient{}
-		client = newClient(httpClient)
+		client = newClient(httpClient, "en")
 	})
 
 	Describe("ArtistImages", func() {
@@ -45,28 +45,6 @@ var _ = Describe("client", func() {
 		})
 	})
 
-	Describe("TopTracks", func() {
-		It("returns top tracks with artist and album info from a successful request", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.top.json")
-			Expect(err).To(BeNil())
-			httpClient.mock("https://api.deezer.com/artist/27/top", http.Response{Body: f, StatusCode: 200})
-
-			tracks, err := client.getTopTracks(GinkgoT().Context(), 27, 5)
-			Expect(err).To(BeNil())
-			Expect(tracks).To(HaveLen(5))
-
-			// Verify first track has all expected fields
-			Expect(tracks[0].Title).To(Equal("Instant Crush (feat. Julian Casablancas)"))
-			Expect(tracks[0].Artist.Name).To(Equal("Daft Punk"))
-			Expect(tracks[0].Album.Title).To(Equal("Random Access Memories"))
-
-			// Verify second track
-			Expect(tracks[1].Title).To(Equal("One More Time"))
-			Expect(tracks[1].Artist.Name).To(Equal("Daft Punk"))
-			Expect(tracks[1].Album.Title).To(Equal("Discovery"))
-		})
-	})
-
 	Describe("ArtistBio", func() {
 		BeforeEach(func() {
 			// Mock the JWT token endpoint with a valid JWT that expires in 5 minutes
@@ -78,33 +56,40 @@ var _ = Describe("client", func() {
 		})
 
 		It("returns artist bio from a successful request", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.en.json")
+			f, err := os.Open("tests/fixtures/deezer.artist.bio.json")
 			Expect(err).To(BeNil())
 			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
 
-			bio, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			bio, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(BeNil())
 			Expect(bio).To(ContainSubstring("Schoolmates Thomas and Guy-Manuel"))
 			Expect(bio).ToNot(ContainSubstring("<p>"))
 			Expect(bio).ToNot(ContainSubstring("</p>"))
 		})
 
-		It("uses the provided language", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.fr.json")
+		It("uses the configured language", func() {
+			client = newClient(httpClient, "fr")
+			// Mock JWT token for the new client instance with a valid JWT
+			testJWT := createTestJWT(5 * time.Minute)
+			httpClient.mock("https://auth.deezer.com/login/anonymous", http.Response{
+				StatusCode: 200,
+				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, testJWT))),
+			})
+			f, err := os.Open("tests/fixtures/deezer.artist.bio.json")
 			Expect(err).To(BeNil())
 			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
 
-			_, err = client.getArtistBio(GinkgoT().Context(), 27, "fr")
+			_, err = client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(BeNil())
 			Expect(httpClient.lastRequest.Header.Get("Accept-Language")).To(Equal("fr"))
 		})
 
 		It("includes the JWT token in the request", func() {
-			f, err := os.Open("tests/fixtures/deezer.artist.bio.en.json")
+			f, err := os.Open("tests/fixtures/deezer.artist.bio.json")
 			Expect(err).To(BeNil())
 			httpClient.mock("https://pipe.deezer.com/api", http.Response{Body: f, StatusCode: 200})
 
-			_, err = client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err = client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(BeNil())
 			// Verify that the Authorization header has the Bearer token format
 			authHeader := httpClient.lastRequest.Header.Get("Authorization")
@@ -135,7 +120,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(errorResponse)),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 999, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 999)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(ContainSubstring("GraphQL error"))
 			Expect(err.Error()).To(ContainSubstring("Artist not found"))
@@ -157,7 +142,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(emptyBioResponse)),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(MatchError("deezer: biography not found"))
 		})
 
@@ -167,7 +152,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"Internal server error"}`)),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(ContainSubstring("failed to get JWT"))
 		})
@@ -180,7 +165,7 @@ var _ = Describe("client", func() {
 				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, expiredJWT))),
 			})
 
-			_, err := client.getArtistBio(GinkgoT().Context(), 27, "en")
+			_, err := client.getArtistBio(GinkgoT().Context(), 27)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(ContainSubstring("JWT token already expired or expires too soon"))
 		})

adapters/deezer/deezer.go

@@ -26,19 +26,15 @@ const deezerArtistSearchLimit = 50
 type deezerAgent struct {
 	dataStore model.DataStore
 	client    *client
-	languages []string
 }
 
 func deezerConstructor(dataStore model.DataStore) agents.Interface {
-	agent := &deezerAgent{
-		dataStore: dataStore,
-		languages: conf.Server.Deezer.Languages,
-	}
+	agent := &deezerAgent{dataStore: dataStore}
 	httpClient := &http.Client{
 		Timeout: consts.DefaultHttpClientTimeOut,
 	}
 	cachedHttpClient := cache.NewHTTPClient(httpClient, consts.DefaultHttpClientTimeOut)
-	agent.client = newClient(cachedHttpClient)
+	agent.client = newClient(cachedHttpClient, conf.Server.Deezer.Language)
 	return agent
 }
 
@@ -139,9 +135,7 @@ func (s *deezerAgent) GetArtistTopSongs(ctx context.Context, _, artistName, _ st
 
 	res := slice.Map(tracks, func(r Track) agents.Song {
 		return agents.Song{
-			Name:     r.Title,
-			Album:    r.Album.Title,
-			Duration: uint32(r.Duration * 1000), // Convert seconds to milliseconds
+			Name: r.Title,
 		}
 	})
 	return res, nil
@@ -153,14 +147,7 @@ func (s *deezerAgent) GetArtistBiography(ctx context.Context, _, name, _ string)
 		return "", err
 	}
 
-	for _, lang := range s.languages {
-		bio, err := s.client.getArtistBio(ctx, artist.ID, lang)
-		if err == nil && bio != "" {
-			return bio, nil
-		}
-		log.Debug(ctx, "Deezer/artist.bio returned empty/error, trying next language", "artist", name, "lang", lang, err)
-	}
-	return "", agents.ErrNotFound
+	return s.client.getArtistBio(ctx, artist.ID)
 }
 
 func init() {

adapters/deezer/deezer_test.go

@@ -1,171 +0,0 @@
-package deezer
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("deezerAgent", func() {
-	var ctx context.Context
-
-	BeforeEach(func() {
-		ctx = context.Background()
-		DeferCleanup(configtest.SetupConfig())
-		conf.Server.Deezer.Enabled = true
-	})
-
-	Describe("deezerConstructor", func() {
-		It("uses configured languages", func() {
-			conf.Server.Deezer.Languages = []string{"pt", "en"}
-			agent := deezerConstructor(&tests.MockDataStore{}).(*deezerAgent)
-			Expect(agent.languages).To(Equal([]string{"pt", "en"}))
-		})
-	})
-
-	Describe("GetArtistBiography - Language Fallback", func() {
-		var agent *deezerAgent
-		var httpClient *langAwareHttpClient
-
-		BeforeEach(func() {
-			httpClient = newLangAwareHttpClient()
-
-			// Mock search artist (returns Michael Jackson)
-			fSearch, _ := os.Open("tests/fixtures/deezer.search.artist.json")
-			httpClient.searchResponse = &http.Response{Body: fSearch, StatusCode: 200}
-
-			// Mock JWT token
-			testJWT := createTestJWT(5 * time.Minute)
-			httpClient.jwtResponse = &http.Response{
-				StatusCode: 200,
-				Body:       io.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{"jwt":"%s","refresh_token":""}`, testJWT))),
-			}
-		})
-
-		setupAgent := func(languages []string) {
-			conf.Server.Deezer.Languages = languages
-			agent = &deezerAgent{
-				dataStore: &tests.MockDataStore{},
-				client:    newClient(httpClient),
-				languages: languages,
-			}
-		}
-
-		It("returns content in first language when available (1 bio API call)", func() {
-			setupAgent([]string{"fr", "en"})
-
-			// French biography available
-			fFr, _ := os.Open("tests/fixtures/deezer.artist.bio.fr.json")
-			httpClient.bioResponses["fr"] = &http.Response{Body: fFr, StatusCode: 200}
-
-			bio, err := agent.GetArtistBiography(ctx, "", "Michael Jackson", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(bio).To(ContainSubstring("Guy-Manuel de Homem Christo et Thomas Bangalter"))
-			Expect(httpClient.bioRequestCount).To(Equal(1))
-			Expect(httpClient.bioRequests[0].Header.Get("Accept-Language")).To(Equal("fr"))
-		})
-
-		It("falls back to second language when first returns empty (2 bio API calls)", func() {
-			setupAgent([]string{"ja", "en"})
-
-			// Japanese returns empty biography
-			fJa, _ := os.Open("tests/fixtures/deezer.artist.bio.empty.json")
-			httpClient.bioResponses["ja"] = &http.Response{Body: fJa, StatusCode: 200}
-			// English returns full biography
-			fEn, _ := os.Open("tests/fixtures/deezer.artist.bio.en.json")
-			httpClient.bioResponses["en"] = &http.Response{Body: fEn, StatusCode: 200}
-
-			bio, err := agent.GetArtistBiography(ctx, "", "Michael Jackson", "")
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(bio).To(ContainSubstring("Schoolmates Thomas and Guy-Manuel"))
-			Expect(httpClient.bioRequestCount).To(Equal(2))
-			Expect(httpClient.bioRequests[0].Header.Get("Accept-Language")).To(Equal("ja"))
-			Expect(httpClient.bioRequests[1].Header.Get("Accept-Language")).To(Equal("en"))
-		})
-
-		It("returns ErrNotFound when all languages return empty", func() {
-			setupAgent([]string{"ja", "xx"})
-
-			// Both languages return empty biography
-			fJa, _ := os.Open("tests/fixtures/deezer.artist.bio.empty.json")
-			httpClient.bioResponses["ja"] = &http.Response{Body: fJa, StatusCode: 200}
-			fXx, _ := os.Open("tests/fixtures/deezer.artist.bio.empty.json")
-			httpClient.bioResponses["xx"] = &http.Response{Body: fXx, StatusCode: 200}
-
-			_, err := agent.GetArtistBiography(ctx, "", "Michael Jackson", "")
-
-			Expect(err).To(MatchError(agents.ErrNotFound))
-			Expect(httpClient.bioRequestCount).To(Equal(2))
-		})
-	})
-})
-
-// langAwareHttpClient is a mock HTTP client that returns different responses based on the Accept-Language header
-type langAwareHttpClient struct {
-	searchResponse  *http.Response
-	jwtResponse     *http.Response
-	bioResponses    map[string]*http.Response
-	bioRequests     []*http.Request
-	bioRequestCount int
-}
-
-func newLangAwareHttpClient() *langAwareHttpClient {
-	return &langAwareHttpClient{
-		bioResponses: make(map[string]*http.Response),
-		bioRequests:  make([]*http.Request, 0),
-	}
-}
-
-func (c *langAwareHttpClient) Do(req *http.Request) (*http.Response, error) {
-	// Handle search artist request
-	if req.URL.Host == "api.deezer.com" && req.URL.Path == "/search/artist" {
-		if c.searchResponse != nil {
-			return c.searchResponse, nil
-		}
-		return &http.Response{
-			StatusCode: 200,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"data":[],"total":0}`)),
-		}, nil
-	}
-
-	// Handle JWT token request
-	if req.URL.Host == "auth.deezer.com" && req.URL.Path == "/login/anonymous" {
-		if c.jwtResponse != nil {
-			return c.jwtResponse, nil
-		}
-		return &http.Response{
-			StatusCode: 500,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"error":"no mock"}`)),
-		}, nil
-	}
-
-	// Handle bio request (GraphQL API)
-	if req.URL.Host == "pipe.deezer.com" && req.URL.Path == "/api" {
-		c.bioRequestCount++
-		c.bioRequests = append(c.bioRequests, req)
-		lang := req.Header.Get("Accept-Language")
-		if resp, ok := c.bioResponses[lang]; ok {
-			return resp, nil
-		}
-		// Return empty bio by default
-		return &http.Response{
-			StatusCode: 200,
-			Body:       io.NopCloser(bytes.NewBufferString(`{"data":{"artist":{"bio":{"full":""}}}}`)),
-		}, nil
-	}
-
-	panic("URL not mocked: " + req.URL.String())
-}

adapters/gotaglib/end_to_end_test.go

@@ -1,274 +0,0 @@
-package gotaglib
-
-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{fs: os.DirFS(".")}
-	})
-
-	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))
-				}
-			}
-		})
-	})
-})

adapters/gotaglib/gotaglib.go

@@ -1,277 +0,0 @@
-// Package gotaglib provides an alternative metadata extractor using go-taglib,
-// a pure Go (WASM-based) implementation of TagLib.
-//
-// This extractor aims for parity with the CGO-based taglib extractor. It uses
-// TagLib's PropertyMap interface for standard tags. The File handle API provides
-// efficient access to format-specific tags (ID3v2 frames, MP4 atoms, ASF attributes)
-// through a single file open operation.
-//
-// This extractor is registered under the name "taglib". It only works with a filesystem
-// (fs.FS) and does not support direct local file paths. Files returned by the filesystem
-// must implement io.ReadSeeker for go-taglib to read them.
-package gotaglib
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"runtime/debug"
-	"strings"
-	"time"
-
-	"github.com/navidrome/navidrome/core/storage/local"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model/metadata"
-	"go.senan.xyz/taglib"
-)
-
-type extractor struct {
-	fs fs.FS
-}
-
-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 "go-taglib (TagLib 2.1.1 WASM)"
-}
-
-func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
-	f, close, err := e.openFile(filePath)
-	if err != nil {
-		return nil, err
-	}
-	defer close()
-
-	// Get all tags and properties in one go
-	allTags := f.AllTags()
-	props := f.Properties()
-
-	// Map properties to AudioProperties
-	ap := metadata.AudioProperties{
-		Duration:   props.Length.Round(time.Millisecond * 10),
-		BitRate:    int(props.Bitrate),
-		Channels:   int(props.Channels),
-		SampleRate: int(props.SampleRate),
-		BitDepth:   int(props.BitsPerSample),
-		Codec:      props.Codec,
-	}
-
-	// Convert normalized tags to lowercase keys (go-taglib returns UPPERCASE keys)
-	normalizedTags := make(map[string][]string, len(allTags.Tags))
-	for key, values := range allTags.Tags {
-		lowerKey := strings.ToLower(key)
-		normalizedTags[lowerKey] = values
-	}
-
-	// Process format-specific raw tags
-	processRawTags(allTags, normalizedTags)
-
-	// Parse track/disc totals from "N/Total" format
-	parseTuple(normalizedTags, "track")
-	parseTuple(normalizedTags, "disc")
-
-	// Adjust some ID3 tags
-	parseLyrics(normalizedTags)
-	parseTIPL(normalizedTags)
-	delete(normalizedTags, "tmcl") // TMCL is already parsed by TagLib
-
-	// Determine if file has embedded picture
-	hasPicture := len(props.Images) > 0
-
-	return &metadata.Info{
-		Tags:            normalizedTags,
-		AudioProperties: ap,
-		HasPicture:      hasPicture,
-	}, nil
-}
-
-// openFile opens the file at filePath using the extractor's filesystem.
-// It returns a TagLib File handle and a cleanup function to close resources.
-func (e extractor) openFile(filePath string) (f *taglib.File, closeFunc func(), err error) {
-	// Recover from panics in the WASM runtime (e.g., wazero failing to mmap executable memory
-	// on hardened systems like NixOS with MemoryDenyWriteExecute=true)
-	debug.SetPanicOnFault(true)
-	defer func() {
-		if r := recover(); r != nil {
-			log.Error("WASM runtime panic: This may be caused by a hardened system that blocks executable memory mapping.", "file", filePath, "panic", r)
-			err = fmt.Errorf("WASM runtime panic (hardened system?): %v", r)
-		}
-	}()
-
-	// Open the file from the filesystem
-	file, err := e.fs.Open(filePath)
-	if err != nil {
-		return nil, nil, err
-	}
-	rs, isSeekable := file.(io.ReadSeeker)
-	if !isSeekable {
-		file.Close()
-		return nil, nil, errors.New("file is not seekable")
-	}
-	f, err = taglib.OpenStream(rs, taglib.WithReadStyle(taglib.ReadStyleFast))
-	if err != nil {
-		file.Close()
-		return nil, nil, err
-	}
-	closeFunc = func() {
-		f.Close()
-		file.Close()
-	}
-	return f, closeFunc, nil
-}
-
-// parseTuple parses track/disc numbers in "N/Total" format and separates them.
-// For example, tracknumber="2/10" becomes tracknumber="2" and tracktotal="10".
-func parseTuple(tags map[string][]string, 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]}
-		}
-	}
-}
-
-// parseLyrics ensures lyrics tags have a language code.
-// If lyrics exist without a language code, they are moved to "lyrics:xxx".
-func parseLyrics(tags map[string][]string) {
-	lyrics := tags["lyrics"]
-	if len(lyrics) > 0 {
-		tags["lyrics:xxx"] = lyrics
-		delete(tags, "lyrics")
-	}
-}
-
-// processRawTags processes format-specific raw tags based on the detected file format.
-// This handles ID3v2 frames (MP3/WAV/AIFF), MP4 atoms, and ASF attributes.
-func processRawTags(allTags taglib.AllTags, normalizedTags map[string][]string) {
-	switch allTags.Format {
-	case taglib.FormatMPEG, taglib.FormatWAV, taglib.FormatAIFF:
-		parseID3v2Frames(allTags.Raw, normalizedTags)
-	case taglib.FormatMP4:
-		parseMP4Atoms(allTags.Raw, normalizedTags)
-	case taglib.FormatASF:
-		parseASFAttributes(allTags.Raw, normalizedTags)
-	}
-}
-
-// parseID3v2Frames processes ID3v2 raw frames to extract USLT/SYLT with language codes.
-// This extracts language-specific lyrics that the standard Tags() doesn't provide.
-func parseID3v2Frames(rawFrames map[string][]string, tags map[string][]string) {
-	// Process frames that have language-specific data
-	for key, values := range rawFrames {
-		lowerKey := strings.ToLower(key)
-
-		// Handle USLT:xxx and SYLT:xxx (lyrics with language codes)
-		if strings.HasPrefix(lowerKey, "uslt:") || strings.HasPrefix(lowerKey, "sylt:") {
-			parts := strings.SplitN(lowerKey, ":", 2)
-			if len(parts) == 2 && parts[1] != "" {
-				lang := parts[1]
-				lyricsKey := "lyrics:" + lang
-				tags[lyricsKey] = append(tags[lyricsKey], values...)
-			}
-		}
-	}
-
-	// If we found any language-specific lyrics from ID3v2 frames, remove the generic lyrics
-	for key := range tags {
-		if strings.HasPrefix(key, "lyrics:") && key != "lyrics" {
-			delete(tags, "lyrics")
-			break
-		}
-	}
-}
-
-const iTunesKeyPrefix = "----:com.apple.iTunes:"
-
-// parseMP4Atoms processes MP4 raw atoms to get iTunes-specific tags.
-func parseMP4Atoms(rawAtoms map[string][]string, tags map[string][]string) {
-	// Process all atoms and add them to tags
-	for key, values := range rawAtoms {
-		// Strip iTunes prefix and convert to lowercase
-		normalizedKey := strings.TrimPrefix(key, iTunesKeyPrefix)
-		normalizedKey = strings.ToLower(normalizedKey)
-
-		// Only add if the tag doesn't already exist (avoid duplication with PropertyMap)
-		if _, exists := tags[normalizedKey]; !exists {
-			tags[normalizedKey] = values
-		}
-	}
-}
-
-// parseASFAttributes processes ASF raw attributes to get WMA-specific tags.
-func parseASFAttributes(rawAttrs map[string][]string, tags map[string][]string) {
-	// Process all attributes and add them to tags
-	for key, values := range rawAttrs {
-		normalizedKey := strings.ToLower(key)
-
-		// Only add if the tag doesn't already exist (avoid duplication with PropertyMap)
-		if _, exists := tags[normalizedKey]; !exists {
-			tags[normalizedKey] = values
-		}
-	}
-}
-
-// 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",
-}
-
-// 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("taglib", func(fsys fs.FS, baseDir string) local.Extractor {
-		return &extractor{fsys}
-	})
-}

adapters/gotaglib/gotaglib_suite_test.go

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

adapters/gotaglib/gotaglib_test.go

@@ -1,302 +0,0 @@
-package gotaglib
-
-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{fs: os.DirFS(".")}
-	})
-
-	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() {
-					// Use root fs for absolute paths in temp directory
-					e = &extractor{fs: os.DirFS("/")}
-					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() {
-					// Strip leading slash for DirFS rooted at "/"
-					_, err := e.extractMetadata(accessForbiddenFile[1:])
-					Expect(err).To(MatchError(os.ErrPermission))
-				})
-
-				It("skips the file if it cannot be read", func() {
-					// Get current working directory to construct paths relative to root
-					cwd, err := os.Getwd()
-					Expect(err).ToNot(HaveOccurred())
-					// Strip leading slash for DirFS rooted at "/"
-					files := []string{
-						cwd[1:] + "/tests/fixtures/test.mp3",
-						cwd[1:] + "/tests/fixtures/test.ogg",
-						accessForbiddenFile[1:],
-					}
-					mds, err := e.Parse(files...)
-					Expect(err).NotTo(HaveOccurred())
-					Expect(mds).To(HaveLen(2))
-					Expect(mds).ToNot(HaveKey(accessForbiddenFile[1:]))
-				})
-			})
-		})
-
-	})
-
-	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())
-			})
-		})
-	})
-
-})

adapters/lastfm/agent.go

@@ -26,8 +26,8 @@ const (
 	sessionKeyProperty = "LastFMSessionKey"
 )
 
-var ignoredContent = []string{
-	// Empty Artist/Album
+var ignoredBiographies = []string{
+	// Unknown Artist
 	`<a href="https://www.last.fm/music/`,
 }
 
@@ -36,7 +36,7 @@ type lastfmAgent struct {
 	sessionKeys  *agents.SessionKeys
 	apiKey       string
 	secret       string
-	languages    []string
+	lang         string
 	client       *client
 	httpClient   httpDoer
 	getInfoMutex sync.Mutex
@@ -48,7 +48,7 @@ func lastFMConstructor(ds model.DataStore) *lastfmAgent {
 	}
 	l := &lastfmAgent{
 		ds:          ds,
-		languages:   conf.Server.LastFM.Languages,
+		lang:        conf.Server.LastFM.Language,
 		apiKey:      conf.Server.LastFM.ApiKey,
 		secret:      conf.Server.LastFM.Secret,
 		sessionKeys: &agents.SessionKeys{DataStore: ds, KeyName: sessionKeyProperty},
@@ -58,7 +58,7 @@ func lastFMConstructor(ds model.DataStore) *lastfmAgent {
 	}
 	chc := cache.NewHTTPClient(hc, consts.DefaultHttpClientTimeOut)
 	l.httpClient = chc
-	l.client = newClient(l.apiKey, l.secret, chc)
+	l.client = newClient(l.apiKey, l.secret, l.lang, chc)
 	return l
 }
 
@@ -68,47 +68,22 @@ func (l *lastfmAgent) AgentName() string {
 
 var imageRegex = regexp.MustCompile(`u\/(\d+)`)
 
-// isValidContent checks if content is non-empty and not in the ignored list
-func isValidContent(content string) bool {
-	content = strings.TrimSpace(content)
-	if content == "" {
-		return false
-	}
-	for _, ign := range ignoredContent {
-		if strings.HasPrefix(content, ign) {
-			return false
-		}
-	}
-	return true
-}
-
 func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*agents.AlbumInfo, error) {
-	var a *Album
-	var resp agents.AlbumInfo
-	for _, lang := range l.languages {
-		var err error
-		a, err = l.callAlbumGetInfo(ctx, name, artist, mbid, lang)
-		if err != nil {
-			return nil, err
-		}
-		resp.Name = a.Name
-		resp.MBID = a.MBID
-		resp.URL = a.URL
-		if isValidContent(a.Description.Summary) {
-			resp.Description = strings.TrimSpace(a.Description.Summary)
-			return &resp, nil
-		}
-		log.Debug(ctx, "LastFM/album.getInfo returned empty/ignored description, trying next language", "album", name, "artist", artist, "lang", lang)
+	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid)
+	if err != nil {
+		return nil, err
 	}
-	// This condition should not be hit (languages default to ["en"]), but just in case
-	if a == nil {
-		return nil, agents.ErrNotFound
-	}
-	return &resp, nil
+
+	return &agents.AlbumInfo{
+		Name:        a.Name,
+		MBID:        a.MBID,
+		Description: a.Description.Summary,
+		URL:         a.URL,
+	}, nil
 }
 
 func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
-	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid, l.languages[0])
+	a, err := l.callAlbumGetInfo(ctx, name, artist, mbid)
 	if err != nil {
 		return nil, err
 	}
@@ -143,7 +118,7 @@ func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid str
 }
 
 func (l *lastfmAgent) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
-	a, err := l.callArtistGetInfo(ctx, name, l.languages[0])
+	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return "", err
 	}
@@ -154,7 +129,7 @@ func (l *lastfmAgent) GetArtistMBID(ctx context.Context, id string, name string)
 }
 
 func (l *lastfmAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
-	a, err := l.callArtistGetInfo(ctx, name, l.languages[0])
+	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return "", err
 	}
@@ -165,17 +140,20 @@ func (l *lastfmAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (
 }
 
 func (l *lastfmAgent) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
-	for _, lang := range l.languages {
-		a, err := l.callArtistGetInfo(ctx, name, lang)
-		if err != nil {
-			return "", err
-		}
-		if isValidContent(a.Bio.Summary) {
-			return strings.TrimSpace(a.Bio.Summary), nil
-		}
-		log.Debug(ctx, "LastFM/artist.getInfo returned empty/ignored biography, trying next language", "artist", name, "lang", lang)
+	a, err := l.callArtistGetInfo(ctx, name)
+	if err != nil {
+		return "", err
 	}
-	return "", agents.ErrNotFound
+	a.Bio.Summary = strings.TrimSpace(a.Bio.Summary)
+	if a.Bio.Summary == "" {
+		return "", agents.ErrNotFound
+	}
+	for _, ign := range ignoredBiographies {
+		if strings.HasPrefix(a.Bio.Summary, ign) {
+			return "", nil
+		}
+	}
+	return a.Bio.Summary, nil
 }
 
 func (l *lastfmAgent) GetSimilarArtists(ctx context.Context, id, name, mbid string, limit int) ([]agents.Artist, error) {
@@ -214,26 +192,6 @@ func (l *lastfmAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbi
 	return res, nil
 }
 
-func (l *lastfmAgent) GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]agents.Song, error) {
-	resp, err := l.callTrackGetSimilar(ctx, name, artist, count)
-	if err != nil {
-		return nil, err
-	}
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-	res := make([]agents.Song, 0, len(resp))
-	for _, t := range resp {
-		res = append(res, agents.Song{
-			Name:       t.Name,
-			MBID:       t.MBID,
-			Artist:     t.Artist.Name,
-			ArtistMBID: t.Artist.MBID,
-		})
-	}
-	return res, nil
-}
-
 var (
 	artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
 	artistIgnoredImage   = "2a96cbd8b46e442fc41c2b86b821562f" // Last.fm artist placeholder image name
@@ -241,7 +199,7 @@ var (
 
 func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string) ([]agents.ExternalImage, error) {
 	log.Debug(ctx, "Getting artist images from Last.fm", "name", name)
-	a, err := l.callArtistGetInfo(ctx, name, l.languages[0])
+	a, err := l.callArtistGetInfo(ctx, name)
 	if err != nil {
 		return nil, fmt.Errorf("get artist info: %w", err)
 	}
@@ -281,14 +239,14 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
 	return res, nil
 }
 
-func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string, lang string) (*Album, error) {
-	a, err := l.client.albumGetInfo(ctx, name, artist, mbid, lang)
+func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string) (*Album, error) {
+	a, err := l.client.albumGetInfo(ctx, name, artist, mbid)
 	var lfErr *lastFMError
 	isLastFMError := errors.As(err, &lfErr)
 
 	if mbid != "" && (isLastFMError && lfErr.Code == 6) {
 		log.Debug(ctx, "LastFM/album.getInfo could not find album by mbid, trying again", "album", name, "mbid", mbid)
-		return l.callAlbumGetInfo(ctx, name, artist, "", lang)
+		return l.callAlbumGetInfo(ctx, name, artist, "")
 	}
 
 	if err != nil {
@@ -302,11 +260,11 @@ func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid s
 	return a, nil
 }
 
-func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string, lang string) (*Artist, error) {
+func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string) (*Artist, error) {
 	l.getInfoMutex.Lock()
 	defer l.getInfoMutex.Unlock()
 
-	a, err := l.client.artistGetInfo(ctx, name, lang)
+	a, err := l.client.artistGetInfo(ctx, name)
 	if err != nil {
 		log.Error(ctx, "Error calling LastFM/artist.getInfo", "artist", name, err)
 		return nil, err
@@ -332,15 +290,6 @@ func (l *lastfmAgent) callArtistGetTopTracks(ctx context.Context, artistName str
 	return t.Track, nil
 }
 
-func (l *lastfmAgent) callTrackGetSimilar(ctx context.Context, name, artist string, count int) ([]SimilarTrack, error) {
-	s, err := l.client.trackGetSimilar(ctx, name, artist, count)
-	if err != nil {
-		log.Error(ctx, "Error calling LastFM/track.getSimilar", "track", name, "artist", artist, err)
-		return nil, err
-	}
-	return s.Track, nil
-}
-
 func (l *lastfmAgent) getArtistForScrobble(track *model.MediaFile, role model.Role, displayName string) string {
 	if conf.Server.LastFM.ScrobbleFirstArtistOnly && len(track.Participants[role]) > 0 {
 		return track.Participants[role][0].Name

adapters/lastfm/agent_test.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"io"
 	"net/http"
-	"net/url"
 	"os"
 	"strconv"
 	"time"
@@ -39,12 +38,12 @@ var _ = Describe("lastfmAgent", func() {
 	})
 	Describe("lastFMConstructor", func() {
 		When("Agent is properly configured", func() {
-			It("uses configured api key and languages", func() {
-				conf.Server.LastFM.Languages = []string{"pt", "en"}
+			It("uses configured api key and language", func() {
+				conf.Server.LastFM.Language = "pt"
 				agent := lastFMConstructor(ds)
 				Expect(agent.apiKey).To(Equal("123"))
 				Expect(agent.secret).To(Equal("secret"))
-				Expect(agent.languages).To(Equal([]string{"pt", "en"}))
+				Expect(agent.lang).To(Equal("pt"))
 			})
 		})
 		When("Agent is disabled", func() {
@@ -72,7 +71,7 @@ var _ = Describe("lastfmAgent", func() {
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -102,129 +101,12 @@ var _ = Describe("lastfmAgent", func() {
 		})
 	})
 
-	Describe("Language Fallback", func() {
-		Describe("GetArtistBiography", func() {
-			var agent *lastfmAgent
-			var httpClient *langAwareHttpClient
-
-			BeforeEach(func() {
-				httpClient = newLangAwareHttpClient()
-			})
-
-			It("returns content in first language when available (1 API call)", func() {
-				conf.Server.LastFM.Languages = []string{"pt", "en"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Portuguese biography available
-				f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
-				httpClient.responses["pt"] = http.Response{Body: f, StatusCode: 200}
-
-				bio, err := agent.GetArtistBiography(ctx, "123", "U2", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(bio).To(ContainSubstring("U2 é uma das mais importantes bandas de rock"))
-				Expect(httpClient.requestCount).To(Equal(1))
-				Expect(httpClient.requests[0].URL.Query().Get("lang")).To(Equal("pt"))
-			})
-
-			It("falls back to second language when first returns empty (2 API calls)", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "en"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Japanese returns empty/ignored biography (actual Last.fm response with just "Read more" link)
-				fJa, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				// English returns full biography
-				fEn, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.en.json")
-				httpClient.responses["en"] = http.Response{Body: fEn, StatusCode: 200}
-
-				bio, err := agent.GetArtistBiography(ctx, "123", "Legião Urbana", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(bio).To(ContainSubstring("Legião Urbana was a Brazilian post-punk band"))
-				Expect(httpClient.requestCount).To(Equal(2))
-				Expect(httpClient.requests[0].URL.Query().Get("lang")).To(Equal("ja"))
-				Expect(httpClient.requests[1].URL.Query().Get("lang")).To(Equal("en"))
-			})
-
-			It("returns ErrNotFound when all languages return empty", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "xx"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Both languages return empty/ignored biography (using actual Last.fm response format)
-				fJa, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				// Second language also returns empty
-				fXx, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.empty.json")
-				httpClient.responses["xx"] = http.Response{Body: fXx, StatusCode: 200}
-
-				_, err := agent.GetArtistBiography(ctx, "123", "Legião Urbana", "")
-
-				Expect(err).To(MatchError(agents.ErrNotFound))
-				Expect(httpClient.requestCount).To(Equal(2))
-			})
-		})
-
-		Describe("GetAlbumInfo", func() {
-			var agent *lastfmAgent
-			var httpClient *langAwareHttpClient
-
-			BeforeEach(func() {
-				httpClient = newLangAwareHttpClient()
-			})
-
-			It("falls back to second language when first returns empty description (2 API calls)", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "en"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Japanese returns album without wiki/description (actual Last.fm response)
-				fJa, _ := os.Open("tests/fixtures/lastfm.album.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				// English returns album with description
-				fEn, _ := os.Open("tests/fixtures/lastfm.album.getinfo.en.json")
-				httpClient.responses["en"] = http.Response{Body: fEn, StatusCode: 200}
-
-				albumInfo, err := agent.GetAlbumInfo(ctx, "Dois", "Legião Urbana", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(albumInfo.Name).To(Equal("Dois"))
-				Expect(albumInfo.Description).To(ContainSubstring("segundo álbum de estúdio"))
-				Expect(httpClient.requestCount).To(Equal(2))
-				Expect(httpClient.requests[0].URL.Query().Get("lang")).To(Equal("ja"))
-				Expect(httpClient.requests[1].URL.Query().Get("lang")).To(Equal("en"))
-			})
-
-			It("returns album without description when all languages return empty", func() {
-				conf.Server.LastFM.Languages = []string{"ja", "xx"}
-				agent = lastFMConstructor(ds)
-				agent.client = newClient("API_KEY", "SECRET", httpClient)
-
-				// Both languages return album without description
-				fJa, _ := os.Open("tests/fixtures/lastfm.album.getinfo.empty.json")
-				httpClient.responses["ja"] = http.Response{Body: fJa, StatusCode: 200}
-				fXx, _ := os.Open("tests/fixtures/lastfm.album.getinfo.empty.json")
-				httpClient.responses["xx"] = http.Response{Body: fXx, StatusCode: 200}
-
-				albumInfo, err := agent.GetAlbumInfo(ctx, "Dois", "Legião Urbana", "")
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(albumInfo.Name).To(Equal("Dois"))
-				Expect(albumInfo.Description).To(BeEmpty())
-				Expect(httpClient.requestCount).To(Equal(2))
-			})
-		})
-	})
-
 	Describe("GetSimilarArtists", func() {
 		var agent *lastfmAgent
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -262,7 +144,7 @@ var _ = Describe("lastfmAgent", func() {
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -295,54 +177,6 @@ var _ = Describe("lastfmAgent", func() {
 		})
 	})
 
-	Describe("GetSimilarSongsByTrack", func() {
-		var agent *lastfmAgent
-		var httpClient *tests.FakeHttpClient
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
-			agent = lastFMConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns similar songs", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			Expect(agent.GetSimilarSongsByTrack(ctx, "123", "Just Can't Get Enough", "Depeche Mode", "", 5)).To(Equal([]agents.Song{
-				{Name: "Dreaming of Me", MBID: "027b553e-7c74-3ed4-a95e-1d4fea51f174", Artist: "Depeche Mode", ArtistMBID: "8538e728-ca0b-4321-b7e5-cff6565dd4c0"},
-				{Name: "Everything Counts", MBID: "5a5a3ca4-bdb8-4641-a674-9b54b9b319a6", Artist: "Depeche Mode", ArtistMBID: "8538e728-ca0b-4321-b7e5-cff6565dd4c0"},
-				{Name: "Don't You Want Me", MBID: "", Artist: "The Human League", ArtistMBID: "7adaabfb-acfb-47bc-8c7c-59471c2f0db8"},
-				{Name: "Tainted Love", MBID: "", Artist: "Soft Cell", ArtistMBID: "7fb50287-029d-47cc-825a-235ca28024b2"},
-				{Name: "Blue Monday", MBID: "727e84c6-1b56-31dd-a958-a5f46305cec0", Artist: "New Order", ArtistMBID: "f1106b17-dcbb-45f6-b938-199ccfab50cc"},
-			}))
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("track")).To(Equal("Just Can't Get Enough"))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("Depeche Mode"))
-		})
-
-		It("returns ErrNotFound when no similar songs found", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.unknown.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			_, err := agent.GetSimilarSongsByTrack(ctx, "123", "UnknownTrack", "UnknownArtist", "", 3)
-			Expect(err).To(MatchError(agents.ErrNotFound))
-			Expect(httpClient.RequestCount).To(Equal(1))
-		})
-
-		It("returns an error if Last.fm call fails", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetSimilarSongsByTrack(ctx, "123", "Believe", "Cher", "", 3)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-		})
-
-		It("returns an error if Last.fm call returns an error", func() {
-			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
-			_, err := agent.GetSimilarSongsByTrack(ctx, "123", "Believe", "Cher", "", 3)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-		})
-	})
-
 	Describe("Scrobbling", func() {
 		var agent *lastfmAgent
 		var httpClient *tests.FakeHttpClient
@@ -350,7 +184,7 @@ var _ = Describe("lastfmAgent", func() {
 		BeforeEach(func() {
 			_ = ds.UserProps(ctx).Put("user-1", sessionKeyProperty, "SK-1")
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "en", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 			track = &model.MediaFile{
@@ -383,8 +217,7 @@ var _ = Describe("lastfmAgent", func() {
 
 				Expect(err).ToNot(HaveOccurred())
 				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
-				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-				sentParams, _ := url.ParseQuery(string(body))
+				sentParams := httpClient.SavedRequest.URL.Query()
 				Expect(sentParams.Get("method")).To(Equal("track.updateNowPlaying"))
 				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
 				Expect(sentParams.Get("track")).To(Equal(track.Title))
@@ -412,8 +245,7 @@ var _ = Describe("lastfmAgent", func() {
 					err := agent.NowPlaying(ctx, "user-1", track, 0)
 
 					Expect(err).ToNot(HaveOccurred())
-					body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-					sentParams, _ := url.ParseQuery(string(body))
+					sentParams := httpClient.SavedRequest.URL.Query()
 					Expect(sentParams.Get("artist")).To(Equal("First Artist"))
 					Expect(sentParams.Get("albumArtist")).To(Equal("First Album Artist"))
 				})
@@ -429,8 +261,7 @@ var _ = Describe("lastfmAgent", func() {
 
 				Expect(err).ToNot(HaveOccurred())
 				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
-				body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-				sentParams, _ := url.ParseQuery(string(body))
+				sentParams := httpClient.SavedRequest.URL.Query()
 				Expect(sentParams.Get("method")).To(Equal("track.scrobble"))
 				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
 				Expect(sentParams.Get("track")).To(Equal(track.Title))
@@ -455,8 +286,7 @@ var _ = Describe("lastfmAgent", func() {
 					err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: ts})
 
 					Expect(err).ToNot(HaveOccurred())
-					body, _ := io.ReadAll(httpClient.SavedRequest.Body)
-					sentParams, _ := url.ParseQuery(string(body))
+					sentParams := httpClient.SavedRequest.URL.Query()
 					Expect(sentParams.Get("artist")).To(Equal("First Artist"))
 					Expect(sentParams.Get("albumArtist")).To(Equal("First Album Artist"))
 				})
@@ -524,7 +354,7 @@ var _ = Describe("lastfmAgent", func() {
 		var httpClient *tests.FakeHttpClient
 		BeforeEach(func() {
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", httpClient)
+			client := newClient("API_KEY", "SECRET", "pt", httpClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 		})
@@ -594,7 +424,7 @@ var _ = Describe("lastfmAgent", func() {
 		BeforeEach(func() {
 			apiClient = &tests.FakeHttpClient{}
 			httpClient = &tests.FakeHttpClient{}
-			client := newClient("API_KEY", "SECRET", apiClient)
+			client := newClient("API_KEY", "SECRET", "pt", apiClient)
 			agent = lastFMConstructor(ds)
 			agent.client = client
 			agent.httpClient = httpClient
@@ -655,31 +485,3 @@ var _ = Describe("lastfmAgent", func() {
 		})
 	})
 })
-
-// langAwareHttpClient is a mock HTTP client that returns different responses based on the lang parameter
-type langAwareHttpClient struct {
-	responses    map[string]http.Response
-	requests     []*http.Request
-	requestCount int
-}
-
-func newLangAwareHttpClient() *langAwareHttpClient {
-	return &langAwareHttpClient{
-		responses: make(map[string]http.Response),
-		requests:  make([]*http.Request, 0),
-	}
-}
-
-func (c *langAwareHttpClient) Do(req *http.Request) (*http.Response, error) {
-	c.requestCount++
-	c.requests = append(c.requests, req)
-	lang := req.URL.Query().Get("lang")
-	if resp, ok := c.responses[lang]; ok {
-		return &resp, nil
-	}
-	// Return default empty response if no specific response is configured
-	return &http.Response{
-		StatusCode: 200,
-		Body:       io.NopCloser(bytes.NewBufferString(`{}`)),
-	}, nil
-}

adapters/lastfm/auth_router.go

@@ -44,7 +44,7 @@ func NewRouter(ds model.DataStore) *Router {
 	hc := &http.Client{
 		Timeout: consts.DefaultHttpClientTimeOut,
 	}
-	r.client = newClient(r.apiKey, r.secret, hc)
+	r.client = newClient(r.apiKey, r.secret, "en", hc)
 	return r
 }
 

adapters/lastfm/client.go

@@ -34,23 +34,24 @@ type httpDoer interface {
 	Do(req *http.Request) (*http.Response, error)
 }
 
-func newClient(apiKey string, secret string, hc httpDoer) *client {
-	return &client{apiKey, secret, hc}
+func newClient(apiKey string, secret string, lang string, hc httpDoer) *client {
+	return &client{apiKey, secret, lang, hc}
 }
 
 type client struct {
 	apiKey string
 	secret string
+	lang   string
 	hc     httpDoer
 }
 
-func (c *client) albumGetInfo(ctx context.Context, name string, artist string, mbid string, lang string) (*Album, error) {
+func (c *client) albumGetInfo(ctx context.Context, name string, artist string, mbid string) (*Album, error) {
 	params := url.Values{}
 	params.Add("method", "album.getInfo")
 	params.Add("album", name)
 	params.Add("artist", artist)
 	params.Add("mbid", mbid)
-	params.Add("lang", lang)
+	params.Add("lang", c.lang)
 	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
 	if err != nil {
 		return nil, err
@@ -58,11 +59,11 @@ func (c *client) albumGetInfo(ctx context.Context, name string, artist string, m
 	return &response.Album, nil
 }
 
-func (c *client) artistGetInfo(ctx context.Context, name string, lang string) (*Artist, error) {
+func (c *client) artistGetInfo(ctx context.Context, name string) (*Artist, error) {
 	params := url.Values{}
 	params.Add("method", "artist.getInfo")
 	params.Add("artist", name)
-	params.Add("lang", lang)
+	params.Add("lang", c.lang)
 	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
 	if err != nil {
 		return nil, err
@@ -94,19 +95,6 @@ func (c *client) artistGetTopTracks(ctx context.Context, name string, limit int)
 	return &response.TopTracks, nil
 }
 
-func (c *client) trackGetSimilar(ctx context.Context, name, artist string, limit int) (*SimilarTracks, error) {
-	params := url.Values{}
-	params.Add("method", "track.getSimilar")
-	params.Add("track", name)
-	params.Add("artist", artist)
-	params.Add("limit", strconv.Itoa(limit))
-	response, err := c.makeRequest(ctx, http.MethodGet, params, false)
-	if err != nil {
-		return nil, err
-	}
-	return &response.SimilarTracks, nil
-}
-
 func (c *client) GetToken(ctx context.Context) (string, error) {
 	params := url.Values{}
 	params.Add("method", "auth.getToken")
@@ -197,15 +185,8 @@ func (c *client) makeRequest(ctx context.Context, method string, params url.Valu
 		c.sign(params)
 	}
 
-	var req *http.Request
-	if method == http.MethodPost {
-		body := strings.NewReader(params.Encode())
-		req, _ = http.NewRequestWithContext(ctx, method, apiBaseUrl, body)
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	} else {
-		req, _ = http.NewRequestWithContext(ctx, method, apiBaseUrl, nil)
-		req.URL.RawQuery = params.Encode()
-	}
+	req, _ := http.NewRequestWithContext(ctx, method, apiBaseUrl, nil)
+	req.URL.RawQuery = params.Encode()
 
 	log.Trace(ctx, fmt.Sprintf("Sending Last.fm %s request", req.Method), "url", req.URL)
 	resp, err := c.hc.Do(req)

adapters/lastfm/client_test.go

@@ -22,7 +22,7 @@ var _ = Describe("client", func() {
 
 	BeforeEach(func() {
 		httpClient = &tests.FakeHttpClient{}
-		client = newClient("API_KEY", "SECRET", httpClient)
+		client = newClient("API_KEY", "SECRET", "pt", httpClient)
 	})
 
 	Describe("albumGetInfo", func() {
@@ -30,7 +30,7 @@ var _ = Describe("client", func() {
 			f, _ := os.Open("tests/fixtures/lastfm.album.getinfo.json")
 			httpClient.Res = http.Response{Body: f, StatusCode: 200}
 
-			album, err := client.albumGetInfo(context.Background(), "Believe", "U2", "mbid-1234", "pt")
+			album, err := client.albumGetInfo(context.Background(), "Believe", "U2", "mbid-1234")
 			Expect(err).To(BeNil())
 			Expect(album.Name).To(Equal("Believe"))
 			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?album=Believe&api_key=API_KEY&artist=U2&format=json&lang=pt&mbid=mbid-1234&method=album.getInfo"))
@@ -42,7 +42,7 @@ var _ = Describe("client", func() {
 			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
 			httpClient.Res = http.Response{Body: f, StatusCode: 200}
 
-			artist, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			artist, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(BeNil())
 			Expect(artist.Name).To(Equal("U2"))
 			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&lang=pt&method=artist.getInfo"))
@@ -54,7 +54,7 @@ var _ = Describe("client", func() {
 				StatusCode: 500,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError("last.fm http status: (500)"))
 		})
 
@@ -64,7 +64,7 @@ var _ = Describe("client", func() {
 				StatusCode: 400,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError(&lastFMError{Code: 3, Message: "Invalid Method - No method with that name in this package"}))
 		})
 
@@ -74,14 +74,14 @@ var _ = Describe("client", func() {
 				StatusCode: 200,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError(&lastFMError{Code: 6, Message: "The artist you supplied could not be found"}))
 		})
 
 		It("fails if HttpClient.Do() returns error", func() {
 			httpClient.Err = errors.New("generic error")
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError("generic error"))
 		})
 
@@ -91,7 +91,7 @@ var _ = Describe("client", func() {
 				StatusCode: 200,
 			}
 
-			_, err := client.artistGetInfo(context.Background(), "U2", "pt")
+			_, err := client.artistGetInfo(context.Background(), "U2")
 			Expect(err).To(MatchError("invalid character '<' looking for beginning of value"))
 		})
 
@@ -121,30 +121,6 @@ var _ = Describe("client", func() {
 		})
 	})
 
-	Describe("trackGetSimilar", func() {
-		It("returns similar tracks for a successful response", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			similar, err := client.trackGetSimilar(context.Background(), "Just Can't Get Enough", "Depeche Mode", 5)
-			Expect(err).To(BeNil())
-			Expect(len(similar.Track)).To(Equal(5))
-			Expect(similar.Track[0].Name).To(Equal("Dreaming of Me"))
-			Expect(similar.Track[0].Artist.Name).To(Equal("Depeche Mode"))
-			Expect(similar.Track[0].Match).To(Equal(1.0))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=Depeche+Mode&format=json&limit=5&method=track.getSimilar&track=Just+Can%27t+Get+Enough"))
-		})
-
-		It("returns empty list when no similar tracks found", func() {
-			f, _ := os.Open("tests/fixtures/lastfm.track.getsimilar.unknown.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			similar, err := client.trackGetSimilar(context.Background(), "UnknownTrack", "UnknownArtist", 3)
-			Expect(err).To(BeNil())
-			Expect(similar.Track).To(BeEmpty())
-		})
-	})
-
 	Describe("GetToken", func() {
 		It("returns a token when the request is successful", func() {
 			httpClient.Res = http.Response{
@@ -178,74 +154,6 @@ var _ = Describe("client", func() {
 		})
 	})
 
-	Describe("scrobble", func() {
-		It("sends parameters in request body for POST", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"scrobbles":{"scrobble":{"ignoredMessage":{"code":"0"}},"@attr":{"accepted":1}}}`)),
-				StatusCode: 200,
-			}
-
-			info := ScrobbleInfo{
-				artist:      "U2",
-				track:       "One",
-				album:       "Achtung Baby",
-				trackNumber: 1,
-				duration:    276,
-				albumArtist: "U2",
-			}
-			err := client.scrobble(context.Background(), "SESSION_KEY", info)
-			Expect(err).To(BeNil())
-
-			req := httpClient.SavedRequest
-			Expect(req.Method).To(Equal(http.MethodPost))
-			Expect(req.Header.Get("Content-Type")).To(Equal("application/x-www-form-urlencoded"))
-			Expect(req.URL.RawQuery).To(BeEmpty())
-
-			body, _ := io.ReadAll(req.Body)
-			bodyParams, _ := url.ParseQuery(string(body))
-			Expect(bodyParams.Get("method")).To(Equal("track.scrobble"))
-			Expect(bodyParams.Get("artist")).To(Equal("U2"))
-			Expect(bodyParams.Get("track")).To(Equal("One"))
-			Expect(bodyParams.Get("sk")).To(Equal("SESSION_KEY"))
-			Expect(bodyParams.Get("api_key")).To(Equal("API_KEY"))
-			Expect(bodyParams.Get("api_sig")).ToNot(BeEmpty())
-		})
-	})
-
-	Describe("updateNowPlaying", func() {
-		It("sends parameters in request body for POST", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"nowplaying":{"ignoredMessage":{"code":"0"}}}`)),
-				StatusCode: 200,
-			}
-
-			info := ScrobbleInfo{
-				artist:      "U2",
-				track:       "One",
-				album:       "Achtung Baby",
-				trackNumber: 1,
-				duration:    276,
-				albumArtist: "U2",
-			}
-			err := client.updateNowPlaying(context.Background(), "SESSION_KEY", info)
-			Expect(err).To(BeNil())
-
-			req := httpClient.SavedRequest
-			Expect(req.Method).To(Equal(http.MethodPost))
-			Expect(req.Header.Get("Content-Type")).To(Equal("application/x-www-form-urlencoded"))
-			Expect(req.URL.RawQuery).To(BeEmpty())
-
-			body, _ := io.ReadAll(req.Body)
-			bodyParams, _ := url.ParseQuery(string(body))
-			Expect(bodyParams.Get("method")).To(Equal("track.updateNowPlaying"))
-			Expect(bodyParams.Get("artist")).To(Equal("U2"))
-			Expect(bodyParams.Get("track")).To(Equal("One"))
-			Expect(bodyParams.Get("sk")).To(Equal("SESSION_KEY"))
-			Expect(bodyParams.Get("api_key")).To(Equal("API_KEY"))
-			Expect(bodyParams.Get("api_sig")).ToNot(BeEmpty())
-		})
-	})
-
 	Describe("sign", func() {
 		It("adds an api_sig param with the signature", func() {
 			params := url.Values{}

adapters/lastfm/responses.go

@@ -5,7 +5,6 @@ type Response struct {
 	SimilarArtists SimilarArtists `json:"similarartists"`
 	TopTracks      TopTracks      `json:"toptracks"`
 	Album          Album          `json:"album"`
-	SimilarTracks  SimilarTracks  `json:"similartracks"`
 	Error          int            `json:"error"`
 	Message        string         `json:"message"`
 	Token          string         `json:"token"`
@@ -60,28 +59,6 @@ type TopTracks struct {
 	Attr  Attr    `json:"@attr"`
 }
 
-type SimilarTracks struct {
-	Track []SimilarTrack `json:"track"`
-	Attr  SimilarAttr    `json:"@attr"`
-}
-
-type SimilarTrack struct {
-	Name   string             `json:"name"`
-	MBID   string             `json:"mbid"`
-	Match  float64            `json:"match"`
-	Artist SimilarTrackArtist `json:"artist"`
-}
-
-type SimilarTrackArtist struct {
-	Name string `json:"name"`
-	MBID string `json:"mbid"`
-}
-
-type SimilarAttr struct {
-	Artist string `json:"artist"`
-	Track  string `json:"track"`
-}
-
 type Session struct {
 	Name       string `json:"name"`
 	Key        string `json:"key"`

adapters/taglib/end_to_end_test.go

@@ -151,7 +151,11 @@ var _ = Describe("Extractor", func() {
 			unsSylt := makeLyrics("xxx", "unspecified SYLT")
 			unsUslt := makeLyrics("xxx", "unspecified")
 
-			Expect(lyrics).To(ConsistOf(engSylt, engUslt, unsSylt, unsUslt))
+			// Why is the order inconsistent between runs? Nobody knows
+			Expect(lyrics).To(Or(
+				Equal(model.LyricList{engSylt, engUslt, unsSylt, unsUslt}),
+				Equal(model.LyricList{unsSylt, unsUslt, engSylt, engUslt}),
+			))
 		})
 
 		DescribeTable("format-specific lyrics", func(file string, isId3 bool) {

adapters/taglib/taglib.go

@@ -168,7 +168,7 @@ func parseTIPL(tags map[string][]string) {
 var _ local.Extractor = (*extractor)(nil)
 
 func init() {
-	local.RegisterExtractor("legacy-taglib", func(_ fs.FS, baseDir string) local.Extractor {
+	local.RegisterExtractor("taglib", func(_ fs.FS, baseDir string) local.Extractor {
 		// ignores fs, as taglib extractor only works with local files
 		return &extractor{baseDir}
 	})

adapters/taglib/taglib_test.go

@@ -80,11 +80,12 @@ var _ = Describe("Extractor", func() {
 			Expect(err).To(BeNil())
 			Expect(m.Tags).To(HaveKeyWithValue("fbpm", []string{"141.7"}))
 
-			// TagLib 1.12 returns 18, previous versions return 39.
+			// TabLib 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.AudioProperties.SampleRate).To(BeElementOf(8000))
 			Expect(m.HasPicture).To(BeTrue())
 		})
 
@@ -105,7 +106,7 @@ var _ = Describe("Extractor", func() {
 
 				Expect(m.Tags).To(Or(
 					HaveKeyWithValue("replaygain_album_gain", []string{albumGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_gain", []string{albumGain}),
+					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_gain", []string{albumGain}),
 				))
 
 				Expect(m.Tags).To(Or(

cmd/root.go

@@ -24,7 +24,6 @@ import (
 
 	// Import adapters to register them
 	_ "github.com/navidrome/navidrome/adapters/deezer"
-	_ "github.com/navidrome/navidrome/adapters/gotaglib"
 	_ "github.com/navidrome/navidrome/adapters/lastfm"
 	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
 	_ "github.com/navidrome/navidrome/adapters/spotify"

cmd/wire_gen.go

@@ -19,7 +19,6 @@ import (
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/scrobbler"
-	"github.com/navidrome/navidrome/core/transcode"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
@@ -34,7 +33,6 @@ import (
 
 import (
 	_ "github.com/navidrome/navidrome/adapters/deezer"
-	_ "github.com/navidrome/navidrome/adapters/gotaglib"
 	_ "github.com/navidrome/navidrome/adapters/lastfm"
 	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
 	_ "github.com/navidrome/navidrome/adapters/spotify"
@@ -103,8 +101,7 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
 	playbackServer := playback.GetInstance(dataStore)
-	decider := transcode.NewDecider(dataStore)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics, decider)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
 	return router
 }
 

conf/configuration.go

@@ -1,7 +1,6 @@
 package conf
 
 import (
-	"cmp"
 	"fmt"
 	"net/url"
 	"os"
@@ -58,7 +57,6 @@ type configOptions struct {
 	AutoTranscodeDownload           bool
 	DefaultDownsamplingFormat       string
 	SearchFullString                bool
-	SimilarSongsMatchThreshold      int
 	RecentlyAddedByModTime          bool
 	PreferSortTags                  bool
 	IgnoredArticles                 string
@@ -128,7 +126,6 @@ type configOptions struct {
 	DevExternalScanner                bool
 	DevScannerThreads                 uint
 	DevSelectiveWatcher               bool
-	DevLegacyEmbedImage               bool
 	DevInsightsInitialDelay           time.Duration
 	DevEnablePlayerInsights           bool
 	DevEnablePluginsInsights          bool
@@ -155,7 +152,6 @@ type subsonicOptions struct {
 	AppendSubtitle        bool
 	ArtistParticipations  bool
 	DefaultReportRealPath bool
-	EnableAverageRating   bool
 	LegacyClients         string
 	MinimalClients        string
 }
@@ -175,9 +171,6 @@ type lastfmOptions struct {
 	Secret                  string
 	Language                string
 	ScrobbleFirstArtistOnly bool
-
-	// Computed values
-	Languages []string // Computed from Language, split by comma
 }
 
 type spotifyOptions struct {
@@ -188,9 +181,6 @@ type spotifyOptions struct {
 type deezerOptions struct {
 	Enabled  bool
 	Language string
-
-	// Computed values
-	Languages []string // Computed from Language, split by comma
 }
 
 type listenBrainzOptions struct {
@@ -376,16 +366,10 @@ func Load(noConfigDump bool) {
 		disableExternalServices()
 	}
 
-	// Make sure we don't have empty PIDs
-	Server.PID.Album = cmp.Or(Server.PID.Album, consts.DefaultAlbumPID)
-	Server.PID.Track = cmp.Or(Server.PID.Track, consts.DefaultTrackPID)
-
-	// Parse LastFM.Language into Languages slice (comma-separated, with fallback to DefaultInfoLanguage)
-	Server.LastFM.Languages = parseLanguages(Server.LastFM.Language)
-
-	// Parse Deezer.Language into Languages slice (comma-separated, with fallback to DefaultInfoLanguage)
-	Server.Deezer.Languages = parseLanguages(Server.Deezer.Language)
-
+	if Server.Scanner.Extractor != consts.DefaultScannerExtractor {
+		log.Warn(fmt.Sprintf("Extractor '%s' is not implemented, using 'taglib'", Server.Scanner.Extractor))
+		Server.Scanner.Extractor = consts.DefaultScannerExtractor
+	}
 	logDeprecatedOptions("Scanner.GenreSeparators", "")
 	logDeprecatedOptions("Scanner.GroupAlbumReleases", "")
 	logDeprecatedOptions("DevEnableBufferedScrobble", "") // Deprecated: Buffered scrobbling is now always enabled and this option is ignored
@@ -474,22 +458,6 @@ func validatePlaylistsPath() error {
 	return nil
 }
 
-// parseLanguages parses a comma-separated language string into a slice.
-// It trims whitespace from each entry and ensures at least [DefaultInfoLanguage] is returned.
-func parseLanguages(lang string) []string {
-	var languages []string
-	for _, l := range strings.Split(lang, ",") {
-		l = strings.TrimSpace(l)
-		if l != "" {
-			languages = append(languages, l)
-		}
-	}
-	if len(languages) == 0 {
-		return []string{consts.DefaultInfoLanguage}
-	}
-	return languages
-}
-
 func validatePurgeMissingOption() error {
 	allowedValues := []string{consts.PurgeMissingNever, consts.PurgeMissingAlways, consts.PurgeMissingFull}
 	valid := false
@@ -589,7 +557,6 @@ func setViperDefaults() {
 	viper.SetDefault("autotranscodedownload", false)
 	viper.SetDefault("defaultdownsamplingformat", consts.DefaultDownsamplingFormat)
 	viper.SetDefault("searchfullstring", false)
-	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")
@@ -642,19 +609,17 @@ func setViperDefaults() {
 	viper.SetDefault("subsonic.appendsubtitle", true)
 	viper.SetDefault("subsonic.artistparticipations", false)
 	viper.SetDefault("subsonic.defaultreportrealpath", false)
-	viper.SetDefault("subsonic.enableaveragerating", true)
-	viper.SetDefault("subsonic.legacyclients", "DSub")
-	viper.SetDefault("subsonic.minimalclients", "SubMusic")
+	viper.SetDefault("subsonic.legacyclients", "DSub,SubMusic")
 	viper.SetDefault("agents", "lastfm,spotify,deezer")
 	viper.SetDefault("lastfm.enabled", true)
-	viper.SetDefault("lastfm.language", consts.DefaultInfoLanguage)
+	viper.SetDefault("lastfm.language", "en")
 	viper.SetDefault("lastfm.apikey", "")
 	viper.SetDefault("lastfm.secret", "")
 	viper.SetDefault("lastfm.scrobblefirstartistonly", false)
 	viper.SetDefault("spotify.id", "")
 	viper.SetDefault("spotify.secret", "")
 	viper.SetDefault("deezer.enabled", true)
-	viper.SetDefault("deezer.language", consts.DefaultInfoLanguage)
+	viper.SetDefault("deezer.language", "en")
 	viper.SetDefault("listenbrainz.enabled", true)
 	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
 	viper.SetDefault("enablescrobblehistory", true)
@@ -669,7 +634,7 @@ func setViperDefaults() {
 	viper.SetDefault("inspect.backloglimit", consts.RequestThrottleBacklogLimit)
 	viper.SetDefault("inspect.backlogtimeout", consts.RequestThrottleBacklogTimeout)
 	viper.SetDefault("plugins.folder", "")
-	viper.SetDefault("plugins.enabled", true)
+	viper.SetDefault("plugins.enabled", false)
 	viper.SetDefault("plugins.cachesize", "200MB")
 	viper.SetDefault("plugins.autoreload", false)
 

conf/configuration_test.go

@@ -26,32 +26,6 @@ var _ = Describe("Configuration", func() {
 		conf.ResetConf()
 	})
 
-	Describe("ParseLanguages", func() {
-		It("parses single language", func() {
-			Expect(conf.ParseLanguages("en")).To(Equal([]string{"en"}))
-		})
-
-		It("parses multiple comma-separated languages", func() {
-			Expect(conf.ParseLanguages("pt,en")).To(Equal([]string{"pt", "en"}))
-		})
-
-		It("trims whitespace from languages", func() {
-			Expect(conf.ParseLanguages(" pt , en ")).To(Equal([]string{"pt", "en"}))
-		})
-
-		It("returns default 'en' when empty", func() {
-			Expect(conf.ParseLanguages("")).To(Equal([]string{"en"}))
-		})
-
-		It("returns default 'en' when only whitespace", func() {
-			Expect(conf.ParseLanguages("   ")).To(Equal([]string{"en"}))
-		})
-
-		It("handles multiple languages with various spacing", func() {
-			Expect(conf.ParseLanguages("ja, pt, en")).To(Equal([]string{"ja", "pt", "en"}))
-		})
-	})
-
 	DescribeTable("should load configuration from",
 		func(format string) {
 			filename := filepath.Join("testdata", "cfg."+format)

conf/export_test.go

@@ -5,5 +5,3 @@ func ResetConf() {
 }
 
 var SetViperDefaults = setViperDefaults
-
-var ParseLanguages = parseLanguages

consts/consts.go

@@ -56,8 +56,6 @@ const (
 
 	ServerReadHeaderTimeout = 3 * time.Second
 
-	DefaultInfoLanguage = "en"
-
 	ArtistInfoTimeToLive      = 24 * time.Hour
 	AlbumInfoTimeToLive       = 7 * 24 * time.Hour
 	UpdateLastAccessFrequency = time.Minute

core/agents/agents.go

@@ -22,8 +22,6 @@ type PluginLoader interface {
 	LoadMediaAgent(name string) (Interface, bool)
 }
 
-// Agents is a meta-agent that aggregates multiple built-in and plugin agents. It tries each enabled agent in order
-// until one returns valid data.
 type Agents struct {
 	ds           model.DataStore
 	pluginLoader PluginLoader
@@ -131,14 +129,26 @@ func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (str
 	case consts.VariousArtistsID:
 		return "", nil
 	}
-
-	return callAgentMethod(ctx, a, "GetArtistMBID", func(ag Interface) (string, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistMBIDRetriever)
 		if !ok {
-			return "", ErrNotFound
+			continue
 		}
-		return retriever.GetArtistMBID(ctx, id, name)
-	})
+		mbid, err := retriever.GetArtistMBID(ctx, id, name)
+		if mbid != "" && err == nil {
+			log.Debug(ctx, "Got MBID", "agent", ag.AgentName(), "artist", name, "mbid", mbid, "elapsed", time.Since(start))
+			return mbid, nil
+		}
+	}
+	return "", ErrNotFound
 }
 
 func (a *Agents) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
@@ -148,14 +158,26 @@ func (a *Agents) GetArtistURL(ctx context.Context, id, name, mbid string) (strin
 	case consts.VariousArtistsID:
 		return "", nil
 	}
-
-	return callAgentMethod(ctx, a, "GetArtistURL", func(ag Interface) (string, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistURLRetriever)
 		if !ok {
-			return "", ErrNotFound
+			continue
 		}
-		return retriever.GetArtistURL(ctx, id, name, mbid)
-	})
+		url, err := retriever.GetArtistURL(ctx, id, name, mbid)
+		if url != "" && err == nil {
+			log.Debug(ctx, "Got External Url", "agent", ag.AgentName(), "artist", name, "url", url, "elapsed", time.Since(start))
+			return url, nil
+		}
+	}
+	return "", ErrNotFound
 }
 
 func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
@@ -165,14 +187,26 @@ func (a *Agents) GetArtistBiography(ctx context.Context, id, name, mbid string)
 	case consts.VariousArtistsID:
 		return "", nil
 	}
-
-	return callAgentMethod(ctx, a, "GetArtistBiography", func(ag Interface) (string, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistBiographyRetriever)
 		if !ok {
-			return "", ErrNotFound
+			continue
 		}
-		return retriever.GetArtistBiography(ctx, id, name, mbid)
-	})
+		bio, err := retriever.GetArtistBiography(ctx, id, name, mbid)
+		if err == nil {
+			log.Debug(ctx, "Got Biography", "agent", ag.AgentName(), "artist", name, "len", len(bio), "elapsed", time.Since(start))
+			return bio, nil
+		}
+	}
+	return "", ErrNotFound
 }
 
 // GetSimilarArtists returns similar artists by id, name, and/or mbid. Because some artists returned from an enabled
@@ -220,14 +254,26 @@ func (a *Agents) GetArtistImages(ctx context.Context, id, name, mbid string) ([]
 	case consts.VariousArtistsID:
 		return nil, nil
 	}
-
-	return callAgentSliceMethod(ctx, a, "GetArtistImages", func(ag Interface) ([]ExternalImage, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistImageRetriever)
 		if !ok {
-			return nil, ErrNotFound
+			continue
 		}
-		return retriever.GetArtistImages(ctx, id, name, mbid)
-	})
+		images, err := retriever.GetArtistImages(ctx, id, name, mbid)
+		if len(images) > 0 && err == nil {
+			log.Debug(ctx, "Got Images", "agent", ag.AgentName(), "artist", name, "images", images, "elapsed", time.Since(start))
+			return images, nil
+		}
+	}
+	return nil, ErrNotFound
 }
 
 // GetArtistTopSongs returns top songs by id, name, and/or mbid. Because some songs returned from an enabled
@@ -242,127 +288,80 @@ func (a *Agents) GetArtistTopSongs(ctx context.Context, id, artistName, mbid str
 
 	overLimit := int(float64(count) * conf.Server.DevExternalArtistFetchMultiplier)
 
-	return callAgentSliceMethod(ctx, a, "GetArtistTopSongs", func(ag Interface) ([]Song, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(ArtistTopSongsRetriever)
 		if !ok {
-			return nil, ErrNotFound
+			continue
 		}
-		return retriever.GetArtistTopSongs(ctx, id, artistName, mbid, overLimit)
-	})
+		songs, err := retriever.GetArtistTopSongs(ctx, id, artistName, mbid, overLimit)
+		if len(songs) > 0 && err == nil {
+			log.Debug(ctx, "Got Top Songs", "agent", ag.AgentName(), "artist", artistName, "songs", songs, "elapsed", time.Since(start))
+			return songs, nil
+		}
+	}
+	return nil, ErrNotFound
 }
 
 func (a *Agents) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*AlbumInfo, error) {
 	if name == consts.UnknownAlbum {
 		return nil, ErrNotFound
 	}
-
-	return callAgentMethod(ctx, a, "GetAlbumInfo", func(ag Interface) (*AlbumInfo, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(AlbumInfoRetriever)
 		if !ok {
-			return nil, ErrNotFound
+			continue
 		}
-		return retriever.GetAlbumInfo(ctx, name, artist, mbid)
-	})
+		album, err := retriever.GetAlbumInfo(ctx, name, artist, mbid)
+		if err == nil {
+			log.Debug(ctx, "Got Album Info", "agent", ag.AgentName(), "album", name, "artist", artist,
+				"mbid", mbid, "elapsed", time.Since(start))
+			return album, nil
+		}
+	}
+	return nil, ErrNotFound
 }
 
 func (a *Agents) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]ExternalImage, error) {
 	if name == consts.UnknownAlbum {
 		return nil, ErrNotFound
 	}
-
-	return callAgentSliceMethod(ctx, a, "GetAlbumImages", func(ag Interface) ([]ExternalImage, error) {
+	start := time.Now()
+	for _, enabledAgent := range a.getEnabledAgentNames() {
+		ag := a.getAgent(enabledAgent)
+		if ag == nil {
+			continue
+		}
+		if utils.IsCtxDone(ctx) {
+			break
+		}
 		retriever, ok := ag.(AlbumImageRetriever)
 		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetAlbumImages(ctx, name, artist, mbid)
-	})
-}
-
-// GetSimilarSongsByTrack returns similar songs for a given track.
-func (a *Agents) GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	return callAgentSliceMethod(ctx, a, "GetSimilarSongsByTrack", func(ag Interface) ([]Song, error) {
-		retriever, ok := ag.(SimilarSongsByTrackRetriever)
-		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetSimilarSongsByTrack(ctx, id, name, artist, mbid, count)
-	})
-}
-
-// GetSimilarSongsByAlbum returns similar songs for a given album.
-func (a *Agents) GetSimilarSongsByAlbum(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	return callAgentSliceMethod(ctx, a, "GetSimilarSongsByAlbum", func(ag Interface) ([]Song, error) {
-		retriever, ok := ag.(SimilarSongsByAlbumRetriever)
-		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetSimilarSongsByAlbum(ctx, id, name, artist, mbid, count)
-	})
-}
-
-// GetSimilarSongsByArtist returns similar songs for a given artist.
-func (a *Agents) GetSimilarSongsByArtist(ctx context.Context, id, name, mbid string, count int) ([]Song, error) {
-	switch id {
-	case consts.UnknownArtistID:
-		return nil, ErrNotFound
-	case consts.VariousArtistsID:
-		return nil, nil
-	}
-
-	return callAgentSliceMethod(ctx, a, "GetSimilarSongsByArtist", func(ag Interface) ([]Song, error) {
-		retriever, ok := ag.(SimilarSongsByArtistRetriever)
-		if !ok {
-			return nil, ErrNotFound
-		}
-		return retriever.GetSimilarSongsByArtist(ctx, id, name, mbid, count)
-	})
-}
-
-func callAgentMethod[T comparable](ctx context.Context, agents *Agents, methodName string, fn func(Interface) (T, error)) (T, error) {
-	var zero T
-	start := time.Now()
-	for _, enabledAgent := range agents.getEnabledAgentNames() {
-		ag := agents.getAgent(enabledAgent)
-		if ag == nil {
 			continue
 		}
-		if utils.IsCtxDone(ctx) {
-			break
-		}
-		result, err := fn(ag)
+		images, err := retriever.GetAlbumImages(ctx, name, artist, mbid)
 		if err != nil {
-			log.Trace(ctx, "Agent method call error", "method", methodName, "agent", ag.AgentName(), "error", err)
-			continue
+			log.Trace(ctx, "Agent GetAlbumImages failed", "agent", ag.AgentName(), "album", name, "artist", artist, "mbid", mbid, err)
 		}
-
-		if result != zero {
-			log.Debug(ctx, "Got result", "method", methodName, "agent", ag.AgentName(), "elapsed", time.Since(start))
-			return result, nil
-		}
-	}
-	return zero, ErrNotFound
-}
-
-func callAgentSliceMethod[T any](ctx context.Context, agents *Agents, methodName string, fn func(Interface) ([]T, error)) ([]T, error) {
-	start := time.Now()
-	for _, enabledAgent := range agents.getEnabledAgentNames() {
-		ag := agents.getAgent(enabledAgent)
-		if ag == nil {
-			continue
-		}
-		if utils.IsCtxDone(ctx) {
-			break
-		}
-		results, err := fn(ag)
-		if err != nil {
-			log.Trace(ctx, "Agent method call error", "method", methodName, "agent", ag.AgentName(), "error", err)
-			continue
-		}
-
-		if len(results) > 0 {
-			log.Debug(ctx, "Got results", "method", methodName, "agent", ag.AgentName(), "count", len(results), "elapsed", time.Since(start))
-			return results, nil
+		if len(images) > 0 && err == nil {
+			log.Debug(ctx, "Got Album Images", "agent", ag.AgentName(), "album", name, "artist", artist,
+				"mbid", mbid, "elapsed", time.Since(start))
+			return images, nil
 		}
 	}
 	return nil, ErrNotFound
@@ -377,6 +376,3 @@ var _ ArtistImageRetriever = (*Agents)(nil)
 var _ ArtistTopSongsRetriever = (*Agents)(nil)
 var _ AlbumInfoRetriever = (*Agents)(nil)
 var _ AlbumImageRetriever = (*Agents)(nil)
-var _ SimilarSongsByTrackRetriever = (*Agents)(nil)
-var _ SimilarSongsByAlbumRetriever = (*Agents)(nil)
-var _ SimilarSongsByArtistRetriever = (*Agents)(nil)

core/agents/agents_test.go

@@ -295,72 +295,6 @@ var _ = Describe("Agents", func() {
 				Expect(mock.Args).To(BeEmpty())
 			})
 		})
-
-		Describe("GetSimilarSongsByTrack", func() {
-			It("returns on first match", func() {
-				Expect(ag.GetSimilarSongsByTrack(ctx, "123", "test song", "test artist", "mb123", 2)).To(Equal([]Song{{
-					Name: "Similar Song",
-					MBID: "mbid555",
-				}}))
-				Expect(mock.Args).To(HaveExactElements("123", "test song", "test artist", "mb123", 2))
-			})
-			It("skips the agent if it returns an error", func() {
-				mock.Err = errors.New("error")
-				_, err := ag.GetSimilarSongsByTrack(ctx, "123", "test song", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(HaveExactElements("123", "test song", "test artist", "mb123", 2))
-			})
-			It("interrupts if the context is canceled", func() {
-				cancel()
-				_, err := ag.GetSimilarSongsByTrack(ctx, "123", "test song", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(BeEmpty())
-			})
-		})
-
-		Describe("GetSimilarSongsByAlbum", func() {
-			It("returns on first match", func() {
-				Expect(ag.GetSimilarSongsByAlbum(ctx, "123", "test album", "test artist", "mb123", 2)).To(Equal([]Song{{
-					Name: "Album Similar Song",
-					MBID: "mbid666",
-				}}))
-				Expect(mock.Args).To(HaveExactElements("123", "test album", "test artist", "mb123", 2))
-			})
-			It("skips the agent if it returns an error", func() {
-				mock.Err = errors.New("error")
-				_, err := ag.GetSimilarSongsByAlbum(ctx, "123", "test album", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(HaveExactElements("123", "test album", "test artist", "mb123", 2))
-			})
-			It("interrupts if the context is canceled", func() {
-				cancel()
-				_, err := ag.GetSimilarSongsByAlbum(ctx, "123", "test album", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(BeEmpty())
-			})
-		})
-
-		Describe("GetSimilarSongsByArtist", func() {
-			It("returns on first match", func() {
-				Expect(ag.GetSimilarSongsByArtist(ctx, "123", "test artist", "mb123", 2)).To(Equal([]Song{{
-					Name: "Artist Similar Song",
-					MBID: "mbid777",
-				}}))
-				Expect(mock.Args).To(HaveExactElements("123", "test artist", "mb123", 2))
-			})
-			It("skips the agent if it returns an error", func() {
-				mock.Err = errors.New("error")
-				_, err := ag.GetSimilarSongsByArtist(ctx, "123", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(HaveExactElements("123", "test artist", "mb123", 2))
-			})
-			It("interrupts if the context is canceled", func() {
-				cancel()
-				_, err := ag.GetSimilarSongsByArtist(ctx, "123", "test artist", "mb123", 2)
-				Expect(err).To(MatchError(ErrNotFound))
-				Expect(mock.Args).To(BeEmpty())
-			})
-		})
 	})
 })
 
@@ -443,39 +377,6 @@ func (a *mockAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string)
 	}, nil
 }
 
-func (a *mockAgent) GetSimilarSongsByTrack(_ context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	a.Args = []interface{}{id, name, artist, mbid, count}
-	if a.Err != nil {
-		return nil, a.Err
-	}
-	return []Song{{
-		Name: "Similar Song",
-		MBID: "mbid555",
-	}}, nil
-}
-
-func (a *mockAgent) GetSimilarSongsByAlbum(_ context.Context, id, name, artist, mbid string, count int) ([]Song, error) {
-	a.Args = []interface{}{id, name, artist, mbid, count}
-	if a.Err != nil {
-		return nil, a.Err
-	}
-	return []Song{{
-		Name: "Album Similar Song",
-		MBID: "mbid666",
-	}}, nil
-}
-
-func (a *mockAgent) GetSimilarSongsByArtist(_ context.Context, id, name, mbid string, count int) ([]Song, error) {
-	a.Args = []interface{}{id, name, mbid, count}
-	if a.Err != nil {
-		return nil, a.Err
-	}
-	return []Song{{
-		Name: "Artist Similar Song",
-		MBID: "mbid777",
-	}}, nil
-}
-
 type emptyAgent struct {
 	Interface
 }

core/agents/interfaces.go

@@ -33,15 +33,9 @@ type ExternalImage struct {
 }
 
 type Song struct {
-	ID         string
-	Name       string
-	MBID       string
-	ISRC       string
-	Artist     string
-	ArtistMBID string
-	Album      string
-	AlbumMBID  string
-	Duration   uint32 // Duration in milliseconds, 0 means unknown
+	ID   string
+	Name string
+	MBID string
 }
 
 var (
@@ -82,41 +76,6 @@ type ArtistTopSongsRetriever interface {
 	GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error)
 }
 
-// SimilarSongsByTrackRetriever provides similar songs based on a specific track
-type SimilarSongsByTrackRetriever interface {
-	// GetSimilarSongsByTrack returns songs similar to the given track.
-	// Parameters:
-	//   - id: local mediafile ID
-	//   - name: track title
-	//   - artist: artist name
-	//   - mbid: MusicBrainz recording ID (may be empty)
-	//   - count: maximum number of results
-	GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error)
-}
-
-// SimilarSongsByAlbumRetriever provides similar songs based on an album
-type SimilarSongsByAlbumRetriever interface {
-	// GetSimilarSongsByAlbum returns songs similar to tracks on the given album.
-	// Parameters:
-	//   - id: local album ID
-	//   - name: album name
-	//   - artist: album artist name
-	//   - mbid: MusicBrainz release ID (may be empty)
-	//   - count: maximum number of results
-	GetSimilarSongsByAlbum(ctx context.Context, id, name, artist, mbid string, count int) ([]Song, error)
-}
-
-// SimilarSongsByArtistRetriever provides similar songs based on an artist
-type SimilarSongsByArtistRetriever interface {
-	// GetSimilarSongsByArtist returns songs similar to the artist's catalog.
-	// Parameters:
-	//   - id: local artist ID
-	//   - name: artist name
-	//   - mbid: MusicBrainz artist ID (may be empty)
-	//   - count: maximum number of results
-	GetSimilarSongsByArtist(ctx context.Context, id, name, mbid string, count int) ([]Song, error)
-}
-
 var Map map[string]Constructor
 
 func Register(name string, init Constructor) {

core/artwork/artwork_internal_test.go

@@ -302,33 +302,6 @@ var _ = Describe("Artwork", func() {
 				Entry("landscape jpg image", "jpg", true, 200),
 			)
 		})
-		When("Requested size is larger than original", func() {
-			It("clamps size to original dimensions", func() {
-				conf.Server.CoverArtPriority = "front.png"
-				// front.png is 16x16, requesting 99999 should return at original size
-				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, false)
-				Expect(err).ToNot(HaveOccurred())
-
-				img, _, err := image.Decode(r)
-				Expect(err).ToNot(HaveOccurred())
-				// Should be clamped to original size (16), not 99999
-				Expect(img.Bounds().Size().X).To(Equal(16))
-				Expect(img.Bounds().Size().Y).To(Equal(16))
-			})
-
-			It("clamps square size to original dimensions", func() {
-				conf.Server.CoverArtPriority = "front.png"
-				// front.png is 16x16, requesting 99999 with square should return 16x16 square
-				r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, true)
-				Expect(err).ToNot(HaveOccurred())
-
-				img, _, err := image.Decode(r)
-				Expect(err).ToNot(HaveOccurred())
-				// Should be clamped to original size (16), not 99999
-				Expect(img.Bounds().Size().X).To(Equal(16))
-				Expect(img.Bounds().Size().Y).To(Equal(16))
-			})
-		})
 	})
 })
 

core/artwork/reader_resized.go

@@ -87,11 +87,6 @@ func resizeImage(reader io.Reader, size int, square bool) (io.Reader, int, error
 	bounds := original.Bounds()
 	originalSize := max(bounds.Max.X, bounds.Max.Y)
 
-	// Clamp size to original dimensions - upscaling wastes resources and adds no information
-	if size > originalSize {
-		size = originalSize
-	}
-
 	if originalSize <= size && !square {
 		return nil, originalSize, nil
 	}

core/artwork/sources.go

@@ -16,14 +16,12 @@ import (
 	"time"
 
 	"github.com/dhowden/tag"
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/core/external"
 	"github.com/navidrome/navidrome/core/ffmpeg"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/resources"
-	"go.senan.xyz/taglib"
 )
 
 func selectImageReader(ctx context.Context, artID model.ArtworkID, extractFuncs ...sourceFunc) (io.ReadCloser, string, error) {
@@ -86,13 +84,6 @@ var picTypeRegexes = []*regexp.Regexp{
 }
 
 func fromTag(ctx context.Context, path string) sourceFunc {
-	if conf.Server.DevLegacyEmbedImage {
-		return fromTagLegacy(ctx, path)
-	}
-	return fromTagGoTaglib(ctx, path)
-}
-
-func fromTagLegacy(ctx context.Context, path string) sourceFunc {
 	return func() (io.ReadCloser, string, error) {
 		if path == "" {
 			return nil, "", nil
@@ -137,44 +128,6 @@ func fromTagLegacy(ctx context.Context, path string) sourceFunc {
 	}
 }
 
-func fromTagGoTaglib(ctx context.Context, path string) sourceFunc {
-	return func() (io.ReadCloser, string, error) {
-		if path == "" {
-			return nil, "", nil
-		}
-		f, err := taglib.OpenReadOnly(path, taglib.WithReadStyle(taglib.ReadStyleFast))
-		if err != nil {
-			return nil, "", err
-		}
-		defer f.Close()
-
-		images := f.Properties().Images
-		if len(images) == 0 {
-			return nil, "", fmt.Errorf("no embedded image found in %s", path)
-		}
-
-		imageIndex := findBestImageIndex(ctx, images, path)
-		data, err := f.Image(imageIndex)
-		if err != nil || len(data) == 0 {
-			return nil, "", fmt.Errorf("could not load embedded image from %s", path)
-		}
-		return io.NopCloser(bytes.NewReader(data)), path, nil
-	}
-}
-
-func findBestImageIndex(ctx context.Context, images []taglib.ImageDesc, path string) int {
-	for _, regex := range picTypeRegexes {
-		for i, img := range images {
-			if regex.MatchString(img.Type) {
-				log.Trace(ctx, "Found embedded image", "type", img.Type, "path", path)
-				return i
-			}
-		}
-	}
-	log.Trace(ctx, "Could not find a front image. Getting the first one", "type", images[0].Type, "path", path)
-	return 0
-}
-
 func fromFFmpegTag(ctx context.Context, ffmpeg ffmpeg.FFmpeg, path string) sourceFunc {
 	return func() (io.ReadCloser, string, error) {
 		if path == "" {

core/external/extdata_helper_test.go

@@ -92,11 +92,6 @@ func (m *mockMediaFileRepo) Get(id string) (*model.MediaFile, error) {
 	return args.Get(0).(*model.MediaFile), args.Error(1)
 }
 
-// GetAllByTags implements model.MediaFileRepository.
-func (m *mockMediaFileRepo) GetAllByTags(_ model.TagName, _ []string, options ...model.QueryOptions) (model.MediaFiles, error) {
-	return m.GetAll(options...)
-}
-
 // GetAll implements model.MediaFileRepository.
 func (m *mockMediaFileRepo) GetAll(options ...model.QueryOptions) (model.MediaFiles, error) {
 	argsSlice := make([]interface{}, len(options))
@@ -287,27 +282,3 @@ func (m *mockAgents) GetAlbumImages(ctx context.Context, name, artist, mbid stri
 	}
 	return nil, args.Error(1)
 }
-
-func (m *mockAgents) GetSimilarSongsByTrack(ctx context.Context, id, name, artist, mbid string, count int) ([]agents.Song, error) {
-	args := m.Called(ctx, id, name, artist, mbid, count)
-	if args.Get(0) != nil {
-		return args.Get(0).([]agents.Song), args.Error(1)
-	}
-	return nil, args.Error(1)
-}
-
-func (m *mockAgents) GetSimilarSongsByAlbum(ctx context.Context, id, name, artist, mbid string, count int) ([]agents.Song, error) {
-	args := m.Called(ctx, id, name, artist, mbid, count)
-	if args.Get(0) != nil {
-		return args.Get(0).([]agents.Song), args.Error(1)
-	}
-	return nil, args.Error(1)
-}
-
-func (m *mockAgents) GetSimilarSongsByArtist(ctx context.Context, id, name, mbid string, count int) ([]agents.Song, error) {
-	args := m.Called(ctx, id, name, mbid, count)
-	if args.Get(0) != nil {
-		return args.Get(0).([]agents.Song), args.Error(1)
-	}
-	return nil, args.Error(1)
-}

core/external/provider.go

@@ -32,7 +32,7 @@ const (
 type Provider interface {
 	UpdateAlbumInfo(ctx context.Context, id string) (*model.Album, error)
 	UpdateArtistInfo(ctx context.Context, id string, count int, includeNotPresent bool) (*model.Artist, error)
-	SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error)
+	ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error)
 	TopSongs(ctx context.Context, artist string, count int) (model.MediaFiles, error)
 	ArtistImage(ctx context.Context, id string) (*url.URL, error)
 	AlbumImage(ctx context.Context, id string) (*url.URL, error)
@@ -80,9 +80,6 @@ type Agents interface {
 	agents.ArtistSimilarRetriever
 	agents.ArtistTopSongsRetriever
 	agents.ArtistURLRetriever
-	agents.SimilarSongsByTrackRetriever
-	agents.SimilarSongsByAlbumRetriever
-	agents.SimilarSongsByArtistRetriever
 }
 
 func NewProvider(ds model.DataStore, agents Agents) Provider {
@@ -259,7 +256,7 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
 	g.Go(func() error { e.callGetImage(ctx, e.ag, &artist); return nil })
 	g.Go(func() error { e.callGetBiography(ctx, e.ag, &artist); return nil })
 	g.Go(func() error { e.callGetURL(ctx, e.ag, &artist); return nil })
-	g.Go(func() error { e.callGetSimilarArtists(ctx, e.ag, &artist, maxSimilarArtists, true); return nil })
+	g.Go(func() error { e.callGetSimilar(ctx, e.ag, &artist, maxSimilarArtists, true); return nil })
 	_ = g.Wait()
 
 	if utils.IsCtxDone(ctx) {
@@ -278,54 +275,22 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
 	return artist, nil
 }
 
-func (e *provider) SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error) {
-	entity, err := model.GetEntityByID(ctx, e.ds, id)
-	if err != nil {
-		return nil, err
-	}
-
-	var songs []agents.Song
-
-	// Try entity-specific similarity first
-	switch v := entity.(type) {
-	case *model.MediaFile:
-		songs, err = e.ag.GetSimilarSongsByTrack(ctx, v.ID, v.Title, v.Artist, v.MbzRecordingID, count)
-	case *model.Album:
-		songs, err = e.ag.GetSimilarSongsByAlbum(ctx, v.ID, v.Name, v.AlbumArtist, v.MbzAlbumID, count)
-	case *model.Artist:
-		songs, err = e.ag.GetSimilarSongsByArtist(ctx, v.ID, v.Name, v.MbzArtistID, count)
-	default:
-		log.Warn(ctx, "Unknown entity type", "id", id, "type", fmt.Sprintf("%T", entity))
-		return nil, model.ErrNotFound
-	}
-
-	if err == nil && len(songs) > 0 {
-		return e.matchSongsToLibrary(ctx, songs, count)
-	}
-
-	// Fallback to existing similar artists + top songs algorithm
-	return e.similarSongsFallback(ctx, id, count)
-}
-
-// similarSongsFallback uses the original similar artists + top songs algorithm. The idea is to
-// get the artist of the given entity, retrieve similar artists, get their top songs, and pick
-// a weighted random selection of songs to return as similar songs.
-func (e *provider) similarSongsFallback(ctx context.Context, id string, count int) (model.MediaFiles, error) {
+func (e *provider) ArtistRadio(ctx context.Context, id string, count int) (model.MediaFiles, error) {
 	artist, err := e.getArtist(ctx, id)
 	if err != nil {
 		return nil, err
 	}
 
-	e.callGetSimilarArtists(ctx, e.ag, &artist, 15, false)
+	e.callGetSimilar(ctx, e.ag, &artist, 15, false)
 	if utils.IsCtxDone(ctx) {
-		log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+		log.Warn(ctx, "ArtistRadio call canceled", ctx.Err())
 		return nil, ctx.Err()
 	}
 
 	weightedSongs := random.NewWeightedChooser[model.MediaFile]()
 	addArtist := func(a model.Artist, weightedSongs *random.WeightedChooser[model.MediaFile], count, artistWeight int) error {
 		if utils.IsCtxDone(ctx) {
-			log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+			log.Warn(ctx, "ArtistRadio call canceled", ctx.Err())
 			return ctx.Err()
 		}
 
@@ -457,20 +422,21 @@ func (e *provider) getMatchingTopSongs(ctx context.Context, agent agents.ArtistT
 		return nil, fmt.Errorf("failed to get top songs for artist %s: %w", artistName, err)
 	}
 
-	// Enrich songs with artist info if not already present (for top songs, we know the artist)
-	for i := range songs {
-		if songs[i].Artist == "" {
-			songs[i].Artist = artistName
-		}
-		if songs[i].ArtistMBID == "" {
-			songs[i].ArtistMBID = artist.MbzArtistID
-		}
+	idMatches, err := e.loadTracksByID(ctx, songs)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load tracks by ID: %w", err)
+	}
+	mbidMatches, err := e.loadTracksByMBID(ctx, songs)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
+	}
+	titleMatches, err := e.loadTracksByTitle(ctx, songs, artist, idMatches, mbidMatches)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
 	}
 
-	mfs, err := e.matchSongsToLibrary(ctx, songs, count)
-	if err != nil {
-		return nil, err
-	}
+	log.Trace(ctx, "Top Songs loaded", "name", artistName, "numSongs", len(songs), "numIDMatches", len(idMatches), "numMBIDMatches", len(mbidMatches), "numTitleMatches", len(titleMatches))
+	mfs := e.selectTopSongs(songs, idMatches, mbidMatches, titleMatches, count)
 
 	if len(mfs) == 0 {
 		log.Debug(ctx, "No matching top songs found", "name", artistName)
@@ -481,6 +447,137 @@ func (e *provider) getMatchingTopSongs(ctx context.Context, agent agents.ArtistT
 	return mfs, nil
 }
 
+func (e *provider) loadTracksByMBID(ctx context.Context, songs []agents.Song) (map[string]model.MediaFile, error) {
+	var mbids []string
+	for _, s := range songs {
+		if s.MBID != "" {
+			mbids = append(mbids, s.MBID)
+		}
+	}
+	matches := map[string]model.MediaFile{}
+	if len(mbids) == 0 {
+		return matches, nil
+	}
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.And{
+			squirrel.Eq{"mbz_recording_id": mbids},
+			squirrel.Eq{"missing": false},
+		},
+	})
+	if err != nil {
+		return matches, err
+	}
+	for _, mf := range res {
+		if id := mf.MbzRecordingID; id != "" {
+			if _, ok := matches[id]; !ok {
+				matches[id] = mf
+			}
+		}
+	}
+	return matches, nil
+}
+
+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 != "" {
+			ids = append(ids, s.ID)
+		}
+	}
+	matches := map[string]model.MediaFile{}
+	if len(ids) == 0 {
+		return matches, nil
+	}
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.And{
+			squirrel.Eq{"media_file.id": ids},
+			squirrel.Eq{"missing": false},
+		},
+	})
+	if err != nil {
+		return matches, err
+	}
+	for _, mf := range res {
+		if _, ok := matches[mf.ID]; !ok {
+			matches[mf.ID] = mf
+		}
+	}
+	return matches, nil
+}
+
+func (e *provider) loadTracksByTitle(ctx context.Context, songs []agents.Song, artist *auxArtist, idMatches, mbidMatches map[string]model.MediaFile) (map[string]model.MediaFile, error) {
+	titleMap := map[string]string{}
+	for _, s := range songs {
+		// Skip if already matched by ID or MBID
+		if s.ID != "" && idMatches[s.ID].ID != "" {
+			continue
+		}
+		if s.MBID != "" && mbidMatches[s.MBID].ID != "" {
+			continue
+		}
+		sanitized := str.SanitizeFieldForSorting(s.Name)
+		titleMap[sanitized] = s.Name
+	}
+	matches := map[string]model.MediaFile{}
+	if len(titleMap) == 0 {
+		return matches, nil
+	}
+	titleFilters := squirrel.Or{}
+	for sanitized := range titleMap {
+		titleFilters = append(titleFilters, squirrel.Like{"order_title": sanitized})
+	}
+
+	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.And{
+			squirrel.Or{
+				squirrel.Eq{"artist_id": artist.ID},
+				squirrel.Eq{"album_artist_id": artist.ID},
+			},
+			titleFilters,
+			squirrel.Eq{"missing": false},
+		},
+		Sort: "starred desc, rating desc, year asc, compilation asc ",
+	})
+	if err != nil {
+		return matches, err
+	}
+	for _, mf := range res {
+		sanitized := str.SanitizeFieldForSorting(mf.Title)
+		if _, ok := matches[sanitized]; !ok {
+			matches[sanitized] = mf
+		}
+	}
+	return matches, nil
+}
+
+func (e *provider) selectTopSongs(songs []agents.Song, byID, byMBID, byTitle map[string]model.MediaFile, count int) model.MediaFiles {
+	var mfs model.MediaFiles
+	for _, t := range songs {
+		if len(mfs) == count {
+			break
+		}
+		// Try ID match first
+		if t.ID != "" {
+			if mf, ok := byID[t.ID]; ok {
+				mfs = append(mfs, mf)
+				continue
+			}
+		}
+		// Try MBID match second
+		if t.MBID != "" {
+			if mf, ok := byMBID[t.MBID]; ok {
+				mfs = append(mfs, mf)
+				continue
+			}
+		}
+		// Fall back to title match
+		if mf, ok := byTitle[str.SanitizeFieldForSorting(t.Name)]; ok {
+			mfs = append(mfs, mf)
+		}
+	}
+	return mfs
+}
+
 func (e *provider) callGetURL(ctx context.Context, agent agents.ArtistURLRetriever, artist *auxArtist) {
 	artisURL, err := agent.GetArtistURL(ctx, artist.ID, artist.Name(), artist.MbzArtistID)
 	if err != nil {
@@ -517,7 +614,7 @@ func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRet
 	}
 }
 
-func (e *provider) callGetSimilarArtists(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
+func (e *provider) callGetSimilar(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
 	limit int, includeNotPresent bool) {
 	artistName := artist.Name()
 	similar, err := agent.GetSimilarArtists(ctx, artist.ID, artistName, artist.MbzArtistID, limit)

core/external/provider_artistradio_test.go

@@ -0,0 +1,205 @@
+package external_test
+
+import (
+	"context"
+	"errors"
+
+	"github.com/Masterminds/squirrel"
+	"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 - ArtistRadio", func() {
+	var ds model.DataStore
+	var provider Provider
+	var mockAgent *mockSimilarArtistAgent
+	var mockTopAgent agents.ArtistTopSongsRetriever
+	var mockSimilarAgent agents.ArtistSimilarRetriever
+	var agentsCombined Agents
+	var artistRepo *mockArtistRepo
+	var mediaFileRepo *mockMediaFileRepo
+	var ctx context.Context
+
+	BeforeEach(func() {
+		ctx = GinkgoT().Context()
+
+		artistRepo = newMockArtistRepo()
+		mediaFileRepo = newMockMediaFileRepo()
+
+		ds = &tests.MockDataStore{
+			MockedArtist:    artistRepo,
+			MockedMediaFile: mediaFileRepo,
+		}
+
+		mockAgent = &mockSimilarArtistAgent{}
+		mockTopAgent = mockAgent
+		mockSimilarAgent = mockAgent
+
+		agentsCombined = &mockAgents{
+			topSongsAgent: mockTopAgent,
+			similarAgent:  mockSimilarAgent,
+		}
+
+		provider = NewProvider(ds, agentsCombined)
+	})
+
+	It("returns similar songs from main artist and similar artists", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+		similarArtist := model.Artist{ID: "artist-3", Name: "Similar Artist"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
+		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
+		song3 := model.MediaFile{ID: "song-3", Title: "Song Three", ArtistID: "artist-3", MbzRecordingID: "mbid-3"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("Get", "artist-3").Return(&similarArtist, nil).Maybe()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Once()
+
+		similarAgentsResp := []agents.Artist{
+			{Name: "Similar Artist", MBID: "similar-mbid"},
+		}
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return(similarAgentsResp, nil).Once()
+
+		// Mock the three-phase artist lookup: ID (skipped - no IDs), MBID, then Name
+		// MBID lookup returns empty (no match)
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			_, ok := opt.Filters.(squirrel.Eq)
+			return opt.Max == 0 && ok
+		})).Return(model.Artists{}, nil).Once()
+		// Name lookup returns the similar artist
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			_, ok := opt.Filters.(squirrel.Or)
+			return opt.Max == 0 && ok
+		})).Return(model.Artists{similarArtist}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song One", MBID: "mbid-1"},
+				{Name: "Song Two", MBID: "mbid-2"},
+			}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-3", "Similar Artist", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song Three", MBID: "mbid-3"},
+			}, nil).Once()
+
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song3}, nil).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 3)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(HaveLen(3))
+		for _, song := range songs {
+			Expect(song.ID).To(BeElementOf("song-1", "song-2", "song-3"))
+		}
+	})
+
+	It("returns ErrNotFound when artist is not found", func() {
+		artistRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
+		mediaFileRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Maybe()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-unknown-artist", 5)
+
+		Expect(err).To(Equal(model.ErrNotFound))
+		Expect(songs).To(BeNil())
+	})
+
+	It("returns songs from main artist when GetSimilarArtists returns error", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Maybe()
+
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return(nil, errors.New("error getting similar artists")).Once()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 0 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song One", MBID: "mbid-1"},
+			}, nil).Once()
+
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 5)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(HaveLen(1))
+		Expect(songs[0].ID).To(Equal("song-1"))
+	})
+
+	It("returns empty list when GetArtistTopSongs returns error", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Maybe()
+
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return([]agents.Artist{}, nil).Once()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 0 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return(nil, errors.New("error getting top songs")).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 5)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(BeEmpty())
+	})
+
+	It("respects count parameter", func() {
+		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
+		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
+		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
+
+		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 1 && opt.Filters != nil
+		})).Return(model.Artists{artist1}, nil).Maybe()
+
+		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
+			Return([]agents.Artist{}, nil).Once()
+
+		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
+			return opt.Max == 0 && opt.Filters != nil
+		})).Return(model.Artists{}, nil).Once()
+
+		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
+			Return([]agents.Song{
+				{Name: "Song One", MBID: "mbid-1"},
+				{Name: "Song Two", MBID: "mbid-2"},
+			}, nil).Once()
+
+		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
+
+		songs, err := provider.ArtistRadio(ctx, "artist-1", 1)
+
+		Expect(err).ToNot(HaveOccurred())
+		Expect(songs).To(HaveLen(1))
+		Expect(songs[0].ID).To(BeElementOf("song-1", "song-2"))
+	})
+})

core/external/provider_matching.go

@@ -1,504 +0,0 @@
-package external
-
-import (
-	"context"
-	"fmt"
-	"math"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/core/agents"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/utils/str"
-	"github.com/xrash/smetrics"
-)
-
-// matchSongsToLibrary matches agent song results to local library tracks using a multi-phase
-// matching algorithm that prioritizes accuracy over recall.
-//
-// # Algorithm Overview
-//
-// The algorithm matches songs from external agents (Last.fm, Deezer, etc.) to tracks in the
-// local music library using four matching strategies in priority order:
-//
-//  1. Direct ID match: Songs with an ID field are matched directly to MediaFiles by ID
-//  2. MusicBrainz Recording ID (MBID) match: Songs with MBID are matched to tracks with
-//     matching mbz_recording_id
-//  3. ISRC match: Songs with ISRC are matched to tracks with matching ISRC tag
-//  4. Title+Artist fuzzy match: Remaining songs are matched using fuzzy string comparison
-//     with metadata specificity scoring
-//
-// # Matching Priority
-//
-// When selecting the final result, matches are prioritized in order: ID > MBID > ISRC > Title+Artist.
-// This ensures that more reliable identifiers take precedence over fuzzy text matching.
-//
-// # Fuzzy Matching Details
-//
-// For title+artist matching, the algorithm uses Jaro-Winkler similarity (threshold configurable
-// 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. 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
-//  4. Album similarity (Jaro-Winkler, as final tiebreaker)
-//
-// # Examples
-//
-// Example 1 - MBID Priority:
-//
-//	Agent returns: {Name: "Paranoid Android", MBID: "abc-123", Artist: "Radiohead"}
-//	Library has: [
-//	  {ID: "t1", Title: "Paranoid Android", MbzRecordingID: "abc-123"},
-//	  {ID: "t2", Title: "Paranoid Android", Artist: "Radiohead"},
-//	]
-//	Result: t1 (MBID match takes priority over title+artist)
-//
-// Example 2 - ISRC Priority:
-//
-//	Agent returns: {Name: "Paranoid Android", ISRC: "GBAYE0000351", Artist: "Radiohead"}
-//	Library has: [
-//	  {ID: "t1", Title: "Paranoid Android", Tags: {isrc: ["GBAYE0000351"]}},
-//	  {ID: "t2", Title: "Paranoid Android", Artist: "Radiohead"},
-//	]
-//	Result: t1 (ISRC match takes priority over title+artist)
-//
-// Example 3 - Specificity Ranking:
-//
-//	Agent returns: {Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"}
-//	Library has: [
-//	  {ID: "t1", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "101"},           // Level 1
-//	  {ID: "t2", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},      // Level 3
-//	]
-//	Result: t2 (Level 3 beats Level 1 due to album match)
-//
-// Example 4 - Fuzzy Title Matching:
-//
-//	Agent returns: {Name: "Bohemian Rhapsody", Artist: "Queen"}
-//	Library has: {ID: "t1", Title: "Bohemian Rhapsody - Remastered", Artist: "Queen"}
-//	With threshold=85%: Match succeeds (similarity ~0.87)
-//	With threshold=100%: No match (not exact)
-//
-// # Parameters
-//
-//   - ctx: Context for database operations
-//   - songs: Slice of agent.Song results from external providers
-//   - count: Maximum number of matches to return
-//
-// # Returns
-//
-// 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 (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 := e.loadTracksByMBID(ctx, songs, idMatches)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by MBID: %w", err)
-	}
-	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 := e.loadTracksByTitleAndArtist(ctx, songs, idMatches, mbidMatches, isrcMatches)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load tracks by title: %w", err)
-	}
-
-	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 {
-		for _, key := range keys {
-			if key != "" {
-				if mf, ok := m[key]; ok && mf.ID != "" {
-					return mf, true
-				}
-			}
-		}
-	}
-	return model.MediaFile{}, false
-}
-
-// loadTracksByID fetches MediaFiles from the library using direct ID matching.
-// 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 != "" {
-			ids = append(ids, s.ID)
-		}
-	}
-	matches := map[string]model.MediaFile{}
-	if len(ids) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.And{
-			squirrel.Eq{"media_file.id": ids},
-			squirrel.Eq{"missing": false},
-		},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, mf := range res {
-		if _, ok := matches[mf.ID]; !ok {
-			matches[mf.ID] = mf
-		}
-	}
-	return matches, nil
-}
-
-// loadTracksByMBID fetches MediaFiles from the library using MusicBrainz Recording IDs.
-// 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...) {
-			mbids = append(mbids, s.MBID)
-		}
-	}
-	matches := map[string]model.MediaFile{}
-	if len(mbids) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
-		Filters: squirrel.And{
-			squirrel.Eq{"mbz_recording_id": mbids},
-			squirrel.Eq{"missing": false},
-		},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, mf := range res {
-		if id := mf.MbzRecordingID; id != "" {
-			if _, ok := matches[id]; !ok {
-				matches[id] = mf
-			}
-		}
-	}
-	return matches, nil
-}
-
-// 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...) {
-			isrcs = append(isrcs, s.ISRC)
-		}
-	}
-	matches := map[string]model.MediaFile{}
-	if len(isrcs) == 0 {
-		return matches, nil
-	}
-	res, err := e.ds.MediaFile(ctx).GetAllByTags(model.TagISRC, isrcs, model.QueryOptions{
-		Filters: squirrel.Eq{"missing": false},
-	})
-	if err != nil {
-		return matches, err
-	}
-	for _, mf := range res {
-		for _, isrc := range mf.Tags.Values(model.TagISRC) {
-			if _, ok := matches[isrc]; !ok {
-				matches[isrc] = mf
-			}
-		}
-	}
-	return matches, nil
-}
-
-// 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 // 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
-type matchScore struct {
-	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
-	}
-	if s.durationProximity != other.durationProximity {
-		return s.durationProximity > other.durationProximity
-	}
-	if s.specificityLevel != other.specificityLevel {
-		return s.specificityLevel > other.specificityLevel
-	}
-	return s.albumSimilarity > other.albumSimilarity
-}
-
-// computeSpecificityLevel determines how well query metadata matches a track (0-5).
-// 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 != "" &&
-		mf.MbzArtistID == q.artistMBID && mf.MbzAlbumID == q.albumMBID {
-		return 5
-	}
-	// Level 4: Title + Artist MBID + Album name (fuzzy)
-	if q.artistMBID != "" && q.album != "" &&
-		mf.MbzArtistID == q.artistMBID && similarityRatio(album, q.album) >= albumThreshold {
-		return 4
-	}
-	// Level 3: Title + Artist name + Album name (fuzzy)
-	if q.artist != "" && q.album != "" &&
-		artist == q.artist && similarityRatio(album, q.album) >= albumThreshold {
-		return 3
-	}
-	// Level 2: Title + Artist MBID
-	if q.artistMBID != "" && mf.MbzArtistID == q.artistMBID {
-		return 2
-	}
-	// Level 1: Title + Artist name
-	if q.artist != "" && artist == q.artist {
-		return 1
-	}
-	// 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 // No exact title match, but could still be a fuzzy match
-}
-
-// loadTracksByTitleAndArtist loads tracks matching by title with optional artist/album filtering.
-// 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.SimilarSongsMatchThreshold) / 100.0
-
-	// Group queries by artist for efficient DB access
-	byArtist := map[string][]songQuery{}
-	for _, q := range queries {
-		if q.artist != "" {
-			byArtist[q.artist] = append(byArtist[q.artist], q)
-		}
-	}
-
-	matches := map[string]model.MediaFile{}
-	for artist, artistQueries := range byArtist {
-		// 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},
-			},
-			Sort: "starred desc, rating desc, year asc, compilation asc",
-		})
-		if err != nil {
-			continue
-		}
-
-		// Find best match for each query using unified scoring
-		for _, q := range artistQueries {
-			if mf, found := e.findBestMatch(q, tracks, threshold); found {
-				key := q.title + "|" + q.artist
-				if _, exists := matches[key]; !exists {
-					matches[key] = mf
-				}
-			}
-		}
-	}
-	return matches, nil
-}
-
-// 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 // Unknown duration — don't penalise
-	}
-	durationSec := float64(durationMs) / 1000.0
-	diff := math.Abs(durationSec - float64(mediaFileDurationSec))
-	return 1.0 / (1.0 + diff)
-}
-
-// findBestMatch finds the best matching track using combined title/album similarity and specificity scoring.
-// 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 _, 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 != "" {
-			trackAlbum := str.SanitizeFieldForSorting(mf.Album)
-			albumSim = similarityRatio(q.album, trackAlbum)
-		}
-
-		score := matchScore{
-			titleSimilarity:   titleSim,
-			durationProximity: durationProximity(q.durationMs, mf.Duration),
-			albumSimilarity:   albumSim,
-			specificityLevel:  computeSpecificityLevel(q, mf, threshold),
-		}
-
-		if score.betterThan(bestScore) {
-			bestScore = score
-			bestMatch = mf
-			found = true
-		}
-	}
-	return bestMatch, found
-}
-
-// buildTitleQueries converts agent songs into normalized songQuery structs for title+artist matching.
-// 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...) {
-			continue
-		}
-		queries = append(queries, songQuery{
-			title:      str.SanitizeFieldForSorting(s.Name),
-			artist:     str.SanitizeFieldForSortingNoArticle(s.Artist),
-			artistMBID: s.ArtistMBID,
-			album:      str.SanitizeFieldForSorting(s.Album),
-			albumMBID:  s.AlbumMBID,
-			durationMs: s.Duration,
-		})
-	}
-	return queries
-}
-
-// selectBestMatchingSongs assembles the final result by mapping input songs to their best matching
-// 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 {
-		if len(mfs) == count {
-			break
-		}
-
-		mf, found := findMatchingTrack(t, byID, byMBID, byISRC, byTitleArtist)
-		if !found {
-			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 // Different input songs → skip mismatch-induced duplicate
-			}
-		} else {
-			addedBy[mf.ID] = t
-		}
-
-		mfs = append(mfs, mf)
-	}
-	return mfs
-}
-
-// 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
-	}
-	return model.MediaFile{}, false
-}
-
-// 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
-	}
-	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)
-}

core/external/provider_matching_internal_test.go

@@ -1,57 +0,0 @@
-package external
-
-import (
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("similarityRatio", func() {
-	It("returns 1.0 for identical strings", func() {
-		Expect(similarityRatio("hello", "hello")).To(BeNumerically("==", 1.0))
-	})
-
-	It("returns 0.0 for empty strings", func() {
-		Expect(similarityRatio("", "test")).To(BeNumerically("==", 0.0))
-		Expect(similarityRatio("test", "")).To(BeNumerically("==", 0.0))
-	})
-
-	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))
-	})
-
-	It("handles unicode characters", func() {
-		ratio := similarityRatio("dont stop believin", "don't stop believin'")
-		Expect(ratio).To(BeNumerically(">=", 0.85))
-	})
-
-	It("returns low similarity for completely different strings", func() {
-		ratio := similarityRatio("abc", "xyz")
-		Expect(ratio).To(BeNumerically("<", 0.5))
-	})
-
-	It("is symmetric", func() {
-		ratio1 := similarityRatio("hello world", "hello")
-		ratio2 := similarityRatio("hello", "hello world")
-		Expect(ratio1).To(Equal(ratio2))
-	})
-})

core/external/provider_matching_test.go

@@ -1,762 +0,0 @@
-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"))
-		})
-	})
-})

core/external/provider_similarsongs_test.go

@@ -1,443 +0,0 @@
-package external_test
-
-import (
-	"context"
-	"errors"
-
-	"github.com/Masterminds/squirrel"
-	"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 - SimilarSongs", func() {
-	var ds model.DataStore
-	var provider Provider
-	var mockAgent *mockSimilarArtistAgent
-	var mockTopAgent agents.ArtistTopSongsRetriever
-	var mockSimilarAgent agents.ArtistSimilarRetriever
-	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,
-		}
-
-		mockAgent = &mockSimilarArtistAgent{}
-		mockTopAgent = mockAgent
-		mockSimilarAgent = mockAgent
-
-		agentsCombined = &mockAgents{
-			topSongsAgent: mockTopAgent,
-			similarAgent:  mockSimilarAgent,
-		}
-
-		provider = NewProvider(ds, agentsCombined)
-	})
-
-	Describe("dispatch by entity type", func() {
-		Context("when ID is a MediaFile (track)", func() {
-			It("calls GetSimilarSongsByTrack and returns matched songs", func() {
-				track := model.MediaFile{ID: "track-1", Title: "Just Can't Get Enough", Artist: "Depeche Mode", MbzRecordingID: "track-mbid"}
-				matchedSong := model.MediaFile{ID: "matched-1", Title: "Dreaming of Me", Artist: "Depeche Mode"}
-
-				// GetEntityByID tries Artist, Album, Playlist, then MediaFile
-				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()
-
-				agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, "track-1", "Just Can't Get Enough", "Depeche Mode", "track-mbid", 5).
-					Return([]agents.Song{
-						{Name: "Dreaming of Me", MBID: "", Artist: "Depeche Mode", ArtistMBID: "artist-mbid"},
-					}, nil).Once()
-
-				// Mock loadTracksByID - no ID matches
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					_, ok := opt.Filters.(squirrel.Eq)
-					return ok
-				})).Return(model.MediaFiles{}, nil).Once()
-
-				// Mock loadTracksByMBID - no MBID matches (empty MBID means this won't be called)
-				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(model.MediaFiles{}, nil).Maybe()
-
-				// Mock 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(model.MediaFiles{matchedSong}, nil).Maybe()
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("matched-1"))
-			})
-
-			It("falls back to artist-based algorithm when GetSimilarSongsByTrack returns empty", func() {
-				track := model.MediaFile{ID: "track-1", Title: "Track", Artist: "Artist", ArtistID: "artist-1"}
-				artist := model.Artist{ID: "artist-1", Name: "Artist"}
-				song := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-
-				// GetEntityByID for the initial call tries Artist, Album, Playlist, then MediaFile
-				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()
-
-				agentsCombined.On("GetSimilarSongsByTrack", mock.Anything, "track-1", "Track", "Artist", "", mock.Anything).
-					Return([]agents.Song{}, nil).Once()
-
-				// Fallback calls getArtist(id) which calls GetEntityByID again - this time it finds the mediafile
-				// and recursively calls getArtist(v.ArtistID)
-				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()
-
-				// Then it recurses with the artist-1 ID
-				artistRepo.On("Get", "artist-1").Return(&artist, nil).Maybe()
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 1 && opt.Filters != nil
-				})).Return(model.Artists{artist}, nil).Maybe()
-
-				mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist", "", 15).
-					Return([]agents.Artist{}, nil).Once()
-
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 0 && opt.Filters != nil
-				})).Return(model.Artists{}, nil).Once()
-
-				mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist", "", mock.Anything).
-					Return([]agents.Song{{Name: "Song One", MBID: "mbid-1"}}, nil).Once()
-
-				mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "track-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("song-1"))
-			})
-		})
-
-		Context("when ID is an Album", func() {
-			It("calls GetSimilarSongsByAlbum and returns matched songs", func() {
-				album := model.Album{ID: "album-1", Name: "Speak & Spell", AlbumArtist: "Depeche Mode", MbzAlbumID: "album-mbid"}
-				matchedSong := model.MediaFile{ID: "matched-1", Title: "New Life", Artist: "Depeche Mode", MbzRecordingID: "song-mbid"}
-
-				// GetEntityByID tries Artist, Album, Playlist, then MediaFile
-				artistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "album-1").Return(&album, nil).Once()
-
-				agentsCombined.On("GetSimilarSongsByAlbum", mock.Anything, "album-1", "Speak & Spell", "Depeche Mode", "album-mbid", 5).
-					Return([]agents.Song{
-						{Name: "New Life", MBID: "song-mbid", Artist: "Depeche Mode"},
-					}, nil).Once()
-
-				// Mock loadTracksByID - no ID matches
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					_, ok := opt.Filters.(squirrel.Eq)
-					return ok
-				})).Return(model.MediaFiles{}, nil).Once()
-
-				// Mock loadTracksByMBID - MBID match
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					and, ok := opt.Filters.(squirrel.And)
-					if !ok || len(and) < 1 {
-						return false
-					}
-					_, hasEq := and[0].(squirrel.Eq)
-					return hasEq
-				})).Return(model.MediaFiles{matchedSong}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "album-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("matched-1"))
-			})
-
-			It("falls back when GetSimilarSongsByAlbum returns ErrNotFound", func() {
-				album := model.Album{ID: "album-1", Name: "Album", AlbumArtist: "Artist", AlbumArtistID: "artist-1"}
-				artist := model.Artist{ID: "artist-1", Name: "Artist"}
-				song := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-
-				// GetEntityByID for the initial call tries Artist, Album, Playlist, then MediaFile
-				artistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "album-1").Return(&album, nil).Once()
-
-				agentsCombined.On("GetSimilarSongsByAlbum", mock.Anything, "album-1", "Album", "Artist", "", mock.Anything).
-					Return(nil, agents.ErrNotFound).Once()
-
-				// Fallback calls getArtist(id) which calls GetEntityByID again - this time it finds the album
-				// and recursively calls getArtist(v.AlbumArtistID)
-				artistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
-				albumRepo.On("Get", "album-1").Return(&album, nil).Once()
-
-				// Then it recurses with the artist-1 ID
-				artistRepo.On("Get", "artist-1").Return(&artist, nil).Maybe()
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 1 && opt.Filters != nil
-				})).Return(model.Artists{artist}, nil).Maybe()
-
-				mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist", "", 15).
-					Return([]agents.Artist{}, nil).Once()
-
-				artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					return opt.Max == 0 && opt.Filters != nil
-				})).Return(model.Artists{}, nil).Once()
-
-				mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist", "", mock.Anything).
-					Return([]agents.Song{{Name: "Song One", MBID: "mbid-1"}}, nil).Once()
-
-				mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "album-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("song-1"))
-			})
-		})
-
-		Context("when ID is an Artist", func() {
-			It("calls GetSimilarSongsByArtist and returns matched songs", func() {
-				artist := model.Artist{ID: "artist-1", Name: "Depeche Mode", MbzArtistID: "artist-mbid"}
-				matchedSong := model.MediaFile{ID: "matched-1", Title: "Enjoy the Silence", Artist: "Depeche Mode", MbzRecordingID: "song-mbid"}
-
-				artistRepo.On("Get", "artist-1").Return(&artist, nil).Once()
-				agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Depeche Mode", "artist-mbid", 5).
-					Return([]agents.Song{
-						{Name: "Enjoy the Silence", MBID: "song-mbid", Artist: "Depeche Mode"},
-					}, nil).Once()
-
-				// Mock loadTracksByID - no ID matches
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					_, ok := opt.Filters.(squirrel.Eq)
-					return ok
-				})).Return(model.MediaFiles{}, nil).Once()
-
-				// Mock loadTracksByMBID - MBID match
-				mediaFileRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-					and, ok := opt.Filters.(squirrel.And)
-					if !ok || len(and) < 1 {
-						return false
-					}
-					_, hasEq := and[0].(squirrel.Eq)
-					return hasEq
-				})).Return(model.MediaFiles{matchedSong}, nil).Once()
-
-				songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(songs).To(HaveLen(1))
-				Expect(songs[0].ID).To(Equal("matched-1"))
-			})
-		})
-	})
-
-	It("returns similar songs from main artist and similar artists", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-		similarArtist := model.Artist{ID: "artist-3", Name: "Similar Artist"}
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
-		song3 := model.MediaFile{ID: "song-3", Title: "Song Three", ArtistID: "artist-3", MbzRecordingID: "mbid-3"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("Get", "artist-3").Return(&similarArtist, nil).Maybe()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Once()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		similarAgentsResp := []agents.Artist{
-			{Name: "Similar Artist", MBID: "similar-mbid"},
-		}
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return(similarAgentsResp, nil).Once()
-
-		// Mock the three-phase artist lookup: ID (skipped - no IDs), MBID, then Name
-		// MBID lookup returns empty (no match)
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			_, ok := opt.Filters.(squirrel.Eq)
-			return opt.Max == 0 && ok
-		})).Return(model.Artists{}, nil).Once()
-		// Name lookup returns the similar artist
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			_, ok := opt.Filters.(squirrel.Or)
-			return opt.Max == 0 && ok
-		})).Return(model.Artists{similarArtist}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song One", MBID: "mbid-1"},
-				{Name: "Song Two", MBID: "mbid-2"},
-			}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-3", "Similar Artist", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song Three", MBID: "mbid-3"},
-			}, nil).Once()
-
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song3}, nil).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 3)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(3))
-		for _, song := range songs {
-			Expect(song.ID).To(BeElementOf("song-1", "song-2", "song-3"))
-		}
-	})
-
-	It("returns ErrNotFound when artist is not found", func() {
-		artistRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
-		mediaFileRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
-		albumRepo.On("Get", "artist-unknown-artist").Return(nil, model.ErrNotFound)
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Maybe()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-unknown-artist", 5)
-
-		Expect(err).To(Equal(model.ErrNotFound))
-		Expect(songs).To(BeNil())
-	})
-
-	It("returns songs from main artist when GetSimilarArtists returns error", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Maybe()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return(nil, errors.New("error getting similar artists")).Once()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 0 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song One", MBID: "mbid-1"},
-			}, nil).Once()
-
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1}, nil).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(1))
-		Expect(songs[0].ID).To(Equal("song-1"))
-	})
-
-	It("returns empty list when GetArtistTopSongs returns error", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Maybe()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return([]agents.Artist{}, nil).Once()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 0 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, errors.New("error getting top songs")).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 5)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(BeEmpty())
-	})
-
-	It("respects count parameter", func() {
-		artist1 := model.Artist{ID: "artist-1", Name: "Artist One"}
-		song1 := model.MediaFile{ID: "song-1", Title: "Song One", ArtistID: "artist-1", MbzRecordingID: "mbid-1"}
-		song2 := model.MediaFile{ID: "song-2", Title: "Song Two", ArtistID: "artist-1", MbzRecordingID: "mbid-2"}
-
-		artistRepo.On("Get", "artist-1").Return(&artist1, nil).Maybe()
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 1 && opt.Filters != nil
-		})).Return(model.Artists{artist1}, nil).Maybe()
-
-		// New similar songs by artist returns ErrNotFound to trigger fallback
-		agentsCombined.On("GetSimilarSongsByArtist", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return(nil, agents.ErrNotFound).Once()
-
-		mockAgent.On("GetSimilarArtists", mock.Anything, "artist-1", "Artist One", "", 15).
-			Return([]agents.Artist{}, nil).Once()
-
-		artistRepo.On("GetAll", mock.MatchedBy(func(opt model.QueryOptions) bool {
-			return opt.Max == 0 && opt.Filters != nil
-		})).Return(model.Artists{}, nil).Once()
-
-		mockAgent.On("GetArtistTopSongs", mock.Anything, "artist-1", "Artist One", "", mock.Anything).
-			Return([]agents.Song{
-				{Name: "Song One", MBID: "mbid-1"},
-				{Name: "Song Two", MBID: "mbid-2"},
-			}, nil).Once()
-
-		mediaFileRepo.On("GetAll", mock.AnythingOfType("model.QueryOptions")).Return(model.MediaFiles{song1, song2}, nil).Once()
-
-		songs, err := provider.SimilarSongs(ctx, "artist-1", 1)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).To(HaveLen(1))
-		Expect(songs[0].ID).To(BeElementOf("song-1", "song-2"))
-	})
-})

core/external/provider_topsongs_test.go

@@ -7,8 +7,6 @@ import (
 	_ "github.com/navidrome/navidrome/adapters/lastfm"
 	_ "github.com/navidrome/navidrome/adapters/listenbrainz"
 	_ "github.com/navidrome/navidrome/adapters/spotify"
-	"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"
@@ -28,10 +26,6 @@ var _ = Describe("Provider - TopSongs", func() {
 	)
 
 	BeforeEach(func() {
-		DeferCleanup(configtest.SetupConfig())
-		// Disable fuzzy matching for these tests to avoid unexpected GetAll calls
-		conf.Server.SimilarSongsMatchThreshold = 100
-
 		ctx = GinkgoT().Context()
 
 		artistRepo = newMockArtistRepo()       // Use helper mock

core/library_test.go

@@ -9,7 +9,7 @@ import (
 	"sync"
 
 	"github.com/deluan/rest"
-	_ "github.com/navidrome/navidrome/adapters/gotaglib" // Register taglib extractor
+	_ "github.com/navidrome/navidrome/adapters/taglib" // Register taglib extractor
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/core"
 	_ "github.com/navidrome/navidrome/core/storage/local" // Register local storage

core/metrics/insights.go

@@ -215,7 +215,6 @@ var staticData = sync.OnceValue(func() insights.Data {
 	data.Config.BackupCount = conf.Server.Backup.Count
 	data.Config.DevActivityPanel = conf.Server.DevActivityPanel
 	data.Config.ScannerEnabled = conf.Server.Scanner.Enabled
-	data.Config.ScannerExtractor = conf.Server.Scanner.Extractor
 	data.Config.ScanSchedule = conf.Server.Scanner.Schedule
 	data.Config.ScanWatcherWait = uint64(math.Trunc(conf.Server.Scanner.WatcherWait.Seconds()))
 	data.Config.ScanOnStartup = conf.Server.Scanner.ScanOnStartup
@@ -266,10 +265,6 @@ func (c *insightsCollector) collect(ctx context.Context) []byte {
 	if err != nil {
 		log.Trace(ctx, "Error reading active users count", err)
 	}
-	data.Library.FileSuffixes, err = c.ds.MediaFile(ctx).CountBySuffix()
-	if err != nil {
-		log.Trace(ctx, "Error reading file suffixes count", err)
-	}
 
 	// Check for smart playlists
 	data.Config.HasSmartPlaylists, err = c.hasSmartPlaylists(ctx)

core/metrics/insights/data.go

@@ -40,14 +40,12 @@ type Data struct {
 		Libraries     int64            `json:"libraries"`
 		ActiveUsers   int64            `json:"activeUsers"`
 		ActivePlayers map[string]int64 `json:"activePlayers,omitempty"`
-		FileSuffixes  map[string]int64 `json:"fileSuffixes,omitempty"`
 	} `json:"library"`
 	Config struct {
 		LogLevel                string `json:"logLevel,omitempty"`
 		LogFileConfigured       bool   `json:"logFileConfigured,omitempty"`
 		TLSConfigured           bool   `json:"tlsConfigured,omitempty"`
 		ScannerEnabled          bool   `json:"scannerEnabled,omitempty"`
-		ScannerExtractor        string `json:"scannerExtractor,omitempty"`
 		ScanSchedule            string `json:"scanSchedule,omitempty"`
 		ScanWatcherWait         uint64 `json:"scanWatcherWait,omitempty"`
 		ScanOnStartup           bool   `json:"scanOnStartup,omitempty"`

core/playlists.go

@@ -168,10 +168,9 @@ func (s *playlists) parseNSP(_ context.Context, pls *model.Playlist, reader io.R
 	if nsp.Comment != "" {
 		pls.Comment = nsp.Comment
 	}
-	if nsp.Public != nil {
-		pls.Public = *nsp.Public
-	} else {
-		pls.Public = conf.Server.DefaultPlaylistPublicVisibility
+	pls.Global = nsp.Global
+	if nsp.Global {
+		pls.Public = true
 	}
 	return nil
 }
@@ -179,9 +178,7 @@ func (s *playlists) parseNSP(_ context.Context, pls *model.Playlist, reader io.R
 func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *model.Folder, reader io.Reader) error {
 	mediaFileRepository := s.ds.MediaFile(ctx)
 	var mfs model.MediaFiles
-	// Chunk size of 100 lines, as each line can generate up to 4 lookup candidates
-	// (NFC/NFD × raw/lowercase), and SQLite has a max expression tree depth of 1000.
-	for lines := range slice.CollectChunks(slice.LinesFrom(reader), 100) {
+	for lines := range slice.CollectChunks(slice.LinesFrom(reader), 400) {
 		filteredLines := make([]string, 0, len(lines))
 		for _, line := range lines {
 			line := strings.TrimSpace(line)
@@ -208,66 +205,33 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
 			continue
 		}
 
-		// SQLite comparisons do not perform Unicode normalization, and filesystem normalization
-		// differs across platforms (macOS often yields NFD, while Linux/Windows typically use NFC).
-		// Generate lookup candidates for both forms so playlist entries match DB paths regardless
-		// of the original normalization. See https://github.com/navidrome/navidrome/issues/4884
-		//
-		// We also include the original (non-lowercased) paths because SQLite's COLLATE NOCASE
-		// only handles ASCII case-insensitivity. Non-ASCII characters like fullwidth letters
-		// (e.g., ＡＢＣＤ vs ａｂｃｄ) are not matched case-insensitively by NOCASE.
-		lookupCandidates := make([]string, 0, len(resolvedPaths)*4)
-		seen := make(map[string]struct{}, len(resolvedPaths)*4)
-		for _, path := range resolvedPaths {
-			// Add original paths first (for exact matching of non-ASCII characters)
-			nfcRaw := norm.NFC.String(path)
-			if _, ok := seen[nfcRaw]; !ok {
-				seen[nfcRaw] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfcRaw)
-			}
-			nfdRaw := norm.NFD.String(path)
-			if _, ok := seen[nfdRaw]; !ok {
-				seen[nfdRaw] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfdRaw)
-			}
+		// Normalize to NFD for filesystem compatibility (macOS). Database stores paths in NFD.
+		// See https://github.com/navidrome/navidrome/issues/4663
+		resolvedPaths = slice.Map(resolvedPaths, func(path string) string {
+			return strings.ToLower(norm.NFD.String(path))
+		})
 
-			// Add lowercased paths (for ASCII case-insensitive matching via NOCASE)
-			nfc := strings.ToLower(nfcRaw)
-			if _, ok := seen[nfc]; !ok {
-				seen[nfc] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfc)
-			}
-			nfd := strings.ToLower(nfdRaw)
-			if _, ok := seen[nfd]; !ok {
-				seen[nfd] = struct{}{}
-				lookupCandidates = append(lookupCandidates, nfd)
-			}
-		}
-
-		found, err := mediaFileRepository.FindByPaths(lookupCandidates)
+		found, err := mediaFileRepository.FindByPaths(resolvedPaths)
 		if err != nil {
 			log.Warn(ctx, "Error reading files from DB", "playlist", pls.Name, err)
 			continue
 		}
-
-		// Build lookup map with library-qualified keys, normalized for comparison.
-		// Canonicalize to NFC so NFD/NFC become comparable.
+		// Build lookup map with library-qualified keys, normalized for comparison
 		existing := make(map[string]int, len(found))
 		for idx := range found {
-			key := fmt.Sprintf("%d:%s", found[idx].LibraryID, strings.ToLower(norm.NFC.String(found[idx].Path)))
+			// Normalize to lowercase for case-insensitive comparison
+			// Key format: "libraryID:path"
+			key := fmt.Sprintf("%d:%s", found[idx].LibraryID, strings.ToLower(found[idx].Path))
 			existing[key] = idx
 		}
 
 		// Find media files in the order of the resolved paths, to keep playlist order
 		for _, path := range resolvedPaths {
-			key := strings.ToLower(norm.NFC.String(path))
-			idx, ok := existing[key]
+			idx, ok := existing[path]
 			if ok {
 				mfs = append(mfs, found[idx])
 			} else {
-				// Prefer logging a composed representation when possible to avoid confusing output
-				// with decomposed combining marks.
-				log.Warn(ctx, "Path in playlist not found", "playlist", pls.Name, "path", norm.NFC.String(path))
+				log.Warn(ctx, "Path in playlist not found", "playlist", pls.Name, "path", path)
 			}
 		}
 	}
@@ -429,20 +393,7 @@ func (s *playlists) resolvePaths(ctx context.Context, folder *model.Folder, line
 func (s *playlists) updatePlaylist(ctx context.Context, newPls *model.Playlist) error {
 	owner, _ := request.UserFrom(ctx)
 
-	// Try to find existing playlist by path. Since filesystem normalization differs across
-	// platforms (macOS uses NFD, Linux/Windows use NFC), we try both forms to match
-	// playlists that may have been imported on a different platform.
 	pls, err := s.ds.Playlist(ctx).FindByPath(newPls.Path)
-	if errors.Is(err, model.ErrNotFound) {
-		// Try alternate normalization form
-		altPath := norm.NFD.String(newPls.Path)
-		if altPath == newPls.Path {
-			altPath = norm.NFC.String(newPls.Path)
-		}
-		if altPath != newPls.Path {
-			pls, err = s.ds.Playlist(ctx).FindByPath(altPath)
-		}
-	}
 	if err != nil && !errors.Is(err, model.ErrNotFound) {
 		return err
 	}
@@ -457,13 +408,16 @@ func (s *playlists) updatePlaylist(ctx context.Context, newPls *model.Playlist)
 		newPls.Name = pls.Name
 		newPls.Comment = pls.Comment
 		newPls.OwnerID = pls.OwnerID
-		newPls.Public = pls.Public
+		// Preserve Public from existing playlist, unless the new playlist is Global
+		if !newPls.Global {
+			newPls.Public = pls.Public
+		}
 		newPls.EvaluatedAt = &time.Time{}
 	} else {
 		log.Info(ctx, "Adding synced playlist", "playlist", newPls.Name, "path", newPls.Path, "owner", owner.UserName)
 		newPls.OwnerID = owner.ID
-		// For NSP files, Public may already be set from the file; for M3U, use server default
-		if !newPls.IsSmartPlaylist() {
+		// Only apply default visibility if not a global playlist (which is always public)
+		if !newPls.Global {
 			newPls.Public = conf.Server.DefaultPlaylistPublicVisibility
 		}
 	}
@@ -529,7 +483,7 @@ type nspFile struct {
 	criteria.Criteria
 	Name    string `json:"name"`
 	Comment string `json:"comment"`
-	Public  *bool  `json:"public"`
+	Global  bool   `json:"global"`
 }
 
 func (i *nspFile) UnmarshalJSON(data []byte) error {
@@ -540,8 +494,6 @@ func (i *nspFile) UnmarshalJSON(data []byte) error {
 	}
 	i.Name, _ = m["name"].(string)
 	i.Comment, _ = m["comment"].(string)
-	if public, ok := m["public"].(bool); ok {
-		i.Public = &public
-	}
+	i.Global, _ = m["global"].(bool)
 	return json.Unmarshal(data, &i.Criteria)
 }

core/playlists_test.go

@@ -107,83 +107,22 @@ var _ = Describe("Playlists", func() {
 				Expect(pls.Rules.Order).To(Equal("desc"))
 				Expect(pls.Rules.Limit).To(Equal(100))
 				Expect(pls.Rules.Expression).To(BeAssignableToTypeOf(criteria.All{}))
+				Expect(pls.Global).To(BeFalse())
+				Expect(pls.Public).To(BeFalse())
 			})
 			It("returns an error if the playlist is not well-formed", func() {
 				_, err := ps.ImportFile(ctx, folder, "invalid_json.nsp")
 				Expect(err.Error()).To(ContainSubstring("line 19, column 1: invalid character '\\n'"))
 			})
-			It("parses NSP with public: true and creates public playlist", func() {
-				pls, err := ps.ImportFile(ctx, folder, "public_playlist.nsp")
+			It("parses global attribute and sets playlist to public", func() {
+				pls, err := ps.ImportFile(ctx, folder, "global_smart_playlist.nsp")
 				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Name).To(Equal("Public Playlist"))
+				Expect(pls.Name).To(Equal("Global Smart Playlist"))
+				Expect(pls.Global).To(BeTrue())
 				Expect(pls.Public).To(BeTrue())
 			})
-			It("parses NSP with public: false and creates private playlist", func() {
-				pls, err := ps.ImportFile(ctx, folder, "private_playlist.nsp")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Name).To(Equal("Private Playlist"))
-				Expect(pls.Public).To(BeFalse())
-			})
-			It("uses server default when public field is absent", func() {
-				DeferCleanup(configtest.SetupConfig())
-				conf.Server.DefaultPlaylistPublicVisibility = true
-
-				pls, err := ps.ImportFile(ctx, folder, "recently_played.nsp")
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Name).To(Equal("Recently Played"))
-				Expect(pls.Public).To(BeTrue()) // Should be true since server default is true
-			})
 		})
 
-		DescribeTable("Playlist filename Unicode normalization (regression fix-playlist-filename-normalization)",
-			func(storedForm, filesystemForm string) {
-				// 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)
-				Expect(plsNameNFD).ToNot(Equal(plsNameNFC)) // Verify they differ
-
-				nameByForm := map[string]string{"NFC": plsNameNFC, "NFD": plsNameNFD}
-				storedName := nameByForm[storedForm]
-				filesystemName := nameByForm[filesystemForm]
-
-				tmpDir := GinkgoT().TempDir()
-				mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
-				ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{}}
-				ps = core.NewPlaylists(ds)
-
-				// Create the playlist file on disk with the filesystem's normalization form
-				plsFile := tmpDir + "/" + filesystemName + ".m3u"
-				Expect(os.WriteFile(plsFile, []byte("#PLAYLIST:Test\n"), 0600)).To(Succeed())
-
-				// Pre-populate mock repo with the stored normalization form
-				storedPath := tmpDir + "/" + storedName + ".m3u"
-				existingPls := &model.Playlist{
-					ID:   "existing-id",
-					Name: "Existing Playlist",
-					Path: storedPath,
-					Sync: true,
-				}
-				mockPlsRepo.data = map[string]*model.Playlist{storedPath: existingPls}
-
-				// Import using the filesystem's normalization form
-				plsFolder := &model.Folder{
-					ID:          "1",
-					LibraryID:   1,
-					LibraryPath: tmpDir,
-					Path:        "",
-					Name:        "",
-				}
-				pls, err := ps.ImportFile(ctx, plsFolder, filesystemName+".m3u")
-				Expect(err).ToNot(HaveOccurred())
-
-				// Should update existing playlist, not create new one
-				Expect(pls.ID).To(Equal("existing-id"))
-				Expect(pls.Name).To(Equal("Existing Playlist"))
-			},
-			Entry("finds NFD-stored playlist when filesystem provides NFC path", "NFD", "NFC"),
-			Entry("finds NFC-stored playlist when filesystem provides NFD path", "NFC", "NFD"),
-		)
-
 		Describe("Cross-library relative paths", func() {
 			var tmpDir, plsDir, songsDir string
 
@@ -495,79 +434,23 @@ var _ = Describe("Playlists", func() {
 			Expect(pls.Tracks[0].Path).To(Equal("abc/tEsT1.Mp3"))
 		})
 
-		// Fullwidth characters (e.g., ＡＢＣＤ) are not handled by SQLite's NOCASE collation,
-		// so we need exact matching for non-ASCII characters.
-		It("matches fullwidth characters exactly (SQLite NOCASE limitation)", func() {
-			// Fullwidth uppercase ＡＣＲＯＳＳ (U+FF21, U+FF23, U+FF32, U+FF2F, U+FF33, U+FF33)
-			repo.data = []string{
-				"plex/02 - ＡＣＲＯＳＳ.flac",
-			}
-			m3u := "/music/plex/02 - ＡＣＲＯＳＳ.flac\n"
+		It("handles Unicode normalization when comparing paths (NFD vs NFC)", func() {
+			// Simulate macOS filesystem: stores paths in NFD (decomposed) form
+			// "è" (U+00E8) in NFC becomes "e" + "◌̀" (U+0065 + U+0300) in NFD
+			nfdPath := "artist/Mich" + string([]rune{'e', '\u0300'}) + "le/song.mp3" // NFD: e + combining grave
+			repo.data = []string{nfdPath}
+
+			// Simulate Apple Music M3U: uses NFC (composed) form
+			nfcPath := "/music/artist/Mich\u00E8le/song.mp3" // NFC: single è character
+			m3u := nfcPath + "\n"
 			f := strings.NewReader(m3u)
 			pls, err := ps.ImportM3U(ctx, f)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(pls.Tracks).To(HaveLen(1))
-			Expect(pls.Tracks[0].Path).To(Equal("plex/02 - ＡＣＲＯＳＳ.flac"))
+			// Should match despite different Unicode normalization forms
+			Expect(pls.Tracks[0].Path).To(Equal(nfdPath))
 		})
 
-		// Unicode normalization tests: NFC (composed) vs NFD (decomposed) forms
-		// macOS stores paths in NFD, Linux/Windows use NFC. Playlists may use either form.
-		DescribeTable("matches paths across Unicode NFC/NFD normalization",
-			func(description, pathNFC string, dbForm, playlistForm norm.Form) {
-				pathNFD := norm.NFD.String(pathNFC)
-				Expect(pathNFD).ToNot(Equal(pathNFC), "test path should have decomposable characters")
-
-				// Set up DB with specified normalization form
-				var dbPath string
-				if dbForm == norm.NFC {
-					dbPath = pathNFC
-				} else {
-					dbPath = pathNFD
-				}
-				repo.data = []string{dbPath}
-
-				// Set up playlist with specified normalization form
-				var playlistPath string
-				if playlistForm == norm.NFC {
-					playlistPath = pathNFC
-				} else {
-					playlistPath = pathNFD
-				}
-				m3u := "/music/" + playlistPath + "\n"
-				f := strings.NewReader(m3u)
-
-				pls, err := ps.ImportM3U(ctx, f)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(pls.Tracks).To(HaveLen(1))
-				Expect(pls.Tracks[0].Path).To(Equal(dbPath))
-			},
-			// French: è (U+00E8) decomposes to e + combining grave (U+0065 + U+0300)
-			Entry("French diacritics - DB:NFD, playlist:NFC",
-				"macOS DB with Apple Music playlist",
-				"artist/Michèle/song.mp3", norm.NFD, norm.NFC),
-
-			// Japanese Katakana: ド (U+30C9) decomposes to ト (U+30C8) + combining dakuten (U+3099)
-			Entry("Japanese Katakana with dakuten - DB:NFC, playlist:NFC (#4884)",
-				"Linux/Windows DB with NFC playlist",
-				"artist/\u30a2\u30a4\u30c9\u30eb/\u30c9\u30ea\u30fc\u30e0\u30bd\u30f3\u30b0.mp3", norm.NFC, norm.NFC),
-			Entry("Japanese Katakana with dakuten - DB:NFD, playlist:NFC (#4884)",
-				"macOS DB with NFC playlist",
-				"artist/\u30a2\u30a4\u30c9\u30eb/\u30c9\u30ea\u30fc\u30e0\u30bd\u30f3\u30b0.mp3", norm.NFD, norm.NFC),
-
-			// Cyrillic: й (U+0439) decomposes to и (U+0438) + combining breve (U+0306)
-			Entry("Cyrillic characters - DB:NFD, playlist:NFC (#4791)",
-				"macOS DB with NFC playlist",
-				"Жуки/Батарейка/01 - Разлюбила.mp3", norm.NFD, norm.NFC),
-
-			// Polish: ó (U+00F3) decomposes to o + combining acute (U+0301)
-			Entry("Polish diacritics - DB:NFD, playlist:NFC (#4663)",
-				"macOS DB with NFC playlist",
-				"Zespół/Człowiek/Piosenka o miłości.mp3", norm.NFD, norm.NFC),
-			Entry("Polish diacritics - DB:NFC, playlist:NFD",
-				"Linux/Windows DB with macOS-exported playlist",
-				"Zespół/Człowiek/Piosenka o miłości.mp3", norm.NFC, norm.NFD),
-		)
-
 	})
 
 	Describe("InPlaylistsPath", func() {
@@ -668,6 +551,9 @@ func (r *mockedMediaFileFromListRepo) FindByPaths(paths []string) (model.MediaFi
 	var mfs model.MediaFiles
 
 	for idx, dataPath := range r.data {
+		// Normalize the data path to NFD (simulates macOS filesystem storage)
+		normalizedDataPath := norm.NFD.String(dataPath)
+
 		for _, requestPath := range paths {
 			// Strip library qualifier if present (format: "libraryID:path")
 			actualPath := requestPath
@@ -679,9 +565,12 @@ func (r *mockedMediaFileFromListRepo) FindByPaths(paths []string) (model.MediaFi
 				}
 			}
 
-			// Case-insensitive comparison (like SQL's "collate nocase"), but with no
-			// implicit Unicode normalization (SQLite does not normalize NFC/NFD).
-			if strings.EqualFold(actualPath, dataPath) {
+			// The request path should already be normalized to NFD by production code
+			// before calling FindByPaths (to match DB storage)
+			normalizedRequestPath := norm.NFD.String(actualPath)
+
+			// Case-insensitive comparison (like SQL's "collate nocase")
+			if strings.EqualFold(normalizedRequestPath, normalizedDataPath) {
 				mfs = append(mfs, model.MediaFile{
 					ID:        strconv.Itoa(idx),
 					Path:      dataPath, // Return original path from DB
@@ -696,16 +585,10 @@ func (r *mockedMediaFileFromListRepo) FindByPaths(paths []string) (model.MediaFi
 
 type mockedPlaylistRepo struct {
 	last *model.Playlist
-	data map[string]*model.Playlist // keyed by path
 	model.PlaylistRepository
 }
 
-func (r *mockedPlaylistRepo) FindByPath(path string) (*model.Playlist, error) {
-	if r.data != nil {
-		if pls, ok := r.data[path]; ok {
-			return pls, nil
-		}
-	}
+func (r *mockedPlaylistRepo) FindByPath(string) (*model.Playlist, error) {
 	return nil, model.ErrNotFound
 }
 

core/transcode/transcode.go

@@ -1,689 +0,0 @@
-package transcode
-
-import (
-	"context"
-	"slices"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/navidrome/navidrome/core/auth"
-	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/model"
-)
-
-const (
-	tokenTTL       = 12 * time.Hour
-	defaultBitrate = 256 // kbps
-)
-
-// Decider is the core service interface for making transcoding decisions
-type Decider interface {
-	MakeDecision(ctx context.Context, mf *model.MediaFile, clientInfo *ClientInfo) (*Decision, error)
-	CreateTranscodeParams(decision *Decision) (string, error)
-	ParseTranscodeParams(token string) (*Params, error)
-}
-
-// ClientInfo represents client playback capabilities.
-// All bitrate values are in kilobits per second (kbps)
-type ClientInfo struct {
-	Name                       string
-	Platform                   string
-	MaxAudioBitrate            int
-	MaxTranscodingAudioBitrate int
-	DirectPlayProfiles         []DirectPlayProfile
-	TranscodingProfiles        []Profile
-	CodecProfiles              []CodecProfile
-}
-
-// DirectPlayProfile describes a format the client can play directly
-type DirectPlayProfile struct {
-	Containers       []string
-	AudioCodecs      []string
-	Protocols        []string
-	MaxAudioChannels int
-}
-
-// Profile describes a transcoding target the client supports
-type Profile struct {
-	Container        string
-	AudioCodec       string
-	Protocol         string
-	MaxAudioChannels int
-}
-
-// CodecProfile describes codec-specific limitations
-type CodecProfile struct {
-	Type        string
-	Name        string
-	Limitations []Limitation
-}
-
-// Limitation describes a specific codec limitation
-type Limitation struct {
-	Name       string
-	Comparison string
-	Values     []string
-	Required   bool
-}
-
-// Protocol values (OpenSubsonic spec enum)
-const (
-	ProtocolHTTP = "http"
-	ProtocolHLS  = "hls"
-)
-
-// Comparison operators (OpenSubsonic spec enum)
-const (
-	ComparisonEquals           = "Equals"
-	ComparisonNotEquals        = "NotEquals"
-	ComparisonLessThanEqual    = "LessThanEqual"
-	ComparisonGreaterThanEqual = "GreaterThanEqual"
-)
-
-// Limitation names (OpenSubsonic spec enum)
-const (
-	LimitationAudioChannels   = "audioChannels"
-	LimitationAudioBitrate    = "audioBitrate"
-	LimitationAudioProfile    = "audioProfile"
-	LimitationAudioSamplerate = "audioSamplerate"
-	LimitationAudioBitdepth   = "audioBitdepth"
-)
-
-// Codec profile types (OpenSubsonic spec enum)
-const (
-	CodecProfileTypeAudio = "AudioCodec"
-)
-
-// Decision represents the internal decision result.
-// All bitrate values are in kilobits per second (kbps).
-type Decision struct {
-	MediaID          string
-	CanDirectPlay    bool
-	CanTranscode     bool
-	TranscodeReasons []string
-	ErrorReason      string
-	TargetFormat     string
-	TargetBitrate    int
-	TargetChannels   int
-	SourceStream     StreamDetails
-	TranscodeStream  *StreamDetails
-}
-
-// StreamDetails describes audio stream properties.
-// Bitrate is in kilobits per second (kbps).
-type StreamDetails struct {
-	Container  string
-	Codec      string
-	Profile    string // Audio profile (e.g., "LC", "HE-AAC"). Empty until scanner support is added.
-	Bitrate    int
-	SampleRate int
-	BitDepth   int
-	Channels   int
-	Duration   float32
-	Size       int64
-	IsLossless bool
-}
-
-// Params contains the parameters extracted from a transcode token.
-// TargetBitrate is in kilobits per second (kbps).
-type Params struct {
-	MediaID        string
-	DirectPlay     bool
-	TargetFormat   string
-	TargetBitrate  int
-	TargetChannels int
-}
-
-func NewDecider(ds model.DataStore) Decider {
-	return &deciderService{
-		ds: ds,
-	}
-}
-
-type deciderService struct {
-	ds model.DataStore
-}
-
-func (s *deciderService) MakeDecision(ctx context.Context, mf *model.MediaFile, clientInfo *ClientInfo) (*Decision, error) {
-	decision := &Decision{
-		MediaID: mf.ID,
-	}
-
-	sourceBitrate := mf.BitRate // kbps
-
-	log.Trace(ctx, "Making transcode decision", "mediaID", mf.ID, "container", mf.Suffix,
-		"codec", mf.AudioCodec(), "bitrate", sourceBitrate, "channels", mf.Channels,
-		"sampleRate", mf.SampleRate, "lossless", mf.IsLossless(), "client", clientInfo.Name)
-
-	// Build source stream details
-	decision.SourceStream = StreamDetails{
-		Container:  mf.Suffix,
-		Codec:      mf.AudioCodec(),
-		Bitrate:    sourceBitrate,
-		SampleRate: mf.SampleRate,
-		BitDepth:   mf.BitDepth,
-		Channels:   mf.Channels,
-		Duration:   mf.Duration,
-		Size:       mf.Size,
-		IsLossless: mf.IsLossless(),
-	}
-
-	// Check global bitrate constraint first.
-	if clientInfo.MaxAudioBitrate > 0 && sourceBitrate > clientInfo.MaxAudioBitrate {
-		log.Trace(ctx, "Global bitrate constraint exceeded, skipping direct play",
-			"sourceBitrate", sourceBitrate, "maxAudioBitrate", clientInfo.MaxAudioBitrate)
-		decision.TranscodeReasons = append(decision.TranscodeReasons, "audio bitrate not supported")
-		// Skip direct play profiles entirely — global constraint fails
-	} else {
-		// Try direct play profiles, collecting reasons for each failure
-		for _, profile := range clientInfo.DirectPlayProfiles {
-			if reason := s.checkDirectPlayProfile(mf, sourceBitrate, &profile, clientInfo); reason == "" {
-				decision.CanDirectPlay = true
-				decision.TranscodeReasons = nil // Clear any previously collected reasons
-				break
-			} else {
-				decision.TranscodeReasons = append(decision.TranscodeReasons, reason)
-			}
-		}
-	}
-
-	// If direct play is possible, we're done
-	if decision.CanDirectPlay {
-		log.Debug(ctx, "Transcode decision: direct play", "mediaID", mf.ID, "container", mf.Suffix, "codec", mf.AudioCodec())
-		return decision, nil
-	}
-
-	// Try transcoding profiles (in order of preference)
-	for _, profile := range clientInfo.TranscodingProfiles {
-		if ts := s.computeTranscodedStream(ctx, mf, sourceBitrate, &profile, clientInfo); ts != nil {
-			decision.CanTranscode = true
-			decision.TargetFormat = ts.Container
-			decision.TargetBitrate = ts.Bitrate
-			decision.TargetChannels = ts.Channels
-			decision.TranscodeStream = ts
-			break
-		}
-	}
-
-	if decision.CanTranscode {
-		log.Debug(ctx, "Transcode decision: transcode", "mediaID", mf.ID,
-			"targetFormat", decision.TargetFormat, "targetBitrate", decision.TargetBitrate,
-			"targetChannels", decision.TargetChannels, "reasons", decision.TranscodeReasons)
-	}
-
-	// If neither direct play nor transcode is possible
-	if !decision.CanDirectPlay && !decision.CanTranscode {
-		decision.ErrorReason = "no compatible playback profile found"
-		log.Warn(ctx, "Transcode decision: no compatible profile", "mediaID", mf.ID,
-			"container", mf.Suffix, "codec", mf.AudioCodec(), "reasons", decision.TranscodeReasons)
-	}
-
-	return decision, nil
-}
-
-// checkDirectPlayProfile returns "" if the profile matches (direct play OK),
-// or a typed reason string if it doesn't match.
-func (s *deciderService) checkDirectPlayProfile(mf *model.MediaFile, sourceBitrate int, profile *DirectPlayProfile, clientInfo *ClientInfo) string {
-	// Check protocol (only http for now)
-	if len(profile.Protocols) > 0 && !containsIgnoreCase(profile.Protocols, ProtocolHTTP) {
-		return "protocol not supported"
-	}
-
-	// Check container
-	if len(profile.Containers) > 0 && !matchesContainer(mf.Suffix, profile.Containers) {
-		return "container not supported"
-	}
-
-	// Check codec
-	if len(profile.AudioCodecs) > 0 && !matchesCodec(mf.AudioCodec(), profile.AudioCodecs) {
-		return "audio codec not supported"
-	}
-
-	// Check channels
-	if profile.MaxAudioChannels > 0 && mf.Channels > profile.MaxAudioChannels {
-		return "audio channels not supported"
-	}
-
-	// Check codec-specific limitations
-	for _, codecProfile := range clientInfo.CodecProfiles {
-		if strings.EqualFold(codecProfile.Type, CodecProfileTypeAudio) && matchesCodec(mf.AudioCodec(), []string{codecProfile.Name}) {
-			if reason := checkLimitations(mf, sourceBitrate, codecProfile.Limitations); reason != "" {
-				return reason
-			}
-		}
-	}
-
-	return ""
-}
-
-// checkLimitations checks codec profile limitations against source media.
-// Returns "" if all limitations pass, or a typed reason string for the first failure.
-func checkLimitations(mf *model.MediaFile, sourceBitrate int, limitations []Limitation) string {
-	for _, lim := range limitations {
-		var ok bool
-		var reason string
-
-		switch lim.Name {
-		case LimitationAudioChannels:
-			ok = checkIntLimitation(mf.Channels, lim.Comparison, lim.Values)
-			reason = "audio channels not supported"
-		case LimitationAudioSamplerate:
-			ok = checkIntLimitation(mf.SampleRate, lim.Comparison, lim.Values)
-			reason = "audio samplerate not supported"
-		case LimitationAudioBitrate:
-			ok = checkIntLimitation(sourceBitrate, lim.Comparison, lim.Values)
-			reason = "audio bitrate not supported"
-		case LimitationAudioBitdepth:
-			ok = checkIntLimitation(mf.BitDepth, lim.Comparison, lim.Values)
-			reason = "audio bitdepth not supported"
-		case LimitationAudioProfile:
-			// TODO: populate source profile when MediaFile has audio profile info
-			ok = checkStringLimitation("", lim.Comparison, lim.Values)
-			reason = "audio profile not supported"
-		default:
-			continue
-		}
-
-		if !ok && lim.Required {
-			return reason
-		}
-	}
-	return ""
-}
-
-// adjustResult represents the outcome of applying a limitation to a transcoded stream value
-type adjustResult int
-
-const (
-	adjustNone      adjustResult = iota // Value already satisfies the limitation
-	adjustAdjusted                      // Value was changed to fit the limitation
-	adjustCannotFit                     // Cannot satisfy the limitation (reject this profile)
-)
-
-// computeTranscodedStream attempts to build a valid transcoded stream for the given profile.
-// Returns nil if the profile cannot produce a valid output.
-func (s *deciderService) computeTranscodedStream(ctx context.Context, mf *model.MediaFile, sourceBitrate int, profile *Profile, clientInfo *ClientInfo) *StreamDetails {
-	// Check protocol (only http for now)
-	if profile.Protocol != "" && !strings.EqualFold(profile.Protocol, ProtocolHTTP) {
-		log.Trace(ctx, "Skipping transcoding profile: unsupported protocol", "protocol", profile.Protocol)
-		return nil
-	}
-
-	targetFormat := strings.ToLower(profile.Container)
-	if targetFormat == "" {
-		targetFormat = strings.ToLower(profile.AudioCodec)
-	}
-
-	// Verify we have a transcoding config for this format
-	tc, err := s.ds.Transcoding(ctx).FindByFormat(targetFormat)
-	if err != nil || tc == nil {
-		log.Trace(ctx, "Skipping transcoding profile: no transcoding config", "targetFormat", targetFormat)
-		return nil
-	}
-
-	targetIsLossless := isLosslessFormat(targetFormat)
-
-	// Reject lossy to lossless conversion
-	if !mf.IsLossless() && targetIsLossless {
-		log.Trace(ctx, "Skipping transcoding profile: lossy to lossless not allowed", "targetFormat", targetFormat)
-		return nil
-	}
-
-	ts := &StreamDetails{
-		Container:  targetFormat,
-		Codec:      strings.ToLower(profile.AudioCodec),
-		SampleRate: mf.SampleRate,
-		Channels:   mf.Channels,
-		IsLossless: targetIsLossless,
-	}
-	if ts.Codec == "" {
-		ts.Codec = targetFormat
-	}
-
-	// Determine target bitrate (all in kbps)
-	if mf.IsLossless() {
-		if !targetIsLossless {
-			// Lossless to lossy: use client's max transcoding bitrate or default
-			if clientInfo.MaxTranscodingAudioBitrate > 0 {
-				ts.Bitrate = clientInfo.MaxTranscodingAudioBitrate
-			} else {
-				ts.Bitrate = defaultBitrate
-			}
-		} else {
-			// Lossless to lossless: check if bitrate is under the global max
-			if clientInfo.MaxAudioBitrate > 0 && sourceBitrate > clientInfo.MaxAudioBitrate {
-				log.Trace(ctx, "Skipping transcoding profile: lossless target exceeds bitrate limit",
-					"targetFormat", targetFormat, "sourceBitrate", sourceBitrate, "maxAudioBitrate", clientInfo.MaxAudioBitrate)
-				return nil
-			}
-			// No explicit bitrate for lossless target (leave 0)
-		}
-	} else {
-		// Lossy to lossy: preserve source bitrate
-		ts.Bitrate = sourceBitrate
-	}
-
-	// Apply maxAudioBitrate as final cap on transcoded stream (#5)
-	if clientInfo.MaxAudioBitrate > 0 && ts.Bitrate > 0 && ts.Bitrate > clientInfo.MaxAudioBitrate {
-		ts.Bitrate = clientInfo.MaxAudioBitrate
-	}
-
-	// Apply MaxAudioChannels from the transcoding profile
-	if profile.MaxAudioChannels > 0 && mf.Channels > profile.MaxAudioChannels {
-		ts.Channels = profile.MaxAudioChannels
-	}
-
-	// Apply codec profile limitations to the TARGET codec (#4)
-	targetCodec := ts.Codec
-	for _, codecProfile := range clientInfo.CodecProfiles {
-		if !strings.EqualFold(codecProfile.Type, CodecProfileTypeAudio) {
-			continue
-		}
-		if !matchesCodec(targetCodec, []string{codecProfile.Name}) {
-			continue
-		}
-		for _, lim := range codecProfile.Limitations {
-			result := applyLimitation(sourceBitrate, &lim, ts)
-			// For lossless codecs, adjusting bitrate is not valid
-			if strings.EqualFold(lim.Name, LimitationAudioBitrate) && targetIsLossless && result == adjustAdjusted {
-				log.Trace(ctx, "Skipping transcoding profile: cannot adjust bitrate for lossless target",
-					"targetFormat", targetFormat, "codec", targetCodec, "limitation", lim.Name)
-				return nil
-			}
-			if result == adjustCannotFit {
-				log.Trace(ctx, "Skipping transcoding profile: codec limitation cannot be satisfied",
-					"targetFormat", targetFormat, "codec", targetCodec, "limitation", lim.Name,
-					"comparison", lim.Comparison, "values", lim.Values)
-				return nil
-			}
-		}
-	}
-
-	return ts
-}
-
-// applyLimitation adjusts a transcoded stream parameter to satisfy the limitation.
-// Returns the adjustment result.
-func applyLimitation(sourceBitrate int, lim *Limitation, ts *StreamDetails) adjustResult {
-	switch lim.Name {
-	case LimitationAudioChannels:
-		return applyIntLimitation(lim.Comparison, lim.Values, ts.Channels, func(v int) { ts.Channels = v })
-	case LimitationAudioBitrate:
-		current := ts.Bitrate
-		if current == 0 {
-			current = sourceBitrate
-		}
-		return applyIntLimitation(lim.Comparison, lim.Values, current, func(v int) { ts.Bitrate = v })
-	case LimitationAudioSamplerate:
-		return applyIntLimitation(lim.Comparison, lim.Values, ts.SampleRate, func(v int) { ts.SampleRate = v })
-	case LimitationAudioBitdepth:
-		if ts.BitDepth > 0 {
-			return applyIntLimitation(lim.Comparison, lim.Values, ts.BitDepth, func(v int) { ts.BitDepth = v })
-		}
-	case LimitationAudioProfile:
-		// TODO: implement when audio profile data is available
-	}
-	return adjustNone
-}
-
-// applyIntLimitation applies a limitation comparison to a value.
-// If the value needs adjusting, calls the setter and returns the result.
-func applyIntLimitation(comparison string, values []string, current int, setter func(int)) adjustResult {
-	if len(values) == 0 {
-		return adjustNone
-	}
-
-	switch comparison {
-	case ComparisonLessThanEqual:
-		limit, ok := parseInt(values[0])
-		if !ok {
-			return adjustNone
-		}
-		if current <= limit {
-			return adjustNone
-		}
-		setter(limit)
-		return adjustAdjusted
-	case ComparisonGreaterThanEqual:
-		limit, ok := parseInt(values[0])
-		if !ok {
-			return adjustNone
-		}
-		if current >= limit {
-			return adjustNone
-		}
-		// Cannot upscale
-		return adjustCannotFit
-	case ComparisonEquals:
-		// Check if current value matches any allowed value
-		for _, v := range values {
-			if limit, ok := parseInt(v); ok && current == limit {
-				return adjustNone
-			}
-		}
-		// Find the closest allowed value below current (don't upscale)
-		var closest int
-		found := false
-		for _, v := range values {
-			if limit, ok := parseInt(v); ok && limit < current {
-				if !found || limit > closest {
-					closest = limit
-					found = true
-				}
-			}
-		}
-		if found {
-			setter(closest)
-			return adjustAdjusted
-		}
-		return adjustCannotFit
-	case ComparisonNotEquals:
-		for _, v := range values {
-			if limit, ok := parseInt(v); ok && current == limit {
-				return adjustCannotFit
-			}
-		}
-		return adjustNone
-	}
-
-	return adjustNone
-}
-
-func (s *deciderService) CreateTranscodeParams(decision *Decision) (string, error) {
-	exp := time.Now().Add(tokenTTL)
-	claims := map[string]any{
-		"mid": decision.MediaID,
-		"dp":  decision.CanDirectPlay,
-	}
-	if decision.CanTranscode && decision.TargetFormat != "" {
-		claims["fmt"] = decision.TargetFormat
-		claims["br"] = decision.TargetBitrate
-		if decision.TargetChannels > 0 {
-			claims["ch"] = decision.TargetChannels
-		}
-	}
-	return auth.CreateExpiringPublicToken(exp, claims)
-}
-
-func (s *deciderService) ParseTranscodeParams(token string) (*Params, error) {
-	claims, err := auth.Validate(token)
-	if err != nil {
-		return nil, err
-	}
-
-	params := &Params{}
-	if mid, ok := claims["mid"].(string); ok {
-		params.MediaID = mid
-	}
-	if dp, ok := claims["dp"].(bool); ok {
-		params.DirectPlay = dp
-	}
-	if fmt, ok := claims["fmt"].(string); ok {
-		params.TargetFormat = fmt
-	}
-	if br, ok := claims["br"].(float64); ok {
-		params.TargetBitrate = int(br)
-	}
-	if ch, ok := claims["ch"].(float64); ok {
-		params.TargetChannels = int(ch)
-	}
-
-	return params, nil
-}
-
-func containsIgnoreCase(slice []string, s string) bool {
-	return slices.ContainsFunc(slice, func(item string) bool {
-		return strings.EqualFold(item, s)
-	})
-}
-
-// containerAliasGroups maps each container alias to a canonical group name.
-var containerAliasGroups = func() map[string]string {
-	groups := [][]string{
-		{"aac", "adts", "m4a", "mp4", "m4b", "m4p"},
-		{"mpeg", "mp3", "mp2"},
-		{"ogg", "oga"},
-		{"aif", "aiff"},
-		{"asf", "wma"},
-		{"mpc", "mpp"},
-		{"wv"},
-	}
-	m := make(map[string]string)
-	for _, g := range groups {
-		canonical := g[0]
-		for _, name := range g {
-			m[name] = canonical
-		}
-	}
-	return m
-}()
-
-// matchesWithAliases checks if a value matches any entry in candidates,
-// consulting the alias map for equivalent names.
-func matchesWithAliases(value string, candidates []string, aliases map[string]string) bool {
-	value = strings.ToLower(value)
-	canonical := aliases[value]
-	for _, c := range candidates {
-		c = strings.ToLower(c)
-		if c == value {
-			return true
-		}
-		if canonical != "" && aliases[c] == canonical {
-			return true
-		}
-	}
-	return false
-}
-
-// matchesContainer checks if a file suffix matches any of the container names,
-// including common aliases.
-func matchesContainer(suffix string, containers []string) bool {
-	return matchesWithAliases(suffix, containers, containerAliasGroups)
-}
-
-// codecAliasGroups maps each codec alias to a canonical group name.
-// Codecs within the same group are considered equivalent.
-var codecAliasGroups = func() map[string]string {
-	groups := [][]string{
-		{"aac", "adts"},
-		{"ac3", "ac-3"},
-		{"eac3", "e-ac3", "e-ac-3", "eac-3"},
-		{"mpc7", "musepack7"},
-		{"mpc8", "musepack8"},
-		{"wma1", "wmav1"},
-		{"wma2", "wmav2"},
-		{"wmalossless", "wma9lossless"},
-		{"wmapro", "wma9pro"},
-		{"shn", "shorten"},
-		{"mp4als", "als"},
-	}
-	m := make(map[string]string)
-	for _, g := range groups {
-		for _, name := range g {
-			m[name] = g[0] // canonical = first entry
-		}
-	}
-	return m
-}()
-
-// matchesCodec checks if a codec matches any of the codec names,
-// including common aliases.
-func matchesCodec(codec string, codecs []string) bool {
-	return matchesWithAliases(codec, codecs, codecAliasGroups)
-}
-
-func checkIntLimitation(value int, comparison string, values []string) bool {
-	if len(values) == 0 {
-		return true
-	}
-
-	switch comparison {
-	case ComparisonLessThanEqual:
-		limit, ok := parseInt(values[0])
-		if !ok {
-			return true
-		}
-		return value <= limit
-	case ComparisonGreaterThanEqual:
-		limit, ok := parseInt(values[0])
-		if !ok {
-			return true
-		}
-		return value >= limit
-	case ComparisonEquals:
-		for _, v := range values {
-			if limit, ok := parseInt(v); ok && value == limit {
-				return true
-			}
-		}
-		return false
-	case ComparisonNotEquals:
-		for _, v := range values {
-			if limit, ok := parseInt(v); ok && value == limit {
-				return false
-			}
-		}
-		return true
-	}
-	return true
-}
-
-// checkStringLimitation checks a string value against a limitation.
-// Only Equals and NotEquals comparisons are meaningful for strings.
-// LessThanEqual/GreaterThanEqual are not applicable and always pass.
-func checkStringLimitation(value string, comparison string, values []string) bool {
-	switch comparison {
-	case ComparisonEquals:
-		for _, v := range values {
-			if strings.EqualFold(value, v) {
-				return true
-			}
-		}
-		return false
-	case ComparisonNotEquals:
-		for _, v := range values {
-			if strings.EqualFold(value, v) {
-				return false
-			}
-		}
-		return true
-	}
-	return true
-}
-
-func parseInt(s string) (int, bool) {
-	v, err := strconv.Atoi(s)
-	if err != nil || v < 0 {
-		return 0, false
-	}
-	return v, true
-}
-
-func isLosslessFormat(format string) bool {
-	switch strings.ToLower(format) {
-	case "flac", "alac", "wav", "aiff", "ape", "wv", "tta", "tak", "shn", "dsd":
-		return true
-	}
-	return false
-}

core/transcode/transcode_suite_test.go

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

core/transcode/transcode_test.go

@@ -1,657 +0,0 @@
-package transcode
-
-import (
-	"context"
-
-	"github.com/navidrome/navidrome/core/auth"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Decider", func() {
-	var (
-		ds  *tests.MockDataStore
-		svc Decider
-		ctx context.Context
-	)
-
-	BeforeEach(func() {
-		ctx = context.Background()
-		ds = &tests.MockDataStore{
-			MockedProperty:    &tests.MockedPropertyRepo{},
-			MockedTranscoding: &tests.MockTranscodingRepo{},
-		}
-		auth.Init(ds)
-		svc = NewDecider(ds)
-	})
-
-	Describe("MakeDecision", func() {
-		Context("Direct Play", func() {
-			It("allows direct play when profile matches", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2, SampleRate: 44100}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}, MaxAudioChannels: 2},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-				Expect(decision.CanTranscode).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(BeEmpty())
-			})
-
-			It("rejects direct play when container doesn't match", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
-			})
-
-			It("rejects direct play when codec doesn't match", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "ALAC", BitRate: 1000, Channels: 2}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement("audio codec not supported"))
-			})
-
-			It("rejects direct play when channels exceed limit", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}, MaxAudioChannels: 2},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement("audio channels not supported"))
-			})
-
-			It("handles container aliases (aac -> m4a)", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"aac"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("handles container aliases (mp4 -> m4a)", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"mp4"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("handles codec aliases (adts -> aac)", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"m4a"}, AudioCodecs: []string{"adts"}, Protocols: []string{"http"}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("allows when protocol list is empty (any protocol)", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, AudioCodecs: []string{"flac"}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("allows when both container and codec lists are empty (wildcard)", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 128, Channels: 2}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{}, AudioCodecs: []string{}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-		})
-
-		Context("MaxAudioBitrate constraint", func() {
-			It("revokes direct play when bitrate exceeds maxAudioBitrate", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1500, Channels: 2}
-				ci := &ClientInfo{
-					MaxAudioBitrate: 500, // kbps
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}},
-					},
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TranscodeReasons).To(ContainElement("audio bitrate not supported"))
-			})
-		})
-
-		Context("Transcoding", func() {
-			It("selects transcoding when direct play isn't possible", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 256, // kbps
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
-					},
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http", MaxAudioChannels: 2},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetFormat).To(Equal("mp3"))
-				Expect(decision.TargetBitrate).To(Equal(256)) // kbps
-				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
-			})
-
-			It("rejects lossy to lossless transcoding", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2}
-				ci := &ClientInfo{
-					TranscodingProfiles: []Profile{
-						{Container: "flac", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeFalse())
-			})
-
-			It("uses default bitrate when client doesn't specify", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, BitDepth: 16}
-				ci := &ClientInfo{
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetBitrate).To(Equal(defaultBitrate)) // 256 kbps
-			})
-
-			It("preserves lossy bitrate when under max", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "ogg", BitRate: 192, Channels: 2}
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 256, // kbps
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetBitrate).To(Equal(192)) // source bitrate in kbps
-			})
-
-			It("rejects unsupported transcoding format", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
-				ci := &ClientInfo{
-					TranscodingProfiles: []Profile{
-						{Container: "aac", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeFalse())
-			})
-
-			It("applies maxAudioBitrate as final cap on transcoded stream", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2}
-				ci := &ClientInfo{
-					MaxAudioBitrate: 96, // kbps
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetBitrate).To(Equal(96)) // capped by maxAudioBitrate
-			})
-
-			It("selects first valid transcoding profile in order", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 48000, BitDepth: 16}
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
-					},
-					TranscodingProfiles: []Profile{
-						{Container: "opus", AudioCodec: "opus", Protocol: "http"},
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http", MaxAudioChannels: 2},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetFormat).To(Equal("opus"))
-			})
-		})
-
-		Context("Lossless to lossless transcoding", func() {
-			It("allows lossless to lossless when samplerate needs downsampling", func() {
-				// MockTranscodingRepo doesn't support "flac" format, so this would fail to find a config.
-				// This test documents the behavior: lossless→lossless requires server transcoding config.
-				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 176400, BitDepth: 1}
-				ci := &ClientInfo{
-					MaxAudioBitrate: 1000,
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}},
-					},
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TargetFormat).To(Equal("mp3"))
-			})
-
-			It("sets IsLossless=true on transcoded stream when target is lossless", func() {
-				// Simulate DSD→FLAC transcoding by using a mock that supports "flac"
-				mockTranscoding := &tests.MockTranscodingRepo{}
-				ds.MockedTranscoding = mockTranscoding
-				svc = NewDecider(ds)
-
-				// MockTranscodingRepo doesn't support flac, so this will skip lossless profile.
-				// Use mp3 which is supported as the fallback.
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TranscodeStream.IsLossless).To(BeFalse()) // mp3 is lossy
-			})
-		})
-
-		Context("No compatible profile", func() {
-			It("returns error when nothing matches", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6}
-				ci := &ClientInfo{}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.CanTranscode).To(BeFalse())
-				Expect(decision.ErrorReason).To(Equal("no compatible playback profile found"))
-			})
-		})
-
-		Context("Codec limitations on direct play", func() {
-			It("rejects direct play when codec limitation fails (required)", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 512, Channels: 2, SampleRate: 44100}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "mp3",
-							Limitations: []Limitation{
-								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"320"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement("audio bitrate not supported"))
-			})
-
-			It("allows direct play when optional limitation fails", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 512, Channels: 2, SampleRate: 44100}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "mp3",
-							Limitations: []Limitation{
-								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"320"}, Required: false},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("handles Equals comparison with multiple values", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "flac",
-							Limitations: []Limitation{
-								{Name: LimitationAudioChannels, Comparison: ComparisonEquals, Values: []string{"1", "2"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("rejects when Equals comparison doesn't match any value", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 44100}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "flac",
-							Limitations: []Limitation{
-								{Name: LimitationAudioChannels, Comparison: ComparisonEquals, Values: []string{"1", "2"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-			})
-
-			It("rejects direct play when audioProfile limitation fails (required)", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2, SampleRate: 44100}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "aac",
-							Limitations: []Limitation{
-								{Name: LimitationAudioProfile, Comparison: ComparisonEquals, Values: []string{"LC"}, Required: true},
-							},
-						},
-					},
-				}
-				// Source profile is empty (not yet populated from scanner), so Equals("LC") fails
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement("audio profile not supported"))
-			})
-
-			It("allows direct play when audioProfile limitation is optional", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2, SampleRate: 44100}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "aac",
-							Limitations: []Limitation{
-								{Name: LimitationAudioProfile, Comparison: ComparisonEquals, Values: []string{"LC"}, Required: false},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeTrue())
-			})
-
-			It("rejects direct play due to samplerate limitation", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "flac",
-							Limitations: []Limitation{
-								{Name: LimitationAudioSamplerate, Comparison: ComparisonLessThanEqual, Values: []string{"48000"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(ContainElement("audio samplerate not supported"))
-			})
-		})
-
-		Context("Codec limitations on transcoded output", func() {
-			It("applies bitrate limitation to transcoded stream", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 192, Channels: 2, SampleRate: 44100}
-				ci := &ClientInfo{
-					MaxAudioBitrate: 96, // force transcode
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "mp3",
-							Limitations: []Limitation{
-								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"96"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TranscodeStream.Bitrate).To(Equal(96))
-			})
-
-			It("applies channel limitation to transcoded stream", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 48000, BitDepth: 16}
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "mp3",
-							Limitations: []Limitation{
-								{Name: LimitationAudioChannels, Comparison: ComparisonLessThanEqual, Values: []string{"2"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TranscodeStream.Channels).To(Equal(2))
-			})
-
-			It("applies samplerate limitation to transcoded stream", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "mp3",
-							Limitations: []Limitation{
-								{Name: LimitationAudioSamplerate, Comparison: ComparisonLessThanEqual, Values: []string{"48000"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeTrue())
-				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
-			})
-
-			It("rejects transcoding profile when GreaterThanEqual cannot be satisfied", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
-				ci := &ClientInfo{
-					MaxTranscodingAudioBitrate: 320,
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-					CodecProfiles: []CodecProfile{
-						{
-							Type: CodecProfileTypeAudio,
-							Name: "mp3",
-							Limitations: []Limitation{
-								{Name: LimitationAudioSamplerate, Comparison: ComparisonGreaterThanEqual, Values: []string{"96000"}, Required: true},
-							},
-						},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanTranscode).To(BeFalse())
-			})
-		})
-
-		Context("Typed transcode reasons from multiple profiles", func() {
-			It("collects reasons from each failed direct play profile", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "ogg", Codec: "Vorbis", BitRate: 128, Channels: 2, SampleRate: 48000}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}},
-						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
-						{Containers: []string{"m4a", "mp4"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
-					},
-					TranscodingProfiles: []Profile{
-						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.CanDirectPlay).To(BeFalse())
-				Expect(decision.TranscodeReasons).To(HaveLen(3))
-				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"))
-			})
-		})
-
-		Context("Source stream details", func() {
-			It("populates source stream correctly with kbps bitrate", func() {
-				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24, Duration: 300.5, Size: 50000000}
-				ci := &ClientInfo{
-					DirectPlayProfiles: []DirectPlayProfile{
-						{Containers: []string{"flac"}, Protocols: []string{"http"}},
-					},
-				}
-				decision, err := svc.MakeDecision(ctx, mf, ci)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(decision.SourceStream.Container).To(Equal("flac"))
-				Expect(decision.SourceStream.Codec).To(Equal("flac"))
-				Expect(decision.SourceStream.Bitrate).To(Equal(1000)) // kbps
-				Expect(decision.SourceStream.SampleRate).To(Equal(96000))
-				Expect(decision.SourceStream.BitDepth).To(Equal(24))
-				Expect(decision.SourceStream.Channels).To(Equal(2))
-			})
-		})
-	})
-
-	Describe("Token round-trip", func() {
-		It("creates and parses a direct play token", func() {
-			decision := &Decision{
-				MediaID:       "media-123",
-				CanDirectPlay: true,
-			}
-			token, err := svc.CreateTranscodeParams(decision)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(token).ToNot(BeEmpty())
-
-			params, err := svc.ParseTranscodeParams(token)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(params.MediaID).To(Equal("media-123"))
-			Expect(params.DirectPlay).To(BeTrue())
-			Expect(params.TargetFormat).To(BeEmpty())
-		})
-
-		It("creates and parses a transcode token with kbps bitrate", func() {
-			decision := &Decision{
-				MediaID:        "media-456",
-				CanDirectPlay:  false,
-				CanTranscode:   true,
-				TargetFormat:   "mp3",
-				TargetBitrate:  256, // kbps
-				TargetChannels: 2,
-			}
-			token, err := svc.CreateTranscodeParams(decision)
-			Expect(err).ToNot(HaveOccurred())
-
-			params, err := svc.ParseTranscodeParams(token)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(params.MediaID).To(Equal("media-456"))
-			Expect(params.DirectPlay).To(BeFalse())
-			Expect(params.TargetFormat).To(Equal("mp3"))
-			Expect(params.TargetBitrate).To(Equal(256)) // kbps
-			Expect(params.TargetChannels).To(Equal(2))
-		})
-
-		It("rejects an invalid token", func() {
-			_, err := svc.ParseTranscodeParams("invalid-token")
-			Expect(err).To(HaveOccurred())
-		})
-	})
-})

core/wire_providers.go

@@ -8,7 +8,6 @@ import (
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/scrobbler"
-	"github.com/navidrome/navidrome/core/transcode"
 )
 
 var Set = wire.NewSet(
@@ -21,7 +20,6 @@ var Set = wire.NewSet(
 	NewLibrary,
 	NewUser,
 	NewMaintenance,
-	transcode.NewDecider,
 	agents.GetAgents,
 	external.NewProvider,
 	wire.Bind(new(external.Agents), new(*agents.Agents)),

db/migrations/20260116135347_add_global_smart_playlist.sql

@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE playlist ADD COLUMN global BOOL DEFAULT FALSE NOT NULL;
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+ALTER TABLE playlist DROP COLUMN global;
+-- +goose StatementEnd

db/migrations/20260117201522_add_avg_rating_column.sql

@@ -1,23 +0,0 @@
--- +goose Up
-ALTER TABLE album ADD COLUMN average_rating REAL NOT NULL DEFAULT 0;
-ALTER TABLE media_file ADD COLUMN average_rating REAL NOT NULL DEFAULT 0;
-ALTER TABLE artist ADD COLUMN average_rating REAL NOT NULL DEFAULT 0;
-
--- Populate average_rating from existing ratings
-UPDATE album SET average_rating = coalesce(
-    (SELECT round(avg(rating), 2) FROM annotation WHERE item_id = album.id AND item_type = 'album' AND rating > 0),
-    0
-);
-UPDATE media_file SET average_rating = coalesce(
-    (SELECT round(avg(rating), 2) FROM annotation WHERE item_id = media_file.id AND item_type = 'media_file' AND rating > 0),
-    0
-);
-UPDATE artist SET average_rating = coalesce(
-    (SELECT round(avg(rating), 2) FROM annotation WHERE item_id = artist.id AND item_type = 'artist' AND rating > 0),
-    0
-);
-
--- +goose Down
-ALTER TABLE artist DROP COLUMN average_rating;
-ALTER TABLE media_file DROP COLUMN average_rating;
-ALTER TABLE album DROP COLUMN average_rating;

db/migrations/20260205120000_add_codec_to_media_file.sql

@@ -1,11 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-ALTER TABLE media_file ADD COLUMN codec VARCHAR(255) DEFAULT '' NOT NULL;
-CREATE INDEX IF NOT EXISTS media_file_codec ON media_file(codec);
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-DROP INDEX IF EXISTS media_file_codec;
-ALTER TABLE media_file DROP COLUMN codec;
--- +goose StatementEnd

go.mod

@@ -2,13 +2,8 @@ module github.com/navidrome/navidrome
 
 go 1.25
 
-replace (
-	// Fork to fix https://github.com/navidrome/navidrome/issues/3254
-	github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8 => github.com/deluan/tag v0.0.0-20241002021117-dfe5e6ea396d
-
-	// Fork to implement raw tags support
-	go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57
-)
+// Fork to fix https://github.com/navidrome/navidrome/issues/3254
+replace github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8 => github.com/deluan/tag v0.0.0-20241002021117-dfe5e6ea396d
 
 require (
 	github.com/Masterminds/squirrel v1.5.4
@@ -58,15 +53,13 @@ require (
 	github.com/rjeczalik/notify v0.9.3
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
-	github.com/santhosh-tekuri/jsonschema/v6 v6.0.2
-	github.com/sirupsen/logrus v1.9.4
+	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/viper v1.21.0
 	github.com/stretchr/testify v1.11.1
 	github.com/tetratelabs/wazero v1.11.0
 	github.com/unrolled/secure v1.17.0
 	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.35.0
 	golang.org/x/net v0.49.0
@@ -98,7 +91,7 @@ require (
 	github.com/goccy/go-json v0.10.5 // 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-20260115054156-294ebfa9ad83 // indirect
+	github.com/google/pprof v0.0.0-20260111202518-71be6bfdd440 // 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

go.sum

@@ -36,8 +36,6 @@ 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.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
-github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57 h1:SXIwfjzTv0UzoUWpFREl8p3AxXVLmbcto1/ISih11a0=
-github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57/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=
@@ -56,8 +54,6 @@ github.com/djherbis/stream v1.4.0 h1:aVD46WZUiq5kJk55yxJAyw6Kuera6kmC3i2vEQyW/AE
 github.com/djherbis/stream v1.4.0/go.mod h1:cqjC1ZRq3FFwkGmUtHwcldbnW8f0Q4YuVsGW1eAFtOk=
 github.com/djherbis/times v1.6.0 h1:w2ctJ92J8fBvWPxugmXIv7Nz7Q3iDMKNx9v5ocVH20c=
 github.com/djherbis/times v1.6.0/go.mod h1:gOHeRAz2h+VJNZ5Gmc/o7iD9k4wW7NMVqieYCY99oc0=
-github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
-github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/dylibso/observe-sdk/go v0.0.0-20240828172851-9145d8ad07e1 h1:idfl8M8rPW93NehFw5H1qqH8yG158t5POr+LX9avbJY=
@@ -110,8 +106,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-20260115054156-294ebfa9ad83 h1:z2ogiKUYzX5Is6zr/vP9vJGqPwcdqsWjOt+V8J7+bTc=
-github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
+github.com/google/pprof v0.0.0-20260111202518-71be6bfdd440 h1:oKBqR+eQXiIM7X8K1JEg9aoTEePLq/c6Awe484abOuA=
+github.com/google/pprof v0.0.0-20260111202518-71be6bfdd440/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=
@@ -238,15 +234,13 @@ github.com/sagikazarmark/locafero v0.12.0 h1:/NQhBAkUb4+fH1jivKHWusDYFjMOOKU88ee
 github.com/sagikazarmark/locafero v0.12.0/go.mod h1:sZh36u/YSZ918v0Io+U9ogLYQJ9tLLBmM4eneO6WwsI=
 github.com/sanity-io/litter v1.5.8 h1:uM/2lKrWdGbRXDrIq08Lh9XtVYoeGtcQxk9rtQ7+rYg=
 github.com/sanity-io/litter v1.5.8/go.mod h1:9gzJgR2i4ZpjZHsKvUXIRQVk7P+yM3e+jAF7bU2UI5U=
-github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 h1:KRzFb2m7YtdldCEkzs6KqmJw4nqEVZGK7IN2kJkjTuQ=
-github.com/santhosh-tekuri/jsonschema/v6 v6.0.2/go.mod h1:JXeL+ps8p7/KNMjDQk3TCwPpBy0wYklyWTfbkIzdIFU=
 github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0=
 github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
 github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE=
 github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w=
-github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
@@ -275,6 +269,7 @@ github.com/stretchr/testify v0.0.0-20161117074351-18a02ba4a312/go.mod h1:a8OnRci
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
@@ -363,6 +358,7 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

model/annotation.go

@@ -3,13 +3,12 @@ package model
 import "time"
 
 type Annotations struct {
-	PlayCount     int64      `structs:"play_count"     json:"playCount,omitempty"`
-	PlayDate      *time.Time `structs:"play_date"      json:"playDate,omitempty" `
-	Rating        int        `structs:"rating"         json:"rating,omitempty"   `
-	RatedAt       *time.Time `structs:"rated_at"       json:"ratedAt,omitempty"  `
-	Starred       bool       `structs:"starred"        json:"starred,omitempty"  `
-	StarredAt     *time.Time `structs:"starred_at"     json:"starredAt,omitempty"`
-	AverageRating float64    `structs:"average_rating" json:"averageRating,omitempty"`
+	PlayCount int64      `structs:"play_count" json:"playCount,omitempty"`
+	PlayDate  *time.Time `structs:"play_date"  json:"playDate,omitempty" `
+	Rating    int        `structs:"rating"     json:"rating,omitempty"   `
+	RatedAt   *time.Time `structs:"rated_at"   json:"ratedAt,omitempty"  `
+	Starred   bool       `structs:"starred"    json:"starred,omitempty"  `
+	StarredAt *time.Time `structs:"starred_at" json:"starredAt,omitempty"`
 }
 
 type AnnotatedRepository interface {

model/mediafile.go

@@ -14,7 +14,6 @@ import (
 
 	"github.com/gohugoio/hashstructure"
 	"github.com/navidrome/navidrome/conf"
-	confmime "github.com/navidrome/navidrome/conf/mime"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/utils"
 	"github.com/navidrome/navidrome/utils/slice"
@@ -57,7 +56,6 @@ type MediaFile struct {
 	SampleRate           int      `structs:"sample_rate" json:"sampleRate"`
 	BitDepth             int      `structs:"bit_depth" json:"bitDepth"`
 	Channels             int      `structs:"channels" json:"channels"`
-	Codec                string   `structs:"codec" json:"codec"`
 	Genre                string   `structs:"genre" json:"genre"`
 	Genres               Genres   `structs:"-" json:"genres,omitempty"`
 	SortTitle            string   `structs:"sort_title" json:"sortTitle,omitempty"`
@@ -163,79 +161,6 @@ func (mf MediaFile) AbsolutePath() string {
 	return filepath.Join(mf.LibraryPath, mf.Path)
 }
 
-// AudioCodec returns the audio codec for this file.
-// Uses the stored Codec field if available, otherwise infers from Suffix and audio properties.
-func (mf MediaFile) AudioCodec() string {
-	// If we have a stored codec from scanning, normalize and return it
-	if mf.Codec != "" {
-		return strings.ToLower(mf.Codec)
-	}
-	// Fallback: infer from Suffix + BitDepth
-	return mf.inferCodecFromSuffix()
-}
-
-// inferCodecFromSuffix infers the codec from the file extension when Codec field is empty.
-func (mf MediaFile) inferCodecFromSuffix() string {
-	switch strings.ToLower(mf.Suffix) {
-	case "mp3", "mpga":
-		return "mp3"
-	case "mp2":
-		return "mp2"
-	case "ogg", "oga":
-		return "vorbis"
-	case "opus":
-		return "opus"
-	case "mpc":
-		return "mpc"
-	case "wma":
-		return "wma"
-	case "flac":
-		return "flac"
-	case "wav":
-		return "pcm"
-	case "aif", "aiff", "aifc":
-		return "pcm"
-	case "ape":
-		return "ape"
-	case "wv", "wvp":
-		return "wv"
-	case "tta":
-		return "tta"
-	case "tak":
-		return "tak"
-	case "shn":
-		return "shn"
-	case "dsf", "dff":
-		return "dsd"
-	case "m4a":
-		// AAC if BitDepth==0, ALAC if BitDepth>0
-		if mf.BitDepth > 0 {
-			return "alac"
-		}
-		return "aac"
-	case "m4b", "m4p", "m4r":
-		return "aac"
-	default:
-		return ""
-	}
-}
-
-// IsLossless returns true if this file uses a lossless codec.
-func (mf MediaFile) IsLossless() bool {
-	codec := mf.AudioCodec()
-	// Primary: codec-based check (most accurate for containers like M4A)
-	switch codec {
-	case "flac", "alac", "pcm", "ape", "wv", "tta", "tak", "shn", "dsd":
-		return true
-	}
-	// Secondary: suffix-based check using configurable list from YAML
-	if slices.Contains(confmime.LosslessFormats, mf.Suffix) {
-		return true
-	}
-	// Fallback heuristic: if BitDepth is set, it's likely lossless
-	return mf.BitDepth > 0
-}
-
 type MediaFiles []MediaFile
 
 // ToAlbum creates an Album object based on the attributes of this MediaFiles collection.
@@ -428,13 +353,11 @@ type MediaFileCursor iter.Seq2[MediaFile, error]
 
 type MediaFileRepository interface {
 	CountAll(options ...QueryOptions) (int64, error)
-	CountBySuffix(options ...QueryOptions) (map[string]int64, error)
 	Exists(id string) (bool, error)
 	Put(m *MediaFile) error
 	Get(id string) (*MediaFile, error)
 	GetWithParticipants(id string) (*MediaFile, error)
 	GetAll(options ...QueryOptions) (MediaFiles, error)
-	GetAllByTags(tag TagName, values []string, options ...QueryOptions) (MediaFiles, error)
 	GetCursor(options ...QueryOptions) (MediaFileCursor, error)
 	Delete(id string) error
 	DeleteMissing(ids []string) error

model/mediafile_test.go

@@ -475,7 +475,7 @@ var _ = Describe("MediaFile", func() {
 		DeferCleanup(configtest.SetupConfig())
 		conf.Server.EnableMediaFileCoverArt = true
 	})
-	Describe("CoverArtId", func() {
+	Describe(".CoverArtId()", func() {
 		It("returns its own id if it HasCoverArt", func() {
 			mf := MediaFile{ID: "111", AlbumID: "1", HasCoverArt: true}
 			id := mf.CoverArtID()
@@ -496,94 +496,6 @@ var _ = Describe("MediaFile", func() {
 			Expect(id.ID).To(Equal(mf.AlbumID))
 		})
 	})
-
-	Describe("AudioCodec", func() {
-		It("returns normalized stored codec when available", func() {
-			mf := MediaFile{Codec: "AAC", Suffix: "m4a"}
-			Expect(mf.AudioCodec()).To(Equal("aac"))
-		})
-
-		It("returns stored codec lowercased", func() {
-			mf := MediaFile{Codec: "ALAC", Suffix: "m4a"}
-			Expect(mf.AudioCodec()).To(Equal("alac"))
-		})
-
-		DescribeTable("infers codec from suffix when Codec field is empty",
-			func(suffix string, bitDepth int, expected string) {
-				mf := MediaFile{Suffix: suffix, BitDepth: bitDepth}
-				Expect(mf.AudioCodec()).To(Equal(expected))
-			},
-			Entry("mp3", "mp3", 0, "mp3"),
-			Entry("mpga", "mpga", 0, "mp3"),
-			Entry("mp2", "mp2", 0, "mp2"),
-			Entry("ogg", "ogg", 0, "vorbis"),
-			Entry("oga", "oga", 0, "vorbis"),
-			Entry("opus", "opus", 0, "opus"),
-			Entry("mpc", "mpc", 0, "mpc"),
-			Entry("wma", "wma", 0, "wma"),
-			Entry("flac", "flac", 0, "flac"),
-			Entry("wav", "wav", 0, "pcm"),
-			Entry("aif", "aif", 0, "pcm"),
-			Entry("aiff", "aiff", 0, "pcm"),
-			Entry("aifc", "aifc", 0, "pcm"),
-			Entry("ape", "ape", 0, "ape"),
-			Entry("wv", "wv", 0, "wv"),
-			Entry("wvp", "wvp", 0, "wv"),
-			Entry("tta", "tta", 0, "tta"),
-			Entry("tak", "tak", 0, "tak"),
-			Entry("shn", "shn", 0, "shn"),
-			Entry("dsf", "dsf", 0, "dsd"),
-			Entry("dff", "dff", 0, "dsd"),
-			Entry("m4a with BitDepth=0 (AAC)", "m4a", 0, "aac"),
-			Entry("m4a with BitDepth>0 (ALAC)", "m4a", 16, "alac"),
-			Entry("m4b", "m4b", 0, "aac"),
-			Entry("m4p", "m4p", 0, "aac"),
-			Entry("m4r", "m4r", 0, "aac"),
-			Entry("unknown suffix", "xyz", 0, ""),
-		)
-
-		It("prefers stored codec over suffix inference", func() {
-			mf := MediaFile{Codec: "ALAC", Suffix: "m4a", BitDepth: 0}
-			Expect(mf.AudioCodec()).To(Equal("alac"))
-		})
-	})
-
-	Describe("IsLossless", func() {
-		BeforeEach(func() {
-			DeferCleanup(configtest.SetupConfig())
-		})
-
-		DescribeTable("detects lossless codecs",
-			func(codec string, suffix string, bitDepth int, expected bool) {
-				mf := MediaFile{Codec: codec, Suffix: suffix, BitDepth: bitDepth}
-				Expect(mf.IsLossless()).To(Equal(expected))
-			},
-			Entry("flac", "FLAC", "flac", 16, true),
-			Entry("alac", "ALAC", "m4a", 24, true),
-			Entry("pcm via wav", "", "wav", 16, true),
-			Entry("pcm via aiff", "", "aiff", 24, true),
-			Entry("ape", "", "ape", 16, true),
-			Entry("wv", "", "wv", 0, true),
-			Entry("tta", "", "tta", 0, true),
-			Entry("tak", "", "tak", 0, true),
-			Entry("shn", "", "shn", 0, true),
-			Entry("dsd", "", "dsf", 0, true),
-			Entry("mp3 is lossy", "MP3", "mp3", 0, false),
-			Entry("aac is lossy", "AAC", "m4a", 0, false),
-			Entry("vorbis is lossy", "", "ogg", 0, false),
-			Entry("opus is lossy", "", "opus", 0, false),
-		)
-
-		It("detects lossless via BitDepth fallback when codec is unknown", func() {
-			mf := MediaFile{Suffix: "xyz", BitDepth: 24}
-			Expect(mf.IsLossless()).To(BeTrue())
-		})
-
-		It("returns false for unknown with no BitDepth", func() {
-			mf := MediaFile{Suffix: "xyz", BitDepth: 0}
-			Expect(mf.IsLossless()).To(BeFalse())
-		})
-	})
 })
 
 func t(v string) time.Time {

model/metadata/map_mediafile.go

@@ -65,7 +65,6 @@ func (md Metadata) ToMediaFile(libID int, folderID string) model.MediaFile {
 	mf.SampleRate = md.AudioProperties().SampleRate
 	mf.BitDepth = md.AudioProperties().BitDepth
 	mf.Channels = md.AudioProperties().Channels
-	mf.Codec = md.AudioProperties().Codec
 	mf.Path = md.FilePath()
 	mf.Suffix = md.Suffix()
 	mf.Size = md.Size()

model/metadata/metadata.go

@@ -35,7 +35,6 @@ type AudioProperties struct {
 	BitDepth   int
 	SampleRate int
 	Channels   int
-	Codec      string
 }
 
 type Date string

model/metadata/persistent_ids.go

@@ -8,7 +8,6 @@ import (
 
 	"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/id"
 	"github.com/navidrome/navidrome/utils"
@@ -27,14 +26,10 @@ type getPIDFunc = func(mf model.MediaFile, md Metadata, spec string, prependLibI
 
 func createGetPID(hash hashFunc) getPIDFunc {
 	var getPID getPIDFunc
-	getAttr := func(mf model.MediaFile, md Metadata, attr string, prependLibId bool, spec string) string {
+	getAttr := func(mf model.MediaFile, md Metadata, attr string, prependLibId bool) 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)
@@ -54,7 +49,7 @@ func createGetPID(hash hashFunc) getPIDFunc {
 			attributes := strings.Split(field, ",")
 			hasValue := false
 			values := slice.Map(attributes, func(attr string) string {
-				v := getAttr(mf, md, attr, prependLibId, spec)
+				v := getAttr(mf, md, attr, prependLibId)
 				if v != "" {
 					hasValue = true
 				}

model/metadata/persistent_ids_test.go

@@ -114,24 +114,6 @@ var _ = Describe("getPID", func() {
 				Expect(getPID(mf, md, spec, false)).To(Equal("(album name)"))
 			})
 		})
-
-		When("albumid configuration refers to albumid recursively", func() {
-			It("should avoid infinite recursion", func() {
-				// Reproduce the issue from #4920
-				conf.Server.PID.Album = "albumid,album,albumversion,releasedate"
-				spec := conf.Server.PID.Album
-				md.tags = map[model.TagName][]string{
-					"album":        {"Album Name"},
-					"albumversion": {"Version"},
-					"releasedate":  {"2022"},
-				}
-				// Should not panic and return a valid PID ignoring the recursive "albumid"
-				Expect(func() {
-					pid := getPID(mf, md, spec, false)
-					Expect(pid).To(Equal("(\\album name\\Version\\2022)"))
-				}).To(Not(Panic()))
-			})
-		})
 	})
 
 	Context("edge cases", func() {

model/playlist.go

@@ -27,6 +27,7 @@ type Playlist struct {
 	// SmartPlaylist attributes
 	Rules       *criteria.Criteria `structs:"rules" json:"rules"`
 	EvaluatedAt *time.Time         `structs:"evaluated_at" json:"evaluatedAt"`
+	Global      bool               `structs:"global" json:"global"`
 }
 
 func (pls Playlist) IsSmartPlaylist() bool {

persistence/album_repository.go

@@ -119,8 +119,8 @@ var albumFilters = sync.OnceValue(func() map[string]filterFunc {
 		"artist_id":       artistFilter,
 		"year":            yearFilter,
 		"recently_played": recentlyPlayedFilter,
-		"starred":         annotationBoolFilter("starred"),
-		"has_rating":      annotationBoolFilter("rating"),
+		"starred":         booleanFilter,
+		"has_rating":      hasRatingFilter,
 		"missing":         booleanFilter,
 		"genre_id":        tagIDFilter,
 		"role_total_id":   allRolesFilter,
@@ -149,6 +149,10 @@ func recentlyPlayedFilter(string, interface{}) Sqlizer {
 	return Gt{"play_count": 0}
 }
 
+func hasRatingFilter(string, interface{}) Sqlizer {
+	return Gt{"rating": 0}
+}
+
 func yearFilter(_ string, value interface{}) Sqlizer {
 	return Or{
 		And{

persistence/album_repository_test.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/Masterminds/squirrel"
-	"github.com/deluan/rest"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/model"
@@ -78,82 +77,6 @@ var _ = Describe("AlbumRepository", func() {
 		})
 	})
 
-	Context("Filters", func() {
-		var albumWithoutAnnotation model.Album
-
-		BeforeEach(func() {
-			// Create album without any annotation (no star, no rating)
-			albumWithoutAnnotation = model.Album{ID: "no-annotation-album", Name: "No Annotation", LibraryID: 1}
-			Expect(albumRepo.Put(&albumWithoutAnnotation)).To(Succeed())
-		})
-
-		AfterEach(func() {
-			_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": albumWithoutAnnotation.ID}))
-		})
-
-		Describe("starred", func() {
-			It("false includes items without annotations", func() {
-				res, err := albumRepo.ReadAll(rest.QueryOptions{
-					Filters: map[string]any{"starred": "false"},
-				})
-				Expect(err).ToNot(HaveOccurred())
-				albums := res.(model.Albums)
-
-				var found bool
-				for _, a := range albums {
-					if a.ID == albumWithoutAnnotation.ID {
-						found = true
-						break
-					}
-				}
-				Expect(found).To(BeTrue(), "Album without annotation should be included in starred=false filter")
-			})
-
-			It("true excludes items without annotations", func() {
-				res, err := albumRepo.ReadAll(rest.QueryOptions{
-					Filters: map[string]any{"starred": "true"},
-				})
-				Expect(err).ToNot(HaveOccurred())
-				albums := res.(model.Albums)
-
-				for _, a := range albums {
-					Expect(a.ID).ToNot(Equal(albumWithoutAnnotation.ID))
-				}
-			})
-		})
-
-		Describe("has_rating", func() {
-			It("false includes items without annotations", func() {
-				res, err := albumRepo.ReadAll(rest.QueryOptions{
-					Filters: map[string]any{"has_rating": "false"},
-				})
-				Expect(err).ToNot(HaveOccurred())
-				albums := res.(model.Albums)
-
-				var found bool
-				for _, a := range albums {
-					if a.ID == albumWithoutAnnotation.ID {
-						found = true
-						break
-					}
-				}
-				Expect(found).To(BeTrue(), "Album without annotation should be included in has_rating=false filter")
-			})
-
-			It("true excludes items without annotations", func() {
-				res, err := albumRepo.ReadAll(rest.QueryOptions{
-					Filters: map[string]any{"has_rating": "true"},
-				})
-				Expect(err).ToNot(HaveOccurred())
-				albums := res.(model.Albums)
-
-				for _, a := range albums {
-					Expect(a.ID).ToNot(Equal(albumWithoutAnnotation.ID))
-				}
-			})
-		})
-	})
-
 	Describe("Album.PlayCount", func() {
 		// Implementation is in withAnnotation() method
 		DescribeTable("normalizes play count when AlbumPlayCountMode is absolute",
@@ -203,89 +126,6 @@ var _ = Describe("AlbumRepository", func() {
 		)
 	})
 
-	Describe("Album.AverageRating", func() {
-		It("returns 0 when no ratings exist", func() {
-			newID := id.NewRandom()
-			Expect(albumRepo.Put(&model.Album{LibraryID: 1, ID: newID, Name: "no ratings album"})).To(Succeed())
-
-			album, err := albumRepo.Get(newID)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(album.AverageRating).To(Equal(0.0))
-
-			_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": newID}))
-		})
-
-		It("returns the user's rating as average when only one user rated", func() {
-			newID := id.NewRandom()
-			Expect(albumRepo.Put(&model.Album{LibraryID: 1, ID: newID, Name: "single rating album"})).To(Succeed())
-			Expect(albumRepo.SetRating(4, newID)).To(Succeed())
-
-			album, err := albumRepo.Get(newID)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(album.AverageRating).To(Equal(4.0))
-
-			_, _ = albumRepo.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": newID}))
-			_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": newID}))
-		})
-
-		It("calculates average across multiple users", func() {
-			newID := id.NewRandom()
-			Expect(albumRepo.Put(&model.Album{LibraryID: 1, ID: newID, Name: "multi rating album"})).To(Succeed())
-
-			Expect(albumRepo.SetRating(4, newID)).To(Succeed())
-
-			user2Ctx := request.WithUser(GinkgoT().Context(), regularUser)
-			user2Repo := NewAlbumRepository(user2Ctx, GetDBXBuilder()).(*albumRepository)
-			Expect(user2Repo.SetRating(5, newID)).To(Succeed())
-
-			album, err := albumRepo.Get(newID)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(album.AverageRating).To(Equal(4.5))
-
-			_, _ = albumRepo.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": newID}))
-			_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": newID}))
-		})
-
-		It("excludes zero ratings from average calculation", func() {
-			newID := id.NewRandom()
-			Expect(albumRepo.Put(&model.Album{LibraryID: 1, ID: newID, Name: "zero rating excluded album"})).To(Succeed())
-			Expect(albumRepo.SetRating(3, newID)).To(Succeed())
-
-			user2Ctx := request.WithUser(GinkgoT().Context(), regularUser)
-			user2Repo := NewAlbumRepository(user2Ctx, GetDBXBuilder()).(*albumRepository)
-			Expect(user2Repo.SetRating(0, newID)).To(Succeed())
-
-			album, err := albumRepo.Get(newID)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(album.AverageRating).To(Equal(3.0))
-
-			_, _ = albumRepo.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": newID}))
-			_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": newID}))
-		})
-
-		It("rounds to 2 decimal places", func() {
-			newID := id.NewRandom()
-			Expect(albumRepo.Put(&model.Album{LibraryID: 1, ID: newID, Name: "rounding test album"})).To(Succeed())
-
-			Expect(albumRepo.SetRating(5, newID)).To(Succeed())
-
-			user2Ctx := request.WithUser(GinkgoT().Context(), regularUser)
-			user2Repo := NewAlbumRepository(user2Ctx, GetDBXBuilder()).(*albumRepository)
-			Expect(user2Repo.SetRating(4, newID)).To(Succeed())
-
-			user3Ctx := request.WithUser(GinkgoT().Context(), thirdUser)
-			user3Repo := NewAlbumRepository(user3Ctx, GetDBXBuilder()).(*albumRepository)
-			Expect(user3Repo.SetRating(4, newID)).To(Succeed())
-
-			album, err := albumRepo.Get(newID)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(album.AverageRating).To(Equal(4.33)) // (5 + 4 + 4) / 3 = 4.333...
-
-			_, _ = albumRepo.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": newID}))
-			_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": newID}))
-		})
-	})
-
 	Describe("dbAlbum mapping", func() {
 		var (
 			a    model.Album

persistence/artist_repository.go

@@ -133,7 +133,7 @@ func NewArtistRepository(ctx context.Context, db dbx.Builder) model.ArtistReposi
 	r.registerModel(&model.Artist{}, map[string]filterFunc{
 		"id":         idFilter(r.tableName),
 		"name":       fullTextFilter(r.tableName, "mbz_artist_id"),
-		"starred":    annotationBoolFilter("starred"),
+		"starred":    booleanFilter,
 		"role":       roleFilter,
 		"missing":    booleanFilter,
 		"library_id": artistLibraryIdFilter,

persistence/artist_repository_test.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 
 	"github.com/Masterminds/squirrel"
-	"github.com/deluan/rest"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/model"
@@ -387,54 +386,6 @@ var _ = Describe("ArtistRepository", func() {
 			})
 		})
 
-		Describe("Filters", func() {
-			var artistWithoutAnnotation model.Artist
-
-			BeforeEach(func() {
-				// Create artist without any annotation
-				artistWithoutAnnotation = model.Artist{ID: "no-annotation-artist", Name: "No Annotation Artist"}
-				err := createArtistWithLibrary(repo, &artistWithoutAnnotation, 1)
-				Expect(err).ToNot(HaveOccurred())
-			})
-
-			AfterEach(func() {
-				if raw, ok := repo.(*artistRepository); ok {
-					_, _ = raw.executeSQL(squirrel.Delete(raw.tableName).Where(squirrel.Eq{"id": artistWithoutAnnotation.ID}))
-				}
-			})
-
-			Describe("starred", func() {
-				It("false includes items without annotations", func() {
-					res, err := repo.(model.ResourceRepository).ReadAll(rest.QueryOptions{
-						Filters: map[string]any{"starred": "false"},
-					})
-					Expect(err).ToNot(HaveOccurred())
-					artists := res.(model.Artists)
-
-					var found bool
-					for _, a := range artists {
-						if a.ID == artistWithoutAnnotation.ID {
-							found = true
-							break
-						}
-					}
-					Expect(found).To(BeTrue(), "Artist without annotation should be included in starred=false filter")
-				})
-
-				It("true excludes items without annotations", func() {
-					res, err := repo.(model.ResourceRepository).ReadAll(rest.QueryOptions{
-						Filters: map[string]any{"starred": "true"},
-					})
-					Expect(err).ToNot(HaveOccurred())
-					artists := res.(model.Artists)
-
-					for _, a := range artists {
-						Expect(a.ID).ToNot(Equal(artistWithoutAnnotation.ID))
-					}
-				})
-			})
-		})
-
 		Describe("MBID and Text Search", func() {
 			var lib2 model.Library
 			var lr model.LibraryRepository

persistence/mediafile_repository.go

@@ -95,7 +95,7 @@ var mediaFileFilter = sync.OnceValue(func() map[string]filterFunc {
 	filters := map[string]filterFunc{
 		"id":         idFilter("media_file"),
 		"title":      fullTextFilter("media_file", "mbz_recording_id", "mbz_release_track_id"),
-		"starred":    annotationBoolFilter("starred"),
+		"starred":    booleanFilter,
 		"genre_id":   tagIDFilter,
 		"missing":    booleanFilter,
 		"artists_id": artistFilter,
@@ -124,25 +124,6 @@ func (r *mediaFileRepository) CountAll(options ...model.QueryOptions) (int64, er
 	return r.count(query, options...)
 }
 
-func (r *mediaFileRepository) CountBySuffix(options ...model.QueryOptions) (map[string]int64, error) {
-	sel := r.newSelect(options...).
-		Columns("lower(suffix) as suffix", "count(*) as count").
-		GroupBy("lower(suffix)")
-	var res []struct {
-		Suffix string
-		Count  int64
-	}
-	err := r.queryAll(sel, &res)
-	if err != nil {
-		return nil, err
-	}
-	counts := make(map[string]int64, len(res))
-	for _, c := range res {
-		counts[c.Suffix] = c.Count
-	}
-	return counts, nil
-}
-
 func (r *mediaFileRepository) Exists(id string) (bool, error) {
 	return r.exists(Eq{"media_file.id": id})
 }
@@ -195,31 +176,6 @@ func (r *mediaFileRepository) GetAll(options ...model.QueryOptions) (model.Media
 	return res.toModels(), nil
 }
 
-func (r *mediaFileRepository) GetAllByTags(tag model.TagName, values []string, options ...model.QueryOptions) (model.MediaFiles, error) {
-	placeholders := make([]string, len(values))
-	args := make([]any, len(values))
-	for i, v := range values {
-		placeholders[i] = "?"
-		args[i] = v
-	}
-	tagFilter := Expr(
-		fmt.Sprintf("exists (select 1 from json_tree(media_file.tags, '$.%s') where key='value' and value in (%s))",
-			tag, strings.Join(placeholders, ",")),
-		args...,
-	)
-
-	var opts model.QueryOptions
-	if len(options) > 0 {
-		opts = options[0]
-	}
-	if opts.Filters != nil {
-		opts.Filters = And{tagFilter, opts.Filters}
-	} else {
-		opts.Filters = tagFilter
-	}
-	return r.GetAll(opts)
-}
-
 func (r *mediaFileRepository) GetCursor(options ...model.QueryOptions) (model.MediaFileCursor, error) {
 	sq := r.selectMediaFile(options...)
 	cursor, err := queryWithStableResults[dbMediaFile](r.sqlRepository, sq)

persistence/mediafile_repository_test.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/Masterminds/squirrel"
-	"github.com/deluan/rest"
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/log"
@@ -42,44 +41,6 @@ var _ = Describe("MediaRepository", func() {
 		Expect(mr.CountAll()).To(Equal(int64(10)))
 	})
 
-	Describe("CountBySuffix", 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"}
-
-			Expect(mr.Put(&mp3File)).To(Succeed())
-			Expect(mr.Put(&flacFile1)).To(Succeed())
-			Expect(mr.Put(&flacFile2)).To(Succeed())
-			Expect(mr.Put(&flacUpperFile)).To(Succeed())
-		})
-
-		AfterEach(func() {
-			_ = mr.Delete(mp3File.ID)
-			_ = mr.Delete(flacFile1.ID)
-			_ = mr.Delete(flacFile2.ID)
-			_ = mr.Delete(flacUpperFile.ID)
-		})
-
-		It("counts media files grouped by suffix with lowercase normalization", func() {
-			counts, err := mr.CountBySuffix()
-			Expect(err).ToNot(HaveOccurred())
-
-			// Should have lowercase keys only
-			Expect(counts).To(HaveKey("mp3"))
-			Expect(counts).To(HaveKey("flac"))
-			Expect(counts).ToNot(HaveKey("FLAC"))
-
-			// mp3: 1 file
-			Expect(counts["mp3"]).To(Equal(int64(1)))
-			// flac: 3 files (2 lowercase + 1 uppercase normalized)
-			Expect(counts["flac"]).To(Equal(int64(3)))
-		})
-	})
-
 	It("returns songs ordered by lyrics with a specific title/artist", func() {
 		// attempt to mimic filters.SongsByArtistTitleWithLyricsFirst, except we want all items
 		results, err := mr.GetAll(model.QueryOptions{
@@ -158,74 +119,6 @@ var _ = Describe("MediaRepository", func() {
 			Expect(mf.PlayCount).To(Equal(int64(1)))
 		})
 
-		Describe("AverageRating", func() {
-			var raw *mediaFileRepository
-
-			BeforeEach(func() {
-				raw = mr.(*mediaFileRepository)
-			})
-
-			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())
-
-				mf, err := mr.Get(newID)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mf.AverageRating).To(Equal(0.0))
-
-				_, _ = raw.executeSQL(squirrel.Delete("media_file").Where(squirrel.Eq{"id": newID}))
-			})
-
-			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.SetRating(5, newID)).To(Succeed())
-
-				mf, err := mr.Get(newID)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mf.AverageRating).To(Equal(5.0))
-
-				_, _ = raw.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": newID}))
-				_, _ = raw.executeSQL(squirrel.Delete("media_file").Where(squirrel.Eq{"id": newID}))
-			})
-
-			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.SetRating(3, newID)).To(Succeed())
-
-				user2Ctx := request.WithUser(GinkgoT().Context(), regularUser)
-				user2Repo := NewMediaFileRepository(user2Ctx, GetDBXBuilder())
-				Expect(user2Repo.SetRating(5, newID)).To(Succeed())
-
-				mf, err := mr.Get(newID)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mf.AverageRating).To(Equal(4.0))
-
-				_, _ = raw.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": newID}))
-				_, _ = raw.executeSQL(squirrel.Delete("media_file").Where(squirrel.Eq{"id": newID}))
-			})
-
-			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.SetRating(4, newID)).To(Succeed())
-
-				user2Ctx := request.WithUser(GinkgoT().Context(), regularUser)
-				user2Repo := NewMediaFileRepository(user2Ctx, GetDBXBuilder())
-				Expect(user2Repo.SetRating(0, newID)).To(Succeed())
-
-				mf, err := mr.Get(newID)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mf.AverageRating).To(Equal(4.0))
-
-				_, _ = raw.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": newID}))
-				_, _ = raw.executeSQL(squirrel.Delete("media_file").Where(squirrel.Eq{"id": newID}))
-			})
-		})
-
 		It("preserves play date if and only if provided date is older", func() {
 			id := "incplay.playdate"
 			Expect(mr.Put(&model.MediaFile{LibraryID: 1, ID: id})).To(BeNil())
@@ -418,50 +311,6 @@ var _ = Describe("MediaRepository", func() {
 		})
 	})
 
-	Context("Filters", func() {
-		var mfWithoutAnnotation model.MediaFile
-
-		BeforeEach(func() {
-			mfWithoutAnnotation = model.MediaFile{ID: "no-annotation-file", LibraryID: 1, Path: "/test/no-annotation.mp3", Title: "No Annotation"}
-			Expect(mr.Put(&mfWithoutAnnotation)).To(Succeed())
-		})
-
-		AfterEach(func() {
-			_ = mr.Delete(mfWithoutAnnotation.ID)
-		})
-
-		Describe("starred", func() {
-			It("false includes items without annotations", func() {
-				res, err := mr.(model.ResourceRepository).ReadAll(rest.QueryOptions{
-					Filters: map[string]any{"starred": "false"},
-				})
-				Expect(err).ToNot(HaveOccurred())
-				files := res.(model.MediaFiles)
-
-				var found bool
-				for _, f := range files {
-					if f.ID == mfWithoutAnnotation.ID {
-						found = true
-						break
-					}
-				}
-				Expect(found).To(BeTrue(), "MediaFile without annotation should be included in starred=false filter")
-			})
-
-			It("true excludes items without annotations", func() {
-				res, err := mr.(model.ResourceRepository).ReadAll(rest.QueryOptions{
-					Filters: map[string]any{"starred": "true"},
-				})
-				Expect(err).ToNot(HaveOccurred())
-				files := res.(model.MediaFiles)
-
-				for _, f := range files {
-					Expect(f.ID).ToNot(Equal(mfWithoutAnnotation.ID))
-				}
-			})
-		})
-	})
-
 	Describe("Search", func() {
 		Context("text search", func() {
 			It("finds media files by title", func() {
@@ -561,92 +410,4 @@ var _ = Describe("MediaRepository", func() {
 			})
 		})
 	})
-
-	Describe("FindByPaths", func() {
-		// Test fixtures for Unicode and case-sensitivity tests
-		var testFiles []model.MediaFile
-
-		BeforeEach(func() {
-			testFiles = []model.MediaFile{
-				{ID: "findpath-1", LibraryID: 1, Path: "artist/Album/track.mp3", Title: "Track"},
-				{ID: "findpath-2", LibraryID: 1, Path: "artist/Album/UPPER.mp3", Title: "Upper"},
-				// Fullwidth uppercase: ＡＣＲＯＳＳ (U+FF21 U+FF23 U+FF32 U+FF2F U+FF33 U+FF33)
-				{ID: "findpath-3", LibraryID: 1, Path: "plex/02 - ＡＣＲＯＳＳ.flac", Title: "Fullwidth"},
-				// French diacritic: è (U+00E8, can decompose to e + combining grave)
-				{ID: "findpath-4", LibraryID: 1, Path: "artist/Michèle/song.mp3", Title: "French"},
-			}
-			for _, mf := range testFiles {
-				Expect(mr.Put(&mf)).To(Succeed())
-			}
-		})
-
-		AfterEach(func() {
-			for _, mf := range testFiles {
-				_ = mr.Delete(mf.ID)
-			}
-		})
-
-		It("finds files by exact path", func() {
-			results, err := mr.FindByPaths([]string{"1:artist/Album/track.mp3"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(HaveLen(1))
-			Expect(results[0].ID).To(Equal("findpath-1"))
-		})
-
-		It("finds files case-insensitively for ASCII characters (NOCASE)", func() {
-			// SQLite's COLLATE NOCASE handles ASCII case-insensitivity
-			results, err := mr.FindByPaths([]string{"1:ARTIST/ALBUM/TRACK.MP3"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(HaveLen(1))
-			Expect(results[0].ID).To(Equal("findpath-1"))
-		})
-
-		It("finds fullwidth characters only with exact case match (SQLite NOCASE limitation)", func() {
-			// SQLite's NOCASE does NOT handle fullwidth uppercase/lowercase equivalence
-			// The DB has fullwidth uppercase ＡＣＲＯＳＳ, searching with exact match should work
-			results, err := mr.FindByPaths([]string{"1:plex/02 - ＡＣＲＯＳＳ.flac"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(HaveLen(1))
-			Expect(results[0].ID).To(Equal("findpath-3"))
-
-			// Searching with fullwidth lowercase ａｃｒｏｓｓ should NOT match
-			// (this is the SQLite limitation that requires exact matching for non-ASCII)
-			results, err = mr.FindByPaths([]string{"1:plex/02 - ａｃｒｏｓｓ.flac"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(BeEmpty())
-		})
-
-		It("returns multiple files when querying multiple paths", func() {
-			results, err := mr.FindByPaths([]string{
-				"1:artist/Album/track.mp3",
-				"1:artist/Album/UPPER.mp3",
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(HaveLen(2))
-		})
-
-		It("returns empty slice for non-existent paths", func() {
-			results, err := mr.FindByPaths([]string{"1:nonexistent/path.mp3"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(BeEmpty())
-		})
-
-		It("returns empty slice for empty input", func() {
-			results, err := mr.FindByPaths([]string{})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(BeEmpty())
-		})
-
-		It("handles library-qualified paths correctly", func() {
-			// Library 1 should find the file
-			results, err := mr.FindByPaths([]string{"1:artist/Album/track.mp3"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(HaveLen(1))
-
-			// Library 2 should NOT find it (file is in library 1)
-			results, err = mr.FindByPaths([]string{"2:artist/Album/track.mp3"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(results).To(BeEmpty())
-		})
-	})
 })

persistence/persistence_suite_test.go

@@ -130,8 +130,7 @@ var (
 var (
 	adminUser   = model.User{ID: "userid", UserName: "userid", Name: "admin", Email: "admin@email.com", IsAdmin: true}
 	regularUser = model.User{ID: "2222", UserName: "regular-user", Name: "Regular User", Email: "regular@example.com"}
-	thirdUser   = model.User{ID: "3333", UserName: "third-user", Name: "Third User", Email: "third@example.com"}
-	testUsers   = model.Users{adminUser, regularUser, thirdUser}
+	testUsers   = model.Users{adminUser, regularUser}
 )
 
 func p(path string) string {

persistence/playlist_repository.go

@@ -227,9 +227,9 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 		return false
 	}
 
-	// Never refresh other users' playlists
+	// Only refresh for owners, unless the playlist is marked as global
 	usr := loggedUser(r.ctx)
-	if pls.OwnerID != usr.ID {
+	if pls.OwnerID != usr.ID && !pls.Global {
 		log.Trace(r.ctx, "Not refreshing smart playlist from other user", "playlist", pls.Name, "id", pls.ID)
 		return false
 	}

persistence/playlist_repository_test.go

@@ -4,6 +4,7 @@ import (
 	"time"
 
 	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/criteria"
@@ -147,6 +148,67 @@ var _ = Describe("PlaylistRepository", func() {
 			})
 		})
 
+		Context("Global smart playlists", func() {
+			var globalPls model.Playlist
+			var otherUserRepo model.PlaylistRepository
+
+			BeforeEach(func() {
+				// Force smart playlist refresh
+				DeferCleanup(configtest.SetupConfig())
+				conf.Server.SmartPlaylistRefreshDelay = -1 * time.Second
+
+				// Create a global smart playlist owned by the admin user
+				globalPls = model.Playlist{Name: "Global Smart", OwnerID: "userid", Rules: rules, Global: true, Public: true}
+				Expect(repo.Put(&globalPls)).To(Succeed())
+
+				// Create a different user context (using regularUser who has library access)
+				otherCtx := log.NewContext(GinkgoT().Context())
+				otherCtx = request.WithUser(otherCtx, regularUser)
+				otherUserRepo = NewPlaylistRepository(otherCtx, GetDBXBuilder())
+			})
+
+			AfterEach(func() {
+				_ = repo.Delete(globalPls.ID)
+			})
+
+			It("stores and retrieves the Global attribute", func() {
+				savedPls, err := repo.Get(globalPls.ID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(savedPls.Global).To(BeTrue())
+			})
+
+			It("allows non-owner to refresh a global smart playlist", func() {
+				// Verify the playlist can be retrieved by non-owner and has Global=true
+				plsCheck, err := otherUserRepo.Get(globalPls.ID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(plsCheck.Global).To(BeTrue(), "Global should be true when retrieved by non-owner")
+				Expect(plsCheck.IsSmartPlaylist()).To(BeTrue(), "Should be smart playlist")
+				Expect(plsCheck.EvaluatedAt).To(BeNil(), "Should not be evaluated yet")
+
+				// Non-owner requests the playlist with refresh
+				_, err = otherUserRepo.GetWithTracks(globalPls.ID, true, false)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Re-fetch to verify EvaluatedAt was updated in DB
+				pls, err := otherUserRepo.Get(globalPls.ID)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(pls.EvaluatedAt).ToNot(BeNil(), "Global smart playlist should be refreshed for non-owner")
+			})
+
+			It("does not allow non-owner to refresh a non-global smart playlist", func() {
+				// Create a non-global smart playlist
+				nonGlobalPls := model.Playlist{Name: "Non-Global Smart", OwnerID: "userid", Rules: rules, Global: false, Public: true}
+				Expect(repo.Put(&nonGlobalPls)).To(Succeed())
+				DeferCleanup(func() { _ = repo.Delete(nonGlobalPls.ID) })
+
+				// Non-owner requests the playlist with refresh
+				pls, err := otherUserRepo.GetWithTracks(nonGlobalPls.ID, true, false)
+				Expect(err).ToNot(HaveOccurred())
+				// EvaluatedAt should be nil because the playlist was not refreshed
+				Expect(pls.EvaluatedAt).To(BeNil())
+			})
+		})
+
 		Context("invalid rules", func() {
 			It("fails to Put it in the DB", func() {
 				rules = &criteria.Criteria{

persistence/sql_annotations.go

@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"strings"
 	"time"
 
 	. "github.com/Masterminds/squirrel"
@@ -18,7 +17,7 @@ const annotationTable = "annotation"
 func (r sqlRepository) withAnnotation(query SelectBuilder, idField string) SelectBuilder {
 	userID := loggedUser(r.ctx).ID
 	if userID == invalidUserId {
-		return query.Columns(fmt.Sprintf("%s.average_rating", r.tableName))
+		return query
 	}
 	query = query.
 		LeftJoin("annotation on ("+
@@ -39,24 +38,9 @@ func (r sqlRepository) withAnnotation(query SelectBuilder, idField string) Selec
 		query = query.Columns("coalesce(play_count, 0) as play_count")
 	}
 
-	query = query.Columns(fmt.Sprintf("%s.average_rating", r.tableName))
-
 	return query
 }
 
-func annotationBoolFilter(field string) func(string, any) Sqlizer {
-	return func(_ string, value any) Sqlizer {
-		v, ok := value.(string)
-		if !ok {
-			return nil
-		}
-		if strings.ToLower(v) == "true" {
-			return Expr(fmt.Sprintf("COALESCE(%s, 0) > 0", field))
-		}
-		return Expr(fmt.Sprintf("COALESCE(%s, 0) = 0", field))
-	}
-}
-
 func (r sqlRepository) annId(itemID ...string) And {
 	userID := loggedUser(r.ctx).ID
 	return And{
@@ -95,22 +79,7 @@ func (r sqlRepository) SetStar(starred bool, ids ...string) error {
 
 func (r sqlRepository) SetRating(rating int, itemID string) error {
 	ratedAt := time.Now()
-	err := r.annUpsert(map[string]interface{}{"rating": rating, "rated_at": ratedAt}, itemID)
-	if err != nil {
-		return err
-	}
-	return r.updateAvgRating(itemID)
-}
-
-func (r sqlRepository) updateAvgRating(itemID string) error {
-	upd := Update(r.tableName).
-		Where(Eq{"id": itemID}).
-		Set("average_rating", Expr(
-			"coalesce((select round(avg(rating), 2) from annotation where item_id = ? and item_type = ? and rating > 0), 0)",
-			itemID, r.tableName,
-		))
-	_, err := r.executeSQL(upd)
-	return err
+	return r.annUpsert(map[string]interface{}{"rating": rating, "rated_at": ratedAt}, itemID)
 }
 
 func (r sqlRepository) IncPlayCount(itemID string, ts time.Time) error {

persistence/sql_annotations_test.go

@@ -1,153 +0,0 @@
-package persistence
-
-import (
-	"context"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/deluan/rest"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/model/request"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Annotation Filters", func() {
-	var (
-		albumRepo              *albumRepository
-		albumWithoutAnnotation model.Album
-	)
-
-	BeforeEach(func() {
-		ctx := request.WithUser(context.Background(), model.User{ID: "userid", UserName: "johndoe"})
-		albumRepo = NewAlbumRepository(ctx, GetDBXBuilder()).(*albumRepository)
-
-		// Create album without any annotation (no star, no rating)
-		albumWithoutAnnotation = model.Album{ID: "no-annotation-album", Name: "No Annotation", LibraryID: 1}
-		Expect(albumRepo.Put(&albumWithoutAnnotation)).To(Succeed())
-	})
-
-	AfterEach(func() {
-		_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": albumWithoutAnnotation.ID}))
-	})
-
-	Describe("annotationBoolFilter", func() {
-		DescribeTable("creates correct SQL expressions",
-			func(field, value string, expectedSQL string, expectedArgs []interface{}) {
-				sqlizer := annotationBoolFilter(field)(field, value)
-				sql, args, err := sqlizer.ToSql()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(sql).To(Equal(expectedSQL))
-				Expect(args).To(Equal(expectedArgs))
-			},
-			Entry("starred=true", "starred", "true", "COALESCE(starred, 0) > 0", []interface{}(nil)),
-			Entry("starred=false", "starred", "false", "COALESCE(starred, 0) = 0", []interface{}(nil)),
-			Entry("starred=True (case insensitive)", "starred", "True", "COALESCE(starred, 0) > 0", []interface{}(nil)),
-			Entry("rating=true", "rating", "true", "COALESCE(rating, 0) > 0", []interface{}(nil)),
-		)
-
-		It("returns nil if value is not a string", func() {
-			sqlizer := annotationBoolFilter("starred")("starred", 123)
-			Expect(sqlizer).To(BeNil())
-		})
-	})
-
-	Describe("starredFilter", func() {
-		It("false includes items without annotations", func() {
-			albums, err := albumRepo.GetAll(model.QueryOptions{
-				Filters: annotationBoolFilter("starred")("starred", "false"),
-			})
-			Expect(err).ToNot(HaveOccurred())
-
-			var found bool
-			for _, a := range albums {
-				if a.ID == albumWithoutAnnotation.ID {
-					found = true
-					break
-				}
-			}
-			Expect(found).To(BeTrue(), "Item without annotation should be included in starred=false filter")
-		})
-
-		It("true excludes items without annotations", func() {
-			albums, err := albumRepo.GetAll(model.QueryOptions{
-				Filters: annotationBoolFilter("starred")("starred", "true"),
-			})
-			Expect(err).ToNot(HaveOccurred())
-
-			for _, a := range albums {
-				Expect(a.ID).ToNot(Equal(albumWithoutAnnotation.ID))
-			}
-		})
-	})
-
-	Describe("hasRatingFilter", func() {
-		It("false includes items without annotations", func() {
-			albums, err := albumRepo.GetAll(model.QueryOptions{
-				Filters: annotationBoolFilter("rating")("rating", "false"),
-			})
-			Expect(err).ToNot(HaveOccurred())
-
-			var found bool
-			for _, a := range albums {
-				if a.ID == albumWithoutAnnotation.ID {
-					found = true
-					break
-				}
-			}
-			Expect(found).To(BeTrue(), "Item without annotation should be included in has_rating=false filter")
-		})
-
-		It("true excludes items without annotations", func() {
-			albums, err := albumRepo.GetAll(model.QueryOptions{
-				Filters: annotationBoolFilter("rating")("rating", "true"),
-			})
-			Expect(err).ToNot(HaveOccurred())
-
-			for _, a := range albums {
-				Expect(a.ID).ToNot(Equal(albumWithoutAnnotation.ID))
-			}
-		})
-
-		It("true includes items with rating > 0", func() {
-			// Create album with rating 1
-			ratedAlbum := model.Album{ID: "rated-album", Name: "Rated Album", LibraryID: 1}
-			Expect(albumRepo.Put(&ratedAlbum)).To(Succeed())
-			Expect(albumRepo.SetRating(1, ratedAlbum.ID)).To(Succeed())
-			defer func() {
-				_, _ = albumRepo.executeSQL(squirrel.Delete("annotation").Where(squirrel.Eq{"item_id": ratedAlbum.ID}))
-				_, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": ratedAlbum.ID}))
-			}()
-
-			albums, err := albumRepo.GetAll(model.QueryOptions{
-				Filters: annotationBoolFilter("rating")("rating", "true"),
-			})
-			Expect(err).ToNot(HaveOccurred())
-
-			var found bool
-			for _, a := range albums {
-				if a.ID == ratedAlbum.ID {
-					found = true
-					break
-				}
-			}
-			Expect(found).To(BeTrue(), "Album with rating 5 should be included in has_rating=true filter")
-		})
-	})
-
-	It("ignores invalid filter values (not strings)", func() {
-		res, err := albumRepo.ReadAll(rest.QueryOptions{
-			Filters: map[string]any{"starred": 123},
-		})
-		Expect(err).ToNot(HaveOccurred())
-		albums := res.(model.Albums)
-
-		var found bool
-		for _, a := range albums {
-			if a.ID == albumWithoutAnnotation.ID {
-				found = true
-				break
-			}
-		}
-		Expect(found).To(BeTrue(), "Item without annotation should be included when filter is ignored")
-	})
-})

plugins/README.md

@@ -1036,8 +1036,9 @@ See [examples/](examples/) for complete working plugins:
 | [coverartarchive-py](examples/coverartarchive-py/)             | Python   | MetadataAgent | HTTP                                       | Cover Art Archive              |
 | [webhook-rs](examples/webhook-rs/)                             | Rust     | Scrobbler     | HTTP                                       | HTTP webhooks                  |
 | [nowplaying-py](examples/nowplaying-py/)                       | Python   | Lifecycle     | Scheduler, SubsonicAPI                     | Periodic now-playing logger    |
-| [library-inspector](examples/library-inspector-rs/)            | Rust     | Lifecycle     | Library, Scheduler                         | Periodic library stats logging |
+| [library-inspector](examples/library-inspector-rs/)               | Rust     | Lifecycle     | Library, Scheduler                         | Periodic library stats logging |
 | [crypto-ticker](examples/crypto-ticker/)                       | Go       | Lifecycle     | WebSocket, Scheduler                       | Real-time crypto prices demo   |
+| [discord-rich-presence](examples/discord-rich-presence/)       | Go       | Scrobbler     | HTTP, WebSocket, Cache, Scheduler, Artwork | Discord integration            |
 | [discord-rich-presence-rs](examples/discord-rich-presence-rs/) | Rust     | Scrobbler     | HTTP, WebSocket, Cache, Scheduler, Artwork | Discord integration (Rust)     |
 
 ---

plugins/capabilities/metadata_agent.go

@@ -40,18 +40,6 @@ type MetadataAgent interface {
 	// GetAlbumImages retrieves images for an album.
 	//nd:export name=nd_get_album_images
 	GetAlbumImages(AlbumRequest) (*AlbumImagesResponse, error)
-
-	// GetSimilarSongsByTrack retrieves songs similar to a specific track.
-	//nd:export name=nd_get_similar_songs_by_track
-	GetSimilarSongsByTrack(SimilarSongsByTrackRequest) (*SimilarSongsResponse, error)
-
-	// GetSimilarSongsByAlbum retrieves songs similar to tracks on an album.
-	//nd:export name=nd_get_similar_songs_by_album
-	GetSimilarSongsByAlbum(SimilarSongsByAlbumRequest) (*SimilarSongsResponse, error)
-
-	// GetSimilarSongsByArtist retrieves songs similar to an artist's catalog.
-	//nd:export name=nd_get_similar_songs_by_artist
-	GetSimilarSongsByArtist(SimilarSongsByArtistRequest) (*SimilarSongsResponse, error)
 }
 
 // ArtistMBIDRequest is the request for GetArtistMBID.
@@ -134,7 +122,7 @@ type TopSongsRequest struct {
 	Count int32 `json:"count"`
 }
 
-// SongRef is a reference to a song with metadata for matching.
+// SongRef is a reference to a song with name and optional MBID.
 type SongRef struct {
 	// ID is the internal Navidrome mediafile ID (if known).
 	ID string `json:"id,omitempty"`
@@ -142,18 +130,6 @@ type SongRef struct {
 	Name string `json:"name"`
 	// MBID is the MusicBrainz ID for the song.
 	MBID string `json:"mbid,omitempty"`
-	// ISRC is the International Standard Recording Code for the song.
-	ISRC string `json:"isrc,omitempty"`
-	// Artist is the artist name.
-	Artist string `json:"artist,omitempty"`
-	// ArtistMBID is the MusicBrainz artist ID.
-	ArtistMBID string `json:"artistMbid,omitempty"`
-	// Album is the album name.
-	Album string `json:"album,omitempty"`
-	// AlbumMBID is the MusicBrainz release ID.
-	AlbumMBID string `json:"albumMbid,omitempty"`
-	// Duration is the song duration in seconds.
-	Duration float32 `json:"duration,omitempty"`
 }
 
 // TopSongsResponse is the response for GetArtistTopSongs.
@@ -189,49 +165,3 @@ type AlbumImagesResponse struct {
 	// Images is the list of album images.
 	Images []ImageInfo `json:"images"`
 }
-
-// SimilarSongsByTrackRequest is the request for GetSimilarSongsByTrack.
-type SimilarSongsByTrackRequest struct {
-	// ID is the internal Navidrome mediafile ID.
-	ID string `json:"id"`
-	// Name is the track title.
-	Name string `json:"name"`
-	// Artist is the artist name.
-	Artist string `json:"artist"`
-	// MBID is the MusicBrainz recording ID (if known).
-	MBID string `json:"mbid,omitempty"`
-	// Count is the maximum number of similar songs to return.
-	Count int32 `json:"count"`
-}
-
-// SimilarSongsByAlbumRequest is the request for GetSimilarSongsByAlbum.
-type SimilarSongsByAlbumRequest struct {
-	// ID is the internal Navidrome album ID.
-	ID string `json:"id"`
-	// Name is the album name.
-	Name string `json:"name"`
-	// Artist is the album artist name.
-	Artist string `json:"artist"`
-	// MBID is the MusicBrainz release ID (if known).
-	MBID string `json:"mbid,omitempty"`
-	// Count is the maximum number of similar songs to return.
-	Count int32 `json:"count"`
-}
-
-// SimilarSongsByArtistRequest is the request for GetSimilarSongsByArtist.
-type SimilarSongsByArtistRequest struct {
-	// ID is the internal Navidrome artist ID.
-	ID string `json:"id"`
-	// Name is the artist name.
-	Name string `json:"name"`
-	// MBID is the MusicBrainz artist ID (if known).
-	MBID string `json:"mbid,omitempty"`
-	// Count is the maximum number of similar songs to return.
-	Count int32 `json:"count"`
-}
-
-// SimilarSongsResponse is the response for GetSimilarSongsBy* functions.
-type SimilarSongsResponse struct {
-	// Songs is the list of similar songs.
-	Songs []SongRef `json:"songs"`
-}

plugins/capabilities/metadata_agent.yaml

@@ -64,30 +64,6 @@ exports:
         output:
             $ref: '#/components/schemas/AlbumImagesResponse'
             contentType: application/json
-    nd_get_similar_songs_by_track:
-        description: GetSimilarSongsByTrack retrieves songs similar to a specific track.
-        input:
-            $ref: '#/components/schemas/SimilarSongsByTrackRequest'
-            contentType: application/json
-        output:
-            $ref: '#/components/schemas/SimilarSongsResponse'
-            contentType: application/json
-    nd_get_similar_songs_by_album:
-        description: GetSimilarSongsByAlbum retrieves songs similar to tracks on an album.
-        input:
-            $ref: '#/components/schemas/SimilarSongsByAlbumRequest'
-            contentType: application/json
-        output:
-            $ref: '#/components/schemas/SimilarSongsResponse'
-            contentType: application/json
-    nd_get_similar_songs_by_artist:
-        description: GetSimilarSongsByArtist retrieves songs similar to an artist's catalog.
-        input:
-            $ref: '#/components/schemas/SimilarSongsByArtistRequest'
-            contentType: application/json
-        output:
-            $ref: '#/components/schemas/SimilarSongsResponse'
-            contentType: application/json
 components:
     schemas:
         AlbumImagesResponse:
@@ -253,86 +229,8 @@ components:
                         $ref: '#/components/schemas/ArtistRef'
             required:
                 - artists
-        SimilarSongsByAlbumRequest:
-            description: SimilarSongsByAlbumRequest is the request for GetSimilarSongsByAlbum.
-            properties:
-                id:
-                    type: string
-                    description: ID is the internal Navidrome album ID.
-                name:
-                    type: string
-                    description: Name is the album name.
-                artist:
-                    type: string
-                    description: Artist is the album artist name.
-                mbid:
-                    type: string
-                    description: MBID is the MusicBrainz release ID (if known).
-                count:
-                    type: integer
-                    format: int32
-                    description: Count is the maximum number of similar songs to return.
-            required:
-                - id
-                - name
-                - artist
-                - count
-        SimilarSongsByArtistRequest:
-            description: SimilarSongsByArtistRequest is the request for GetSimilarSongsByArtist.
-            properties:
-                id:
-                    type: string
-                    description: ID is the internal Navidrome artist ID.
-                name:
-                    type: string
-                    description: Name is the artist name.
-                mbid:
-                    type: string
-                    description: MBID is the MusicBrainz artist ID (if known).
-                count:
-                    type: integer
-                    format: int32
-                    description: Count is the maximum number of similar songs to return.
-            required:
-                - id
-                - name
-                - count
-        SimilarSongsByTrackRequest:
-            description: SimilarSongsByTrackRequest is the request for GetSimilarSongsByTrack.
-            properties:
-                id:
-                    type: string
-                    description: ID is the internal Navidrome mediafile ID.
-                name:
-                    type: string
-                    description: Name is the track title.
-                artist:
-                    type: string
-                    description: Artist is the artist name.
-                mbid:
-                    type: string
-                    description: MBID is the MusicBrainz recording ID (if known).
-                count:
-                    type: integer
-                    format: int32
-                    description: Count is the maximum number of similar songs to return.
-            required:
-                - id
-                - name
-                - artist
-                - count
-        SimilarSongsResponse:
-            description: SimilarSongsResponse is the response for GetSimilarSongsBy* functions.
-            properties:
-                songs:
-                    type: array
-                    description: Songs is the list of similar songs.
-                    items:
-                        $ref: '#/components/schemas/SongRef'
-            required:
-                - songs
         SongRef:
-            description: SongRef is a reference to a song with metadata for matching.
+            description: SongRef is a reference to a song with name and optional MBID.
             properties:
                 id:
                     type: string
@@ -343,25 +241,6 @@ components:
                 mbid:
                     type: string
                     description: MBID is the MusicBrainz ID for the song.
-                isrc:
-                    type: string
-                    description: ISRC is the International Standard Recording Code for the song.
-                artist:
-                    type: string
-                    description: Artist is the artist name.
-                artistMbid:
-                    type: string
-                    description: ArtistMBID is the MusicBrainz artist ID.
-                album:
-                    type: string
-                    description: Album is the album name.
-                albumMbid:
-                    type: string
-                    description: AlbumMBID is the MusicBrainz release ID.
-                duration:
-                    type: number
-                    format: float
-                    description: Duration is the song duration in seconds.
             required:
                 - name
         TopSongsRequest:

plugins/cmd/ndpgen/go.mod

@@ -4,10 +4,10 @@ go 1.25
 
 require (
 	github.com/extism/go-pdk v1.1.3
-	github.com/onsi/ginkgo/v2 v2.27.5
-	github.com/onsi/gomega v1.39.0
-	github.com/santhosh-tekuri/jsonschema/v6 v6.0.2
-	golang.org/x/tools v0.41.0
+	github.com/onsi/ginkgo/v2 v2.27.3
+	github.com/onsi/gomega v1.38.3
+	github.com/xeipuuv/gojsonschema v1.2.0
+	golang.org/x/tools v0.40.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -16,11 +16,13 @@ require (
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
-	github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83 // indirect
+	github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 // indirect
+	github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
+	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/mod v0.32.0 // indirect
-	golang.org/x/net v0.49.0 // indirect
+	golang.org/x/mod v0.31.0 // indirect
+	golang.org/x/net v0.48.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/sys v0.40.0 // indirect
-	golang.org/x/text v0.33.0 // indirect
+	golang.org/x/sys v0.39.0 // indirect
+	golang.org/x/text v0.32.0 // indirect
 )

plugins/cmd/ndpgen/go.sum

@@ -1,9 +1,8 @@
 github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
 github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
-github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/extism/go-pdk v1.1.3 h1:hfViMPWrqjN6u67cIYRALZTZLk/enSPpNKa+rZ9X2SQ=
 github.com/extism/go-pdk v1.1.3/go.mod h1:Gz+LIU/YCKnKXhgge8yo5Yu1F/lbv7KtKFkiCSzW/P4=
 github.com/gkampitakis/ciinfo v0.3.2 h1:JcuOPk8ZU7nZQjdUhctuhQofk7BGHuIy0c9Ez8BNhXs=
@@ -20,8 +19,8 @@ github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
 github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 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/pprof v0.0.0-20260115054156-294ebfa9ad83 h1:z2ogiKUYzX5Is6zr/vP9vJGqPwcdqsWjOt+V8J7+bTc=
-github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
+github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8=
+github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/joshdk/go-junit v1.0.0 h1:S86cUKIdwBHWwA6xCmFlf3RTLfVXYQfvanM5Uh+K6GE=
 github.com/joshdk/go-junit v1.0.0/go.mod h1:TiiV0PqkaNfFXjEiyjWM3XXrhVyCa1K4Zfga6W52ung=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
@@ -32,16 +31,16 @@ github.com/maruel/natural v1.1.1 h1:Hja7XhhmvEFhcByqDoHz9QZbkWey+COd9xWfCfn1ioo=
 github.com/maruel/natural v1.1.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
 github.com/mfridman/tparse v0.18.0 h1:wh6dzOKaIwkUGyKgOntDW4liXSo37qg5AXbIhkMV3vE=
 github.com/mfridman/tparse v0.18.0/go.mod h1:gEvqZTuCgEhPbYk/2lS3Kcxg1GmTxxU7kTC8DvP0i/A=
-github.com/onsi/ginkgo/v2 v2.27.5 h1:ZeVgZMx2PDMdJm/+w5fE/OyG6ILo1Y3e+QX4zSR0zTE=
-github.com/onsi/ginkgo/v2 v2.27.5/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo=
-github.com/onsi/gomega v1.39.0 h1:y2ROC3hKFmQZJNFeGAMeHZKkjBL65mIZcvrLQBF9k6Q=
-github.com/onsi/gomega v1.39.0/go.mod h1:ZCU1pkQcXDO5Sl9/VVEGlDyp+zm0m1cmeG5TOzLgdh4=
+github.com/onsi/ginkgo/v2 v2.27.3 h1:ICsZJ8JoYafeXFFlFAG75a7CxMsJHwgKwtO+82SE9L8=
+github.com/onsi/ginkgo/v2 v2.27.3/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo=
+github.com/onsi/gomega v1.38.3 h1:eTX+W6dobAYfFeGC2PV6RwXRu/MyT+cQguijutvkpSM=
+github.com/onsi/gomega v1.38.3/go.mod h1:ZCU1pkQcXDO5Sl9/VVEGlDyp+zm0m1cmeG5TOzLgdh4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
-github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 h1:KRzFb2m7YtdldCEkzs6KqmJw4nqEVZGK7IN2kJkjTuQ=
-github.com/santhosh-tekuri/jsonschema/v6 v6.0.2/go.mod h1:JXeL+ps8p7/KNMjDQk3TCwPpBy0wYklyWTfbkIzdIFU=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
@@ -52,20 +51,26 @@ github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
 github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
 github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
+github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
+github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
-golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
-golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
-golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
+golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
+golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
+golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
-golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
-golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
-golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
-golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
-golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
+golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
+golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
 google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
 google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

plugins/cmd/ndpgen/integration_test.go

@@ -282,9 +282,6 @@ type ServiceB interface {
 
 			Entry("option pattern (value, exists bool)",
 				"config_service.go.txt", "config_client_expected.go.txt", "config_client_expected.py", "config_client_expected.rs"),
-
-			Entry("raw=true binary response",
-				"raw_service.go.txt", "raw_client_expected.go.txt", "raw_client_expected.py", "raw_client_expected.rs"),
 		)
 
 		It("generates compilable client code for comprehensive service", func() {

plugins/cmd/ndpgen/internal/generator.go

@@ -568,18 +568,6 @@ func skipSerializingFunc(goType string) string {
 		return "String::is_empty"
 	case "bool":
 		return "std::ops::Not::not"
-	case "int32":
-		return "is_zero_i32"
-	case "uint32":
-		return "is_zero_u32"
-	case "int64":
-		return "is_zero_i64"
-	case "uint64":
-		return "is_zero_u64"
-	case "float32":
-		return "is_zero_f32"
-	case "float64":
-		return "is_zero_f64"
 	default:
 		return "Option::is_none"
 	}

plugins/cmd/ndpgen/internal/generator_test.go

@@ -264,96 +264,6 @@ var _ = Describe("Generator", func() {
 			Expect(codeStr).To(ContainSubstring(`extism "github.com/extism/go-sdk"`))
 		})
 
-		It("should generate binary framing for raw=true methods", func() {
-			svc := Service{
-				Name:       "Stream",
-				Permission: "stream",
-				Interface:  "StreamService",
-				Methods: []Method{
-					{
-						Name:     "GetStream",
-						HasError: true,
-						Raw:      true,
-						Params:   []Param{NewParam("uri", "string")},
-						Returns: []Param{
-							NewParam("contentType", "string"),
-							NewParam("data", "[]byte"),
-						},
-					},
-				},
-			}
-
-			code, err := GenerateHost(svc, "host")
-			Expect(err).NotTo(HaveOccurred())
-
-			_, err = format.Source(code)
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			// Should include encoding/binary import for raw methods
-			Expect(codeStr).To(ContainSubstring(`"encoding/binary"`))
-
-			// Should NOT generate a response type for raw methods
-			Expect(codeStr).NotTo(ContainSubstring("type StreamGetStreamResponse struct"))
-
-			// Should generate request type (request is still JSON)
-			Expect(codeStr).To(ContainSubstring("type StreamGetStreamRequest struct"))
-
-			// Should build binary frame [0x00][4-byte CT len][CT][data]
-			Expect(codeStr).To(ContainSubstring("frame[0] = 0x00"))
-			Expect(codeStr).To(ContainSubstring("binary.BigEndian.PutUint32"))
-
-			// Should have writeRawError helper
-			Expect(codeStr).To(ContainSubstring("streamWriteRawError"))
-
-			// Should use writeRawError instead of writeError for raw methods
-			Expect(codeStr).To(ContainSubstring("streamWriteRawError(p, stack"))
-		})
-
-		It("should generate both writeError and writeRawError for mixed services", func() {
-			svc := Service{
-				Name:       "API",
-				Permission: "api",
-				Interface:  "APIService",
-				Methods: []Method{
-					{
-						Name:     "Call",
-						HasError: true,
-						Params:   []Param{NewParam("uri", "string")},
-						Returns:  []Param{NewParam("response", "string")},
-					},
-					{
-						Name:     "CallRaw",
-						HasError: true,
-						Raw:      true,
-						Params:   []Param{NewParam("uri", "string")},
-						Returns: []Param{
-							NewParam("contentType", "string"),
-							NewParam("data", "[]byte"),
-						},
-					},
-				},
-			}
-
-			code, err := GenerateHost(svc, "host")
-			Expect(err).NotTo(HaveOccurred())
-
-			_, err = format.Source(code)
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			// Should have both helpers
-			Expect(codeStr).To(ContainSubstring("apiWriteResponse"))
-			Expect(codeStr).To(ContainSubstring("apiWriteError"))
-			Expect(codeStr).To(ContainSubstring("apiWriteRawError"))
-
-			// Should generate response type for non-raw method only
-			Expect(codeStr).To(ContainSubstring("type APICallResponse struct"))
-			Expect(codeStr).NotTo(ContainSubstring("type APICallRawResponse struct"))
-		})
-
 		It("should always include json import for JSON protocol", func() {
 			// All services use JSON protocol, so json import is always needed
 			svc := Service{
@@ -716,72 +626,6 @@ var _ = Describe("Generator", func() {
 			Expect(codeStr).To(ContainSubstring(`response.get("floatVal", 0.0)`))
 			Expect(codeStr).To(ContainSubstring(`response.get("boolVal", False)`))
 		})
-
-		It("should generate binary frame parsing for raw methods", func() {
-			svc := Service{
-				Name:       "Stream",
-				Permission: "stream",
-				Interface:  "StreamService",
-				Methods: []Method{
-					{
-						Name:     "GetStream",
-						HasError: true,
-						Raw:      true,
-						Params:   []Param{NewParam("uri", "string")},
-						Returns: []Param{
-							NewParam("contentType", "string"),
-							NewParam("data", "[]byte"),
-						},
-						Doc: "GetStream returns raw binary stream data.",
-					},
-				},
-			}
-
-			code, err := GenerateClientPython(svc)
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			// Should import Tuple and struct for raw methods
-			Expect(codeStr).To(ContainSubstring("from typing import Any, Tuple"))
-			Expect(codeStr).To(ContainSubstring("import struct"))
-
-			// Should return Tuple[str, bytes]
-			Expect(codeStr).To(ContainSubstring("-> Tuple[str, bytes]:"))
-
-			// Should parse binary frame instead of JSON
-			Expect(codeStr).To(ContainSubstring("response_bytes = response_mem.bytes()"))
-			Expect(codeStr).To(ContainSubstring("response_bytes[0] == 0x01"))
-			Expect(codeStr).To(ContainSubstring("struct.unpack"))
-			Expect(codeStr).To(ContainSubstring("return content_type, data"))
-
-			// Should NOT use json.loads for response
-			Expect(codeStr).NotTo(ContainSubstring("json.loads(extism.memory.string(response_mem))"))
-		})
-
-		It("should not import Tuple or struct for non-raw services", func() {
-			svc := Service{
-				Name:       "Test",
-				Permission: "test",
-				Interface:  "TestService",
-				Methods: []Method{
-					{
-						Name:     "Call",
-						HasError: true,
-						Params:   []Param{NewParam("uri", "string")},
-						Returns:  []Param{NewParam("response", "string")},
-					},
-				},
-			}
-
-			code, err := GenerateClientPython(svc)
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			Expect(codeStr).NotTo(ContainSubstring("Tuple"))
-			Expect(codeStr).NotTo(ContainSubstring("import struct"))
-		})
 	})
 
 	Describe("GenerateGoDoc", func() {
@@ -938,47 +782,6 @@ var _ = Describe("Generator", func() {
 			// Check for PDK import
 			Expect(codeStr).To(ContainSubstring("github.com/navidrome/navidrome/plugins/pdk/go/pdk"))
 		})
-
-		It("should include encoding/binary import for raw methods", func() {
-			svc := Service{
-				Name:       "Stream",
-				Permission: "stream",
-				Interface:  "StreamService",
-				Methods: []Method{
-					{
-						Name:     "GetStream",
-						HasError: true,
-						Raw:      true,
-						Params:   []Param{NewParam("uri", "string")},
-						Returns: []Param{
-							NewParam("contentType", "string"),
-							NewParam("data", "[]byte"),
-						},
-					},
-				},
-			}
-
-			code, err := GenerateClientGo(svc, "host")
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			// Should include encoding/binary for raw binary frame parsing
-			Expect(codeStr).To(ContainSubstring(`"encoding/binary"`))
-
-			// Should NOT generate response type struct for raw methods
-			Expect(codeStr).NotTo(ContainSubstring("streamGetStreamResponse struct"))
-
-			// Should still generate request type
-			Expect(codeStr).To(ContainSubstring("streamGetStreamRequest struct"))
-
-			// Should parse binary frame
-			Expect(codeStr).To(ContainSubstring("responseBytes[0] == 0x01"))
-			Expect(codeStr).To(ContainSubstring("binary.BigEndian.Uint32"))
-
-			// Should return (string, []byte, error)
-			Expect(codeStr).To(ContainSubstring("func StreamGetStream(uri string) (string, []byte, error)"))
-		})
 	})
 
 	Describe("GenerateClientGoStub", func() {
@@ -1431,37 +1234,6 @@ type OnInitOutput struct {
 })
 
 var _ = Describe("Rust Generation", func() {
-	Describe("skipSerializingFunc", func() {
-		It("should return Option::is_none for pointer, slice, and map types", func() {
-			Expect(skipSerializingFunc("*string")).To(Equal("Option::is_none"))
-			Expect(skipSerializingFunc("*MyStruct")).To(Equal("Option::is_none"))
-			Expect(skipSerializingFunc("[]string")).To(Equal("Option::is_none"))
-			Expect(skipSerializingFunc("[]int32")).To(Equal("Option::is_none"))
-			Expect(skipSerializingFunc("map[string]int")).To(Equal("Option::is_none"))
-		})
-
-		It("should return String::is_empty for string type", func() {
-			Expect(skipSerializingFunc("string")).To(Equal("String::is_empty"))
-		})
-
-		It("should return std::ops::Not::not for bool type", func() {
-			Expect(skipSerializingFunc("bool")).To(Equal("std::ops::Not::not"))
-		})
-
-		It("should return is_zero_* functions for numeric types", func() {
-			Expect(skipSerializingFunc("int32")).To(Equal("is_zero_i32"))
-			Expect(skipSerializingFunc("uint32")).To(Equal("is_zero_u32"))
-			Expect(skipSerializingFunc("int64")).To(Equal("is_zero_i64"))
-			Expect(skipSerializingFunc("uint64")).To(Equal("is_zero_u64"))
-			Expect(skipSerializingFunc("float32")).To(Equal("is_zero_f32"))
-			Expect(skipSerializingFunc("float64")).To(Equal("is_zero_f64"))
-		})
-
-		It("should return Option::is_none for unknown types", func() {
-			Expect(skipSerializingFunc("CustomType")).To(Equal("Option::is_none"))
-		})
-	})
-
 	Describe("rustOutputType", func() {
 		It("should convert Go primitives to Rust primitives", func() {
 			Expect(rustOutputType("bool")).To(Equal("bool"))
@@ -1747,51 +1519,6 @@ var _ = Describe("Rust Generation", func() {
 			Expect(codeStr).To(ContainSubstring("Result<bool, Error>"))
 			Expect(codeStr).NotTo(ContainSubstring("Option<bool>"))
 		})
-
-		It("should generate raw extern C import and binary frame parsing for raw methods", func() {
-			svc := Service{
-				Name:       "Stream",
-				Permission: "stream",
-				Interface:  "StreamService",
-				Methods: []Method{
-					{
-						Name:     "GetStream",
-						HasError: true,
-						Raw:      true,
-						Params:   []Param{NewParam("uri", "string")},
-						Returns: []Param{
-							NewParam("contentType", "string"),
-							NewParam("data", "[]byte"),
-						},
-						Doc: "GetStream returns raw binary stream data.",
-					},
-				},
-			}
-
-			code, err := GenerateClientRust(svc)
-			Expect(err).NotTo(HaveOccurred())
-
-			codeStr := string(code)
-
-			// Should use extern "C" with wasm_import_module for raw methods, not #[host_fn] extern "ExtismHost"
-			Expect(codeStr).To(ContainSubstring(`#[link(wasm_import_module = "extism:host/user")]`))
-			Expect(codeStr).To(ContainSubstring(`extern "C"`))
-			Expect(codeStr).To(ContainSubstring("fn stream_getstream(offset: u64) -> u64"))
-
-			// Should NOT generate response type for raw methods
-			Expect(codeStr).NotTo(ContainSubstring("StreamGetStreamResponse"))
-
-			// Should generate request type (request is still JSON)
-			Expect(codeStr).To(ContainSubstring("struct StreamGetStreamRequest"))
-
-			// Should return Result<(String, Vec<u8>), Error>
-			Expect(codeStr).To(ContainSubstring("Result<(String, Vec<u8>), Error>"))
-
-			// Should parse binary frame
-			Expect(codeStr).To(ContainSubstring("response_bytes[0] == 0x01"))
-			Expect(codeStr).To(ContainSubstring("u32::from_be_bytes"))
-			Expect(codeStr).To(ContainSubstring("String::from_utf8_lossy"))
-		})
 	})
 })
 

plugins/cmd/ndpgen/internal/parser.go

@@ -761,7 +761,6 @@ func parseMethod(name string, funcType *ast.FuncType, annotation map[string]stri
 	m := Method{
 		Name:       name,
 		ExportName: annotation["name"],
-		Raw:        annotation["raw"] == "true",
 		Doc:        doc,
 	}
 
@@ -800,13 +799,6 @@ func parseMethod(name string, funcType *ast.FuncType, annotation map[string]stri
 		}
 	}
 
-	// Validate raw=true methods: must return exactly (string, []byte, error)
-	if m.Raw {
-		if !m.HasError || len(m.Returns) != 2 || m.Returns[0].Type != "string" || m.Returns[1].Type != "[]byte" {
-			return m, fmt.Errorf("raw=true method %s must return (string, []byte, error) — content-type, data, error", name)
-		}
-	}
-
 	return m, nil
 }
 

plugins/cmd/ndpgen/internal/parser_test.go

@@ -122,119 +122,6 @@ type TestService interface {
 			Expect(services[0].Methods[0].Name).To(Equal("Exported"))
 		})
 
-		It("should parse raw=true annotation", func() {
-			src := `package host
-
-import "context"
-
-//nd:hostservice name=Stream permission=stream
-type StreamService interface {
-	//nd:hostfunc raw=true
-	GetStream(ctx context.Context, uri string) (contentType string, data []byte, err error)
-}
-`
-			err := os.WriteFile(filepath.Join(tmpDir, "stream.go"), []byte(src), 0600)
-			Expect(err).NotTo(HaveOccurred())
-
-			services, err := ParseDirectory(tmpDir)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(services).To(HaveLen(1))
-
-			m := services[0].Methods[0]
-			Expect(m.Name).To(Equal("GetStream"))
-			Expect(m.Raw).To(BeTrue())
-			Expect(m.HasError).To(BeTrue())
-			Expect(m.Returns).To(HaveLen(2))
-			Expect(m.Returns[0].Name).To(Equal("contentType"))
-			Expect(m.Returns[0].Type).To(Equal("string"))
-			Expect(m.Returns[1].Name).To(Equal("data"))
-			Expect(m.Returns[1].Type).To(Equal("[]byte"))
-		})
-
-		It("should set Raw=false when raw annotation is absent", func() {
-			src := `package host
-
-import "context"
-
-//nd:hostservice name=Test permission=test
-type TestService interface {
-	//nd:hostfunc
-	Call(ctx context.Context, uri string) (response string, err error)
-}
-`
-			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
-			Expect(err).NotTo(HaveOccurred())
-
-			services, err := ParseDirectory(tmpDir)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(services[0].Methods[0].Raw).To(BeFalse())
-		})
-
-		It("should reject raw=true with invalid return signature", func() {
-			src := `package host
-
-import "context"
-
-//nd:hostservice name=Test permission=test
-type TestService interface {
-	//nd:hostfunc raw=true
-	BadRaw(ctx context.Context, uri string) (result string, err error)
-}
-`
-			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
-			Expect(err).NotTo(HaveOccurred())
-
-			_, err = ParseDirectory(tmpDir)
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("raw=true"))
-			Expect(err.Error()).To(ContainSubstring("must return (string, []byte, error)"))
-		})
-
-		It("should reject raw=true without error return", func() {
-			src := `package host
-
-import "context"
-
-//nd:hostservice name=Test permission=test
-type TestService interface {
-	//nd:hostfunc raw=true
-	BadRaw(ctx context.Context, uri string) (contentType string, data []byte)
-}
-`
-			err := os.WriteFile(filepath.Join(tmpDir, "test.go"), []byte(src), 0600)
-			Expect(err).NotTo(HaveOccurred())
-
-			_, err = ParseDirectory(tmpDir)
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("raw=true"))
-		})
-
-		It("should parse mixed raw and non-raw methods", func() {
-			src := `package host
-
-import "context"
-
-//nd:hostservice name=API permission=api
-type APIService interface {
-	//nd:hostfunc
-	Call(ctx context.Context, uri string) (responseJSON string, err error)
-
-	//nd:hostfunc raw=true
-	CallRaw(ctx context.Context, uri string) (contentType string, data []byte, err error)
-}
-`
-			err := os.WriteFile(filepath.Join(tmpDir, "api.go"), []byte(src), 0600)
-			Expect(err).NotTo(HaveOccurred())
-
-			services, err := ParseDirectory(tmpDir)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(services).To(HaveLen(1))
-			Expect(services[0].Methods).To(HaveLen(2))
-			Expect(services[0].Methods[0].Raw).To(BeFalse())
-			Expect(services[0].Methods[1].Raw).To(BeTrue())
-			Expect(services[0].HasRawMethods()).To(BeTrue())
-		})
-
 		It("should handle custom export name", func() {
 			src := `package host
 

plugins/cmd/ndpgen/internal/templates/capability.rs.tmpl

@@ -7,20 +7,6 @@ use serde::{Deserialize, Serialize};
 {{- if hasHashMap .Capability}}
 use std::collections::HashMap;
 {{- end}}
-
-// Helper functions for skip_serializing_if with numeric types
-#[allow(dead_code)]
-fn is_zero_i32(value: &i32) -> bool { *value == 0 }
-#[allow(dead_code)]
-fn is_zero_u32(value: &u32) -> bool { *value == 0 }
-#[allow(dead_code)]
-fn is_zero_i64(value: &i64) -> bool { *value == 0 }
-#[allow(dead_code)]
-fn is_zero_u64(value: &u64) -> bool { *value == 0 }
-#[allow(dead_code)]
-fn is_zero_f32(value: &f32) -> bool { *value == 0.0 }
-#[allow(dead_code)]
-fn is_zero_f64(value: &f64) -> bool { *value == 0.0 }
 {{- end}}
 
 {{- /* Generate type alias definitions */ -}}

plugins/cmd/ndpgen/internal/templates/client.go.tmpl

@@ -8,9 +8,6 @@
 package {{.Package}}
 
 import (
-{{- if .Service.HasRawMethods}}
-	"encoding/binary"
-{{- end}}
 	"encoding/json"
 {{- if .Service.HasErrors}}
 	"errors"
@@ -52,7 +49,7 @@ type {{requestType .}} struct {
 {{- end}}
 }
 {{- end}}
-{{- if and (not .IsErrorOnly) (not .Raw)}}
+{{- if not .IsErrorOnly}}
 
 type {{responseType .}} struct {
 {{- range .Returns}}
@@ -98,27 +95,7 @@ func {{$.Service.Name}}{{.Name}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{
 	// Read the response from memory
 	responseMem := pdk.FindMemory(responsePtr)
 	responseBytes := responseMem.ReadBytes()
-{{- if .Raw}}
-
-	// Parse binary-framed response
-	if len(responseBytes) == 0 {
-		return "", nil, errors.New("empty response from host")
-	}
-	if responseBytes[0] == 0x01 { // error
-		return "", nil, errors.New(string(responseBytes[1:]))
-	}
-	if responseBytes[0] != 0x00 {
-		return "", nil, errors.New("unknown response status")
-	}
-	if len(responseBytes) < 5 {
-		return "", nil, errors.New("malformed raw response: incomplete header")
-	}
-	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
-	if uint32(len(responseBytes)) < 5+ctLen {
-		return "", nil, errors.New("malformed raw response: content-type overflow")
-	}
-	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
-{{- else if .IsErrorOnly}}
+{{- if .IsErrorOnly}}
 
 	// Parse error-only response
 	var response struct {

plugins/cmd/ndpgen/internal/templates/client.py.tmpl

@@ -8,13 +8,10 @@
 # main __init__.py file. Copy the needed functions from this file into your plugin.
 
 from dataclasses import dataclass
-from typing import Any{{- if .Service.HasRawMethods}}, Tuple{{end}}
+from typing import Any
 
 import extism
 import json
-{{- if .Service.HasRawMethods}}
-import struct
-{{- end}}
 
 
 class HostFunctionError(Exception):
@@ -32,7 +29,7 @@ def _{{exportName .}}(offset: int) -> int:
 {{- end}}
 {{- /* Generate dataclasses for multi-value returns */ -}}
 {{range .Service.Methods}}
-{{- if and .NeedsResultClass (not .Raw)}}
+{{- if .NeedsResultClass}}
 
 
 @dataclass
@@ -47,7 +44,7 @@ class {{pythonResultType .}}:
 {{range .Service.Methods}}
 
 
-def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonName}}: {{$p.PythonType}}{{end}}){{if .Raw}} -> Tuple[str, bytes]{{else if .NeedsResultClass}} -> {{pythonResultType .}}{{else if .HasReturns}} -> {{(index .Returns 0).PythonType}}{{else}} -> None{{end}}:
+def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonName}}: {{$p.PythonType}}{{end}}){{if .NeedsResultClass}} -> {{pythonResultType .}}{{else if .HasReturns}} -> {{(index .Returns 0).PythonType}}{{else}} -> None{{end}}:
     """{{if .Doc}}{{.Doc}}{{else}}Call the {{exportName .}} host function.{{end}}
 {{- if .HasParams}}
 
@@ -56,11 +53,7 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
         {{.PythonName}}: {{.PythonType}} parameter.
 {{- end}}
 {{- end}}
-{{- if .Raw}}
-
-    Returns:
-        Tuple of (content_type, data) with the raw binary response.
-{{- else if .HasReturns}}
+{{- if .HasReturns}}
 
     Returns:
 {{- if .NeedsResultClass}}
@@ -86,24 +79,6 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
     request_mem = extism.memory.alloc(request_bytes)
     response_offset = _{{exportName .}}(request_mem.offset)
     response_mem = extism.memory.find(response_offset)
-{{- if .Raw}}
-    response_bytes = response_mem.bytes()
-
-    if len(response_bytes) == 0:
-        raise HostFunctionError("empty response from host")
-    if response_bytes[0] == 0x01:
-        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
-    if response_bytes[0] != 0x00:
-        raise HostFunctionError("unknown response status")
-    if len(response_bytes) < 5:
-        raise HostFunctionError("malformed raw response: incomplete header")
-    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
-    if len(response_bytes) < 5 + ct_len:
-        raise HostFunctionError("malformed raw response: content-type overflow")
-    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
-    data = response_bytes[5 + ct_len:]
-    return content_type, data
-{{- else}}
     response = json.loads(extism.memory.string(response_mem))
 {{if .HasError}}
     if response.get("error"):
@@ -119,4 +94,3 @@ def {{pythonFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.PythonNam
     return response.get("{{(index .Returns 0).JSONName}}"{{pythonDefault (index .Returns 0)}})
 {{- end}}
 {{- end}}
-{{- end}}

plugins/cmd/ndpgen/internal/templates/client.rs.tmpl

@@ -33,7 +33,6 @@ struct {{requestType .}} {
 {{- end}}
 }
 {{- end}}
-{{- if not .Raw}}
 
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -48,92 +47,16 @@ struct {{responseType .}} {
 {{- end}}
 }
 {{- end}}
-{{- end}}
 
 #[host_fn]
 extern "ExtismHost" {
 {{- range .Service.Methods}}
-{{- if not .Raw}}
     fn {{exportName .}}(input: Json<{{if .HasParams}}{{requestType .}}{{else}}serde_json::Value{{end}}>) -> Json<{{responseType .}}>;
 {{- end}}
-{{- end}}
 }
-{{- /* Declare raw extern "C" imports for raw methods */ -}}
-{{- range .Service.Methods}}
-{{- if .Raw}}
-
-#[link(wasm_import_module = "extism:host/user")]
-extern "C" {
-    fn {{exportName .}}(offset: u64) -> u64;
-}
-{{- end}}
-{{- end}}
 
 {{- /* Generate wrapper functions */ -}}
 {{range .Service.Methods}}
-{{- if .Raw}}
-
-{{if .Doc}}{{rustDocComment .Doc}}{{else}}/// Calls the {{exportName .}} host function.{{end}}
-{{- if .HasParams}}
-///
-/// # Arguments
-{{- range .Params}}
-/// * `{{.RustName}}` - {{rustType .}} parameter.
-{{- end}}
-{{- end}}
-///
-/// # Returns
-/// A tuple of (content_type, data) with the raw binary response.
-///
-/// # Errors
-/// Returns an error if the host function call fails.
-pub fn {{rustFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.RustName}}: {{rustParamType $p}}{{end}}) -> Result<(String, Vec<u8>), Error> {
-{{- if .HasParams}}
-    let req = {{requestType .}} {
-{{- range .Params}}
-        {{.RustName}}: {{.RustName}}{{if .NeedsToOwned}}.to_owned(){{end}},
-{{- end}}
-    };
-    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
-{{- else}}
-    let input_bytes = b"{}".to_vec();
-{{- end}}
-    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
-
-    let response_offset = unsafe { {{exportName .}}(input_mem.offset()) };
-
-    let response_mem = Memory::find(response_offset)
-        .ok_or_else(|| Error::msg("empty response from host"))?;
-    let response_bytes = response_mem.to_vec();
-
-    if response_bytes.is_empty() {
-        return Err(Error::msg("empty response from host"));
-    }
-    if response_bytes[0] == 0x01 {
-        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
-        return Err(Error::msg(msg));
-    }
-    if response_bytes[0] != 0x00 {
-        return Err(Error::msg("unknown response status"));
-    }
-    if response_bytes.len() < 5 {
-        return Err(Error::msg("malformed raw response: incomplete header"));
-    }
-    let ct_len = u32::from_be_bytes([
-        response_bytes[1],
-        response_bytes[2],
-        response_bytes[3],
-        response_bytes[4],
-    ]) as usize;
-    if ct_len > response_bytes.len() - 5 {
-        return Err(Error::msg("malformed raw response: content-type overflow"));
-    }
-    let ct_end = 5 + ct_len;
-    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
-    let data = response_bytes[ct_end..].to_vec();
-    Ok((content_type, data))
-}
-{{- else}}
 
 {{if .Doc}}{{rustDocComment .Doc}}{{else}}/// Calls the {{exportName .}} host function.{{end}}
 {{- if .HasParams}}
@@ -209,4 +132,3 @@ pub fn {{rustFunc .}}({{range $i, $p := .Params}}{{if $i}}, {{end}}{{$p.RustName
 }
 {{- end}}
 {{- end}}
-{{- end}}

plugins/cmd/ndpgen/internal/templates/host.go.tmpl

@@ -4,9 +4,6 @@ package {{.Package}}
 
 import (
 	"context"
-{{- if .Service.HasRawMethods}}
-	"encoding/binary"
-{{- end}}
 	"encoding/json"
 
 	extism "github.com/extism/go-sdk"
@@ -23,7 +20,6 @@ type {{requestType .}} struct {
 {{- end}}
 }
 {{- end}}
-{{- if not .Raw}}
 
 // {{responseType .}} is the response type for {{$.Service.Name}}.{{.Name}}.
 type {{responseType .}} struct {
@@ -34,7 +30,6 @@ type {{responseType .}} struct {
 	Error string `json:"error,omitempty"`
 {{- end}}
 }
-{{- end}}
 {{end}}
 
 // Register{{.Service.Name}}HostFunctions registers {{.Service.Name}} service host functions.
@@ -56,48 +51,18 @@ func new{{$.Service.Name}}{{.Name}}HostFunction(service {{$.Service.Interface}})
 			// Read JSON request from plugin memory
 			reqBytes, err := p.ReadBytes(stack[0])
 			if err != nil {
-{{- if .Raw}}
-				{{$.Service.Name | lower}}WriteRawError(p, stack, err)
-{{- else}}
 				{{$.Service.Name | lower}}WriteError(p, stack, err)
-{{- end}}
 				return
 			}
 			var req {{requestType .}}
 			if err := json.Unmarshal(reqBytes, &req); err != nil {
-{{- if .Raw}}
-				{{$.Service.Name | lower}}WriteRawError(p, stack, err)
-{{- else}}
 				{{$.Service.Name | lower}}WriteError(p, stack, err)
-{{- end}}
 				return
 			}
 {{- end}}
 
 			// Call the service method
-{{- if .Raw}}
-			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}}, svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
-			if svcErr != nil {
-				{{$.Service.Name | lower}}WriteRawError(p, stack, svcErr)
-				return
-			}
-
-			// Write binary-framed response to plugin memory:
-			// [0x00][4-byte content-type length (big-endian)][content-type string][raw data]
-			ctBytes := []byte({{lower (index .Returns 0).Name}})
-			frame := make([]byte, 1+4+len(ctBytes)+len({{lower (index .Returns 1).Name}}))
-			frame[0] = 0x00 // success
-			binary.BigEndian.PutUint32(frame[1:5], uint32(len(ctBytes)))
-			copy(frame[5:5+len(ctBytes)], ctBytes)
-			copy(frame[5+len(ctBytes):], {{lower (index .Returns 1).Name}})
-
-			respPtr, err := p.WriteBytes(frame)
-			if err != nil {
-				stack[0] = 0
-				return
-			}
-			stack[0] = respPtr
-{{- else if .HasReturns}}
+{{- if .HasReturns}}
 {{- if .HasError}}
 			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}}, svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
 			if svcErr != nil {
@@ -107,6 +72,14 @@ func new{{$.Service.Name}}{{.Name}}HostFunction(service {{$.Service.Interface}})
 {{- else}}
 			{{range $i, $r := .Returns}}{{if $i}}, {{end}}{{lower $r.Name}}{{end}} := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
 {{- end}}
+{{- else if .HasError}}
+			if svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}}); svcErr != nil {
+				{{$.Service.Name | lower}}WriteError(p, stack, svcErr)
+				return
+			}
+{{- else}}
+			service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
+{{- end}}
 
 			// Write JSON response to plugin memory
 			resp := {{responseType .}}{
@@ -115,22 +88,6 @@ func new{{$.Service.Name}}{{.Name}}HostFunction(service {{$.Service.Interface}})
 {{- end}}
 			}
 			{{$.Service.Name | lower}}WriteResponse(p, stack, resp)
-{{- else if .HasError}}
-			if svcErr := service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}}); svcErr != nil {
-				{{$.Service.Name | lower}}WriteError(p, stack, svcErr)
-				return
-			}
-
-			// Write JSON response to plugin memory
-			resp := {{responseType .}}{}
-			{{$.Service.Name | lower}}WriteResponse(p, stack, resp)
-{{- else}}
-			service.{{.Name}}(ctx{{range .Params}}, req.{{title .Name}}{{end}})
-
-			// Write JSON response to plugin memory
-			resp := {{responseType .}}{}
-			{{$.Service.Name | lower}}WriteResponse(p, stack, resp)
-{{- end}}
 		},
 		[]extism.ValueType{extism.ValueTypePTR},
 		[]extism.ValueType{extism.ValueTypePTR},
@@ -162,16 +119,3 @@ func {{.Service.Name | lower}}WriteError(p *extism.CurrentPlugin, stack []uint64
 	respPtr, _ := p.WriteBytes(respBytes)
 	stack[0] = respPtr
 }
-{{- if .Service.HasRawMethods}}
-
-// {{.Service.Name | lower}}WriteRawError writes a binary-framed error response to plugin memory.
-// Format: [0x01][UTF-8 error message]
-func {{.Service.Name | lower}}WriteRawError(p *extism.CurrentPlugin, stack []uint64, err error) {
-	errMsg := []byte(err.Error())
-	frame := make([]byte, 1+len(errMsg))
-	frame[0] = 0x01 // error
-	copy(frame[1:], errMsg)
-	respPtr, _ := p.WriteBytes(frame)
-	stack[0] = respPtr
-}
-{{- end}}

plugins/cmd/ndpgen/internal/types.go

@@ -173,16 +173,6 @@ func (s Service) HasErrors() bool {
 	return false
 }
 
-// HasRawMethods returns true if any method in the service uses raw binary framing.
-func (s Service) HasRawMethods() bool {
-	for _, m := range s.Methods {
-		if m.Raw {
-			return true
-		}
-	}
-	return false
-}
-
 // Method represents a host function method within a service.
 type Method struct {
 	Name       string  // Go method name (e.g., "Call")
@@ -191,7 +181,6 @@ type Method struct {
 	Returns    []Param // Return values (excluding error)
 	HasError   bool    // Whether the method returns an error
 	Doc        string  // Documentation comment for the method
-	Raw        bool    // If true, response uses binary framing instead of JSON
 }
 
 // FunctionName returns the Extism host function export name.
@@ -477,7 +466,9 @@ func RustDefaultValue(goType string) string {
 	switch goType {
 	case "string":
 		return `String::new()`
-	case "int", "int32", "int64", "uint", "uint32", "uint64":
+	case "int", "int32":
+		return "0"
+	case "int64":
 		return "0"
 	case "float32", "float64":
 		return "0.0"
@@ -611,10 +602,6 @@ func ToRustTypeWithStructs(goType string, knownStructs map[string]bool) string {
 		return "i32"
 	case "int64":
 		return "i64"
-	case "uint", "uint32":
-		return "u32"
-	case "uint64":
-		return "u64"
 	case "float32":
 		return "f32"
 	case "float64":

plugins/cmd/ndpgen/internal/xtp_schema.go

@@ -106,7 +106,7 @@ func buildExport(export Export) xtpExport {
 // isPrimitiveGoType returns true if the Go type is a primitive type.
 func isPrimitiveGoType(goType string) bool {
 	switch goType {
-	case "bool", "string", "int", "int32", "int64", "uint", "uint32", "uint64", "float32", "float64", "[]byte":
+	case "bool", "string", "int", "int32", "int64", "float32", "float64", "[]byte":
 		return true
 	}
 	return false
@@ -302,12 +302,6 @@ func goTypeToXTPTypeAndFormat(goType string) (typ, format string) {
 		return "integer", "int32"
 	case "int64":
 		return "integer", "int64"
-	case "uint", "uint32":
-		// XTP schema doesn't support unsigned formats; use int64 to hold full uint32 range
-		return "integer", "int64"
-	case "uint64":
-		// XTP schema doesn't support unsigned formats; use int64 (may lose precision for large values)
-		return "integer", "int64"
 	case "float32":
 		return "number", "float"
 	case "float64":

plugins/cmd/ndpgen/internal/xtp_schema_validate.go

@@ -3,11 +3,10 @@ package internal
 import (
 	_ "embed"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"strings"
 
-	"github.com/santhosh-tekuri/jsonschema/v6"
+	"github.com/xeipuuv/gojsonschema"
 	"gopkg.in/yaml.v3"
 )
 
@@ -26,61 +25,27 @@ func ValidateXTPSchema(generatedSchema []byte) error {
 		return fmt.Errorf("failed to parse generated schema as YAML: %w", err)
 	}
 
-	// Parse the XTP schema JSON
-	var xtpSchema any
-	if err := json.Unmarshal([]byte(xtpSchemaJSON), &xtpSchema); err != nil {
-		return fmt.Errorf("failed to parse XTP schema: %w", err)
-	}
-
-	// Compile the XTP schema
-	compiler := jsonschema.NewCompiler()
-	if err := compiler.AddResource("xtp-schema.json", xtpSchema); err != nil {
-		return fmt.Errorf("failed to add XTP schema resource: %w", err)
-	}
-
-	schema, err := compiler.Compile("xtp-schema.json")
+	// Convert to JSON for the validator
+	jsonBytes, err := json.Marshal(schemaDoc)
 	if err != nil {
-		return fmt.Errorf("failed to compile XTP schema: %w", err)
+		return fmt.Errorf("failed to convert schema to JSON: %w", err)
 	}
 
-	// Validate the generated schema against XTP schema
-	if err := schema.Validate(schemaDoc); err != nil {
-		return fmt.Errorf("schema validation errors:\n%s", formatValidationErrors(err))
+	schemaLoader := gojsonschema.NewStringLoader(xtpSchemaJSON)
+	documentLoader := gojsonschema.NewBytesLoader(jsonBytes)
+
+	result, err := gojsonschema.Validate(schemaLoader, documentLoader)
+	if err != nil {
+		return fmt.Errorf("schema validation failed: %w", err)
+	}
+
+	if !result.Valid() {
+		var errs []string
+		for _, desc := range result.Errors() {
+			errs = append(errs, fmt.Sprintf("- %s", desc))
+		}
+		return fmt.Errorf("schema validation errors:\n%s", strings.Join(errs, "\n"))
 	}
 
 	return nil
 }
-
-// formatValidationErrors formats jsonschema validation errors into readable strings.
-func formatValidationErrors(err error) string {
-	var validationErr *jsonschema.ValidationError
-	if !errors.As(err, &validationErr) {
-		return fmt.Sprintf("- %s", err.Error())
-	}
-
-	var errs []string
-	collectValidationErrors(validationErr, &errs)
-
-	if len(errs) == 0 {
-		return fmt.Sprintf("- %s", validationErr.Error())
-	}
-	return strings.Join(errs, "\n")
-}
-
-// collectValidationErrors recursively collects leaf validation errors.
-func collectValidationErrors(err *jsonschema.ValidationError, errs *[]string) {
-	if len(err.Causes) > 0 {
-		for _, cause := range err.Causes {
-			collectValidationErrors(cause, errs)
-		}
-		return
-	}
-
-	// Leaf error - format with location if available
-	msg := err.Error()
-	if len(err.InstanceLocation) > 0 {
-		location := strings.Join(err.InstanceLocation, "/")
-		msg = fmt.Sprintf("%s: %s", location, msg)
-	}
-	*errs = append(*errs, fmt.Sprintf("- %s", msg))
-}

plugins/cmd/ndpgen/testdata/raw_client_expected.go.txt

@@ -1,66 +0,0 @@
-// Code generated by ndpgen. DO NOT EDIT.
-//
-// This file contains client wrappers for the Stream host service.
-// It is intended for use in Navidrome plugins built with TinyGo.
-//
-//go:build wasip1
-
-package ndpdk
-
-import (
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-
-	"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
-)
-
-// stream_getstream is the host function provided by Navidrome.
-//
-//go:wasmimport extism:host/user stream_getstream
-func stream_getstream(uint64) uint64
-
-type streamGetStreamRequest struct {
-	Uri string `json:"uri"`
-}
-
-// StreamGetStream calls the stream_getstream host function.
-// GetStream returns raw binary stream data with content type.
-func StreamGetStream(uri string) (string, []byte, error) {
-	// Marshal request to JSON
-	req := streamGetStreamRequest{
-		Uri: uri,
-	}
-	reqBytes, err := json.Marshal(req)
-	if err != nil {
-		return "", nil, err
-	}
-	reqMem := pdk.AllocateBytes(reqBytes)
-	defer reqMem.Free()
-
-	// Call the host function
-	responsePtr := stream_getstream(reqMem.Offset())
-
-	// Read the response from memory
-	responseMem := pdk.FindMemory(responsePtr)
-	responseBytes := responseMem.ReadBytes()
-
-	// Parse binary-framed response
-	if len(responseBytes) == 0 {
-		return "", nil, errors.New("empty response from host")
-	}
-	if responseBytes[0] == 0x01 { // error
-		return "", nil, errors.New(string(responseBytes[1:]))
-	}
-	if responseBytes[0] != 0x00 {
-		return "", nil, errors.New("unknown response status")
-	}
-	if len(responseBytes) < 5 {
-		return "", nil, errors.New("malformed raw response: incomplete header")
-	}
-	ctLen := binary.BigEndian.Uint32(responseBytes[1:5])
-	if uint32(len(responseBytes)) < 5+ctLen {
-		return "", nil, errors.New("malformed raw response: content-type overflow")
-	}
-	return string(responseBytes[5 : 5+ctLen]), responseBytes[5+ctLen:], nil
-}

plugins/cmd/ndpgen/testdata/raw_client_expected.py

@@ -1,63 +0,0 @@
-# Code generated by ndpgen. DO NOT EDIT.
-#
-# This file contains client wrappers for the Stream host service.
-# It is intended for use in Navidrome plugins built with extism-py.
-#
-# IMPORTANT: Due to a limitation in extism-py, you cannot import this file directly.
-# The @extism.import_fn decorators are only detected when defined in the plugin's
-# main __init__.py file. Copy the needed functions from this file into your plugin.
-
-from dataclasses import dataclass
-from typing import Any, Tuple
-
-import extism
-import json
-import struct
-
-
-class HostFunctionError(Exception):
-    """Raised when a host function returns an error."""
-    pass
-
-
-@extism.import_fn("extism:host/user", "stream_getstream")
-def _stream_getstream(offset: int) -> int:
-    """Raw host function - do not call directly."""
-    ...
-
-
-def stream_get_stream(uri: str) -> Tuple[str, bytes]:
-    """GetStream returns raw binary stream data with content type.
-
-    Args:
-        uri: str parameter.
-
-    Returns:
-        Tuple of (content_type, data) with the raw binary response.
-
-    Raises:
-        HostFunctionError: If the host function returns an error.
-    """
-    request = {
-        "uri": uri,
-    }
-    request_bytes = json.dumps(request).encode("utf-8")
-    request_mem = extism.memory.alloc(request_bytes)
-    response_offset = _stream_getstream(request_mem.offset)
-    response_mem = extism.memory.find(response_offset)
-    response_bytes = response_mem.bytes()
-
-    if len(response_bytes) == 0:
-        raise HostFunctionError("empty response from host")
-    if response_bytes[0] == 0x01:
-        raise HostFunctionError(response_bytes[1:].decode("utf-8"))
-    if response_bytes[0] != 0x00:
-        raise HostFunctionError("unknown response status")
-    if len(response_bytes) < 5:
-        raise HostFunctionError("malformed raw response: incomplete header")
-    ct_len = struct.unpack(">I", response_bytes[1:5])[0]
-    if len(response_bytes) < 5 + ct_len:
-        raise HostFunctionError("malformed raw response: content-type overflow")
-    content_type = response_bytes[5:5 + ct_len].decode("utf-8")
-    data = response_bytes[5 + ct_len:]
-    return content_type, data

plugins/cmd/ndpgen/testdata/raw_client_expected.rs

@@ -1,73 +0,0 @@
-// Code generated by ndpgen. DO NOT EDIT.
-//
-// This file contains client wrappers for the Stream host service.
-// It is intended for use in Navidrome plugins built with extism-pdk.
-
-use extism_pdk::*;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-struct StreamGetStreamRequest {
-    uri: String,
-}
-
-#[host_fn]
-extern "ExtismHost" {
-}
-
-#[link(wasm_import_module = "extism:host/user")]
-extern "C" {
-    fn stream_getstream(offset: u64) -> u64;
-}
-
-/// GetStream returns raw binary stream data with content type.
-///
-/// # Arguments
-/// * `uri` - String parameter.
-///
-/// # Returns
-/// A tuple of (content_type, data) with the raw binary response.
-///
-/// # Errors
-/// Returns an error if the host function call fails.
-pub fn get_stream(uri: &str) -> Result<(String, Vec<u8>), Error> {
-    let req = StreamGetStreamRequest {
-        uri: uri.to_owned(),
-    };
-    let input_bytes = serde_json::to_vec(&req).map_err(|e| Error::msg(e.to_string()))?;
-    let input_mem = Memory::from_bytes(&input_bytes).map_err(|e| Error::msg(e.to_string()))?;
-
-    let response_offset = unsafe { stream_getstream(input_mem.offset()) };
-
-    let response_mem = Memory::find(response_offset)
-        .ok_or_else(|| Error::msg("empty response from host"))?;
-    let response_bytes = response_mem.to_vec();
-
-    if response_bytes.is_empty() {
-        return Err(Error::msg("empty response from host"));
-    }
-    if response_bytes[0] == 0x01 {
-        let msg = String::from_utf8_lossy(&response_bytes[1..]).to_string();
-        return Err(Error::msg(msg));
-    }
-    if response_bytes[0] != 0x00 {
-        return Err(Error::msg("unknown response status"));
-    }
-    if response_bytes.len() < 5 {
-        return Err(Error::msg("malformed raw response: incomplete header"));
-    }
-    let ct_len = u32::from_be_bytes([
-        response_bytes[1],
-        response_bytes[2],
-        response_bytes[3],
-        response_bytes[4],
-    ]) as usize;
-    if ct_len > response_bytes.len() - 5 {
-        return Err(Error::msg("malformed raw response: content-type overflow"));
-    }
-    let ct_end = 5 + ct_len;
-    let content_type = String::from_utf8_lossy(&response_bytes[5..ct_end]).to_string();
-    let data = response_bytes[ct_end..].to_vec();
-    Ok((content_type, data))
-}

plugins/cmd/ndpgen/testdata/raw_service.go.txt

@@ -1,10 +0,0 @@
-package testpkg
-
-import "context"
-
-//nd:hostservice name=Stream permission=stream
-type StreamService interface {
-	// GetStream returns raw binary stream data with content type.
-	//nd:hostfunc raw=true
-	GetStream(ctx context.Context, uri string) (contentType string, data []byte, err error)
-}

plugins/config_validation.go

@@ -1,129 +0,0 @@
-package plugins
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/santhosh-tekuri/jsonschema/v6"
-)
-
-// ConfigValidationError represents a validation error with field path and message.
-type ConfigValidationError struct {
-	Field   string `json:"field"`
-	Message string `json:"message"`
-}
-
-// ConfigValidationErrors is a collection of validation errors.
-type ConfigValidationErrors struct {
-	Errors []ConfigValidationError `json:"errors"`
-}
-
-func (e *ConfigValidationErrors) Error() string {
-	if len(e.Errors) == 0 {
-		return "validation failed"
-	}
-	var msgs []string
-	for _, err := range e.Errors {
-		if err.Field != "" {
-			msgs = append(msgs, fmt.Sprintf("%s: %s", err.Field, err.Message))
-		} else {
-			msgs = append(msgs, err.Message)
-		}
-	}
-	return strings.Join(msgs, "; ")
-}
-
-// ValidateConfig validates a config JSON string against a plugin's config schema.
-// If the manifest has no config schema, it returns an error indicating the plugin
-// has no configurable options.
-// Returns nil if validation passes, ConfigValidationErrors if validation fails.
-func ValidateConfig(manifest *Manifest, configJSON string) error {
-	// If no config schema defined, plugin has no configurable options
-	if !manifest.HasConfigSchema() {
-		return fmt.Errorf("plugin has no configurable options")
-	}
-
-	// Parse the config JSON (empty string treated as empty object)
-	var configData any
-	if configJSON == "" {
-		configData = map[string]any{}
-	} else {
-		if err := json.Unmarshal([]byte(configJSON), &configData); err != nil {
-			return &ConfigValidationErrors{
-				Errors: []ConfigValidationError{{
-					Message: fmt.Sprintf("invalid JSON: %v", err),
-				}},
-			}
-		}
-	}
-
-	// Compile the schema
-	compiler := jsonschema.NewCompiler()
-	if err := compiler.AddResource("schema.json", manifest.Config.Schema); err != nil {
-		return fmt.Errorf("adding schema resource: %w", err)
-	}
-
-	schema, err := compiler.Compile("schema.json")
-	if err != nil {
-		return fmt.Errorf("compiling schema: %w", err)
-	}
-
-	// Validate config against schema
-	if err := schema.Validate(configData); err != nil {
-		return convertValidationError(err)
-	}
-
-	return nil
-}
-
-// convertValidationError converts jsonschema validation errors to our format.
-func convertValidationError(err error) *ConfigValidationErrors {
-	var validationErr *jsonschema.ValidationError
-	if !errors.As(err, &validationErr) {
-		return &ConfigValidationErrors{
-			Errors: []ConfigValidationError{{
-				Message: err.Error(),
-			}},
-		}
-	}
-
-	var configErrors []ConfigValidationError
-	collectErrors(validationErr, &configErrors)
-
-	if len(configErrors) == 0 {
-		configErrors = append(configErrors, ConfigValidationError{
-			Message: validationErr.Error(),
-		})
-	}
-
-	return &ConfigValidationErrors{Errors: configErrors}
-}
-
-// collectErrors recursively collects validation errors from the error tree.
-func collectErrors(err *jsonschema.ValidationError, errors *[]ConfigValidationError) {
-	// If there are child errors, collect from them
-	if len(err.Causes) > 0 {
-		for _, cause := range err.Causes {
-			collectErrors(cause, errors)
-		}
-		return
-	}
-
-	// Leaf error - add it
-	field := ""
-	if len(err.InstanceLocation) > 0 {
-		field = strings.Join(err.InstanceLocation, "/")
-	}
-
-	*errors = append(*errors, ConfigValidationError{
-		Field:   field,
-		Message: err.Error(),
-	})
-}
-
-// HasConfigSchema returns true if the manifest defines a config schema.
-func (m *Manifest) HasConfigSchema() bool {
-	return m.Config != nil && m.Config.Schema != nil
-}

plugins/config_validation_test.go

@@ -1,186 +0,0 @@
-//go:build !windows
-
-package plugins
-
-import (
-	"errors"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Config Validation", func() {
-	Describe("ValidateConfig", func() {
-		Context("when manifest has no config schema", func() {
-			It("returns an error", func() {
-				manifest := &Manifest{
-					Name:    "test",
-					Author:  "test",
-					Version: "1.0.0",
-				}
-				err := ValidateConfig(manifest, `{"key": "value"}`)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("no configurable options"))
-			})
-		})
-
-		Context("when manifest has config schema", func() {
-			var manifest *Manifest
-
-			BeforeEach(func() {
-				manifest = &Manifest{
-					Name:    "test",
-					Author:  "test",
-					Version: "1.0.0",
-					Config: &ConfigDefinition{
-						Schema: map[string]any{
-							"type": "object",
-							"properties": map[string]any{
-								"apiKey": map[string]any{
-									"type":        "string",
-									"description": "API key for the service",
-									"minLength":   float64(1),
-								},
-								"timeout": map[string]any{
-									"type":    "integer",
-									"minimum": float64(1),
-									"maximum": float64(300),
-								},
-								"enabled": map[string]any{
-									"type": "boolean",
-								},
-							},
-							"required": []any{"apiKey"},
-						},
-					},
-				}
-			})
-
-			It("accepts valid config", func() {
-				err := ValidateConfig(manifest, `{"apiKey": "secret123", "timeout": 30}`)
-				Expect(err).ToNot(HaveOccurred())
-			})
-
-			It("rejects empty config when required fields are missing", func() {
-				err := ValidateConfig(manifest, "")
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("apiKey"))
-
-				err = ValidateConfig(manifest, "{}")
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("apiKey"))
-			})
-
-			It("rejects config missing required field", func() {
-				err := ValidateConfig(manifest, `{"timeout": 30}`)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("apiKey"))
-			})
-
-			It("rejects config with wrong type", func() {
-				err := ValidateConfig(manifest, `{"apiKey": "secret", "timeout": "not a number"}`)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("timeout"))
-			})
-
-			It("rejects config with value out of range", func() {
-				err := ValidateConfig(manifest, `{"apiKey": "secret", "timeout": 500}`)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("timeout"))
-			})
-
-			It("rejects config with empty required string", func() {
-				err := ValidateConfig(manifest, `{"apiKey": ""}`)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("apiKey"))
-			})
-
-			It("rejects invalid JSON", func() {
-				err := ValidateConfig(manifest, `{invalid json}`)
-				Expect(err).To(HaveOccurred())
-				var validationErr *ConfigValidationErrors
-				Expect(errors.As(err, &validationErr)).To(BeTrue())
-				Expect(validationErr.Errors[0].Message).To(ContainSubstring("invalid JSON"))
-			})
-		})
-
-		Context("with enum values", func() {
-			It("accepts valid enum value", func() {
-				manifest := &Manifest{
-					Name:    "test",
-					Author:  "test",
-					Version: "1.0.0",
-					Config: &ConfigDefinition{
-						Schema: map[string]any{
-							"type": "object",
-							"properties": map[string]any{
-								"logLevel": map[string]any{
-									"type": "string",
-									"enum": []any{"debug", "info", "warn", "error"},
-								},
-							},
-						},
-					},
-				}
-				err := ValidateConfig(manifest, `{"logLevel": "info"}`)
-				Expect(err).ToNot(HaveOccurred())
-			})
-
-			It("rejects invalid enum value", func() {
-				manifest := &Manifest{
-					Name:    "test",
-					Author:  "test",
-					Version: "1.0.0",
-					Config: &ConfigDefinition{
-						Schema: map[string]any{
-							"type": "object",
-							"properties": map[string]any{
-								"logLevel": map[string]any{
-									"type": "string",
-									"enum": []any{"debug", "info", "warn", "error"},
-								},
-							},
-						},
-					},
-				}
-				err := ValidateConfig(manifest, `{"logLevel": "verbose"}`)
-				Expect(err).To(HaveOccurred())
-			})
-		})
-	})
-
-	Describe("HasConfigSchema", func() {
-		It("returns false when config is nil", func() {
-			manifest := &Manifest{
-				Name:    "test",
-				Author:  "test",
-				Version: "1.0.0",
-			}
-			Expect(manifest.HasConfigSchema()).To(BeFalse())
-		})
-
-		It("returns false when schema is nil", func() {
-			manifest := &Manifest{
-				Name:    "test",
-				Author:  "test",
-				Version: "1.0.0",
-				Config:  &ConfigDefinition{},
-			}
-			Expect(manifest.HasConfigSchema()).To(BeFalse())
-		})
-
-		It("returns true when schema is present", func() {
-			manifest := &Manifest{
-				Name:    "test",
-				Author:  "test",
-				Version: "1.0.0",
-				Config: &ConfigDefinition{
-					Schema: map[string]any{
-						"type": "object",
-					},
-				},
-			}
-			Expect(manifest.HasConfigSchema()).To(BeTrue())
-		})
-	})
-})

plugins/examples/README.md

@@ -9,6 +9,7 @@ This folder contains example plugins demonstrating various capabilities and lang
 | [minimal](minimal/)                                   | Go       | MetadataAgent                                   | Basic plugin structure         |
 | [wikimedia](wikimedia/)                               | Go       | MetadataAgent                                   | Wikidata/Wikipedia metadata    |
 | [crypto-ticker](crypto-ticker/)                       | Go       | Scheduler, WebSocket, Cache                     | Real-time crypto prices (demo) |
+| [discord-rich-presence](discord-rich-presence/)       | Go       | Scrobbler, Scheduler, WebSocket, Cache, Artwork | Discord integration            |
 | [coverartarchive-py](coverartarchive-py/)             | Python   | MetadataAgent                                   | Cover Art Archive              |
 | [nowplaying-py](nowplaying-py/)                       | Python   | Scheduler, SubsonicAPI                          | Now playing logger             |
 | [webhook-rs](webhook-rs/)                             | Rust     | Scrobbler                                       | HTTP webhook on scrobble       |
@@ -36,7 +37,7 @@ This creates `.ndp` package files for each plugin.
 ```bash
 make minimal.ndp
 make wikimedia.ndp
-make discord-rich-presence-rs.ndp
+make discord-rich-presence.ndp
 ```
 
 ### Clean