Replace * binding with Ctrl+B and rename favorite to bookmark

Layout-unstable * is remapped to Ctrl+B (layout-stable Ctrl+letter).
Playlist-track favorites are renamed to bookmarks throughout: struct
field, playlist/provider APIs, CLI subcommands (playlist bookmark/
bookmarks), TOML key, JSON output. The TOML reader still accepts the
legacy favorite key for backward compatibility with existing playlists.
The unrelated radio-station FavoriteToggler is left untouched.

Author: bjarneo

cmd/playlist.go

@@ -156,7 +156,7 @@ func PlaylistShow(name string, jsonOutput bool) error {
 			Year         int    `json:"year,omitempty"`
 			TrackNumber  int    `json:"track_number,omitempty"`
 			DurationSecs int    `json:"duration_secs,omitempty"`
-			Favorite     bool   `json:"favorite,omitempty"`
+			Bookmark     bool   `json:"bookmark,omitempty"`
 		}
 		out := make([]jsonTrack, len(tracks))
 		for i, t := range tracks {
@@ -169,7 +169,7 @@ func PlaylistShow(name string, jsonOutput bool) error {
 				Year:         t.Year,
 				TrackNumber:  t.TrackNumber,
 				DurationSecs: t.DurationSecs,
-				Favorite:     t.Favorite,
+				Bookmark:     t.Bookmark,
 			}
 		}
 		enc := json.NewEncoder(os.Stdout)
@@ -219,15 +219,15 @@ func PlaylistDelete(name string) error {
 	return nil
 }
 
-// PlaylistFavorite toggles the favorite flag on a track by index.
-func PlaylistFavorite(name string, index int) error {
+// PlaylistBookmark toggles the bookmark flag on a track by index.
+func PlaylistBookmark(name string, index int) error {
 	prov, err := newProvider()
 	if err != nil {
 		return err
 	}
 
-	if err := prov.SetFavorite(name, index-1); err != nil {
-		return fmt.Errorf("toggling favorite: %w", err)
+	if err := prov.SetBookmark(name, index-1); err != nil {
+		return fmt.Errorf("toggling bookmark: %w", err)
 	}
 
 	tracks, err := prov.Tracks(name)
@@ -238,16 +238,16 @@ func PlaylistFavorite(name string, index int) error {
 		return fmt.Errorf("track %d no longer exists in playlist (now has %d tracks)", index, len(tracks))
 	}
 	t := tracks[index-1]
-	if t.Favorite {
+	if t.Bookmark {
 		fmt.Printf("★ %s\n", t.DisplayName())
 	} else {
 		fmt.Printf("☆ %s\n", t.DisplayName())
 	}
 	return nil
 }
 
-// PlaylistFavorites lists all favorited tracks across all playlists.
-func PlaylistFavorites() error {
+// PlaylistBookmarks lists all bookmarked tracks across all playlists.
+func PlaylistBookmarks() error {
 	prov, err := newProvider()
 	if err != nil {
 		return err
@@ -265,17 +265,17 @@ func PlaylistFavorites() error {
 			continue
 		}
 		for i, t := range tracks {
-			if t.Favorite {
+			if t.Bookmark {
 				fmt.Printf("  ★ [%s] %d. %s\n", pl.Name, i+1, t.DisplayName())
 				total++
 			}
 		}
 	}
 
 	if total == 0 {
-		fmt.Println("No favorites yet. Press * on a track to favorite it.")
+		fmt.Println("No bookmarks yet. Press Ctrl+B on a track to bookmark it.")
 	} else {
-		fmt.Printf("\n  %d favorites across %d playlists.\n", total, len(lists))
+		fmt.Printf("\n  %d bookmarks across %d playlists.\n", total, len(lists))
 	}
 	return nil
 }

commands.go

@@ -315,24 +315,24 @@ func playlistCommand() *cli.Command {
 				},
 			},
 			{
-				Name:      "favorite",
-				Usage:     "toggle favorite on a track by index",
+				Name:      "bookmark",
+				Usage:     "toggle bookmark on a track by index",
 				ArgsUsage: "\"Name\"",
 				Flags: []cli.Flag{
 					&cli.IntFlag{Name: "index", Usage: "track index (1-based)", Required: true},
 				},
 				Action: func(ctx context.Context, c *cli.Command) error {
 					if c.Args().Len() == 0 {
-						return fmt.Errorf("usage: cliamp playlist favorite \"Name\" --index N")
+						return fmt.Errorf("usage: cliamp playlist bookmark \"Name\" --index N")
 					}
-					return cmd.PlaylistFavorite(c.Args().First(), int(c.Int("index")))
+					return cmd.PlaylistBookmark(c.Args().First(), int(c.Int("index")))
 				},
 			},
 			{
-				Name:  "favorites",
-				Usage: "list all favorited tracks across playlists",
+				Name:  "bookmarks",
+				Usage: "list all bookmarked tracks across playlists",
 				Action: func(ctx context.Context, c *cli.Command) error {
-					return cmd.PlaylistFavorites()
+					return cmd.PlaylistBookmarks()
 				},
 			},
 			{

docs/keybindings.md

@@ -70,6 +70,7 @@ Press `Ctrl+K` in the player to see all keybindings.
 | `p` | Playlist manager |
 | `r` | Cycle repeat (Off / All / One) |
 | `z` | Toggle shuffle |
+| `Ctrl+B` | Toggle bookmark ★ on selected track |
 
 ## General
 

external/local/provider.go

@@ -192,16 +192,16 @@ func (p *Provider) savePlaylist(name string, tracks []playlist.Track) error {
 	return os.Rename(tmp, path)
 }
 
-// SetFavorite toggles the favorite flag on a track and rewrites the playlist.
-func (p *Provider) SetFavorite(playlistName string, idx int) error {
+// SetBookmark toggles the bookmark flag on a track and rewrites the playlist.
+func (p *Provider) SetBookmark(playlistName string, idx int) error {
 	tracks, err := p.loadTOMLByName(playlistName)
 	if err != nil {
 		return err
 	}
 	if idx < 0 || idx >= len(tracks) {
 		return fmt.Errorf("index %d out of range (playlist has %d tracks)", idx, len(tracks))
 	}
-	tracks[idx].Favorite = !tracks[idx].Favorite
+	tracks[idx].Bookmark = !tracks[idx].Bookmark
 	return p.savePlaylist(playlistName, tracks)
 }
 
@@ -277,8 +277,8 @@ func writeTrack(w io.Writer, t playlist.Track) {
 	if t.DurationSecs != 0 {
 		fmt.Fprintf(w, "duration_secs = %d\n", t.DurationSecs)
 	}
-	if t.Favorite {
-		fmt.Fprintln(w, "favorite = true")
+	if t.Bookmark {
+		fmt.Fprintln(w, "bookmark = true")
 	}
 }
 
@@ -349,8 +349,9 @@ func (p *Provider) loadTOML(path string) ([]playlist.Track, error) {
 			if n, err := strconv.Atoi(val); err == nil {
 				current.DurationSecs = n
 			}
-		case "favorite":
-			current.Favorite = val == "true"
+		case "bookmark", "favorite":
+			// "favorite" accepted for backward compatibility with playlists saved before the rename.
+			current.Bookmark = val == "true"
 		}
 	}
 	if current != nil {

external/local/provider_test.go

@@ -79,8 +79,8 @@ func TestWriteTrackMinimal(t *testing.T) {
 	if strings.Contains(got, "artist") {
 		t.Fatal("empty artist should not be written")
 	}
-	if strings.Contains(got, "favorite") {
-		t.Fatal("false favorite should not be written")
+	if strings.Contains(got, "bookmark") {
+		t.Fatal("false bookmark should not be written")
 	}
 }
 
@@ -95,7 +95,7 @@ func TestWriteTrackAllFields(t *testing.T) {
 		Year:         2024,
 		TrackNumber:  3,
 		DurationSecs: 240,
-		Favorite:     true,
+		Bookmark:     true,
 		Feed:         true,
 	})
 	got := buf.String()
@@ -109,7 +109,7 @@ func TestWriteTrackAllFields(t *testing.T) {
 		"year = 2024",
 		"track_number = 3",
 		"duration_secs = 240",
-		"favorite = true",
+		"bookmark = true",
 		"feed = true",
 	} {
 		if !strings.Contains(got, want) {
@@ -125,7 +125,7 @@ func TestLoadTOMLRoundTrip(t *testing.T) {
 	os.MkdirAll(p.dir, 0o755)
 
 	tracks := []playlist.Track{
-		{Path: "/a.mp3", Title: "A", Artist: "Art1", Album: "Alb", Year: 2020, TrackNumber: 1, DurationSecs: 180, Favorite: true},
+		{Path: "/a.mp3", Title: "A", Artist: "Art1", Album: "Alb", Year: 2020, TrackNumber: 1, DurationSecs: 180, Bookmark: true},
 		{Path: "/b.flac", Title: "B", Genre: "Jazz", Feed: true},
 	}
 
@@ -144,8 +144,8 @@ func TestLoadTOMLRoundTrip(t *testing.T) {
 	if loaded[0].Path != "/a.mp3" || loaded[0].Title != "A" || loaded[0].Artist != "Art1" {
 		t.Fatalf("track 0 mismatch: %+v", loaded[0])
 	}
-	if !loaded[0].Favorite {
-		t.Fatal("track 0 should be favorite")
+	if !loaded[0].Bookmark {
+		t.Fatal("track 0 should be bookmarked")
 	}
 	if loaded[0].Year != 2020 || loaded[0].TrackNumber != 1 || loaded[0].DurationSecs != 180 {
 		t.Fatalf("track 0 numeric fields mismatch: %+v", loaded[0])
@@ -267,37 +267,37 @@ func TestExists(t *testing.T) {
 	}
 }
 
-// --- SetFavorite ---
+// --- SetBookmark ---
 
-func TestSetFavorite(t *testing.T) {
+func TestSetBookmark(t *testing.T) {
 	p := newTestProvider(t)
-	p.AddTrack("favs", playlist.Track{Path: "/a.mp3", Title: "A"})
+	p.AddTrack("marks", playlist.Track{Path: "/a.mp3", Title: "A"})
 
-	if err := p.SetFavorite("favs", 0); err != nil {
-		t.Fatalf("SetFavorite: %v", err)
+	if err := p.SetBookmark("marks", 0); err != nil {
+		t.Fatalf("SetBookmark: %v", err)
 	}
 
-	tracks, _ := p.Tracks("favs")
-	if !tracks[0].Favorite {
-		t.Fatal("track should be favorite after toggle")
+	tracks, _ := p.Tracks("marks")
+	if !tracks[0].Bookmark {
+		t.Fatal("track should be bookmarked after toggle")
 	}
 
 	// Toggle off.
-	p.SetFavorite("favs", 0)
-	tracks, _ = p.Tracks("favs")
-	if tracks[0].Favorite {
-		t.Fatal("track should not be favorite after second toggle")
+	p.SetBookmark("marks", 0)
+	tracks, _ = p.Tracks("marks")
+	if tracks[0].Bookmark {
+		t.Fatal("track should not be bookmarked after second toggle")
 	}
 }
 
-func TestSetFavoriteOutOfRange(t *testing.T) {
+func TestSetBookmarkOutOfRange(t *testing.T) {
 	p := newTestProvider(t)
 	p.AddTrack("one", playlist.Track{Path: "/a.mp3", Title: "A"})
 
-	if err := p.SetFavorite("one", 5); err == nil {
+	if err := p.SetBookmark("one", 5); err == nil {
 		t.Fatal("expected error for out-of-range index")
 	}
-	if err := p.SetFavorite("one", -1); err == nil {
+	if err := p.SetBookmark("one", -1); err == nil {
 		t.Fatal("expected error for negative index")
 	}
 }

playlist/playlist.go

@@ -42,7 +42,7 @@ type Track struct {
 	Realtime     bool // true for real-time/live streams (e.g. radio)
 	Feed         bool // true for RSS/podcast feed URLs (resolved before playback)
 	DurationSecs int  // known duration in seconds (0 = unknown)
-	Favorite     bool // user-favorited track
+	Bookmark     bool // user-bookmarked track
 
 	Unplayable bool // true when the track is known not playable in the current playback context
 
@@ -699,18 +699,18 @@ func (p *Playlist) SetTrack(i int, t Track) {
 // Tracks returns all tracks in the playlist.
 func (p *Playlist) Tracks() []Track { return p.tracks }
 
-// ToggleFavorite flips the Favorite flag on the track at the given index.
-func (p *Playlist) ToggleFavorite(idx int) {
+// ToggleBookmark flips the Bookmark flag on the track at the given index.
+func (p *Playlist) ToggleBookmark(idx int) {
 	if idx >= 0 && idx < len(p.tracks) {
-		p.tracks[idx].Favorite = !p.tracks[idx].Favorite
+		p.tracks[idx].Bookmark = !p.tracks[idx].Bookmark
 	}
 }
 
-// FavoriteCount returns the number of favorited tracks.
-func (p *Playlist) FavoriteCount() int {
+// BookmarkCount returns the number of bookmarked tracks.
+func (p *Playlist) BookmarkCount() int {
 	n := 0
 	for _, t := range p.tracks {
-		if t.Favorite {
+		if t.Bookmark {
 			n++
 		}
 	}

playlist/shuffle_repeat_test.go

@@ -141,46 +141,46 @@ func TestSetTrackOutOfBounds(t *testing.T) {
 	}
 }
 
-func TestToggleFavorite(t *testing.T) {
+func TestToggleBookmark(t *testing.T) {
 	p := makePlaylist(3, false)
 
-	p.ToggleFavorite(0)
-	if !p.Tracks()[0].Favorite {
-		t.Fatal("track 0 should be favorited")
+	p.ToggleBookmark(0)
+	if !p.Tracks()[0].Bookmark {
+		t.Fatal("track 0 should be bookmarked")
 	}
-	if p.FavoriteCount() != 1 {
-		t.Fatalf("FavoriteCount() = %d, want 1", p.FavoriteCount())
+	if p.BookmarkCount() != 1 {
+		t.Fatalf("BookmarkCount() = %d, want 1", p.BookmarkCount())
 	}
 
-	p.ToggleFavorite(0) // toggle off
-	if p.Tracks()[0].Favorite {
-		t.Fatal("track 0 should be unfavorited")
+	p.ToggleBookmark(0) // toggle off
+	if p.Tracks()[0].Bookmark {
+		t.Fatal("track 0 should be unbookmarked")
 	}
-	if p.FavoriteCount() != 0 {
-		t.Fatalf("FavoriteCount() = %d, want 0", p.FavoriteCount())
+	if p.BookmarkCount() != 0 {
+		t.Fatalf("BookmarkCount() = %d, want 0", p.BookmarkCount())
 	}
 }
 
-func TestToggleFavoriteOutOfBounds(t *testing.T) {
+func TestToggleBookmarkOutOfBounds(t *testing.T) {
 	p := makePlaylist(3, false)
 
 	// Should be no-op, not panic
-	p.ToggleFavorite(-1)
-	p.ToggleFavorite(5)
+	p.ToggleBookmark(-1)
+	p.ToggleBookmark(5)
 
-	if p.FavoriteCount() != 0 {
-		t.Fatal("favorites were modified by out-of-bounds ToggleFavorite")
+	if p.BookmarkCount() != 0 {
+		t.Fatal("bookmarks were modified by out-of-bounds ToggleBookmark")
 	}
 }
 
-func TestFavoriteCount(t *testing.T) {
+func TestBookmarkCount(t *testing.T) {
 	p := makePlaylist(5, false)
 
-	p.ToggleFavorite(0)
-	p.ToggleFavorite(2)
-	p.ToggleFavorite(4)
+	p.ToggleBookmark(0)
+	p.ToggleBookmark(2)
+	p.ToggleBookmark(4)
 
-	if got := p.FavoriteCount(); got != 3 {
-		t.Fatalf("FavoriteCount() = %d, want 3", got)
+	if got := p.BookmarkCount(); got != 3 {
+		t.Fatalf("BookmarkCount() = %d, want 3", got)
 	}
 }

provider/interfaces.go

@@ -67,10 +67,10 @@ type PlaylistDeleter interface {
 	RemoveTrack(name string, index int) error
 }
 
-// FavoriteSetter is implemented by providers that support toggling
-// track favorites and persisting them.
-type FavoriteSetter interface {
-	SetFavorite(playlistName string, idx int) error
+// BookmarkSetter is implemented by providers that support toggling
+// track bookmarks and persisting them.
+type BookmarkSetter interface {
+	SetBookmark(playlistName string, idx int) error
 }
 
 // CustomStreamer is implemented by providers that need a custom audio

site/index.html

@@ -1866,6 +1866,7 @@
           <div class="key-row"><kbd>o</kbd><span>Open file browser</span></div>
           <div class="key-row"><kbd>a / A</kbd><span>Queue (play next) / Queue manager</span></div>
           <div class="key-row"><kbd>p</kbd><span>Playlist manager</span></div>
+          <div class="key-row"><kbd>Ctrl+B</kbd><span>Toggle bookmark &#9733;</span></div>
           <div class="key-row"><kbd>L</kbd><span>Browse local playlists</span></div>
           <div class="key-row"><kbd>Ctrl+X</kbd><span>Expand playlist</span></div>
         </div>

ui/model/audio.go

@@ -5,7 +5,6 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
 )
 
 const speedSaveDebounce = time.Second