Skip to content

🎧 Your Personal Streaming Service

feat(matcher): match similar/top songs by multiple artists (#5668)

Deluan Quintão7b7721f00283
diff --git a/core/agents/interfaces.go b/core/agents/interfaces.go
index 19df91d02..1fe8c2a23 100644
--- a/core/agents/interfaces.go
+++ b/core/agents/interfaces.go
@@ -4,6 +4,7 @@ import (
"context"
"errors"
+ "github.com/gohugoio/hashstructure"
"github.com/navidrome/navidrome/model"
)
@@ -39,11 +40,31 @@ type Song struct {
ISRC string
Artist string
ArtistMBID string
+ Artists []Artist // optional full artist list; ArtistList normalizes against Artist/ArtistMBID
Album string
AlbumMBID string
Duration uint32 // Duration in milliseconds, 0 means unknown
}
+// Equals reports strict whole-value equality, used to dedup identical input songs. It hashes
+// rather than comparing with ==, which the Artists slice makes illegal.
+func (s Song) Equals(other Song) bool {
+ h1, _ := hashstructure.Hash(s, nil)
+ h2, _ := hashstructure.Hash(other, nil)
+ return h1 == h2
+}
+
+// ArtistList normalizes the single/multi-artist representations so callers never branch on len(Artists).
+func (s Song) ArtistList() []Artist {
+ if len(s.Artists) > 0 {
+ return s.Artists
+ }
+ if s.Artist != "" {
+ return []Artist{{Name: s.Artist, MBID: s.ArtistMBID}}
+ }
+ return nil
+}
+
var (
ErrNotFound = errors.New("not found")
)
diff --git a/core/agents/interfaces_test.go b/core/agents/interfaces_test.go
new file mode 100644
index 000000000..46bd2f93b
--- /dev/null
+++ b/core/agents/interfaces_test.go
@@ -0,0 +1,47 @@
+package agents
+
+import (
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("Song.Equals", func() {
+ base := Song{ID: "1", Name: "S", Artist: "A", Artists: []Artist{{ID: "x", Name: "A"}}}
+ It("true for identical songs incl Artists", func() {
+ Expect(base.Equals(base)).To(BeTrue())
+ })
+ It("false when Artists differ", func() {
+ other := base
+ other.Artists = []Artist{{ID: "y", Name: "B"}}
+ Expect(base.Equals(other)).To(BeFalse())
+ })
+ It("false when a scalar differs", func() {
+ other := base
+ other.Name = "T"
+ Expect(base.Equals(other)).To(BeFalse())
+ })
+ It("true when both have empty Artists and equal scalars", func() {
+ a := Song{ID: "1", Name: "S", Artist: "A"}
+ Expect(a.Equals(a)).To(BeTrue())
+ })
+})
+
+var _ = Describe("Song.ArtistList", func() {
+ It("returns the Artists slice when present", func() {
+ s := Song{Artist: "Primary", ArtistMBID: "mbid-primary", Artists: []Artist{
+ {ID: "id-drake", Name: "Drake", MBID: "mbid-drake"},
+ {Name: "Future", MBID: "mbid-future"},
+ }}
+ Expect(s.ArtistList()).To(Equal([]Artist{
+ {ID: "id-drake", Name: "Drake", MBID: "mbid-drake"},
+ {Name: "Future", MBID: "mbid-future"},
+ }))
+ })
+ It("falls back to the single Artist field with empty ID", func() {
+ s := Song{Artist: "Drake", ArtistMBID: "mbid-drake"}
+ Expect(s.ArtistList()).To(Equal([]Artist{{Name: "Drake", MBID: "mbid-drake"}}))
+ })
+ It("returns empty when no artist is set", func() {
+ Expect(Song{}.ArtistList()).To(BeEmpty())
+ })
+})
diff --git a/core/matcher/doc.go b/core/matcher/doc.go
index cff866799..1024bc274 100644
--- a/core/matcher/doc.go
+++ b/core/matcher/doc.go
@@ -39,25 +39,40 @@
// 1. Title similarity (Jaro-Winkler score, 0.0–1.0)
// 2. Duration proximity (closer duration scores higher; 1.0 when the agent
// reports no duration)
-// 3. Preferred-track flag (enabled by conf.Server.Matcher.PreferStarred;
-// prioritizes tracks that are starred or rated >= 4)
-// 4. Specificity level (0–5, based on metadata precision; higher is better)
-// 5. Album similarity (Jaro-Winkler, as the final tiebreaker)
+// 3. Specificity level (0–5, based on metadata precision; higher is better)
+// 4. Artist overlap (how many of the song's artists the track credits; more
+// shared artists is better)
+// 5. Preferred-track flag (enabled by conf.Server.Matcher.PreferStarred;
+// prioritizes tracks that are starred or rated >= 4, but only among
+// candidates of equal specificity and overlap)
+// 6. Album similarity (Jaro-Winkler, as the final tiebreaker)
//
// The specificity levels, from most to least specific, are:
//
-// Level 5: Title + Artist MBID + Album MBID
-// Level 4: Title + Artist MBID + Album name (fuzzy)
+// Level 5: Title + Artist identity + Album MBID
+// Level 4: Title + Artist identity + Album name (fuzzy)
// Level 3: Title + Artist name + Album name (fuzzy)
-// Level 2: Title + Artist MBID
+// Level 2: Title + Artist identity
// Level 1: Title + Artist name
// Level 0: Title only
//
+// "Artist identity" is a match on the artist's Navidrome ID (the strongest signal,
+// when a source supplies one) or its MBID. A plain name match is the weaker fallback
+// used for an artist with no identity match (e.g. a cover credited to a different
+// artist of the same name).
+//
// The title phase always requires an agent artist to scope the library query, so
// Level 0 does not mean "no artist": it applies when a candidate matches on title
// but its own artist differs from the query's (e.g. a cover or a featured-artist
// credit), leaving the title as the only shared field.
//
+// A song may carry several artists, and the title phase scopes candidate tracks by
+// ANY of them: a track credited to at least one shared artist is considered. When a
+// source supplies a Navidrome artist ID, that artist is matched directly, skipping
+// name/MBID resolution. Among equally specific candidates, the one sharing more of
+// the song's artists wins, so a track crediting every collaborator outranks one
+// crediting only a single artist.
+//
// Each input song is scored independently, so two songs with the same title and
// artist but different durations can resolve to different library tracks (each
// matches the track closest to its own duration).
@@ -97,12 +112,13 @@
// Result: studio for the first song, live for the second
//
// Preferred track — when conf.Server.Matcher.PreferStarred is enabled, a
-// starred (or rating >= 4) track is preferred even over a more specific match,
-// because the preferred flag outranks specificity:
+// starred (or rating >= 4) track is preferred, but only when specificity and
+// artist overlap are equal. A more specific match always wins regardless of the
+// preferred flag:
//
// Agent returns: {Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"}
// Library has:
// {ID: "exact", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"} // Level 3
// {ID: "starred", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Singles", Starred: true} // Level 1, starred
-// Result: starred (the preferred flag outranks the better album match)
+// Result: exact (specificity outranks the starred flag; preferred only breaks ties of equal identity)
package matcher
diff --git a/core/matcher/matcher.go b/core/matcher/matcher.go
index 5322b649f..d472f4a95 100644
--- a/core/matcher/matcher.go
+++ b/core/matcher/matcher.go
@@ -209,11 +209,18 @@ func (m *Matcher) matchByISRC(ctx context.Context, songs []agents.Song, result m
return nil
}
+// queryArtist is one of a song's artists. A non-empty id is matched directly, skipping name/MBID
+// resolution; name is pre-sanitized (article-stripped).
+type queryArtist struct {
+ id string
+ name string
+ mbid string
+}
+
// songQuery represents a normalized query for matching a song to library tracks.
type songQuery struct {
title string
- artist string
- artistMBID string
+ artists []queryArtist
album string
albumMBID string
durationMs uint32
@@ -224,11 +231,13 @@ type matchScore struct {
titleSimilarity float64
durationProximity float64
preferredMatch bool
- albumSimilarity float64
specificityLevel int
+ artistOverlap int
+ albumSimilarity float64
}
// betterThan returns true if this score beats another.
+// Identity signals (specificity, overlap) outrank the taste signal (preferred).
func (s matchScore) betterThan(other matchScore) bool {
if s.titleSimilarity != other.titleSimilarity {
return s.titleSimilarity > other.titleSimilarity
@@ -236,12 +245,15 @@ func (s matchScore) betterThan(other matchScore) bool {
if s.durationProximity != other.durationProximity {
return s.durationProximity > other.durationProximity
}
- if s.preferredMatch != other.preferredMatch {
- return s.preferredMatch
- }
if s.specificityLevel != other.specificityLevel {
return s.specificityLevel > other.specificityLevel
}
+ if s.artistOverlap != other.artistOverlap {
+ return s.artistOverlap > other.artistOverlap
+ }
+ if s.preferredMatch != other.preferredMatch {
+ return s.preferredMatch
+ }
return s.albumSimilarity > other.albumSimilarity
}
@@ -249,46 +261,57 @@ func (s matchScore) betterThan(other matchScore) bool {
// when the same track is scored against multiple queries. The `mf` field is a pointer to avoid
// copying the large MediaFile struct into each entry of the sanitized slice.
type sanitizedTrack struct {
- mf *model.MediaFile
- title string
- artist string
- album string
- artistMBID string // resolved from the artist table; mf.MbzArtistID is not populated on the bulk path
+ mf *model.MediaFile
+ title string
+ artist string
+ album string
+ artistIDs map[string]struct{} // query's owned artist IDs this track credits; an ID match is the strongest identity signal
+ artistMBIDs map[string]struct{} // MBIDs of those artists (artist table; mf.MbzArtistID is not populated on the bulk path)
}
-func newSanitizedTrack(mf *model.MediaFile, artistMBID string) sanitizedTrack {
+func newSanitizedTrack(mf *model.MediaFile, artistIDs, artistMBIDs map[string]struct{}) sanitizedTrack {
return sanitizedTrack{
- mf: mf,
- title: str.SanitizeFieldForSorting(mf.Title),
- artist: str.SanitizeFieldForSortingNoArticle(mf.Artist),
- album: str.SanitizeFieldForSorting(mf.Album),
- artistMBID: artistMBID,
+ mf: mf,
+ title: str.SanitizeFieldForSorting(mf.Title),
+ artist: str.SanitizeFieldForSortingNoArticle(mf.Artist),
+ album: str.SanitizeFieldForSorting(mf.Album),
+ artistIDs: artistIDs,
+ artistMBIDs: artistMBIDs,
}
}
-// computeSpecificityLevel determines how well query metadata matches a track (0-5).
-// The track's title, artist, and album fields must be pre-sanitized, and artistMBID
-// must hold the resolved artist MBID.
+// computeSpecificityLevel determines how well query metadata matches a track (0-5), taking the best
+// level achievable across any of the query's artists. Fields must be pre-sanitized.
+//
+// A query artist counts as an identity match when the track credits its resolved Navidrome ID (the
+// strongest signal, our own primary key) or its MBID; that identity then unlocks the album tiers.
+// Name matching is the lowest fallback for an artist with no identity match (e.g. a cover credited
+// to a different artist by the same name).
func computeSpecificityLevel(q songQuery, t sanitizedTrack, albumThreshold float64) int {
- if q.artistMBID != "" && q.albumMBID != "" &&
- t.artistMBID == q.artistMBID && t.mf.MbzAlbumID == q.albumMBID {
- return 5
- }
- if q.artistMBID != "" && q.album != "" &&
- t.artistMBID == q.artistMBID && similarityRatio(t.album, q.album) >= albumThreshold {
- return 4
- }
- if q.artist != "" && q.album != "" &&
- t.artist == q.artist && similarityRatio(t.album, q.album) >= albumThreshold {
- return 3
- }
- if q.artistMBID != "" && t.artistMBID == q.artistMBID {
- return 2
- }
- if q.artist != "" && t.artist == q.artist {
- return 1
+ best := 0
+ albumOK := q.album != "" && similarityRatio(t.album, q.album) >= albumThreshold
+ for _, a := range q.artists {
+ _, idMember := t.artistIDs[a.id]
+ _, mbidMember := t.artistMBIDs[a.mbid]
+ identity := (a.id != "" && idMember) || (a.mbid != "" && mbidMember)
+ level := 0
+ switch {
+ case identity && q.albumMBID != "" && t.mf.MbzAlbumID == q.albumMBID:
+ level = 5
+ case identity && q.album != "" && albumOK:
+ level = 4
+ case a.name != "" && q.album != "" && t.artist == a.name && albumOK:
+ level = 3
+ case identity:
+ level = 2
+ case a.name != "" && t.artist == a.name:
+ level = 1
+ }
+ if level > best {
+ best = level
+ }
}
- return 0
+ return best
}
// indexedQuery pairs a normalized songQuery with the index of the input song
@@ -301,12 +324,12 @@ type indexedQuery struct {
// matchByTitle fills result with fuzzy title+artist matches, skipping songs
// already matched by a higher-priority loader.
func (m *Matcher) matchByTitle(ctx context.Context, songs []agents.Song, result map[int]model.MediaFile) error {
- byArtist := groupQueriesByArtist(songs, result)
- if len(byArtist) == 0 {
+ queries := groupQueries(songs, result)
+ if len(queries) == 0 {
return nil
}
- resolved, err := m.resolveArtists(ctx, byArtist)
+ resolved, err := m.resolveArtists(ctx, queries)
if err != nil || len(resolved.allIDs) == 0 {
return err
}
@@ -318,137 +341,192 @@ func (m *Matcher) matchByTitle(ctx context.Context, songs []agents.Song, result
tracksByQuery := resolved.bucketTracks(tracks)
threshold := float64(conf.Server.Matcher.FuzzyThreshold) / 100.0
- for artist, queries := range byArtist {
- sanitized := tracksByQuery[artist]
- // Each song is matched independently by index, so two songs with the same
- // (title, artist) but different durations can resolve to different tracks.
- for _, iq := range queries {
- if mf, found := m.findBestMatch(iq.query, sanitized, threshold); found {
- result[iq.index] = mf
- }
+ for _, iq := range queries {
+ sanitized := tracksByQuery[iq.index]
+ if mf, found := m.findBestMatch(iq.query, sanitized, threshold); found {
+ result[iq.index] = mf
}
}
return nil
}
-// groupQueriesByArtist buckets the still-unmatched title queries by sanitized artist name.
-// Songs without an artist are skipped: title matching needs one to scope the library query.
-func groupQueriesByArtist(songs []agents.Song, result map[int]model.MediaFile) map[string][]indexedQuery {
- byArtist := map[string][]indexedQuery{}
+// groupQueries builds one normalized title query per still-unmatched song, carrying its full
+// artist set. An artist is usable if it carries a Navidrome ID or a non-empty sanitized name;
+// songs with no usable artist are skipped (the title phase needs at least one to scope the query).
+func groupQueries(songs []agents.Song, result map[int]model.MediaFile) []indexedQuery {
+ var queries []indexedQuery
for i, s := range songs {
if _, done := result[i]; done {
continue
}
- artist := str.SanitizeFieldForSortingNoArticle(s.Artist)
- if artist == "" {
+ var artists []queryArtist
+ for _, a := range s.ArtistList() {
+ name := str.SanitizeFieldForSortingNoArticle(a.Name)
+ if a.ID == "" && name == "" {
+ continue
+ }
+ artists = append(artists, queryArtist{id: a.ID, name: name, mbid: a.MBID})
+ }
+ if len(artists) == 0 {
continue
}
- byArtist[artist] = append(byArtist[artist], indexedQuery{index: i, query: songQuery{
+ queries = append(queries, indexedQuery{index: i, query: songQuery{
title: str.SanitizeFieldForSorting(s.Name),
- artist: artist,
- artistMBID: s.ArtistMBID,
+ artists: artists,
album: str.SanitizeFieldForSorting(s.Album),
albumMBID: s.AlbumMBID,
durationMs: s.Duration,
}})
}
- return byArtist
+ return queries
}
-// resolvedArtists holds the agent artists resolved to artist-table rows. Everything routes by
-// stable artist ID, never by name, so MBID-resolved artists whose order name differs from the
-// query name are not misrouted.
+// resolvedArtists holds the agent artists resolved to artist-table rows, keyed by the query index
+// that owns them. Routing is always by stable artist ID, never by name.
type resolvedArtists struct {
- byQuery map[string]map[string]struct{} // sanitized query name -> set of resolved artist IDs
- mbid map[string]string // artist ID -> its MBID (the real one, from the artist table)
- allIDs []string // every resolved artist ID, for the track lookup
+ byQuery map[int]map[string]struct{} // query index -> set of resolved artist IDs
+ mbid map[string]string // artist ID -> its MBID (from the artist table)
+ allIDs []string // every resolved artist ID, for the track lookup
}
-// resolveArtists resolves the queries' artists against the artist table (by sort name or
-// agent-provided MBID) and records, for each query, which artist IDs it owns.
-func (m *Matcher) resolveArtists(ctx context.Context, byArtist map[string][]indexedQuery) (resolvedArtists, error) {
- names := make([]string, 0, len(byArtist))
- mbidToQueries := make(map[string][]string, len(byArtist)) // agent ArtistMBID -> query names that supplied it
- for name, queries := range byArtist {
- names = append(names, name)
- for _, iq := range queries {
- if iq.query.artistMBID != "" {
- mbidToQueries[iq.query.artistMBID] = append(mbidToQueries[iq.query.artistMBID], name)
+// resolveArtists resolves every artist of every query to artist-table rows. Artists that carry a
+// Navidrome ID are owned directly (no name/MBID lookup). The remaining names/MBIDs are resolved in
+// one batched query. Ownership is recorded per query index.
+func (m *Matcher) resolveArtists(ctx context.Context, queries []indexedQuery) (resolvedArtists, error) {
+ res := resolvedArtists{
+ byQuery: make(map[int]map[string]struct{}, len(queries)),
+ mbid: make(map[string]string),
+ }
+ allIDs := map[string]struct{}{} // de-dupe across fast-path + resolved
+
+ // One pending entry per non-ID artist (carrying the query that owns it). ID-bearing artists
+ // take the fast-path and are owned directly.
+ type pendingArtist struct {
+ name, mbid string
+ query int
+ }
+ var pending []pendingArtist
+ for _, iq := range queries {
+ for _, a := range iq.query.artists {
+ if a.id != "" {
+ addToSet(res.byQuery, iq.index, a.id) // ID fast-path: own directly
+ allIDs[a.id] = struct{}{}
+ continue
}
+ pending = append(pending, pendingArtist{name: a.name, mbid: a.mbid, query: iq.index})
+ }
+ }
+ // query indices that supplied each order name / each MBID (skip the empty key — an artist may
+ // have only one of name/mbid).
+ nameToQueries := map[string][]int{}
+ mbidToQueries := map[string][]int{}
+ for _, p := range pending {
+ if p.name != "" {
+ nameToQueries[p.name] = append(nameToQueries[p.name], p.query)
+ }
+ if p.mbid != "" {
+ mbidToQueries[p.mbid] = append(mbidToQueries[p.mbid], p.query)
}
}
- filter := squirrel.Or{squirrel.Eq{"order_artist_name": names}}
+ // Query the artist table for name/MBID artists AND for the fast-path IDs (so their MBIDs are
+ // available for specificity scoring).
+ var filter squirrel.Or
+ if len(nameToQueries) > 0 {
+ filter = append(filter, squirrel.Eq{"order_artist_name": slices.Collect(maps.Keys(nameToQueries))})
+ }
if len(mbidToQueries) > 0 {
filter = append(filter, squirrel.Eq{"mbz_artist_id": slices.Collect(maps.Keys(mbidToQueries))})
}
- artists, err := m.ds.Artist(ctx).GetAll(model.QueryOptions{Filters: filter})
- if err != nil {
- return resolvedArtists{}, err
+ if len(allIDs) > 0 {
+ filter = append(filter, squirrel.Eq{"id": slices.Collect(maps.Keys(allIDs))})
}
-
- res := resolvedArtists{
- byQuery: make(map[string]map[string]struct{}, len(byArtist)),
- mbid: make(map[string]string, len(artists)),
- allIDs: make([]string, 0, len(artists)),
- }
- for _, a := range artists {
- res.mbid[a.ID] = a.MbzArtistID
- res.allIDs = append(res.allIDs, a.ID)
- // An artist belongs to a query if its order name matches the query name, or if its MBID
- // matches one a query supplied. The same MBID can come from several queries (agent aliases),
- // so every one of them owns the artist.
- res.own(a.OrderArtistName, a.ID)
- if a.MbzArtistID != "" {
- for _, name := range mbidToQueries[a.MbzArtistID] {
- res.own(name, a.ID)
+ if len(filter) > 0 {
+ artists, err := m.ds.Artist(ctx).GetAll(model.QueryOptions{Filters: filter})
+ if err != nil {
+ return resolvedArtists{}, err
+ }
+ for _, a := range artists {
+ res.mbid[a.ID] = a.MbzArtistID
+ allIDs[a.ID] = struct{}{}
+ for _, idx := range nameToQueries[a.OrderArtistName] {
+ addToSet(res.byQuery, idx, a.ID)
+ }
+ if a.MbzArtistID != "" {
+ for _, idx := range mbidToQueries[a.MbzArtistID] {
+ addToSet(res.byQuery, idx, a.ID)
+ }
}
}
}
+
+ res.allIDs = slices.Collect(maps.Keys(allIDs))
return res, nil
}
-// own records that the named query owns the given artist ID. A name that is not a query simply
-// gets its own (unused) entry.
-func (r resolvedArtists) own(name, artistID string) {
- if r.byQuery[name] == nil {
- r.byQuery[name] = map[string]struct{}{}
+func addToSet(m map[int]map[string]struct{}, k int, v string) {
+ if m[k] == nil {
+ m[k] = map[string]struct{}{}
}
- r.byQuery[name][artistID] = struct{}{}
+ m[k][v] = struct{}{}
+}
+
+// scoredTrack is a candidate track for a query; overlap is how many of the query's distinct
+// artist IDs the track credits.
+type scoredTrack struct {
+ sanitizedTrack
+ overlap int
}
-// bucketTracks groups tracks by query name, at most once per query even when a track credits
-// several of that query's artists, so the same track is not scored twice. The participants JSON
-// on each track carries artist IDs but not their MBID, so the MBID comes from r.mbid instead.
-func (r resolvedArtists) bucketTracks(tracks []model.MediaFile) map[string][]sanitizedTrack {
- // Invert byQuery once so each participant maps straight to the queries that own it, instead of
- // scanning every query per participant.
- queriesByArtist := make(map[string][]string)
- for name, ids := range r.byQuery {
+// queryAccum tallies, for one track against one query, the overlap count, the credited artists'
+// owned IDs, and their MBIDs.
+type queryAccum struct {
+ overlap int
+ ids map[string]struct{}
+ mbids map[string]struct{}
+}
+
+func (r resolvedArtists) bucketTracks(tracks []model.MediaFile) map[int][]scoredTrack {
+ queriesByArtist := make(map[string][]int)
+ for idx, ids := range r.byQuery {
for id := range ids {
- queriesByArtist[id] = append(queriesByArtist[id], name)
+ queriesByArtist[id] = append(queriesByArtist[id], idx)
}
}
- byQuery := make(map[string][]sanitizedTrack, len(r.byQuery))
- added := make(map[string]map[string]struct{}, len(r.byQuery)) // query name -> set of track IDs already bucketed
+ byQuery := make(map[int][]scoredTrack, len(r.byQuery))
for i := range tracks {
+ acc := map[int]*queryAccum{}
+ credited := map[string]struct{}{}
for _, p := range tracks[i].Participants[model.RoleArtist] {
- mbid, isResolved := r.mbid[p.ID]
- if !isResolved {
+ if _, dup := credited[p.ID]; dup {
+ continue
+ }
+ owners, owned := queriesByArtist[p.ID]
+ if !owned {
continue
}
- for _, name := range queriesByArtist[p.ID] {
- if added[name] == nil {
- added[name] = map[string]struct{}{}
+ credited[p.ID] = struct{}{}
+ mbid := r.mbid[p.ID] // "" if not in the artist-table result
+ for _, idx := range owners {
+ a := acc[idx]
+ if a == nil {
+ a = &queryAccum{ids: map[string]struct{}{}, mbids: map[string]struct{}{}}
+ acc[idx] = a
}
- if _, dup := added[name][tracks[i].ID]; dup {
- continue
+ a.overlap++
+ a.ids[p.ID] = struct{}{}
+ if mbid != "" {
+ a.mbids[mbid] = struct{}{}
}
- added[name][tracks[i].ID] = struct{}{}
- byQuery[name] = append(byQuery[name], newSanitizedTrack(&tracks[i], mbid))
}
}
+ for idx, a := range acc {
+ byQuery[idx] = append(byQuery[idx], scoredTrack{
+ sanitizedTrack: newSanitizedTrack(&tracks[i], a.ids, a.mbids),
+ overlap: a.overlap,
+ })
+ }
}
return byQuery
}
@@ -488,35 +566,32 @@ func durationProximity(durationMs uint32, mediaFileDurationSec float32) float64
}
// findBestMatch finds the best matching track using combined title/album similarity and specificity scoring.
-func (m *Matcher) findBestMatch(q songQuery, sanitizedTracks []sanitizedTrack, threshold float64) (model.MediaFile, bool) {
+func (m *Matcher) findBestMatch(q songQuery, candidates []scoredTrack, threshold float64) (model.MediaFile, bool) {
var bestMatch model.MediaFile
bestScore := matchScore{titleSimilarity: -1}
found := false
preferStarred := conf.Server.Matcher.PreferStarred
- for _, t := range sanitizedTracks {
- titleSim := similarityRatio(q.title, t.title)
-
+ for _, c := range candidates {
+ titleSim := similarityRatio(q.title, c.title)
if titleSim < threshold {
continue
}
-
var albumSim float64
if q.album != "" {
- albumSim = similarityRatio(q.album, t.album)
+ albumSim = similarityRatio(q.album, c.album)
}
-
score := matchScore{
titleSimilarity: titleSim,
- durationProximity: durationProximity(q.durationMs, t.mf.Duration),
- preferredMatch: preferStarred && isPreferredTrack(t.mf),
+ durationProximity: durationProximity(q.durationMs, c.mf.Duration),
+ preferredMatch: preferStarred && isPreferredTrack(c.mf),
albumSimilarity: albumSim,
- specificityLevel: computeSpecificityLevel(q, t, threshold),
+ specificityLevel: computeSpecificityLevel(q, c.sanitizedTrack, threshold),
+ artistOverlap: c.overlap,
}
-
if score.betterThan(bestScore) {
bestScore = score
- bestMatch = *t.mf
+ bestMatch = *c.mf
found = true
}
}
@@ -544,7 +619,7 @@ func orderAndDedup(songs []agents.Song, matches map[int]model.MediaFile, count i
continue
}
if prevIdx, alreadyAdded := addedBy[mf.ID]; alreadyAdded {
- if s != songs[prevIdx] {
+ if !s.Equals(songs[prevIdx]) {
continue
}
} else {
diff --git a/core/matcher/matcher_internal_test.go b/core/matcher/matcher_internal_test.go
index 62bccd844..b81fa9012 100644
--- a/core/matcher/matcher_internal_test.go
+++ b/core/matcher/matcher_internal_test.go
@@ -1,7 +1,9 @@
package matcher
import (
+ "github.com/navidrome/navidrome/core/agents"
"github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -54,14 +56,200 @@ var _ = Describe("similarityRatio", func() {
})
var _ = Describe("matcher internals", func() {
- It("computeSpecificityLevel uses sanitizedTrack.artistMBID for artist-MBID levels", func() {
+ It("computeSpecificityLevel uses sanitizedTrack.artistMBIDs for artist-MBID levels", func() {
q := songQuery{
- title: "song",
- artistMBID: "artist-mbid-1",
- albumMBID: "album-mbid-1",
+ title: "song",
+ artists: []queryArtist{{mbid: "artist-mbid-1"}},
+ albumMBID: "album-mbid-1",
}
mf := model.MediaFile{Title: "Song", MbzAlbumID: "album-mbid-1"} // note: mf.MbzArtistID intentionally empty
- t := newSanitizedTrack(&mf, "artist-mbid-1") // resolved MBID supplied here
+ t := newSanitizedTrack(&mf, nil, map[string]struct{}{"artist-mbid-1": {}})
Expect(computeSpecificityLevel(q, t, 0.85)).To(Equal(5))
})
+
+ It("computeSpecificityLevel maximizes the level over all query artists", func() {
+ // First artist does not match; second matches by name with a matching album → level 3.
+ q := songQuery{
+ title: "song",
+ album: "violator",
+ artists: []queryArtist{
+ {name: "no match"},
+ {name: "depeche mode"},
+ },
+ }
+ mf := model.MediaFile{Title: "Song", Artist: "Depeche Mode", Album: "Violator"}
+ t := newSanitizedTrack(&mf, nil, nil)
+ Expect(computeSpecificityLevel(q, t, 0.85)).To(Equal(3))
+ })
+
+ It("scores MBID specificity for any credited artist, not just the last", func() {
+ q := songQuery{
+ title: "song",
+ artists: []queryArtist{
+ {name: "drake", mbid: "mbz-drake"},
+ {name: "future", mbid: "mbz-future"},
+ },
+ album: "wrong album", // force album mismatch so only MBID-level (2) is reachable, not 3+
+ }
+ // Track credits BOTH MBIDs; with the old last-wins string this would only match one.
+ t := sanitizedTrack{
+ mf: &model.MediaFile{},
+ title: "song",
+ artist: "drake",
+ album: "some other album",
+ artistMBIDs: map[string]struct{}{"mbz-drake": {}, "mbz-future": {}},
+ }
+ // Either artist's MBID matching yields level 2 (MBID, no album match). The point: it is
+ // reached via mbz-future too, which the old code would have dropped.
+ Expect(computeSpecificityLevel(q, t, 0.85)).To(Equal(2))
+ })
+
+ It("treats an ID-only artist (no name/MBID) as an identity match, unlocking album tiers", func() {
+ // A plugin that supplies only a Navidrome artist ID: name and mbid are empty. The ID is the
+ // strongest identity signal, so the track's album still elevates specificity above 0.
+ q := songQuery{
+ title: "song",
+ artists: []queryArtist{{id: "artist-1"}},
+ album: "violator",
+ albumMBID: "album-mbid-1",
+ }
+ // Track credits the owned artist ID; no MBID anywhere (untagged library / ID-only plugin).
+ mf := model.MediaFile{Title: "Song", Album: "Violator", MbzAlbumID: "album-mbid-1"}
+ t := newSanitizedTrack(&mf, map[string]struct{}{"artist-1": {}}, nil)
+ // Album MBID matches → level 5 via the ID identity, where the old code scored 0.
+ Expect(computeSpecificityLevel(q, t, 0.85)).To(Equal(5))
+
+ // Same artist, album name matches but no album MBID → level 4 via the ID identity.
+ q.albumMBID = ""
+ mf2 := model.MediaFile{Title: "Song", Album: "Violator"}
+ t2 := newSanitizedTrack(&mf2, map[string]struct{}{"artist-1": {}}, nil)
+ Expect(computeSpecificityLevel(q, t2, 0.85)).To(Equal(4))
+ })
})
+
+var _ = Describe("groupQueries", func() {
+ It("builds one query per unmatched song carrying all artists", func() {
+ songs := []agents.Song{
+ {Name: "Song A", Artists: []agents.Artist{{Name: "Drake"}, {Name: "Future"}}},
+ }
+ queries := groupQueries(songs, map[int]model.MediaFile{})
+ Expect(queries).To(HaveLen(1))
+ Expect(queries[0].index).To(Equal(0))
+ Expect(queries[0].query.title).To(Equal("song a"))
+ Expect(queries[0].query.artists).To(HaveLen(2))
+ Expect(queries[0].query.artists[0].name).To(Equal("drake"))
+ Expect(queries[0].query.artists[1].name).To(Equal("future"))
+ })
+
+ It("strips leading articles from artist names", func() {
+ songs := []agents.Song{
+ {Name: "Song A", Artist: "The Drake"},
+ }
+ queries := groupQueries(songs, map[int]model.MediaFile{})
+ Expect(queries).To(HaveLen(1))
+ Expect(queries[0].query.artists).To(HaveLen(1))
+ Expect(queries[0].query.artists[0].name).To(Equal("drake"))
+ })
+
+ It("keeps an artist that carries only an ID (empty name)", func() {
+ songs := []agents.Song{
+ {Name: "Song A", Artists: []agents.Artist{{ID: "ar-x"}}},
+ }
+ queries := groupQueries(songs, map[int]model.MediaFile{})
+ Expect(queries).To(HaveLen(1))
+ Expect(queries[0].query.artists).To(HaveLen(1))
+ Expect(queries[0].query.artists[0].id).To(Equal("ar-x"))
+ Expect(queries[0].query.artists[0].name).To(Equal(""))
+ })
+
+ It("drops an artist with empty id and empty name but keeps usable ones", func() {
+ songs := []agents.Song{
+ {Name: "Song A", Artists: []agents.Artist{{Name: ""}, {Name: "Future"}}},
+ }
+ queries := groupQueries(songs, map[int]model.MediaFile{})
+ Expect(queries).To(HaveLen(1))
+ Expect(queries[0].query.artists).To(HaveLen(1))
+ Expect(queries[0].query.artists[0].name).To(Equal("future"))
+ })
+
+ It("falls back to the single Artist field via ArtistList", func() {
+ songs := []agents.Song{
+ {Name: "Song A", Artist: "Future", ArtistMBID: "mbid-1"},
+ }
+ queries := groupQueries(songs, map[int]model.MediaFile{})
+ Expect(queries).To(HaveLen(1))
+ Expect(queries[0].query.artists).To(HaveLen(1))
+ Expect(queries[0].query.artists[0].name).To(Equal("future"))
+ Expect(queries[0].query.artists[0].mbid).To(Equal("mbid-1"))
+ })
+
+ It("skips already-matched songs and songs with no usable artist", func() {
+ songs := []agents.Song{
+ {Name: "Already Matched", Artist: "Drake"},
+ {Name: "No Artist"},
+ {Name: "Song C", Artist: "Future"},
+ }
+ queries := groupQueries(songs, map[int]model.MediaFile{0: {ID: "done"}})
+ Expect(queries).To(HaveLen(1))
+ Expect(queries[0].index).To(Equal(2))
+ Expect(queries[0].query.artists[0].name).To(Equal("future"))
+ })
+})
+
+var _ = Describe("bucketTracks", func() {
+ It("scores tracks by how many of the query's artists they credit (overlap)", func() {
+ r := resolvedArtists{
+ byQuery: map[int]map[string]struct{}{
+ 0: {"ar-1": {}, "ar-2": {}},
+ },
+ mbid: map[string]string{},
+ }
+ trackA := model.MediaFile{ID: "a", Title: "A",
+ Participants: artistParticipants(
+ model.Artist{ID: "ar-1", OrderArtistName: "one"},
+ model.Artist{ID: "ar-2", OrderArtistName: "two"},
+ ),
+ }
+ trackB := model.MediaFile{ID: "b", Title: "B",
+ Participants: artistParticipants(model.Artist{ID: "ar-1", OrderArtistName: "one"}),
+ }
+ byQuery := r.bucketTracks(model.MediaFiles{trackA, trackB})
+ Expect(byQuery[0]).To(HaveLen(2))
+ overlaps := map[string]int{}
+ for _, st := range byQuery[0] {
+ overlaps[st.mf.ID] = st.overlap
+ }
+ Expect(overlaps["a"]).To(Equal(2))
+ Expect(overlaps["b"]).To(Equal(1))
+ })
+})
+
+var _ = Describe("resolveArtists ID fast-path", func() {
+ It("owns an artist supplied by ID without a name match", func() {
+ ctx := GinkgoT().Context()
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{
+ {ID: "ar-x", Name: "Some Artist", OrderArtistName: "some artist", MbzArtistID: "mbz-x"},
+ })
+ ds := &tests.MockDataStore{MockedArtist: artistRepo}
+ m := New(ds)
+
+ queries := []indexedQuery{
+ {index: 0, query: songQuery{title: "song", artists: []queryArtist{{id: "ar-x"}}}},
+ }
+ res, err := m.resolveArtists(ctx, queries)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.byQuery[0]).To(HaveKey("ar-x"))
+ Expect(res.allIDs).To(ContainElement("ar-x"))
+ Expect(res.mbid["ar-x"]).To(Equal("mbz-x"))
+ })
+})
+
+// artistParticipants builds a Participants map crediting the given artists under RoleArtist.
+func artistParticipants(artists ...model.Artist) model.Participants {
+ list := make(model.ParticipantList, len(artists))
+ for i, a := range artists {
+ list[i] = model.Participant{Artist: a}
+ }
+ return model.Participants{model.RoleArtist: list}
+}
diff --git a/core/matcher/matcher_test.go b/core/matcher/matcher_test.go
index 1fad0ebcc..1b3af3aa3 100644
--- a/core/matcher/matcher_test.go
+++ b/core/matcher/matcher_test.go
@@ -466,6 +466,103 @@ var _ = Describe("Matcher", func() {
Expect(result[0].ID).To(Equal("track-1"))
})
})
+
+ Context("multiple artists", func() {
+ It("prefers the track that shares more of the song's artists", func() {
+ conf.Server.Matcher.FuzzyThreshold = 85
+ songs := []agents.Song{
+ {Name: "Life Is Good", Artists: []agents.Artist{{Name: "Drake"}, {Name: "Future"}}},
+ }
+ // Both candidates have display Artist "Drake", so they tie at specificity level 1
+ // (name match). The deciding factor is artistOverlap: "both" credits Drake AND
+ // Future (overlap 2), "one" credits only Drake (overlap 1).
+ bothArtists := model.MediaFile{
+ ID: "both", Title: "Life Is Good", Artist: "Drake",
+ Participants: artistParticipants(
+ model.Artist{ID: "drake", Name: "Drake", OrderArtistName: "drake"},
+ model.Artist{ID: "future", Name: "Future", OrderArtistName: "future"},
+ ),
+ }
+ oneArtist := model.MediaFile{
+ ID: "one", Title: "Life Is Good", Artist: "Drake",
+ Participants: artistParticipants(
+ model.Artist{ID: "drake", Name: "Drake", OrderArtistName: "drake"},
+ ),
+ }
+ allowTitlePhase(model.MediaFiles{oneArtist, bothArtists})
+
+ result, err := m.MatchSongs(ctx, songs, 5)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(result).To(HaveLen(1))
+ Expect(result[0].ID).To(Equal("both"))
+ })
+
+ It("matches a single-artist song against a track crediting several artists", func() {
+ conf.Server.Matcher.FuzzyThreshold = 85
+ songs := []agents.Song{
+ {Name: "Life Is Good", Artist: "Future"},
+ }
+ track := model.MediaFile{
+ ID: "multi", Title: "Life Is Good", Artist: "Future feat. Drake",
+ Participants: artistParticipants(
+ model.Artist{ID: "future", Name: "Future", OrderArtistName: "future"},
+ model.Artist{ID: "drake", Name: "Drake", OrderArtistName: "drake"},
+ ),
+ }
+ allowTitlePhase(model.MediaFiles{track})
+
+ result, err := m.MatchSongs(ctx, songs, 5)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(result).To(HaveLen(1))
+ Expect(result[0].ID).To(Equal("multi"))
+ })
+
+ It("matches by a directly-supplied Navidrome artist ID (fast-path)", func() {
+ conf.Server.Matcher.FuzzyThreshold = 85
+ songs := []agents.Song{
+ {Name: "Song A", Artists: []agents.Artist{{ID: "ar-x"}}},
+ }
+ track := model.MediaFile{
+ ID: "by-id", Title: "Song A", Artist: "Some Artist",
+ Participants: artistParticipants(
+ model.Artist{ID: "ar-x", Name: "Some Artist", OrderArtistName: "some artist"},
+ ),
+ }
+ allowTitlePhase(model.MediaFiles{track})
+
+ result, err := m.MatchSongs(ctx, songs, 5)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(result).To(HaveLen(1))
+ Expect(result[0].ID).To(Equal("by-id"))
+ })
+
+ It("prefers a higher artist-overlap track over a starred lower-overlap track", func() {
+ conf.Server.Matcher.PreferStarred = true
+ conf.Server.Matcher.FuzzyThreshold = 85
+ songs := []agents.Song{
+ {Name: "Collab Hit", Artists: []agents.Artist{{Name: "Drake"}, {Name: "Future"}}},
+ }
+ // Shares only Drake (overlap 1) but starred.
+ starredOne := model.MediaFile{
+ ID: "starred-one", Title: "Collab Hit",
+ Annotations: model.Annotations{Starred: true},
+ Participants: artistParticipants(model.Artist{ID: "id-drake", Name: "Drake", OrderArtistName: "drake"}),
+ }
+ // Shares both (overlap 2), not starred.
+ shareTwo := model.MediaFile{
+ ID: "share-two", Title: "Collab Hit",
+ Participants: artistParticipants(
+ model.Artist{ID: "id-drake", Name: "Drake", OrderArtistName: "drake"},
+ model.Artist{ID: "id-future", Name: "Future", OrderArtistName: "future"},
+ ),
+ }
+ allowTitlePhase(model.MediaFiles{starredOne, shareTwo})
+ result, err := m.MatchSongs(ctx, songs, 5)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(result).To(HaveLen(1))
+ Expect(result[0].ID).To(Equal("share-two")) // overlap outranks the starred flag
+ })
+ })
})
Describe("MatchSongsIndexed", func() {
@@ -848,7 +945,7 @@ var _ = Describe("Matcher", func() {
Expect(result[0].ID).To(Equal("exact"))
})
- It("prefers starred songs over better album match when enabled", func() {
+ It("prefers a more specific match over a starred track when PreferStarred is enabled", func() {
conf.Server.Matcher.PreferStarred = true
songs := []agents.Song{
{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
@@ -862,17 +959,14 @@ var _ = Describe("Matcher", func() {
Annotations: model.Annotations{Starred: true},
Participants: artistParticipants(model.Artist{ID: "dm", Name: "Depeche Mode", OrderArtistName: "depeche mode"}),
}
-
allowTitlePhase(model.MediaFiles{albumMatch, starredTrack})
-
result, err := m.MatchSongs(ctx, songs, 5)
-
Expect(err).ToNot(HaveOccurred())
Expect(result).To(HaveLen(1))
- Expect(result[0].ID).To(Equal("starred"))
+ Expect(result[0].ID).To(Equal("album-match")) // specificity now outranks the starred flag
})
- It("prefers 4-star songs over better album match when enabled", func() {
+ It("prefers a more specific match over a 4-star track when PreferStarred is enabled", func() {
conf.Server.Matcher.PreferStarred = true
songs := []agents.Song{
{Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
@@ -886,14 +980,33 @@ var _ = Describe("Matcher", func() {
Annotations: model.Annotations{Rating: 4},
Participants: artistParticipants(model.Artist{ID: "dm", Name: "Depeche Mode", OrderArtistName: "depeche mode"}),
}
-
allowTitlePhase(model.MediaFiles{albumMatch, ratedTrack})
-
result, err := m.MatchSongs(ctx, songs, 5)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(result).To(HaveLen(1))
+ Expect(result[0].ID).To(Equal("album-match")) // specificity now outranks the 4-star rating
+ })
+ It("prefers a starred track when specificity and overlap are equal", func() {
+ conf.Server.Matcher.PreferStarred = true
+ songs := []agents.Song{
+ {Name: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator"},
+ }
+ // Both credit the same single artist and the same album → equal specificity AND equal overlap.
+ plain := model.MediaFile{
+ ID: "plain", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator",
+ Participants: artistParticipants(model.Artist{ID: "dm", Name: "Depeche Mode", OrderArtistName: "depeche mode"}),
+ }
+ starred := model.MediaFile{
+ ID: "starred", Title: "Enjoy the Silence", Artist: "Depeche Mode", Album: "Violator",
+ Annotations: model.Annotations{Starred: true},
+ Participants: artistParticipants(model.Artist{ID: "dm", Name: "Depeche Mode", OrderArtistName: "depeche mode"}),
+ }
+ allowTitlePhase(model.MediaFiles{plain, starred})
+ result, err := m.MatchSongs(ctx, songs, 5)
Expect(err).ToNot(HaveOccurred())
Expect(result).To(HaveLen(1))
- Expect(result[0].ID).To(Equal("rated"))
+ Expect(result[0].ID).To(Equal("starred")) // preferred still wins the tie
})
})
diff --git a/plugins/capabilities/metadata_agent.go b/plugins/capabilities/metadata_agent.go
index 407f21ec5..935594abd 100644
--- a/plugins/capabilities/metadata_agent.go
+++ b/plugins/capabilities/metadata_agent.go
@@ -148,6 +148,8 @@ type SongRef struct {
Artist string `json:"artist,omitempty"`
// ArtistMBID is the MusicBrainz artist ID.
ArtistMBID string `json:"artistMbid,omitempty"`
+ // Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ Artists []ArtistRef `json:"artists,omitempty"`
// Album is the album name.
Album string `json:"album,omitempty"`
// AlbumMBID is the MusicBrainz release ID.
diff --git a/plugins/capabilities/metadata_agent.yaml b/plugins/capabilities/metadata_agent.yaml
index 4940a5056..c90ac1ce0 100644
--- a/plugins/capabilities/metadata_agent.yaml
+++ b/plugins/capabilities/metadata_agent.yaml
@@ -352,6 +352,11 @@ components:
artistMbid:
type: string
description: ArtistMBID is the MusicBrainz artist ID.
+ artists:
+ type: array
+ description: Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ items:
+ $ref: '#/components/schemas/ArtistRef'
album:
type: string
description: Album is the album name.
diff --git a/plugins/capabilities/sonic_similarity.yaml b/plugins/capabilities/sonic_similarity.yaml
index cba97d9b0..1d35e1e92 100644
--- a/plugins/capabilities/sonic_similarity.yaml
+++ b/plugins/capabilities/sonic_similarity.yaml
@@ -16,6 +16,20 @@ exports:
contentType: application/json
components:
schemas:
+ ArtistRef:
+ description: ArtistRef is a reference to an artist with name and optional MBID.
+ properties:
+ id:
+ type: string
+ description: ID is the internal Navidrome artist ID (if known).
+ name:
+ type: string
+ description: Name is the artist name.
+ mbid:
+ type: string
+ description: MBID is the MusicBrainz ID for the artist.
+ required:
+ - name
FindSonicPathRequest:
properties:
startSong:
@@ -60,6 +74,11 @@ components:
artistMbid:
type: string
description: ArtistMBID is the MusicBrainz artist ID.
+ artists:
+ type: array
+ description: Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ items:
+ $ref: '#/components/schemas/ArtistRef'
album:
type: string
description: Album is the album name.
diff --git a/plugins/cmd/ndpgen/internal/generator.go b/plugins/cmd/ndpgen/internal/generator.go
index 705cd4d36..514da578b 100644
--- a/plugins/cmd/ndpgen/internal/generator.go
+++ b/plugins/cmd/ndpgen/internal/generator.go
@@ -568,9 +568,16 @@ func rustConstName(name string) string {
}
// skipSerializingFunc returns the appropriate skip_serializing_if function name.
+// The check must match the rendered Rust type: pointers become Option<T>, slices Vec<T>,
+// and maps HashMap<K,V>, each with a different emptiness predicate.
func skipSerializingFunc(goType string) string {
- if strings.HasPrefix(goType, "*") || strings.HasPrefix(goType, "[]") || strings.HasPrefix(goType, "map[") {
+ switch {
+ case strings.HasPrefix(goType, "*"):
return "Option::is_none"
+ case strings.HasPrefix(goType, "[]"):
+ return "Vec::is_empty"
+ case strings.HasPrefix(goType, "map["):
+ return "HashMap::is_empty"
}
switch goType {
case "string":
diff --git a/plugins/cmd/ndpgen/internal/generator_test.go b/plugins/cmd/ndpgen/internal/generator_test.go
index 34c2c2886..052aa146c 100644
--- a/plugins/cmd/ndpgen/internal/generator_test.go
+++ b/plugins/cmd/ndpgen/internal/generator_test.go
@@ -1289,12 +1289,16 @@ type OnInitOutput struct {
var _ = Describe("Rust Generation", func() {
Describe("skipSerializingFunc", func() {
- It("should return Option::is_none for pointer, slice, and map types", func() {
+ It("should return Option::is_none for pointer 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 the matching emptiness predicate for slice and map types", func() {
+ // The predicate must match the rendered Rust type: []T -> Vec<T>, map[K]V -> HashMap<K,V>.
+ Expect(skipSerializingFunc("[]string")).To(Equal("Vec::is_empty"))
+ Expect(skipSerializingFunc("[]int32")).To(Equal("Vec::is_empty"))
+ Expect(skipSerializingFunc("map[string]int")).To(Equal("HashMap::is_empty"))
})
It("should return String::is_empty for string type", func() {
diff --git a/plugins/metadata_agent.go b/plugins/metadata_agent.go
index 52542300c..f3c26411c 100644
--- a/plugins/metadata_agent.go
+++ b/plugins/metadata_agent.go
@@ -229,6 +229,13 @@ func (a *MetadataAgent) GetSimilarSongsByArtist(ctx context.Context, id, name, m
// songRefToAgentSong converts a single SongRef to agents.Song
func songRefToAgentSong(s capabilities.SongRef) agents.Song {
+ var artists []agents.Artist
+ if len(s.Artists) > 0 {
+ artists = make([]agents.Artist, len(s.Artists))
+ for i, a := range s.Artists {
+ artists[i] = agents.Artist{ID: a.ID, Name: a.Name, MBID: a.MBID}
+ }
+ }
return agents.Song{
ID: s.ID,
Name: s.Name,
@@ -236,6 +243,7 @@ func songRefToAgentSong(s capabilities.SongRef) agents.Song {
ISRC: s.ISRC,
Artist: s.Artist,
ArtistMBID: s.ArtistMBID,
+ Artists: artists,
Album: s.Album,
AlbumMBID: s.AlbumMBID,
Duration: uint32(s.Duration * 1000),
diff --git a/plugins/metadata_agent_test.go b/plugins/metadata_agent_test.go
index 067ae80ca..be9d309ae 100644
--- a/plugins/metadata_agent_test.go
+++ b/plugins/metadata_agent_test.go
@@ -4,6 +4,7 @@ package plugins
import (
"github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/plugins/capabilities"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -329,3 +330,24 @@ var _ = Describe("MetadataAgent partial implementation", Ordered, func() {
Expect(err).To(MatchError(errNotImplemented))
})
})
+
+var _ = Describe("songRefToAgentSong multi-artist", func() {
+ It("maps ArtistRef to agents.Artist", func() {
+ ref := capabilities.SongRef{Name: "Collab", Artist: "Drake", Artists: []capabilities.ArtistRef{
+ {ID: "id-drake", Name: "Drake", MBID: "m-drake"},
+ {Name: "Future", MBID: "m-future"},
+ }}
+ got := songRefToAgentSong(ref)
+ Expect(got.Artists).To(Equal([]agents.Artist{
+ {ID: "id-drake", Name: "Drake", MBID: "m-drake"},
+ {Name: "Future", MBID: "m-future"},
+ }))
+ })
+ It("leaves Artists nil and keeps the single Artist when no Artists provided", func() {
+ ref := capabilities.SongRef{Name: "Solo", Artist: "Drake", ArtistMBID: "m-drake"}
+ got := songRefToAgentSong(ref)
+ Expect(got.Artists).To(BeNil())
+ Expect(got.Artist).To(Equal("Drake"))
+ Expect(got.ArtistMBID).To(Equal("m-drake"))
+ })
+})
diff --git a/plugins/pdk/go/metadata/metadata.go b/plugins/pdk/go/metadata/metadata.go
index 7cd63865b..cec6ce339 100644
--- a/plugins/pdk/go/metadata/metadata.go
+++ b/plugins/pdk/go/metadata/metadata.go
@@ -177,6 +177,8 @@ type SongRef struct {
Artist string `json:"artist,omitempty"`
// ArtistMBID is the MusicBrainz artist ID.
ArtistMBID string `json:"artistMbid,omitempty"`
+ // Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ Artists []ArtistRef `json:"artists,omitempty"`
// Album is the album name.
Album string `json:"album,omitempty"`
// AlbumMBID is the MusicBrainz release ID.
diff --git a/plugins/pdk/go/metadata/metadata_stub.go b/plugins/pdk/go/metadata/metadata_stub.go
index bdcd06fcb..b71a4902f 100644
--- a/plugins/pdk/go/metadata/metadata_stub.go
+++ b/plugins/pdk/go/metadata/metadata_stub.go
@@ -174,6 +174,8 @@ type SongRef struct {
Artist string `json:"artist,omitempty"`
// ArtistMBID is the MusicBrainz artist ID.
ArtistMBID string `json:"artistMbid,omitempty"`
+ // Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ Artists []ArtistRef `json:"artists,omitempty"`
// Album is the album name.
Album string `json:"album,omitempty"`
// AlbumMBID is the MusicBrainz release ID.
diff --git a/plugins/pdk/go/sonicsimilarity/sonicsimilarity.go b/plugins/pdk/go/sonicsimilarity/sonicsimilarity.go
index 7a2681f93..864d13311 100644
--- a/plugins/pdk/go/sonicsimilarity/sonicsimilarity.go
+++ b/plugins/pdk/go/sonicsimilarity/sonicsimilarity.go
@@ -11,6 +11,16 @@ import (
"github.com/navidrome/navidrome/plugins/pdk/go/pdk"
)
+// ArtistRef is a reference to an artist with name and optional MBID.
+type ArtistRef struct {
+ // ID is the internal Navidrome artist ID (if known).
+ ID string `json:"id,omitempty"`
+ // Name is the artist name.
+ Name string `json:"name"`
+ // MBID is the MusicBrainz ID for the artist.
+ MBID string `json:"mbid,omitempty"`
+}
+
// FindSonicPathRequest represents the FindSonicPathRequest data structure.
type FindSonicPathRequest struct {
StartSong SongRef `json:"startSong"`
@@ -38,6 +48,8 @@ type SongRef struct {
Artist string `json:"artist,omitempty"`
// ArtistMBID is the MusicBrainz artist ID.
ArtistMBID string `json:"artistMbid,omitempty"`
+ // Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ Artists []ArtistRef `json:"artists,omitempty"`
// Album is the album name.
Album string `json:"album,omitempty"`
// AlbumMBID is the MusicBrainz release ID.
diff --git a/plugins/pdk/go/sonicsimilarity/sonicsimilarity_stub.go b/plugins/pdk/go/sonicsimilarity/sonicsimilarity_stub.go
index 28d86301c..cf4cfc7ef 100644
--- a/plugins/pdk/go/sonicsimilarity/sonicsimilarity_stub.go
+++ b/plugins/pdk/go/sonicsimilarity/sonicsimilarity_stub.go
@@ -8,6 +8,16 @@
package sonicsimilarity
+// ArtistRef is a reference to an artist with name and optional MBID.
+type ArtistRef struct {
+ // ID is the internal Navidrome artist ID (if known).
+ ID string `json:"id,omitempty"`
+ // Name is the artist name.
+ Name string `json:"name"`
+ // MBID is the MusicBrainz ID for the artist.
+ MBID string `json:"mbid,omitempty"`
+}
+
// FindSonicPathRequest represents the FindSonicPathRequest data structure.
type FindSonicPathRequest struct {
StartSong SongRef `json:"startSong"`
@@ -35,6 +45,8 @@ type SongRef struct {
Artist string `json:"artist,omitempty"`
// ArtistMBID is the MusicBrainz artist ID.
ArtistMBID string `json:"artistMbid,omitempty"`
+ // Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ Artists []ArtistRef `json:"artists,omitempty"`
// Album is the album name.
Album string `json:"album,omitempty"`
// AlbumMBID is the MusicBrainz release ID.
diff --git a/plugins/pdk/rust/nd-pdk-capabilities/src/metadata.rs b/plugins/pdk/rust/nd-pdk-capabilities/src/metadata.rs
index 463e52c37..1a51ad9fd 100644
--- a/plugins/pdk/rust/nd-pdk-capabilities/src/metadata.rs
+++ b/plugins/pdk/rust/nd-pdk-capabilities/src/metadata.rs
@@ -251,6 +251,9 @@ pub struct SongRef {
/// ArtistMBID is the MusicBrainz artist ID.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub artist_mbid: String,
+ /// Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub artists: Vec<ArtistRef>,
/// Album is the album name.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub album: String,
diff --git a/plugins/pdk/rust/nd-pdk-capabilities/src/sonicsimilarity.rs b/plugins/pdk/rust/nd-pdk-capabilities/src/sonicsimilarity.rs
index eb2868929..81b163e5f 100644
--- a/plugins/pdk/rust/nd-pdk-capabilities/src/sonicsimilarity.rs
+++ b/plugins/pdk/rust/nd-pdk-capabilities/src/sonicsimilarity.rs
@@ -18,6 +18,20 @@ fn is_zero_u64(value: &u64) -> bool { *value == 0 }
fn is_zero_f32(value: &f32) -> bool { *value == 0.0 }
#[allow(dead_code)]
fn is_zero_f64(value: &f64) -> bool { *value == 0.0 }
+/// ArtistRef is a reference to an artist with name and optional MBID.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ArtistRef {
+ /// ID is the internal Navidrome artist ID (if known).
+ #[serde(default, skip_serializing_if = "String::is_empty")]
+ pub id: String,
+ /// Name is the artist name.
+ #[serde(default)]
+ pub name: String,
+ /// MBID is the MusicBrainz ID for the artist.
+ #[serde(default, skip_serializing_if = "String::is_empty")]
+ pub mbid: String,
+}
/// FindSonicPathRequest represents the FindSonicPathRequest data structure.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
@@ -60,6 +74,9 @@ pub struct SongRef {
/// ArtistMBID is the MusicBrainz artist ID.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub artist_mbid: String,
+ /// Artists is the full artist list; when set, takes precedence over Artist/ArtistMBID for matching.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub artists: Vec<ArtistRef>,
/// Album is the album name.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub album: String,
diff --git a/plugins/sonic_similarity_adapter.go b/plugins/sonic_similarity_adapter.go
index ff399680e..e29684512 100644
--- a/plugins/sonic_similarity_adapter.go
+++ b/plugins/sonic_similarity_adapter.go
@@ -72,6 +72,9 @@ func mediaFileToSongRef(mf *model.MediaFile) capabilities.SongRef {
AlbumMBID: mf.MbzAlbumID,
Duration: mf.Duration,
}
+ for _, p := range mf.Participants[model.RoleArtist] {
+ ref.Artists = append(ref.Artists, capabilities.ArtistRef{ID: p.ID, Name: p.Name, MBID: p.MbzArtistID})
+ }
if isrcs := mf.Tags.Values(model.TagISRC); len(isrcs) > 0 {
ref.ISRC = isrcs[0]
}
diff --git a/plugins/sonic_similarity_adapter_test.go b/plugins/sonic_similarity_adapter_test.go
index daea04761..1b8d4efa4 100644
--- a/plugins/sonic_similarity_adapter_test.go
+++ b/plugins/sonic_similarity_adapter_test.go
@@ -5,6 +5,7 @@ package plugins
import (
"github.com/navidrome/navidrome/core/sonic"
"github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/plugins/capabilities"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -108,3 +109,24 @@ var _ = Describe("SonicSimilarityPlugin error handling", Ordered, func() {
Expect(err.Error()).To(ContainSubstring("simulated plugin error"))
})
})
+
+var _ = Describe("mediaFileToSongRef multi-artist", func() {
+ It("fills Artists (with IDs) from role=artist participants", func() {
+ mf := &model.MediaFile{ID: "x", Title: "Collab", Participants: model.Participants{
+ model.RoleArtist: model.ParticipantList{
+ {Artist: model.Artist{ID: "ar-drake", Name: "Drake", MbzArtistID: "m-drake"}},
+ {Artist: model.Artist{ID: "ar-future", Name: "Future", MbzArtistID: "m-future"}},
+ },
+ }}
+ ref := mediaFileToSongRef(mf)
+ Expect(ref.Artists).To(Equal([]capabilities.ArtistRef{
+ {ID: "ar-drake", Name: "Drake", MBID: "m-drake"},
+ {ID: "ar-future", Name: "Future", MBID: "m-future"},
+ }))
+ })
+ It("leaves Artists nil when the track has no role=artist participants", func() {
+ mf := &model.MediaFile{ID: "x", Title: "Solo", Artist: "Drake"}
+ ref := mediaFileToSongRef(mf)
+ Expect(ref.Artists).To(BeNil())
+ })
+})