Merge queue-deque-redesign into dev

Two-level deque queue model + five bug fixes, plus review cleanup.

DeepDrftPublic.Client/Controls/AddToQueueButton.razor

@@ -3,10 +3,11 @@
 @using DeepDrftPublic.Client.Services
 
 @* Append-only "Add to Queue" affordance placed beside a play control. Add is NOT play: it calls the
-   cascaded IQueueService's Enqueue/EnqueueRange (which append without disturbing current playback and
-   leave a coherent CurrentIndex on a first add into a dormant queue) — never PlayRelease/Start/Select.
-   Track mode (Track set) appends a single track; release mode (ReleaseTracks set) appends the whole
-   ordered list. Reads queue state from the layout-level cascade (C1); owns no data fetch. *@
+   cascaded IQueueService's Enqueue/EnqueueRange (which append to the END without disturbing current
+   playback; a first add into a dormant queue seeds the head from the externally-playing track when one
+   exists, then appends) — never PlayRelease/PlayTrack/Start/Select. Track mode (Track set) appends a
+   single track; release mode (ReleaseTracks set) appends the whole ordered list. Reads queue state from
+   the layout-level cascade (C1); owns no data fetch. *@
 
 <MudTooltip Text="@Tooltip">
     <MudIconButton Icon="@Icons.Material.Filled.PlaylistAdd"

DeepDrftPublic.Client/Controls/AudioPlayerBar/AudioPlayerBar.razor

@@ -45,7 +45,7 @@ else
                 @* Fixed (embed) queue panel (§4 / AC5). A release embed shows the up-next inline below the
                    controls as a read-only list (Editable=false → no drag handles, no remove buttons; C3).
                    Jump-to-track is still allowed (OQ2) — routed through the same OnQueueJump as the docked
-                   overlay, which calls PlayRelease (clearing IsArmed if the embed was armed-but-not-started).
+                   overlay, which calls JumpTo (moves the pointer and streams the row, clearing IsArmed).
                    Gated on ShowFixedPanel so a single-track embed (empty queue) stays panel-free (UC6). The
                    Queue button collapses/expands this panel (OQ1 Option A); collapse hides it and posts the
                    shrunken height to the host iframe. *@

DeepDrftPublic.Client/Controls/AudioPlayerBar/AudioPlayerBar.razor.cs

@@ -85,7 +85,15 @@ public partial class AudioPlayerBar : ComponentBase, IAsyncDisposable
     // Gated on Fixed + non-empty so single-track embeds keep their compact, panel-free bar (UC6).
     private bool ShowFixedPanel => Fixed && HasQueue;
 
-    private IReadOnlyList<TrackDto> QueueItems => QueueService?.Items ?? [];
+    // Cached snapshot of the queue list (bug #4 fix). QueueService.Items returns the service's
+    // backing list by reference, so passing it straight through means Blazor parameter diffing sees
+    // an unchanged reference after an in-place Clear/remove/reorder and the child (QueueList /
+    // MudDropContainer) keeps its stale snapshot until reopened. We snapshot on first access and
+    // rebuild in OnQueueChanged, so every real mutation hands the child a NEW reference while
+    // progress-tick re-renders (the frequent path) reuse the cached one without allocating.
+    private IReadOnlyList<TrackDto>? _queueItemsCache;
+    private IReadOnlyList<TrackDto> QueueItems =>
+        _queueItemsCache ??= QueueService is null ? [] : QueueService.Items.ToList();
     private int QueueCurrentIndex => QueueService?.CurrentIndex ?? -1;
 
     // Fixed-mode panel collapse state (OQ1 Option A). Default expanded so a release embed shows the
@@ -141,6 +149,11 @@ public partial class AudioPlayerBar : ComponentBase, IAsyncDisposable
 
     private void OnQueueChanged()
     {
+        // Invalidate the snapshot so QueueItems rebuilds a fresh list on the next render.
+        // This gives Blazor a new reference on every real mutation (bug #4 reactivity preserved)
+        // while progress-tick re-renders that don't go through here keep the cached reference.
+        _queueItemsCache = null;
+
         // If a removal emptied the queue while the overlay was open, the button disappears (AC1) — close
         // the overlay so it cannot strand open over an empty queue. The button gate hides the overlay
         // mount too, so this keeps state and view consistent.
@@ -189,12 +202,14 @@ public partial class AudioPlayerBar : ComponentBase, IAsyncDisposable
 
     private void ClearUpcoming() => QueueService?.ClearUpcoming();
 
-    // Jump reuses the existing "play from index" semantics (OQ2). This is the one queue action that
-    // touches playback — it streams the chosen track via the player.
+    // Jump to a row already in the queue. Under the deque model PlayRelease prepends (it is a PLAY,
+    // not an in-place seek), so a jump cannot route through it without duplicating the queue. JumpTo
+    // moves the pointer to the chosen row and streams it once — preserving deque order. This is the one
+    // queue action besides PLAY/skip that touches playback.
     private async Task OnQueueJump(int index)
     {
         if (QueueService == null) return;
-        await QueueService.PlayRelease(QueueService.Items, index);
+        await QueueService.JumpTo(index);
     }
 
     protected override async Task OnAfterRenderAsync(bool firstRender)

DeepDrftPublic.Client/Controls/QueueList.razor

@@ -71,6 +71,13 @@
 
     private MudDropContainer<QueueRow>? _dropContainer;
 
+    // MudDropContainer snapshots its Items into internal drop zones and does not re-read them on a
+    // plain re-render — so a Clear/remove/reorder that changes the parent's Items list must be pushed
+    // into the container explicitly, or the panel shows the stale order until reopened (bug #4). The
+    // parent passes a fresh Items reference per mutation; refreshing here on every parameter set re-flows
+    // the container's snapshot to match. Cheap: Refresh only re-reads the bound list.
+    protected override void OnParametersSet() => _dropContainer?.Refresh();
+
     // Index-tagged view rows. The index is the row's position in Items at render time and is the
     // value surfaced to the parent's callbacks — the component never mutates the underlying list.
     private List<QueueRow> Rows =>

DeepDrftPublic.Client/Controls/QueueOverlay.razor

@@ -20,7 +20,7 @@
             Class="deepdrft-queue-overlay">
     <div class="deepdrft-queue-modal" @onclick:stopPropagation="true">
         <div class="deepdrft-queue-modal-header">
-            <span class="deepdrft-queue-modal-title">Up Next</span>
+            <span class="deepdrft-queue-modal-title">Playlist</span>
             <MudButton Variant="Variant.Text"
                        Size="Size.Small"
                        Color="Color.Primary"

DeepDrftPublic.Client/Controls/ReleaseDetailScaffold.razor.cs

@@ -13,6 +13,7 @@ namespace DeepDrftPublic.Client.Controls;
 public partial class ReleaseDetailScaffold : ComponentBase
 {
     [CascadingParameter] public IStreamingPlayerService? PlayerService { get; set; }
+    [CascadingParameter] public IQueueService? Queue { get; set; }
 
     [Parameter] public required string Title { get; set; }
     [Parameter] public string? Artist { get; set; }
@@ -96,13 +97,19 @@ public partial class ReleaseDetailScaffold : ComponentBase
     {
         if (Track is null || PlayerService is null) return;
 
-        // Toggle if this track is already active (playing or paused); otherwise start a fresh
-        // stream. SelectTrackStreaming is the live entry point — the buffered path is dead.
+        // Toggle if this track is already active (playing or paused); otherwise PLAY it —
+        // prepend to the queue's front (deque PLAY semantics) so it becomes current and
+        // the existing queue stays intact behind it. Falls back to a direct stream when
+        // the queue cascade is absent (prerender / non-interactive).
         var isThisTrack = PlayerService.CurrentTrack?.Id == Track.Id;
         if (isThisTrack && (PlayerService.IsPlaying || PlayerService.IsPaused))
         {
             await PlayerService.TogglePlayPause();
         }
+        else if (Queue is not null)
+        {
+            await Queue.PlayTrack(Track);
+        }
         else
         {
             await PlayerService.SelectTrackStreaming(Track);

DeepDrftPublic.Client/Controls/StreamNowButton.razor

@@ -27,6 +27,7 @@
     [Parameter] public string LoadingLabel { get; set; } = "Finding a track…";
     [Parameter] public EventCallback OnStreamStarted { get; set; }
     [CascadingParameter] public IStreamingPlayerService? PlayerService { get; set; }
+    [CascadingParameter] public IQueueService? Queue { get; set; }
     [Inject] public required ITrackDataService TrackData { get; set; }
 
     private bool _streamLoading;
@@ -79,7 +80,12 @@
             _findingTrack = false;
             StateHasChanged();
 
-            if (PlayerService is not null)
+            // PLAY semantics: prepend to the queue's front so a "stream now" track becomes current and
+            // any existing queue stays intact behind it. Falls back to a direct stream when the queue
+            // cascade is absent.
+            if (Queue is not null)
+                await Queue.PlayTrack(track);
+            else if (PlayerService is not null)
                 await PlayerService.SelectTrackStreaming(track);
         }
         catch (Exception)