Connect the qbz-theme registry to the running app and persist the choice
across restarts (owner hard requirement 2026-06-20).
- `src/theme.rs`: Rgba->slint::Color conversion, `to_slint` building the
generated `ThemeColors` (55 fields, exact name parity with the Slint struct),
`apply_theme` (set_c + set_is_system), and slug<->index<->id mapping with
slug as the source of truth. Unit tests cover the roundtrip + fallbacks.
- `ui_prefs.rs`: new `theme: String` slug field, `#[serde(default)]` ->
`qbz_theme::default_slug()` (OLED). Old profiles without the field restore to
OLED. Tests assert the default.
- `main.rs`: add the missing `"theme"` arm in `on_appearance_select` (was
falling into the debug `other =>` arm) — maps dropdown index to id, persists
the slug, hot-switches the palette. Startup restore seeds the dropdown list
from the registry, derives the index from the persisted slug, syncs the
legacy `ThemeState.mode`, and applies the theme before first paint.
- `app.slint`: export `Theme`/`ThemeColors`/`ThemeState` so Rust can drive them.
- `AppearanceSettings.slint`/`state.slint`: the theme list is now Rust-seeded;
comments updated (index no longer drives colors; slug is source of truth).
Headline acceptance: pick a theme, quit, relaunch -> same theme; fresh profile
boots into OLED Dark. The 4 existing themes are unchanged (legacy alias values
preserved in the registry).
cc
minimize/maximize/fullscreen were calling winit directly, but the Slint
winit adapter reconciles window state from Slint's own properties on every
realization (winitwindowadapter.rs ~1328 toggles winit to match
properties.is_fullscreen()), so a direct winit set_fullscreen was undone on
the next frame - fullscreen never stuck. Drive them through
slint::Window::{set_minimized,set_maximized,set_fullscreen} (api.rs), the
same properties the adapter reads, so the state holds. Drag stays on winit
(no Slint API). Same lesson as the miniplayer decorations fix.
cc
Replace the immersive ModeBar/ShaderBar with a two-level dropdown (Focus
and Split groups with their children) behind a display glyph, freeing the
header for a future Album/Playlist search (an inert styled placeholder
sits in the center for now). Port the Tauri header window-controls cluster
1:1: a new WindowControlActions global drives the main window via the
winit accessor (minimize, toggle-maximize, toggle-fullscreen, drag-move)
plus exit-immersive and close-app (reusing invoke_close_app). Fix the
split layout: the columns were both stretch 1 so the panel got a sliver;
art-left is now 55% with a large responsive cover, the panel 45%.
cc
The focus line used the cover's dominant hue (spectrum-primary), which
matched the atmosphere (built from the same cover) and blended in. Derive
a contrast accent instead: immersive::lyrics_accent_color takes the cover's
coverage-dominant hue and rotates it to the complement (+180deg), vivid and
mid-bright, with a teal fallback for B&W covers; exposed as
ImmersiveState.lyrics-accent and set on every cover decode.
cc
Extend the wgpu fragment-shader underlay from one scene to three.
shader_underlay builds a pipeline per scene (Vec, indexed by mode-1) over
the shared uniform feed; render_frame takes the active mode. Two original
clean-room WGSL scenes: tunnel.wgsl (neon polar-warped tunnel, zoom on
energy0, ring flare on transient) and aurora.wgsl (domain-warped curtains).
ImmersiveView gains a header scene picker (Off/Plasma/Tunnel/Aurora) and
the g key now cycles 0->1->2->3. WGSL is wgpu-compiled at runtime, so the
look needs a GUI smoke (cargo only checks the Rust/Slint).
cc
The 30Hz lyrics engine gated solely on ShellState.lyrics-open (the
sidebar), so the immersive Lyrics panels (focus + split) never advanced:
active-index/line-progress stayed frozen and the open-time kick() no-op'd
because it bailed at the same gate before computing. Widen the gate so the
engine also ticks while an immersive lyrics panel is active (focus mode 4
or split panel 0), read directly from ImmersiveState.
cc
Add ImmersiveSuggestionsPanel for the split-right slot (split-panel 2):
a cards row (up to 2 artist-playlist book-collage cards + a Song-Radio
diamond-collage card) and a recommended-tracks list. New suggestions.rs
controller assembles everything in Rust (ADR-006): artist tracks_appears_on
with an artist-tracks fallback under 5, dedupe by title, drop the current
track, shuffle, take 10; cards from the first two playlists plus a track
radio. New core method QbzCore::create_smart_track_radio mirrors the smart
artist radio (spawn_blocking + block_on, seed hoisted to index 0). Does NOT
use reco_store (live Qobuz queries only). Collage tilt deferred (flat for
now); blacklist drop happens downstream in play_tracks.
cc
Add ImmersiveTrackInfoPanel for the split-right slot (split-panel 1):
title + album, Duration/Quality/ISRC/Label-link metadata rows, grouped
credits and copyright, reusing MetaCell/CreditCell from TrackInfoModal
(now exported). A new load-without-open path (info_modals::
load_track_info_inline via TrackInfoActions.load-inline) populates
TrackInfoState without raising the floating modal, so the inline panel
fills in place; the data refreshes on now-playing track change. Header
gains a Track Info tab in the split rail (Lyrics, Track Info, Queue).
cc
Port Tauri's AwardView/AwardAlbumsView to Slint: the award landing
(hero + acclaimed-releases preview grid + other-awards rail + follow
heart), the paginated albums listing with client-side search, and
clickable album-sidebar laurels that open the award page (resolving the
award id by name when /album/get omits it).
- AwardState/AwardActions globals + AwardEntry; AlbumState.awards now
carries award ids
- award controller (src/award.rs): /award/page hero (never page.releases),
/award/getAlbums grid, /award/explore other-awards + name->id resolver;
follow via the shared favorite_awards cache (plural-read/singular-write
favType, skip-if-remote, login seed)
- nav registration: NavEntry::Award/AwardAlbums, ContentView arms,
navigate_award/navigate_award_albums, AppShell mounts, app.slint exports
- ArtworkTarget::AwardAlbum/AwardOther
cc
A wrapped lyric line (one logical line over two visual rows) lit BOTH rows at
once because the active line was a single word-wrap Text masked by one clip
Rectangle of full block height + scalar width. Now it progresses per visual
line — row 1 fills to 100% before row 2 starts — matching the final Tauri
behavior. NOT a Slint limitation (proven in the investigation doc).
- lyrics_measure.rs (new): swash advance pass over the active line at the same
font (by font-index) + ppem + wght=700 + 0.2px letter-spacing the view
renders with, greedy word-wrap (CJK per-char) -> per-visual-line segments
with pixel widths. Embeds the same TTFs the view registers. swash is the
shaper femtovg uses, so widths match the render.
- lyrics_sync.rs: on active-index / content-width / font / size / uppercase
change, segment the active line and push [LyricsSegment{text, start-weight,
width-weight}] (Tauri's width-weighted partition); pushed atomically with the
active index. Per-surface cache keys (main + mini). line-progress unchanged.
- state.slint: LyricsSegment struct + active-segments + content-width on
LyricsState.
- LyricsLinesView.slint: active row renders a VerticalLayout of per-segment
rows (no-wrap), each the existing dim-base + clipped-bright-overlay with clip
width = segwidth * clamp((line-progress - start-weight)/width-weight, 0, 1).
Root publishes content-width. Inactive rows unchanged.
- miniplayer.rs: mini lyrics surface segmentation fan-out.
Investigation + plan: qbz-nix-docs/lyrics/2026-06-18-karaoke-highlight-investigation/.
Owner-verified working. Known tuning point: wrap-boundary precision per font tier.
cc
Pre-existing dead code unrelated to cast; restores the zero-warnings policy.
Deleted (abandoned refactor leftovers): ModeTextToggle (LocalLibraryView.slint,
unreferenced), section_artwork_jobs + ArtworkTarget::Section variant + its match
arm (Discover-slice leftover; live render uses DiscoverSectionAlbum),
rename_folder (orphan DB wrapper).
Marked #[allow(dead_code)] with a "reserved, pending wiring" note (ported work
from other epics, not discarded): qconnect_service set_autoplay_mode_if_remote /
autoplay_load_tracks_if_remote / stop_if_remote (QConnect autoplay/stop API);
myqbz_play skip_to_next_item / skip_to_previous_item (Mixtape item-skip, spec 40).
cargo check -p qbz-slint: 0 warnings.
cc
- Lyrics auto-follow while casting: the local poll's cast-skip now runs BEFORE
clear_remote_anchor() (it was wiping the anchor every 450ms), and the cast
poll publishes its position via lyrics_sync::publish_remote_anchor each tick
(the 30Hz engine extrapolates between ticks, like the QConnect path). Anchor
cleared on disconnect so local lyrics resume.
- DLNA seekbar: many renderers report TrackDuration=0 in GetPositionInfo, which
left the bar permanently full (position/0 -> clamp 1.0) with no total time.
Fall back to the track's catalog duration when the renderer reports 0 (the
renderer's position is still authoritative). Chromecast reports a real
duration, so it's unaffected.
cc
The cast was slow because the resolver always did a full CMAF download
(~10s for a 190MB hi-res FLAC) and never read the cache — unlike the fast last
Tauri build, which resolved bytes cache-first.
- P1 cache-first: Player::fetch_for_external_stream now checks L1 (in-memory) ->
L2 (on-disk playback cache) before any download. The gapless prefetch already
warms the next 2 tracks at UltraHiRes while casting, so next/advance/replay are
now instant; only a cold track pays the download.
- Offline tier: CoreBridge::fetch_for_external_stream_resolved gains offline +
sink params and tries resolve_offline_bytes (local CMAF decrypt, no network)
before the network path — a downloaded track casts fast with no connection
(the same local-segments+decrypt path offline playback uses). Replaces the
hard "Qobuz cast needs a connection" gate (offline-cached tracks now work).
- P2 quality label: derived from the track's catalog metadata
(bit_depth/sample_rate/hires) in cast_track — no extra API call, consistent
whether bytes came from cache, offline, or network.
cargo check -p qbz-slint: clean.
cc
Smoke-test fixes after the first real Chromecast session:
- Local 450ms poll now skips the bar update while casting (it was pushing the
stopped local player's position=0/playing=false/local-volume every tick,
fighting the cast poll → seekbar flicker, wrong play icon, dead volume bar).
The cast poll owns the bar, mirroring the existing QConnect-controller skip.
- Cast poll + connection-state push now set NowPlayingState.playing (the
play/pause icon was stuck on play), and set_volume_if_cast pushes the slider
position (the local set_volume that normally moves it is skipped while casting).
- next/previous no longer use a cast-only path: that advanced the renderer +
core cursor but never refreshed the card/queue, and left the cursor desynced
so queue-click resolved the wrong track. They now run the local
next()/previous() flow (move cursor -> refresh card+queue -> play_audible
casts the new track), keeping UI + renderer in sync. Auto-advance on track end
uses the same local next() flow.
cc
- play_audible now gates Cast-first (before the QConnect peer route): when a
renderer is connected, a newly-played track is cast to it instead of starting
the local audio backend (no double audio). Mirrors the existing QConnect
play_on_peer_if_active chokepoint.
- Offline gate: casting a Qobuz track while offline is refused with a clear
message (the external-stream resolver is network/CMAF only; local files still
cast offline). Offline-cached Qobuz cast is a tracked follow-up.
Deferred (documented, non-blocking): continue-locally prompt on disconnect
(needs a small Slint modal); skipIfRemote UI gate (cast while this instance is
a QConnect remote — rare edge).
cargo check -p qbz-slint: clean.
cc
- CastPicker.slint: real modal (scrim + 400px card) replacing the static
PlayerBar/PlayerBarSmall cast-menu PopupWindow stubs. Two rectangular tabs
(Chromecast/DLNA, no pills, plain count) + per-tab device list from
CastState.devices, connect-on-click (DLNA rows gate on can-play), connected
banner with Disconnect + delivered-quality line (D3), scanning/empty states,
error line. Mounted last in AppShell (on top).
- PlayerBar + PlayerBarSmall cast buttons now open the modal
(CastState.picker-open = true; CastActions.open()) instead of the dead popup.
- Cast teardown wired: shutdown() on logout (fixes the Tauri connection + poll
leak #33) and best-effort on app exit (renderer Stop + media server, #32).
cargo check -p qbz-slint: clean (only the 6 pre-existing warnings).
cc
The Slint-side seam over the qbz-cast crate, modeled on qconnect_service.rs.
cast_service.rs (singleton):
- discovery (mDNS + SSDP) with a 2s device-refresh loop and 15s scan window;
- connect/disconnect: snapshot local playback, stop the local backend, suspend
QConnect (remember + restore), connect, then re-cast the current track
passing its REAL source (fixes the Tauri resume-source bug) + deferred seek;
- cast_track: source-routed (qobuz via the Phase-0 shared resolver at
UltraHiRes; local via register_file streaming + rich MIME; plex = TODO),
one shared lazy MediaServer, per-device source-IP URL, Chromecast auto-play
vs DLNA two-step load->play;
- 1s position poll mirroring position/duration/elapsed to the bar + CastState,
with the verbatim track-end heuristic (Chromecast ->IDLE, DLNA ->STOPPED/
NO_MEDIA_PRESENT) driving auto-advance;
- delivered-quality (D3) pushed to CastState; shutdown() for logout/exit.
state.slint: CastState global + CastActions + CastDevice (tagged record with
DLNA capability flags); re-exported in app.slint.
main.rs: init + CastActions wiring (open/close/refresh/connect/disconnect) and
transport gating — play/pause/next/previous/seek/volume now route Cast >
QConnect > local.
Compiles clean (only stop_if_cast/shutdown unused pending the stop callback +
logout/exit wiring, next).
cc
Port the Tauri MiniPlayer to a second Slint MiniPlayerWindow (not an
AppWindow morph). Borderless via the native no-frame property (Slint's
winit adapter re-applies decorations from no-frame on every realization,
so the attributes hook alone was undone); the vendored renderer gives the
transparent rounded floating card. First QBZ surface with no system
titlebar.
State is mirror-driven with no second poll loop: the existing 450ms
playback poll and the 30Hz lyrics tick each fan out one mirror call into
the mini's per-window globals (REQ-1), gating the expensive copies
(artwork / queue / lyric lines) on track-id change. The queue surface owns
a self-contained navigable model (current + full upcoming, not the 40-row
sidebar page), and per-row play routes remote-first and bails before
mutating local (REQ-2). Transport callbacks delegate to the main window's
already-wired remote-first handlers (zero duplication).
Surfaces: micro / compact / artwork / queue / lyrics (reuses
LyricsLinesView + LyricsState). Footer with pending-seek state, transport,
volume popover, and the hover-expand controls capsule (surface tabs +
background-blur toggle + move-drag + close). Optional static
artwork-derived background-blur backdrop. Lifecycle in src/miniplayer.rs
(create-once / enter / exit / close / per-surface geometry persistence /
winit hooks). Menu entry enabled in PlayerBar + PlayerBarSmall.
cc
Drop to the winit backend (on_winit_window_event) to (1) route the browser
Back/Forward mouse buttons to navigation before Slint hands them to the
topmost TouchArea, so cards/sidebar rows no longer swallow them, and (2)
mirror the cursor position into ShellState (pointer-x/y/in-window) so passive
hover chrome can react without installing a TouchArea over interactive
content. This is the seam that unblocks the auto-hide scrollbars.
cx
- Checkboxes are now whole-row clickable (new CheckRow primitive, HTML <label>
behavior): clicking the text toggles it, not just the box. Applied to the
welcome accept + the three Configure progress checks.
- "Use my current queue" guards an empty queue: it checks get_all_queue_tracks
and shows "Your queue is empty — add some tracks first, or press Play test."
instead of sitting on a dead read-back.
- Welcome step gains a "What to test with" notice recommending one track of each
bit-depth/sample-rate (16/44.1, 24/44.1, 24/96, 24/192) so users who bring
their own queue exercise every rate.
cc
The review step generates the copy-paste config per selected DAC (read-only —
QBZ never writes these files, Decision 2): an honest info banner, a backup
CommandBlock first, then one collapsible accordion per DAC (Decision 5 multi-DAC)
holding the three snippets ported 1:1 from the Tauri wizard — pipewire
allowed-rates, per-app bit-perfect client rules, and the WirePlumber rule that
pins node.name + rates + disables resample/channelmix — and finally an
init-aware restart CommandBlock. Rates are re-probed at generation time
(query_dac_capabilities); the filename slug is the description (fixes the old
dacShortName regex that only kept two underscore tokens). The done step lists
the config paths.
Controller: checked_dacs -> gen_configs_blocking (off-thread re-probe + template
build via line-join, no format!-brace escaping) -> apply_configs; toggle_config
flips an accordion. gen-configs fires on the select-dacs -> review transition.
2 unit tests (slugify, wireplumber pins node+rates). DacConfigRow state +
gen-configs/toggle-config actions.
cc
Fixes from owner testing of the Slice 9 playback test:
- No audio: removed the incomplete reinit_device(node) that routed output to the
selected DAC (the proper switch is set_output_device -> reload_settings ->
reinit; doing it half-way broke playback). The test now plays through the
current output; route QBZ to the DAC under test in Settings > Audio.
- Bit-perfect read-back: dropped the pw-top panel (batch snapshot never reflected
the live nodes) and enriched the N6 read-back to show the DAC's real
/proc/asound hw_params — rate + ALSA container format (S32_LE etc.) + channels.
That container format is the bit-perfect proof. Probe scans for the actively
playing card, so it's DAC-agnostic (answers the multi-DAC case: one output at
a time).
- Track jump: clicking a test row now re-sets the queue at that index via the
working play_tracks path (play_index alone only moved the pointer). Resolved
tracks are stashed for this.
- "Use my own music" button: starts the read-back + resumes the user's own queue
for those who don't want the curated tracks.
- Row hover no longer changes the row height (fixed-size glyph slot; the ♪->▶
swap can't reflow what's below).
cc
player.get_sample_rate/get_bit_depth don't exist on Arc<Player>; the accessors
live on player.state (as the QConnect engine already does). Fixes the Slice 9
build.
cc
Replaces the impossible "watch pw-top" verify step with an in-wizard test. The
overlay modal doesn't grab the window, so playback runs underneath while the
test plays.
start-test resolves the 4 owner-curated tracks by id-hint first, then by
"artist title" search if the id 404s (a pulled license — never raw-id-only),
routes QBZ output to the selected DAC (reinit_device), and plays them via the
existing play_tracks path. A 1.5s Slint Timer drives poll-test while playing:
it reads the rate QBZ REQUESTED (player.get_sample_rate — honest) and the DAC's
REAL negotiated rate (N6 / negotiated_stream_rate over /proc/asound), showing a
green check only when they actually match. Read-only; protected audio path
untouched.
State: reuses the test-* fields from Slice 5; adds a poll-test callback and a
TEST_NODE thread_local (no extra model). 3 unit tests already cover the pure
seed-matching/formatting helpers.
cc
Replaces the manual node.name paste with auto-enumeration. Controller
detect_blocking() enumerates via the Slice-0 pw-dump path, projects each sink to
a DacCandidate (looks_like_dac = is_hardware && bus in {usb,pci}), and probes
rates (Slice-2 query_dac_capabilities) for the likely DACs; apply_candidates
pre-selects them and flips has-enumeration off when empty. toggle_dac flips a
VecModel row + recomputes the Next gate; validate_manual is a 1:1 port of the
Tauri validateNodeName/detectDacType (+3 unit tests).
UI step 2: circular SelectionCheckbox rows with a bordered bus label (no pill),
a default star and the probed rate list; a "Can't see your DAC?" disclosure
reveals the two wpctl CommandBlocks + a validated node.name input (shown
unconditionally when nothing enumerated). Next gates on any-dac-selected ||
manual-valid; enumeration fires on the check->dacs transition. Read-only.
cc
Wires the check step on top of the Slice-0/2/6 backend: a health verdict
(success/warning WarningBanner — new `success` variant), a per-missing-piece
CommandBlock with copy, and TWO overridable dropdowns — distro (package
manager) and init system (service commands), which are orthogonal so a Gentoo
box on systemd vs OpenRC gets the right restart command.
New `src/dac_wizard.rs` controller: open() runs the probe off-thread
(spawn_blocking → upgrade_in_event_loop), caches it, and recompute() rebuilds
remediations from the cached probe + the current distro/init selections.
Init-aware restart_cmd (systemd/OpenRC/runit/s6/dinit). NixOS special-cased to
a declarative configuration.nix block.
Sandbox honesty: in Flatpak/Snap the host probes are blind, so the check step
shows an info banner + reference setup commands (full stack incl. pipewire-alsa
+ restart) for the chosen distro/init instead of a false health verdict.
main.rs wires on_open/on_set_distro/on_set_init/on_copy_command; the Audio
settings trigger calls DacWizardActions.open().
cc
Album and local-album track lists render a "Disc N" header above the
first track of each disc when the album spans more than one disc
(media_number-driven; single-disc albums render flat), matching Tauri.
Each header carries a context menu (new — Tauri has none) with Play all /
Shuffle / Add to queue / Play next scoped to that disc's tracks only; the
whole-album header buttons are unchanged.
The menu lives in a DiscHeaderMenu wrapper because Slint rejects a
PopupWindow placed directly under a for/if delegate — wrapping it makes
the popup a non-root child (same pattern as TrackRow + TrackContextMenu).
Every TrackItem constructor gains disc-header-number: 0; artist
top-tracks (a flat cross-album list) default the disc to 1.
cc
Single-cover Discover playlist cards now letterbox the cover with
image-fit: contain over its dominant colour (computed host-side from the
decoded cover), matching Tauri, and show the first tag as an accent
category subtag. Add a multi-select category filter dropdown (sm toolbar
variant, no pills per ADR-008) that re-filters the cached playlists row
client-side; an empty selection shows everything. Raise the playlists
cap from 18 to 100 so the filter operates on a full set.
cc
Bring the Slint mix generation to Tauri parity: build a track_to_analysed
payload from up to 9 spread-sampled seeds (pick_spread -> get_track ->
{track_id,artist_id,genre_id,label_id}, drop artist_id==0) for the PRIMARY
/dynamic/suggest algorithm, limit = max(1, 50 - analysed), and fall back to
the empty-analysis call when the primary returns nothing. The listened-seed
build is factored into mix_listened_seed_ids (recents + favorites, ~120,
Qobuz-only) as a seam the reco-store swap (b3) replaces. Logs seed/analysed/
result counts so an empty mix is diagnosable.
cc
DailyQ/WeeklyQ build their /dynamic/suggest seed from recently-played track
ids. Recently-played now includes local and Plex tracks whose ids are not
Qobuz catalog ids — numeric Plex rating keys even passed the u64 parse, so
they reached Qobuz and the mix request failed. Filter the seed to Qobuz (and
legacy pre-source) tracks before parsing, and skip the request when no Qobuz
seeds remain. Local tracks stay visible in the Recent rows.
cc
The configurator offers Qobuzissimes on the Home tab (in DEFAULT_PREFS.home,
off by default), but Slice 2d had removed it from the Home cache, so enabling
it rendered nothing (descriptors_for found no backing data and dropped it).
Visibility is now governed by the prefs (off by default), so keep the data in
the Home cache pool; enabling Qobuzissimes on Home now renders.
cc
Replace the fixed Discover layouts with the prefs-driven descriptor repeaters
that read DiscoverState's ordered ENABLED section lists, so the configurator's
visibility + reorder choices drive what renders.
- HomeView.slint: drop `for section in HomeState.sections` + the 5 hardcoded
typed blocks; render one repeater over the active tab's descriptor list
(editor-sections when active-tab == "editorPicks", else home-sections). The
single-root delegate dispatches on desc.id: generic album carousels bind the
embedded desc.section; qobuzPlaylists / continueListening / recentlyPlayedAlbums
/ mostStreamed(slim) bind HomeState fields and keep their length gates +
placeholders. `if forYou: ForYouView` stays a static sibling.
- ForYouView.slint: replace the fixed if-sequence with a descriptor repeater
over foryou-sections; each arm reads the typed ForYouState field by id and
keeps its own length gate (qobuzMixes excepted — always rendered). The
skeleton stays a static sibling. essentialsByGenre has no arm (Slice-2c-blocked;
Rust drops it from the list).
- home.rs: select_tab writes DiscoverState.active-tab (single source of truth,
alongside the kept HomeState.active-tab pill bindings) and re-renders the
active tab from the cache via the descriptor lists; apply_home pushes the
descriptor lists once the cache is populated.
- main.rs: the initial discover load fires album-section artwork via the
descriptor-targeted jobs returned by select_tab (DiscoverSectionAlbum), spawned
on the UI thread; slim-grid / recent-album / playlist covers still target the
HomeState fields the fixed arms render.
Build-time verifications to confirm (documented in the .slint comments): the
for-over-ternary-model form compiles, and an empty delegate does not double the
outer 40px spacing (Rust already drops data-empty album ids — policy b).
cc
Add the Slice 5 foundation for the Discover section configurator: a single
DiscoverState/DiscoverActions global pair owning both the prefs-driven render
descriptor lists and the modal payload, plus a thin frontend controller over
the headless qbz_app discover_prefs store.
- state.slint: SectionDescriptor + ConfigRow structs and the DiscoverState /
DiscoverActions globals (active-tab lives here; render loop + modal read it).
- app.slint: re-export the new globals/structs so the Rust layer can bind them.
- discover_prefs.rs: per-user store lifecycle (init_for_user/teardown mirror
fav_cache), in-memory authoritative prefs, descriptor + config-row push
helpers, id->kind/label maps, and toggle/move/reset/open/close handlers
(mutate -> persist -> re-push -> re-render, re-firing artwork for the active
Home/Editor tab). Labels resolve in Rust (English today) since Slint @tr needs
a literal key and the gettext pipeline is unwired.
- home.rs: add the SectionData.id key; build the Home/Editor ordered descriptor
lists from the cached section data (album ids embed their DiscoverSection,
fixed ids carry an empty section); rerender_active_tab + descriptor artwork
jobs. Empty album sections are dropped (policy b); placeholder-bearing Home
sections are kept and gated in the view.
- artwork.rs: DiscoverSectionAlbum target so covers paint on the descriptor
list (DiscoverState.home-sections / editor-sections) rather than HomeState.
- main.rs/auth.rs: mod + seed at both shell entries + per-user init/teardown at
every session-activation point + the 5 DiscoverActions callback registrations.
Descriptor lists are pushed but not yet rendered (the views still draw the old
way); no behavior change until the render loop lands.
cc
The More From Your Library / similarAlbums row was hardcoded "More From
Your Library"; Tauri titles it "Similar to {seed}" where seed is the album
the suggestions are seeded from (discovery.similarTo).
Thread a seed_title through apply_more_from_library: the common case passes
the most-recent album title (recents_seed_title), the no-recent-history
fallback passes the first favorite album title. Empty seed falls back to
"More From Your Library" so the row is never titleless. Title stays a Rust
data string (rendered raw at Carousel.slint), matching the other For You
section titles.
cc
Qobuzissimes was pushed into the Home sections vec unconditionally, so
it always rendered on the Home tab — but Tauri's home default has it OFF.
Editor's Picks keeps it (push_section_ref, correct). Remove the Home push;
borrow-safe (containers.qobuzissims is now consumed only by the editor
push_section_ref).
cc
Add the missing For You "Favorite Albums" carousel (Tauri's
favoriteAlbums), the user's favorited albums capped at 18 in favorite
order, self-hiding when empty. Reuses the album fav-fetch already done in
albums_branch — no new endpoint.
- state.slint: ForYouState.favorite-albums: DiscoverSection.
- foryou.rs: build_favorite_albums (cap 18, unfiltered) + apply_favorite_albums
(mirrors apply_rediscover); wired into albums_branch right after fav_albums
resolves, painting in the same layer as rediscover/radio.
- artwork.rs: ForYouFavoriteAlbum { index } variant + apply arm.
- ForYouView.slint: mount the Carousel after Your Top Artists, before More
From Your Library, gated on favorite-albums.albums.length > 0.
Titled "Favorite Albums" (not Tauri's literal "More From Your Library")
to avoid the label collision with similarAlbums.
cc
Add the missing Discover "Qobuz Playlists" row, present on the Home and
Editor's Picks tabs (never For You), 1:1 with Tauri's PlaylistCardLite:
single cover (rectangle || covers[0]), name only, body=open / overlay=play.
- home.rs: PlaylistCardData + map_playlist (drops owner/duration/count);
HomeData + TabSections playlist fields; capture containers.playlists
(capped 18) in load_home; playlist_to_item (single-cover SearchPlaylistItem,
mirrors label.rs); playlist_artwork_jobs; select_tab swaps the active tab's
row + concatenates its artwork jobs; apply_home caches both sets + pushes Home.
- state.slint: HomeState.playlists: [SearchPlaylistItem].
- PlaylistCarousel.slint: forward a new body-opens prop to PlaylistCard.
- HomeView.slint: mount PlaylistCarousel after the section loop, gated on
active-tab != forYou && playlists.length > 0, body-opens: true.
- artwork.rs: HomePlaylistCover { idx } variant + apply arm (cover1).
- main.rs: reload_home extends jobs with the active tab's playlist covers.
cc
The on_media_action chain had no ("playlist","play") arm, so the
PlaylistCard play-overlay button and context-menu Play (which emit
"play") fell through to the dead _ => {} no-op everywhere they were
used (Search, Label, and now Discover).
Add a playback::play_playlist(id) that fetches the playlist fresh,
interleaves the mixed-playlist sidecar rows (same as enqueue_playlist),
replaces the queue and starts at the first track (set_queue + context),
then wire the new ("playlist","play") arm to it. Unlike the stateful
play-all arm (which reads the open PlaylistView state), this serves a
cold card play from any carousel.
cc