Update persistence/playlist_repository.go

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

.gitignore

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

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{}
-	})
-
-	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,255 +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.
-package gotaglib
-
-import (
-	"errors"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"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 {
-	baseDir string
-}
-
-func (e extractor) Parse(files ...string) (map[string]metadata.Info, error) {
-	results := make(map[string]metadata.Info)
-	for _, path := range files {
-		props, err := e.extractMetadata(path)
-		if err != nil {
-			continue
-		}
-		results[path] = *props
-	}
-	return results, nil
-}
-
-func (e extractor) Version() string {
-	return "go-taglib (TagLib 2.1.1 WASM)"
-}
-
-func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
-	fullPath := filepath.Join(e.baseDir, filePath)
-
-	// Open the file once and read all data
-	f, err := taglib.OpenReadOnly(fullPath)
-	if err != nil {
-		// Check if file doesn't exist
-		if _, statErr := os.Stat(fullPath); os.IsNotExist(statErr) {
-			return nil, fs.ErrNotExist
-		}
-		// Check if permission denied
-		if errors.Is(err, taglib.ErrInvalidFile) {
-			// Try to open the file to check for permission errors
-			if osFile, openErr := os.Open(fullPath); openErr != nil {
-				if os.IsPermission(openErr) {
-					return nil, os.ErrPermission
-				}
-			} else {
-				osFile.Close()
-			}
-		}
-		log.Warn("gotaglib extractor: Error reading metadata from file. Skipping", "filePath", fullPath, err)
-		return nil, err
-	}
-	defer f.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),
-	}
-
-	// Convert normalized tags to lowercase keys (go-taglib returns UPPERCASE keys)
-	normalizedTags := make(map[string][]string)
-	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
-}
-
-// 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("gotaglib", func(_ fs.FS, baseDir string) local.Extractor {
-		return &extractor{baseDir}
-	})
-}

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,295 +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{}
-	})
-
-	Describe("Parse", func() {
-		It("correctly parses metadata from all files in folder", func() {
-			mds, err := e.Parse(
-				"tests/fixtures/test.mp3",
-				"tests/fixtures/test.ogg",
-			)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(mds).To(HaveLen(2))
-
-			// Test MP3
-			m := mds["tests/fixtures/test.mp3"]
-			Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Song"}))
-			Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
-			Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
-			Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
-
-			Expect(m.HasPicture).To(BeTrue())
-			Expect(m.AudioProperties.Duration.String()).To(Equal("1.02s"))
-			Expect(m.AudioProperties.BitRate).To(Equal(192))
-			Expect(m.AudioProperties.Channels).To(Equal(2))
-			Expect(m.AudioProperties.SampleRate).To(Equal(44100))
-
-			Expect(m.Tags).To(Or(
-				HaveKeyWithValue("compilation", []string{"1"}),
-				HaveKeyWithValue("tcmp", []string{"1"})),
-			)
-			Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
-			Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014-05-21"}))
-			Expect(m.Tags).To(HaveKeyWithValue("originaldate", []string{"1996-11-21"}))
-			Expect(m.Tags).To(HaveKeyWithValue("releasedate", []string{"2020-12-31"}))
-			Expect(m.Tags).To(HaveKeyWithValue("discnumber", []string{"1"}))
-			Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_gain", []string{"+3.21518 dB"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_album_peak", []string{"0.9125"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_gain", []string{"-1.48 dB"}))
-			Expect(m.Tags).To(HaveKeyWithValue("replaygain_track_peak", []string{"0.4512"}))
-
-			Expect(m.Tags).To(HaveKeyWithValue("tracknumber", []string{"2"}))
-			Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
-
-			Expect(m.Tags).ToNot(HaveKey("lyrics"))
-			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:eng", []string{
-				"[00:00.00]This is\n[00:02.50]English SYLT\n",
-				"[00:00.00]This is\n[00:02.50]English",
-			}), HaveKeyWithValue("lyrics:eng", []string{
-				"[00:00.00]This is\n[00:02.50]English",
-				"[00:00.00]This is\n[00:02.50]English SYLT\n",
-			})))
-			Expect(m.Tags).To(Or(HaveKeyWithValue("lyrics:xxx", []string{
-				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
-				"[00:00.00]This is\n[00:02.50]unspecified",
-			}), HaveKeyWithValue("lyrics:xxx", []string{
-				"[00:00.00]This is\n[00:02.50]unspecified",
-				"[00:00.00]This is\n[00:02.50]unspecified SYLT\n",
-			})))
-
-			// Test OGG
-			m = mds["tests/fixtures/test.ogg"]
-			Expect(err).To(BeNil())
-			Expect(m.Tags).To(HaveKeyWithValue("fbpm", []string{"141.7"}))
-
-			// TagLib 1.12 returns 18, previous versions return 39.
-			// See https://github.com/taglib/taglib/commit/2f238921824741b2cfe6fbfbfc9701d9827ab06b
-			Expect(m.AudioProperties.BitRate).To(BeElementOf(18, 19, 39, 40, 43, 49))
-			Expect(m.AudioProperties.Channels).To(BeElementOf(2))
-			Expect(m.AudioProperties.SampleRate).To(BeElementOf(8000))
-			Expect(m.HasPicture).To(BeTrue())
-		})
-
-		DescribeTable("Format-Specific tests",
-			func(file, duration string, channels, samplerate, bitdepth int, albumGain, albumPeak, trackGain, trackPeak string, id3Lyrics bool, image bool) {
-				file = "tests/fixtures/" + file
-				mds, err := e.Parse(file)
-				Expect(err).NotTo(HaveOccurred())
-				Expect(mds).To(HaveLen(1))
-
-				m := mds[file]
-
-				Expect(m.HasPicture).To(Equal(image))
-				Expect(m.AudioProperties.Duration.String()).To(Equal(duration))
-				Expect(m.AudioProperties.Channels).To(Equal(channels))
-				Expect(m.AudioProperties.SampleRate).To(Equal(samplerate))
-				Expect(m.AudioProperties.BitDepth).To(Equal(bitdepth))
-
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_album_gain", []string{albumGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_gain", []string{albumGain}),
-				))
-
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_album_peak", []string{albumPeak}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_album_peak", []string{albumPeak}),
-				))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_track_gain", []string{trackGain}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_gain", []string{trackGain}),
-				))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("replaygain_track_peak", []string{trackPeak}),
-					HaveKeyWithValue("----:com.apple.itunes:replaygain_track_peak", []string{trackPeak}),
-				))
-
-				Expect(m.Tags).To(HaveKeyWithValue("title", []string{"Title"}))
-				Expect(m.Tags).To(HaveKeyWithValue("album", []string{"Album"}))
-				Expect(m.Tags).To(HaveKeyWithValue("artist", []string{"Artist"}))
-				Expect(m.Tags).To(HaveKeyWithValue("albumartist", []string{"Album Artist"}))
-				Expect(m.Tags).To(HaveKeyWithValue("genre", []string{"Rock"}))
-				Expect(m.Tags).To(HaveKeyWithValue("date", []string{"2014"}))
-
-				Expect(m.Tags).To(HaveKeyWithValue("bpm", []string{"123"}))
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("tracknumber", []string{"3"}),
-					HaveKeyWithValue("tracknumber", []string{"3/10"}),
-				))
-				if !strings.HasSuffix(file, "test.wma") {
-					// TODO Not sure why this is not working for WMA
-					Expect(m.Tags).To(HaveKeyWithValue("tracktotal", []string{"10"}))
-				}
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("discnumber", []string{"1"}),
-					HaveKeyWithValue("discnumber", []string{"1/2"}),
-				))
-				Expect(m.Tags).To(HaveKeyWithValue("disctotal", []string{"2"}))
-
-				// WMA does not have a "compilation" tag, but "wm/iscompilation"
-				Expect(m.Tags).To(Or(
-					HaveKeyWithValue("compilation", []string{"1"}),
-					HaveKeyWithValue("wm/iscompilation", []string{"1"})),
-				)
-
-				if id3Lyrics {
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:eng", []string{
-						"[00:00.00]This is\n[00:02.50]English",
-					}))
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
-						"[00:00.00]This is\n[00:02.50]unspecified",
-					}))
-				} else {
-					Expect(m.Tags).To(HaveKeyWithValue("lyrics:xxx", []string{
-						"[00:00.00]This is\n[00:02.50]unspecified",
-						"[00:00.00]This is\n[00:02.50]English",
-					}))
-				}
-
-				Expect(m.Tags).To(HaveKeyWithValue("comment", []string{"Comment1\nComment2"}))
-			},
-
-			// ffmpeg -f lavfi -i "sine=frequency=1200:duration=1" test.flac
-			Entry("correctly parses flac tags", "test.flac", "1s", 1, 44100, 16, "+4.06 dB", "0.12496948", "+4.06 dB", "0.12496948", false, true),
-
-			Entry("correctly parses m4a (aac) gain tags", "01 Invisible (RED) Edit Version.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false, true),
-			Entry("correctly parses m4a (aac) gain tags (uppercase)", "test.m4a", "1.04s", 2, 44100, 16, "0.37", "0.48", "0.37", "0.48", false, true),
-			Entry("correctly parses ogg (vorbis) tags", "test.ogg", "1.04s", 2, 8000, 0, "+7.64 dB", "0.11772506", "+7.64 dB", "0.11772506", false, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=900:duration=1" test.wma
-			// Weird note: for the tag parsing to work, the lyrics are actually stored in the reverse order
-			Entry("correctly parses wma/asf tags", "test.wma", "1.02s", 1, 44100, 16, "3.27 dB", "0.132914", "3.27 dB", "0.132914", false, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=800:duration=1" test.wv
-			Entry("correctly parses wv (wavpak) tags", "test.wv", "1s", 1, 44100, 16, "3.43 dB", "0.125061", "3.43 dB", "0.125061", false, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=1000:duration=1" test.wav
-			Entry("correctly parses wav tags", "test.wav", "1s", 1, 44100, 16, "3.06 dB", "0.125056", "3.06 dB", "0.125056", true, true),
-
-			// ffmpeg -f lavfi -i "sine=frequency=1400:duration=1" test.aiff
-			Entry("correctly parses aiff tags", "test.aiff", "1s", 1, 44100, 16, "2.00 dB", "0.124972", "2.00 dB", "0.124972", true, true),
-		)
-
-		// Skip these tests when running as root
-		Context("Access Forbidden", func() {
-			var accessForbiddenFile string
-			var RegularUserContext = XContext
-			var isRegularUser = os.Getuid() != 0
-			if isRegularUser {
-				RegularUserContext = Context
-			}
-
-			// Only run permission tests if we are not root
-			RegularUserContext("when run without root privileges", func() {
-				BeforeEach(func() {
-					accessForbiddenFile = utils.TempFileName("access_forbidden-", ".mp3")
-
-					f, err := os.OpenFile(accessForbiddenFile, os.O_WRONLY|os.O_CREATE, 0222)
-					Expect(err).ToNot(HaveOccurred())
-
-					DeferCleanup(func() {
-						Expect(f.Close()).To(Succeed())
-						Expect(os.Remove(accessForbiddenFile)).To(Succeed())
-					})
-				})
-
-				It("correctly handle unreadable file due to insufficient read permission", func() {
-					_, err := e.extractMetadata(accessForbiddenFile)
-					Expect(err).To(MatchError(os.ErrPermission))
-				})
-
-				It("skips the file if it cannot be read", func() {
-					files := []string{
-						"tests/fixtures/test.mp3",
-						"tests/fixtures/test.ogg",
-						accessForbiddenFile,
-					}
-					mds, err := e.Parse(files...)
-					Expect(err).NotTo(HaveOccurred())
-					Expect(mds).To(HaveLen(2))
-					Expect(mds).ToNot(HaveKey(accessForbiddenFile))
-				})
-			})
-		})
-
-	})
-
-	Describe("Error Checking", func() {
-		It("returns a generic ErrPath if file does not exist", func() {
-			testFilePath := "tests/fixtures/NON_EXISTENT.ogg"
-			_, err := e.extractMetadata(testFilePath)
-			Expect(err).To(MatchError(fs.ErrNotExist))
-		})
-		It("does not throw a SIGSEGV error when reading a file with an invalid frame", func() {
-			// File has an empty TDAT frame
-			md, err := e.extractMetadata("tests/fixtures/invalid-files/test-invalid-frame.mp3")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(md.Tags).To(HaveKeyWithValue("albumartist", []string{"Elvis Presley"}))
-		})
-	})
-
-	Describe("parseTIPL", func() {
-		var tags map[string][]string
-
-		BeforeEach(func() {
-			tags = make(map[string][]string)
-		})
-
-		Context("when the TIPL string is populated", func() {
-			It("correctly parses roles and names", func() {
-				tags["tipl"] = []string{"arranger Andrew Powell DJ-mix François Kevorkian DJ-mix Jane Doe engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags["arranger"]).To(ConsistOf("Andrew Powell"))
-				Expect(tags["engineer"]).To(ConsistOf("Chris Blair"))
-				Expect(tags["djmixer"]).To(ConsistOf("François Kevorkian", "Jane Doe"))
-			})
-
-			It("handles multiple names for a single role", func() {
-				tags["tipl"] = []string{"engineer Pat Stapley producer Eric Woolfson engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags["producer"]).To(ConsistOf("Eric Woolfson"))
-				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
-			})
-
-			It("discards roles without names", func() {
-				tags["tipl"] = []string{"engineer Pat Stapley producer engineer Chris Blair"}
-				parseTIPL(tags)
-				Expect(tags).ToNot(HaveKey("producer"))
-				Expect(tags["engineer"]).To(ConsistOf("Pat Stapley", "Chris Blair"))
-			})
-		})
-
-		Context("when the TIPL string is empty", func() {
-			It("does nothing", func() {
-				tags["tipl"] = []string{""}
-				parseTIPL(tags)
-				Expect(tags).To(BeEmpty())
-			})
-		})
-
-		Context("when the TIPL is not present", func() {
-			It("does nothing", func() {
-				parseTIPL(tags)
-				Expect(tags).To(BeEmpty())
-			})
-		})
-	})
-
-})

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_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

@@ -33,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"

conf/configuration.go

@@ -366,6 +366,10 @@ func Load(noConfigDump bool) {
 		disableExternalServices()
 	}
 
+	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

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
 }
@@ -409,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
 		}
 	}
@@ -481,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 {
@@ -492,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,32 +107,20 @@ 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
-			})
 		})
 
 		Describe("Cross-library relative paths", func() {

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

go.mod

@@ -5,8 +5,6 @@ go 1.25
 // 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
 
-replace go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260117215539-f414ba45cbd9
-
 require (
 	github.com/Masterminds/squirrel v1.5.4
 	github.com/RaveNoX/go-jsoncommentstrip v1.0.0
@@ -62,7 +60,6 @@ require (
 	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.0.0-00010101000000-000000000000
 	go.uber.org/goleak v1.3.0
 	golang.org/x/image v0.35.0
 	golang.org/x/net v0.49.0

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-20260117215539-f414ba45cbd9 h1:h2YB9dUm8wQ1ERSQCFuIJp3tecnm+AOJiRFrw3zJa3E=
-github.com/deluan/go-taglib v0.0.0-20260117215539-f414ba45cbd9/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=

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/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{

plugins/examples/discord-rich-presence-rs/README.md

@@ -1,6 +1,6 @@
 # Discord Rich Presence Plugin (Rust)
 
-A Navidrome plugin that displays your currently playing track on Discord using Rich Presence. This is the Rust implementation demonstrating how to use the `nd-pdk` library.
+A Navidrome plugin that displays your currently playing track on Discord using Rich Presence. This is the Rust implementation demonstrating how to use the generated `nd-host` library.
 
 ## ⚠️ Warning
 
@@ -21,20 +21,20 @@ This plugin is for **demonstration purposes only**. It requires storing your Dis
 
 ## Capabilities
 
-This plugin implements multiple capabilities to demonstrate the nd-pdk library:
+This plugin implements three capabilities to demonstrate the nd-host library:
 
 - **Scrobbler**: Receives now-playing events from Navidrome
 - **SchedulerCallback**: Handles heartbeat and activity clearing timers
-- **WebSocketCallback**: Communicates with Discord gateway (text, binary, error, and close handlers)
+- **WebSocketCallback**: Communicates with Discord gateway
 
 ## Configuration
 
 Configure in the Navidrome UI (Settings → Plugins → discord-rich-presence):
 
-| Key           | Description                          | Example                   |
-|---------------|--------------------------------------|---------------------------|
-| `clientid`    | Your Discord application ID          | `123456789012345678`      |
-| `user.<name>` | Discord token for the specified user | `user.alice` = `token123` |
+| Key           | Description                                | Example                        |
+|---------------|-------------------------------------------|--------------------------------|
+| `clientid`    | Your Discord application ID               | `123456789012345678`           |
+| `user.<name>` | Discord token for the specified user      | `user.alice` = `token123`      |
 
 Each user is configured as a separate key with the `user.` prefix.
 
@@ -69,30 +69,27 @@ make discord-rich-presence-rs.ndp
 3. Enable and configure the plugin in the Navidrome UI (Settings → Plugins)
 4. Restart Navidrome if needed
 
-## Using nd-pdk Library
+## Using nd-host Library
 
-This plugin demonstrates how to use the Rust plugin development kit:
+This plugin demonstrates how to use the generated Rust host function wrappers:
 
 ```rust
-use nd_pdk::host::{artwork, cache, scheduler, websocket};
-use std::collections::HashMap;
+use nd_host::{artwork, cache, scheduler, websocket};
 
 // Get artwork URL
-let url = artwork::get_track_url(track_id, 300)?;
+let (url, _) = artwork::artwork_get_track_url(track_id, 300)?;
 
 // Cache operations
-cache::set_string("key", "value", 3600)?;
-if let Some(value) = cache::get_string("key")? {
-    // Use the cached value
-}
+cache::cache_set_string("key", "value", 3600)?;
+let (value, exists) = cache::cache_get_string("key")?;
 
 // Schedule tasks
-scheduler::schedule_one_time(60, "payload", "task-id")?;
-scheduler::schedule_recurring("@every 30s", "heartbeat", "heartbeat-task")?;
+scheduler::scheduler_schedule_one_time(60, "payload", "task-id")?;
+scheduler::scheduler_schedule_recurring("@every 30s", "heartbeat", "heartbeat-task")?;
 
 // WebSocket operations
-let conn_id = websocket::connect("wss://example.com/socket", HashMap::new(), "my-conn")?;
-websocket::send_text(&conn_id, "Hello")?;
+let conn_id = websocket::websocket_connect("wss://example.com/socket")?;
+websocket::websocket_send_text(&conn_id, "Hello")?;
 ```
 
 ## License

plugins/plugins_suite_test.go

@@ -13,7 +13,6 @@ import (
 	"path/filepath"
 	"runtime"
 	"testing"
-	"time"
 
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/conf/configtest"
@@ -43,11 +42,10 @@ func TestPlugins(t *testing.T) {
 
 func buildTestPlugins(t *testing.T, path string) {
 	t.Helper()
-	start := time.Now()
 	t.Logf("[BeforeSuite] Current working directory: %s", path)
 	cmd := exec.Command("make", "-C", path)
 	out, err := cmd.CombinedOutput()
-	t.Logf("[BeforeSuite] Make output: %s elapsed: %s", string(out), time.Since(start))
+	t.Logf("[BeforeSuite] Make output: %s", string(out))
 	if err != nil {
 		t.Fatalf("Failed to build test plugins: %v", err)
 	}

resources/i18n/pt-br.json

@@ -200,6 +200,7 @@
         "duration": "Duração",
         "ownerName": "Dono",
         "public": "Pública",
+        "global": "Global",
         "updatedAt": "Últ. Atualização",
         "createdAt": "Data de Criação",
         "songCount": "Músicas",
@@ -222,7 +223,8 @@
         "duplicate_song": "Adicionar músicas duplicadas",
         "song_exist": "Algumas destas músicas já existem na playlist. Você quer adicionar as duplicadas ou ignorá-las?",
         "noPlaylistsFound": "Nenhuma playlist encontrada",
-        "noPlaylists": "Nenhuma playlist disponível"
+        "noPlaylists": "Nenhuma playlist disponível",
+        "globalPlaylistPublicDisabled": "Playlists globais são sempre públicas"
       }
     },
     "radio": {

tests/fixtures/playlists/global_smart_playlist.nsp

@@ -0,0 +1,10 @@
+{
+  "name": "Global Smart Playlist",
+  "comment": "Available for evaluation by any user",
+  "global": true,
+  "all": [
+    {"is": {"loved": true}}
+  ],
+  "sort": "title",
+  "order": "asc"
+}

tests/fixtures/playlists/private_playlist.nsp

@@ -1,11 +0,0 @@
-{
-  "name": "Private Playlist",
-  "comment": "A smart playlist that is explicitly private",
-  "public": false,
-  "all": [
-    {"is": {"loved": true}}
-  ],
-  "sort": "title",
-  "order": "asc",
-  "limit": 100
-}

tests/fixtures/playlists/public_playlist.nsp

@@ -1,11 +0,0 @@
-{
-  "name": "Public Playlist",
-  "comment": "A smart playlist that is public",
-  "public": true,
-  "all": [
-    {"inTheLast": {"lastPlayed": 30}}
-  ],
-  "sort": "lastPlayed",
-  "order": "desc",
-  "limit": 50
-}

ui/src/common/playlistUtils.js

@@ -9,7 +9,9 @@ export const isReadOnly = (ownerId) => {
   return !isWritable(ownerId)
 }
 
-export const isSmartPlaylist = (pls) => !!pls.rules
+export const isSmartPlaylist = (pls) => !!pls?.rules
+
+export const isGlobalPlaylist = (pls) => isSmartPlaylist(pls) && !!pls?.global
 
 export const canChangeTracks = (pls) =>
-  isWritable(pls.ownerId) && !isSmartPlaylist(pls)
+  isWritable(pls?.ownerId) && !isSmartPlaylist(pls)

ui/src/common/playlistUtils.test.js

@@ -2,6 +2,7 @@ import {
   isWritable,
   isReadOnly,
   isSmartPlaylist,
+  isGlobalPlaylist,
   canChangeTracks,
 } from './playlistUtils'
 
@@ -56,6 +57,28 @@ describe('playlistUtils', () => {
     })
   })
 
+  describe('isGlobalPlaylist', () => {
+    it('returns true if playlist is smart and global', () => {
+      const playlist = { rules: [], global: true }
+      expect(isGlobalPlaylist(playlist)).toBe(true)
+    })
+
+    it('returns false if playlist is smart but not global', () => {
+      const playlist = { rules: [], global: false }
+      expect(isGlobalPlaylist(playlist)).toBe(false)
+    })
+
+    it('returns false if playlist is not smart even if global is true', () => {
+      const playlist = { global: true }
+      expect(isGlobalPlaylist(playlist)).toBe(false)
+    })
+
+    it('returns false if playlist is not smart and not global', () => {
+      const playlist = {}
+      expect(isGlobalPlaylist(playlist)).toBe(false)
+    })
+  })
+
   describe('canChangeTracks', () => {
     it('returns true if user is the owner and playlist is not smart', () => {
       localStorage.setItem('userId', 'user1')

ui/src/i18n/en.json

@@ -200,6 +200,7 @@
         "duration": "Duration",
         "ownerName": "Owner",
         "public": "Public",
+        "global": "Global",
         "updatedAt": "Updated at",
         "createdAt": "Created at",
         "songCount": "Songs",
@@ -222,7 +223,8 @@
         "duplicate_song": "Add duplicated songs",
         "song_exist": "There are duplicates being added to the playlist. Would you like to add the duplicates or skip them?",
         "noPlaylistsFound": "No playlists found",
-        "noPlaylists": "No playlists available"
+        "noPlaylists": "No playlists available",
+        "globalPlaylistPublicDisabled": "Global playlists are always public"
       }
     },
     "radio": {

ui/src/playlist/PlaylistDetails.jsx

@@ -2,15 +2,22 @@ import {
   Card,
   CardContent,
   CardMedia,
+  Chip,
   Typography,
   useMediaQuery,
 } from '@material-ui/core'
+import PublicIcon from '@material-ui/icons/Public'
 import { makeStyles } from '@material-ui/core/styles'
 import { useTranslate } from 'react-admin'
 import { useCallback, useState, useEffect } from 'react'
 import Lightbox from 'react-image-lightbox'
 import 'react-image-lightbox/style.css'
-import { CollapsibleComment, DurationField, SizeField } from '../common'
+import {
+  CollapsibleComment,
+  DurationField,
+  SizeField,
+  isGlobalPlaylist,
+} from '../common'
 import subsonic from '../subsonic'
 
 const useStyles = makeStyles(
@@ -77,6 +84,10 @@ const useStyles = makeStyles(
       marginTop: '1em',
       marginBottom: '0.5em',
     },
+    globalChip: {
+      marginLeft: '0.5em',
+      verticalAlign: 'middle',
+    },
   }),
   {
     name: 'NDPlaylistDetails',
@@ -146,6 +157,14 @@ const PlaylistDetails = (props) => {
               className={classes.title}
             >
               {record.name || translate('ra.page.loading')}
+              {isGlobalPlaylist(record) && (
+                <Chip
+                  icon={<PublicIcon />}
+                  label={translate('resources.playlist.fields.global')}
+                  size="small"
+                  className={classes.globalChip}
+                />
+              )}
             </Typography>
             <Typography component="p" className={classes.stats}>
               {record.songCount ? (

ui/src/playlist/PlaylistEdit.jsx

@@ -11,7 +11,16 @@ import {
   ReferenceInput,
   SelectInput,
 } from 'react-admin'
-import { isWritable, Title } from '../common'
+import { useForm } from 'react-final-form'
+import Tooltip from '@material-ui/core/Tooltip'
+import { makeStyles } from '@material-ui/core/styles'
+import { isWritable, isSmartPlaylist, Title } from '../common'
+
+const useStyles = makeStyles({
+  tooltipWrapper: {
+    display: 'inline-block',
+  },
+})
 
 const SyncFragment = ({ formData, variant, ...rest }) => {
   return (
@@ -28,9 +37,48 @@ const PlaylistTitle = ({ record }) => {
   return <Title subTitle={`${resourceName} "${record ? record.name : ''}"`} />
 }
 
+const PublicInput = ({ record, formData }) => {
+  const translate = useTranslate()
+  const classes = useStyles()
+  const isGlobal = isSmartPlaylist(record) && formData?.global
+  const disabled = !isWritable(record.ownerId) || isGlobal
+
+  const input = <BooleanInput source="public" disabled={disabled} />
+
+  if (isGlobal) {
+    return (
+      <Tooltip
+        title={translate(
+          'resources.playlist.message.globalPlaylistPublicDisabled',
+        )}
+      >
+        <div className={classes.tooltipWrapper}>{input}</div>
+      </Tooltip>
+    )
+  }
+  return input
+}
+
+const GlobalInput = ({ record }) => {
+  const form = useForm()
+  const handleChange = (value) => {
+    if (value) {
+      form.change('public', true)
+    }
+  }
+  return (
+    <BooleanInput
+      source="global"
+      disabled={!isWritable(record.ownerId)}
+      onChange={handleChange}
+    />
+  )
+}
+
 const PlaylistEditForm = (props) => {
   const { record } = props
   const { permissions } = usePermissions()
+  const isSmart = isSmartPlaylist(record)
   return (
     <SimpleForm redirect="list" variant={'outlined'} {...props}>
       <TextInput source="name" validate={required()} />
@@ -50,7 +98,10 @@ const PlaylistEditForm = (props) => {
       ) : (
         <TextField source="ownerName" />
       )}
-      <BooleanInput source="public" disabled={!isWritable(record.ownerId)} />
+      <FormDataConsumer>
+        {({ formData }) => <PublicInput record={record} formData={formData} />}
+      </FormDataConsumer>
+      {isSmart && <GlobalInput record={record} />}
       <FormDataConsumer>
         {(formDataProps) => <SyncFragment {...formDataProps} />}
       </FormDataConsumer>

ui/src/playlist/PlaylistList.jsx

@@ -14,8 +14,10 @@ import {
   useRecordContext,
   BulkDeleteButton,
   usePermissions,
+  useTranslate,
 } from 'react-admin'
 import Switch from '@material-ui/core/Switch'
+import Tooltip from '@material-ui/core/Tooltip'
 import { makeStyles } from '@material-ui/core/styles'
 import { useMediaQuery } from '@material-ui/core'
 import {
@@ -23,6 +25,7 @@ import {
   List,
   Writable,
   isWritable,
+  isGlobalPlaylist,
   useSelectedFields,
   useResourceRefresh,
 } from '../common'
@@ -59,6 +62,7 @@ const PlaylistFilter = (props) => {
 const TogglePublicInput = ({ resource, source }) => {
   const record = useRecordContext()
   const notify = useNotify()
+  const translate = useTranslate()
   const [togglePublic] = useUpdate(
     resource,
     record.id,
@@ -79,13 +83,29 @@ const TogglePublicInput = ({ resource, source }) => {
     e.stopPropagation()
   }
 
-  return (
+  const isGlobal = isGlobalPlaylist(record)
+  const disabled = !isWritable(record.ownerId) || isGlobal
+
+  const switchElement = (
     <Switch
       checked={record[source]}
       onClick={handleClick}
-      disabled={!isWritable(record.ownerId)}
+      disabled={disabled}
     />
   )
+
+  if (isGlobal) {
+    return (
+      <Tooltip
+        title={translate(
+          'resources.playlist.message.globalPlaylistPublicDisabled',
+        )}
+      >
+        <span>{switchElement}</span>
+      </Tooltip>
+    )
+  }
+  return switchElement
 }
 
 const ToggleAutoImport = ({ resource, source }) => {