Full surface for create/get/list/rename/description/play_mode/kind/
delete/touch_play on collections and add/list/remove/reorder on items.
Dedup on exact (source, source_item_id) within a collection. Artist
collection kind is locked (cannot be converted to/from). Cascade
delete covers items. Position compaction on remove; atomic transaction
on reorder.
Covered by 10 unit tests using in-memory SQLite.
cc
Two new tables (mixtape_collections, mixtape_collection_items) with
CASCADE on delete and indexes for the two common query patterns. One
additive column on session_queue_state for queue-source tracking.
Idempotent (CREATE TABLE IF NOT EXISTS, ALTER only when missing),
safe on every app start. The ALTER is skipped gracefully if
session_queue_state hasn't been created yet.
Adds LibraryDatabase::with_connection() helper (qbz-library) so
src-tauri can run external DDL on the shared Connection without
exposing it as a field. Migration is wired in session_lifecycle
immediately after library.init_at() in both the online and offline
activation paths.
cc
Reserved for upcoming Mixtape/Collection enqueue paths to mark item
boundaries. Existing enqueue paths populate it with the track's
album_id as a safe fallback so skip-to-item commands behave
correctly even for queues built via "play album" today.
cc
Zero visual change. The Mixtape/Collection detail view will import the
same component. Adds qobuz_streaming as a new value alongside the four
existing LocalLibrary values; AlbumCard's own prop type is unchanged.
cc
Disambiguates Qobuz's auto-generated "Your Mixes" section from the
upcoming user-owned Mixtapes feature (spec
qbz-nix-docs/specs/2026-04-18-mixtapes-collections-design.md).
- Renamed HomeSectionId type union entry from 'yourMixes' to 'qobuzMixes'
- Updated DEFAULT_SECTIONS in homeSettingsStore.ts
- Renamed translation keys in all 5 locale files (en, es, de, fr, pt)
- Updated section labels to "Qobuz Mixes", "Mixes de Qobuz", etc.
- Updated all component references in HomeView, DynamicSuggestView, FavQView,
ForYouTab, TopQView, and WeeklySuggestView
cc
Provided by user for the upcoming Mixtapes & Collections feature (spec
qbz-nix-docs/specs/2026-04-18-mixtapes-collections-design.md, §5.5).
Used for sidebar nav items and detail-view headers.
cc
Defensive keyring handling for credentials/mod.rs to fix issue #329:
- 2.5s wall-clock timeout on every Secret Service call
- Session-wide atomic latch so a broken keyring prompts at most once per process
- File-first semantics everywhere (save_oauth_token inverted from keyring-first)
qbz-secrets (offline-cache master key) deliberately left untouched to avoid
breaking existing BACKEND_MARKER_KEYRING blobs. Phase 2.
Fixes#329.
cc
Linux Secret Service (GNOME Keyring / KWallet) can block indefinitely on
an unlock dialog when the user's login keyring is out of sync with their
session password. Each credential touch (load at bootstrap, save after
login, save-credentials on password path) used to produce its own dialog,
so every login triggered 3-4 prompts the user had to dismiss before the
app could continue (issue #329).
Make credentials/mod.rs defensive:
- Every keyring operation runs on a worker thread with a 2.5 s wall-clock
timeout (run_with_keyring_timeout). If the user is staring at an
unlock dialog they can't satisfy, control flow continues after the
timeout while the worker stays blocked in the background.
- A process-wide atomic (KEYRING_STATE) latches to BROKEN on the first
failure or timeout. Subsequent keyring_get / keyring_set /
keyring_delete calls short-circuit and the app falls back to the
encrypted file path for the rest of the session. One prompt max per
process. NoEntry does not count as a failure.
- The encrypted file in the config directory is the single source of
truth for every credential. save_qobuz_credentials already worked this
way; save_oauth_token was inverted from keyring-first to file-first so
the keyring is no longer on the success path of OAuth login.
- Load paths try the keyring first (cheap when it works) and fall back
to the file; the obsolete "migrate file to keyring" branches are gone.
Public API is unchanged. All existing callers compile unmodified. Existing
encrypted files and keyring entries remain readable; no file-format
changes.
qbz-secrets (offline-cache master key) is deliberately untouched — adding
a KDF fallback there without a migration plan would make existing
BACKEND_MARKER_KEYRING blobs undecipherable. Filed as Phase 2 in the
analysis doc at qbz-nix-docs/bugfix/2026-04-18-issue-329-keyring-unlock-dialog.md.
Fixes#329.
cc
Sidebar lyrics display controls per issue #328:
- Popover with Auto-follow, Font, Size (S/M/L/XL), Dimming, Active color,
Uppercase toggle, Copy to clipboard, Reset
- Per-user persisted preferences via userStorage
- Font select uses the app Dropdown for style consistency
- Reload hook in +page.svelte so scoped storage is read after login
- Active color overrides the karaoke gradient and glow via a new
--lyrics-active-color CSS custom property, falling back to the theme
accent when unset
- Immersive lyrics and the standalone lyrics-only view are untouched
cc
Add two persisted prefs to the lyrics sidebar display controls:
- activeColor: hex color override for the karaoke/active-line accent.
Empty string means follow the theme's --accent-primary. Rendered via
a new --lyrics-active-color CSS custom property set inline on the
LyricsLines container; all four references to --accent-primary in
the active-line gradient and glow shadows now fall back through it.
Popover row shows a native color input plus a 'Theme' clear button
that appears only when a custom color is set.
- uppercase: render all lines as uppercase in the sidebar. Applied via
text-transform on .lyrics-lines.compact.uppercase. Switch toggle in
the popover.
Bump L and XL sidebar sizes by the requested amount:
- L: 17/20 -> 18/21
- XL: 20/24 -> 22/26
(small and medium are unchanged.)
Both new prefs persist per-user in the same localStorage payload via
the existing sanitize/reload flow, and the hex validator rejects
malformed values on read.
cc
Move the copy-lyrics action from the sidebar header into the controls
popover footer, alongside Reset. The sidebar header is back to a single
Settings trigger. Footer layout uses space-between so Copy sits on the
left and Reset on the right, both sharing the same button style.
Add reloadLyricsDisplay() to the store and call it from +page.svelte
right after resyncPersistedVolume. The store is initialized at module
load time (before login), so the first read falls back to the unscoped
storage key. Without this reload, the logged-in user's saved
preferences — including auto-follow — were never picked up after an
app restart, leaving the sidebar stuck on defaults.
cc
A Copy icon button to the left of the Display settings trigger writes
the current track's lyrics (joined with newlines) to the clipboard via
the Tauri clipboard-manager plugin. The icon briefly swaps to a Check
for 1.5s on success, and a success/error toast is shown. The button is
disabled while lyrics are loading, when an error is displayed, or when
no lyrics are available.
cc
Swap the native <select> in LyricsControlsPopover for the shared Dropdown
component so the font picker matches the app's settings style. Widen the
popover to fit the Dropdown trigger and shrink its chrome to keep the
overall scale compact.
Add an XL font size (20/24 px) alongside S/M/L, extending the
LyricsFontSize type, the sanitize validator, the size class in
LyricsLines, and the i18n entry across all five locales.
cc
Pin the API-usage + trademark disclaimer to the bottom of the initializing
state of LoginView so the legal notice is visible during startup, not only
on the login screen proper. Update legal.trademarkNotice in all five locales
to mention the MIT license explicitly.
cc
The .cargo/config.toml used [build] rustflags which applies globally
to every target. On aarch64-apple-darwin this injects
target-cpu=x86-64-v3 and +ssse3 as "ignored features", but the ring
crate's static CPU feature assertions detect the perturbed feature
set and fail to compile with:
error[E0080]: evaluation panicked:
assertion failed: CAPS_STATIC == MIN_STATIC_FEATURES
at ring-0.17.14/src/cpu/arm/darwin.rs:51
Move the flags under [target.'cfg(target_arch = "x86_64")'] so only
x86_64 builds see them. ARM/Apple Silicon targets get their own AES
hardware path automatically via the aes crate's armv8 dispatch — no
explicit flags needed.
cc
Collapse .action-btn-circle.primary to a single size override in
app.css (44x44) so it inherits the same transparent fill + muted
ring as the secondaries. Size is now the only visual differentiator.
The previous accent-hover fill + white ring combination looked
cut-off on some themes and demanded per-theme babysitting — a
consistent, theme-independent visual language is worth more than the
"main action" color cue, which is reinforced already by the larger
glyph (size 20 vs 18).
Also drop LabelView's local scoped override of .action-btn-circle
(bg-tertiary fill + accent-primary primary). It predated the global
rule and drifted. Now everything cascades from app.css.
cc
Logs showed play_next_gapless firing every ~1s for the entire end of a
track when the backend answered "not in any cache, gapless not
possible". The .finally() block was clearing gaplessAttemptTrackId,
which defeated the one-shot guard it was supposed to implement: the
guard check gaplessAttemptTrackId !== currentTrack.id flipped back to
true on every event, so each gapless_ready signal re-fired the invoke.
The event handler at line ~634 already clears the guard when the
event reports a different track_id (a real transition), so pinning
the attempt to currentTrack.id and leaving it alone until then is
the correct lifecycle.
cc
Two polish beats on top of the existing offline:unlock_start/end
signal so the user can tell encrypted-at-rest playback apart from a
slow network:
1. TrackRow gains a "recently unlocked" state: the store holds each
id in recentlyUnlockedIds for 600ms after unlock_end, and the row
flashes an opened-padlock (LockOpen) glyph before the equalizer
takes over. Failure end-events skip the flash so broken decrypts
don't look celebratory.
2. Toast.svelte subscribes to isAnyUnlocking() and, while any track
is being decrypted, swaps the spinner for a jiggling Lock icon
and cycles the shimmer label through Unlocking / Decrypting /
Loading / Validating. Plain network buffering still shows
"Buffering" as before.
cc
The rough compact QualityBadge was overflowing the Most Popular card
on narrow layouts (visible on tracks like Mini World). Every other
place in the app already uses formatQuality() text for this density;
the Most Popular card was the last holdout. Now matches ArtistDetail /
Purchases / Label views.
cc
User feedback from live testing: even with gapless working correctly,
the cold first-play of an offline CMAF bundle takes ~500ms to decrypt
on AES-NI hardware, 5-6s on the software fallback. No visible
indicator of what was happening — UX felt like the app was stalling.
Solution: when a track is being decrypted, replace its play glyph in
the track row with an animated padlock (lucide-svelte Lock icon +
CSS keyframe shake/scale). Tells the user "we're unlocking your
content", which is literally what's happening.
Implementation:
- Backend: new helper `load_cmaf_bundle_with_ui_events` wraps the
spawn_blocking decrypt with two Tauri events:
- `offline:unlock_start { trackId }`
- `offline:unlock_end { trackId, success }`
The helper takes two ids: `display_track_id` (what the frontend
knows this track as — Qobuz id or library row id depending on
flow) and `cmaf_track_id` (the Qobuz id used to key the bundle
inside load_cmaf_bundle itself). Same track shows the animation
whether clicked from Qobuz view or Local Library.
- All three v2 decrypt call sites now route through the helper:
v2_play_track offline branch, v2_play_next_gapless (both the
Qobuz-id and Library-qobuz_download branches), and
v2_library_play_track.
- Frontend: new store `unlockingStore` maintains a `Set<trackId>`
updated from the events, with subscribe/isUnlocking API. Started
from +page.svelte alongside the existing player/queue pollers.
- TrackRow.svelte: new `isUnlocking` reactive state derived from
the store, a new branch in the play-number template that renders
the Lock icon with `lock-shake` animation, scoped CSS keyframes
(qbz-unlocking — slight rotate + scale + opacity pulse at 1.2s
loop, accent-primary colour, cursor: progress).
The animation fires on cold decrypt only; warm L1/L2 hits bypass the
decrypt entirely and don't emit the events, so the user never sees
the padlock for a cached track — correct behavior.
cc
Qobuz-cached tracks (both v1 legacy and new v2 bundles) weren't
showing album art in Local Library. Root cause was a pair of bugs:
1. Legacy v1 path DID download cover.jpg to the organized album
directory (via save_album_artwork) but passed None as artwork_path
when inserting into the library index. So the file existed on
disk but the DB row didn't point at it — the UI had no way to
find it. Pre-existing bug, not introduced by the v2 work.
2. v2 CMAF bundle path didn't save artwork at all. Worked fine for
encrypted playback but the tracks-cmaf/<id>/ directory had no
cover.jpg for the UI to fall back to.
Fix: in both paths, call save_album_artwork next to the cached
content (organized FLAC parent for v1, tracks-cmaf/<id>/ for v2),
then pass the cover.jpg path to insert_qobuz_cached_track_with_
grouping's artwork_path parameter. Library rows now carry the
on-disk path to the artwork and the UI picks it up just like for
user-owned local FLACs.
New downloads will have artwork immediately. Tracks already in the
cache from before this commit will remain artwork-less until
re-downloaded — acceptable since the user can just re-trigger
download per track if they want the art back, and the 30-day
subscription wipe refreshes everything eventually anyway.
cc
Offline-cache v2 bundles need runway for the decrypt pipeline. At 10
MB/s (software AES fallback) a 58 MB track needs 6 seconds, which
blew past the old 5s pre-emptive window and missed the gapless handoff
entirely. With AES-NI active the decrypt is ~500ms, so 10s is
harmless overkill — the decrypted bytes just sit in L1 a few seconds
earlier.
Design note: this is complementary to the AES-NI target-feature fix,
not a substitute. A too-small lead time makes gapless brittle even on
fast hardware (any hiccup blows the window); a too-large one is
wasted memory but otherwise fine. 10s is comfortable for every
realistic hardware/track-size combo we'll see.
If we ever want user-visible control, plumb a `gapless_lead_secs`
through AudioSettings and read it at the hot site.
cc
Previous commit tried to enable AES-NI via target-cpu=x86-64-v3 but
that microarchitecture level does NOT include AES-NI — it's a separate
ISA extension added on top. The aes crate kept falling back to software
decrypt (~10 MB/s), so the first live test still showed a 6s gap on
offline-cache gapless for a 58 MB track (~10 MB/s).
Fix: add target-feature=+aes,+ssse3 to rustflags. The aes crate's
runtime dispatch via cpufeatures only works if the AES-NI code path
was actually compiled in, which requires the build-time feature flag.
Expected: 58 MB decrypt drops from ~6s to ~150ms, fits inside the 5s
gapless pre-emptive window with headroom.
cc
CMAF decrypt was the bottleneck for offline-cache gapless. Live
testing showed a 208 MB HiRes bundle took ~22 seconds to decrypt end-
to-end, which made gapless for anything longer than a 3-minute track
impossible (the gapless pre-emptive window is ~5s before track end,
so a 22s decrypt can't land in time regardless of how early we start).
Two changes, complementary:
1. `.cargo/config.toml` with `target-cpu=x86-64-v3` (Haswell baseline).
The `aes` crate ships both a software implementation and an AES-NI
hardware path, runtime-dispatched via `cpufeatures` — but the
AES-NI path is only compiled in when the appropriate target-feature
is enabled at build time. Default dev builds compile ONLY the
software path, which hits ~10 MB/s on a modern CPU. Haswell+ (2013
and up, every realistic QBZ user) supports AES-NI and clears
400 MB/s+. For prebuilt distribution binaries we'll want runtime-
dispatch via subfunction build or dynamic linking, but for self-
built and release-source-from-tag scenarios this is the right
default.
2. `decrypt_segments_into` no longer allocates a Vec per frame. Was:
frame = seg_data[..].to_vec(); // alloc
decrypt_frame(&mut frame); // in-place
output.extend_from_slice(&frame); // copy back
Now:
let start = output.len();
output.extend_from_slice(&seg_data[..]); // single copy
decrypt_frame(&mut output[start..]); // in-place
For a HiRes FLAC with ~50K frames this saves 50K small allocs +
50K double-copies. Output Vec is already pre-sized via
with_capacity(total), so no reallocation growth during extend.
Combined expected impact: 22s decrypt on a 208 MB track → under 500ms,
which fits inside the 5s gapless window with headroom to spare.
cc
Library auto-advance had a ~6s gap between two Qobuz-cached v2 tracks.
Tracks within Qobuz flow had gapless working because those pass the
Qobuz track id to v2_play_next_gapless and the offline cache is keyed
by that id. From Local Library the frontend passes the LIBRARY row id
(small autoincrement, e.g. 542), so:
- L1 keyed by library row id → miss (prefetches key by Qobuz id)
- L2 keyed by library row id → miss
- offline cache get_cmaf_bundle(542) → miss (cache is keyed by Qobuz id)
- library fallback: file_path for qobuz_download v2 tracks is a
directory, std::fs::read blows up → gapless returns Ok(false)
Result: gapless declined, track ended, frontend called play_track as
normal transition, which went through v2_library_play_track's full
decrypt path from cold → 5-6s silence.
Fix: in the library-fallback branch of v2_play_next_gapless, detect
source='qobuz_download' and re-query the offline cache by the row's
qobuz_track_id. If a v2 bundle exists, decrypt it on the blocking
pool and feed to play_next using the LIBRARY row id (so the player
keys match what the frontend is waiting for — same pattern as the
earlier library track-id fix). Warm L1 keyed by library row id too,
so next transition between tracks in this library view hits memory
instead of re-decrypting.
This leaves the v1 path working (plain FLAC at segments_path) and
the regular user-owned local FLAC path unchanged.
cc
Live testing from Local Library with a v2 CMAF-cached Qobuz track
showed a cascade of UI breakage: seekbar never appeared, track never
auto-advanced, queue-manager fired next_track every 1s for 30+
iterations in a loop, currently-playing song card stayed on the first
track. Audio was playing fine; the UI just couldn't see it.
Root cause: my v2_library_play_track CMAF path was passing the Qobuz
track id (from the library row's qobuz_track_id field) to
player.play_data. Every other piece of the UI state machine — queue
sync, seekbar progress events, auto-advance trigger, now-playing card
— keys off whatever id the frontend invoked with, which is the
library row id (e.g. 542), not the Qobuz id (e.g. 95787326). So the
player was emitting updates about "playing 95787326" while the
frontend was waiting for updates about 542 that never came.
Fix: play_data now takes track_id (library row id) on both the v2
CMAF decrypt branch and the v1 plain-FLAC branch. The offline-cache
DB lookup still uses qobuz_track_id (that DB is keyed by Qobuz id),
the player gets the library id. AudioCache insert also keyed by
library id so Library-side replay hits L1 correctly.
cc
Live testing showed gapless between two offline-cached v2 tracks still
had a 6s gap even with the L1 warming + spawn_blocking + track_id fixes.
Root cause: v2_play_next_gapless checked the offline cache FIRST, which
meant for tracks that were BOTH on disk AND already in L1 (prefetched
from the CDN into memory), we took the slow offline decrypt path even
though instant bytes were sitting in RAM.
Log evidence:
16:52:09 Prefetch put track 47683552 in L1 (61MB)
16:53:00 play_next_gapless for 47683552
16:53:06 [V2/GAPLESS] Track 47683552 from OFFLINE cache (CMAF v2)
(decrypted 58MB — took ~5s while L1 had the bytes)
16:53:06 Gapless: no engine, ignoring PlayNext
(engine dropped at 16:53:05 when old track ended)
The very next transition (47683552 → 47683553), where 47683553 happened
to be ONLY in L1 and not in the offline cache, worked perfectly:
16:55:58 [V2/GAPLESS] Track 47683553 from MEMORY cache (72MB) ← 60ms
16:56:02 Gapless transition: track 47683552 -> 47683553 (clean)
Fix: reorder tiers to L1 → L2 → offline → library. The offline v2
decrypt path is expensive precisely because we already warm L1 after
every decrypt — so the second time around (or whenever prefetch beat
us to it), L1 hit is instant. The offline tier is correctly reserved
for the "truly cold" case: track on disk but not in memory.
Also added a "warm L1 from L2" step so a disk-cache hit also populates
memory, matching the warm-L1-on-decrypt pattern the offline path
already did.
cc
Live testing showed v2 offline tracks had a 3-6s gap on gapless
transitions even after the track_id + spawn_blocking fixes, because
the decrypt itself takes 5-7 seconds for a typical 60-200MB FLAC
(disk read of encrypted segments.bin + AES-CTR per-frame decrypt is
slower than the track's natural tail). By the time load_cmaf_bundle
returns, the previous track has ended and the player's gapless engine
has been dropped.
Workable only second time: once a track's decrypted bytes are in L1
memory cache, subsequent accesses are ~60ms. That's what happened on
the second transition we observed — prefetched tracks hit L1 for
free, so gapless landed in time.
Fix: after successfully decrypting a v2 bundle, insert the resulting
plain-FLAC bytes into the AudioCache (L1) before handing them to the
player. Applies to three call sites:
- v2_play_track offline cache branch → warm on first play
- v2_play_next_gapless CMAF v2 branch → warm on gapless success
- v2_library_play_track CMAF v2 branch → warm on Library click
Next access to the same track (replay, scrub, gapless re-queue,
upcoming-track peek) is now a <100ms L1 hit regardless of the v2
cache_format the row has. The decrypt cost is paid once per track
per session, not once per access.
This still leaves the "first play of an offline track" taking 5-7s
before audio starts. That's a separate optimization — candidates are
(a) offline-track prefetch that pre-decrypts upcoming tracks in the
background, (b) storing decrypted FLAC in L2 disk cache so cold
restarts don't have to decrypt, (c) speeding up the decrypt itself.
cc
Two bugs the live testing surfaced.
1. v2_library_play_track was passing the library row id (autoincrement
small integer) to the offline-cache DB lookup. The offline cache is
keyed by the Qobuz track id (the big id like 95787327). So the
lookup always missed and my earlier "orphan" error fired for EVERY
v2 track clicked from Local Library. Fix: read qobuz_track_id from
the library row and use THAT for the offline-cache lookup.
2. load_cmaf_bundle is synchronous (std::fs::read + AES-CTR decrypt +
FLAC assemble). When called directly from an async fn on the tokio
executor, a 200MB offline track took ~22 seconds end-to-end during
concurrent prefetch activity — because the sync work starved the
executor thread, delaying the queue's auto-advance event, which
fired play_track as a fallback AFTER the old track stopped (which
killed the gapless engine). Net: 6-8 second audible gap between
two offline-cached tracks even though the bytes were on disk.
Fix: wrap load_cmaf_bundle in tokio::task::spawn_blocking in all
three call sites (v2_play_track, v2_play_next_gapless,
v2_library_play_track). The executor stays responsive, gapless
finishes before the engine drops, transition is clean.
Together these close the two loudest symptoms from the live session:
"Is a directory" when playing v2 from Library, and the seconds-long
gap between consecutive v2 tracks even with gapless enabled.
cc
The CMAF session cache is an Arc<RwLock<Option<CmafSession>>>. The old
ensure_cmaf_session did a read-check then dropped the guard then did
its POST unlocked, which meant two concurrent callers would each see
"no session", each POST /session/start, and each receive a different
session_id + infos. The second to finish stored its session as the new
cache, clobbering the first.
That was a problem because file/url wraps the per-track AES key against
whichever session_id the X-Session-Id header carried. If task A got its
wrapped key under session X but the cache got overwritten to Y before
decrypt time, the HKDF over Y-infos produced the wrong session_key and
the AES-CBC unwrap failed with "Unpad Error" — which is exactly the
warning that showed up in prefetch runs during parallel downloads and
caused the >3s gap between offline-cached tracks when the next track's
prefetch had silently fallen back to legacy.
The symptom in logs:
[CMAF] Starting new session ← task A
[CMAF] Starting new session ← task B (same ms)
Session started: id=bHoSYBFx...
Session started: id=bJ-w2wgm... ← cache now holds B
[PREFETCH] CMAF failed for track N: Content key unwrap failed:
AES-CBC unwrap failed: Unpad Error
Fix: double-checked lock pattern. Fast path stays on the read guard
for existing-valid sessions. Slow path takes the write guard, re-checks
under exclusive ownership, and only the first caller actually hits
session/start. Everyone else wakes up and returns the freshly-cached
value.
Compile check only — full behaviour validation in the running dev
session after this commit.
cc
Two symptoms with the same root cause — code paths that touched the
offline cache read file_path as "a plain FLAC file" and handed it
straight to std::fs::read + Symphonia. For v2 bundles the file_path is
the encrypted segments.bin, so both paths exploded.
1. v2_library_play_track: error "Is a directory (os error 21)" when
clicking a v2-cached track from Local Library.
Fix: for source='qobuz_download' rows, the offline-cache DB is the
authoritative source of file paths, not the library index (library
carries display metadata only). Query get_cmaf_bundle:
- cache_format=2 → load_cmaf_bundle (decrypt + play)
- cache_format=1 → read row.segments_path (which for v1 IS the FLAC)
- no row → clean error instead of reading the library directory
2. v2_play_next_gapless: "Symphonia probe failed: end of stream" with
~6 failed retries per track transition → ~6s gap between two v2
offline-cached tracks.
Fix: same cache_format branching as v2_play_track already does.
Reuse load_cmaf_bundle so the probe sees plain FLAC bytes, not
encrypted mp4 boxes.
The prefetch AES-CBC unpad error during concurrent downloads is the
other piece of today's gap story — session race in ensure_cmaf_session.
That's a separate fix in the next commit.
cc
The UI's offline-download progress ring listens to
'offline:caching_progress' events. The legacy StreamFetcher::fetch_to_file
emits those per HTTP chunk via app_handle. The new CMAF path went
silent because cmaf_download_raw lives in the qbz-qobuz crate with no
Tauri access — the user saw the completion toast but never saw the
ring fill.
Fix:
- Add an optional CmafProgressCallback to the qbz_qobuz::cmaf public
API. Typed as Arc<dyn Fn(CmafProgressUpdate) + Send + Sync>.
- New download_full_with_progress and download_raw_with_progress
variants; the callback-less versions delegate to them with None.
- fetch_all_segments fires the callback once per completed segment
with cumulative (k, n, bytes_this_segment). Callback is invoked on
the worker thread after the bytes land, before the rate-limit
cooldown.
- try_cmaf_offline_download passes a callback that emits
'offline:caching_progress' events in the exact shape the UI already
expects (trackId, progressPercent 0..100, bytesDownloaded,
totalBytes: null, status: 'downloading'). Also emits one
zero-progress event up front so the ring doesn't sit at "queued"
while the first segment fetches.
Percentage is computed as (segments_completed / n_segments) * 100,
rounded and clamped. It's segment-granular rather than byte-granular
so the ring advances in N discrete steps (typically 8-20 for a 4-min
track) rather than smoothly — matching what the CMAF pipeline can
actually observe, which is segment-complete events.
cc
Two loose ends after v2 landed:
1. Local Library integration. Qobuz-cached offline tracks already show
up in the Local Library view (via insert_qobuz_cached_track_with_
grouping with source='qobuz_download'). v2_library_play_track was
reading track.file_path and doing std::fs::read() — that works for
plain-FLAC v1 entries, but for v2 the path is the bundle directory,
not a playable file. Fixed:
- Extract the CMAF-load-and-decrypt logic into a shared module
(offline_cache::playback::load_cmaf_bundle) used by both
v2_play_track and v2_library_play_track.
- v2_library_play_track checks source='qobuz_download' +
cache_format=2 on the row and routes through the shared helper.
Legacy v1 entries and regular user local files unchanged.
2. purge_all_cached_files. Previously deleted individual file_path
entries only. For v2 the file_path points inside a track dir
(segments.bin) — removing just that file orphans init.mp4 and
manifest.json. Fixed:
- When the file_path looks like tracks-cmaf/<id>/segments.bin
(matched by the path shape, not a schema flag), remove the whole
enclosing <id>/ directory.
- Belt-and-suspenders: also delete the top-level tracks-cmaf/ dir
after the per-row pass, so orphaned bundles from corrupted rows
are swept up too.
Net: Local Library view preserves the "cached Qobuz tracks appear
here" UX, AND the 30-day grace wipe still removes every encrypted
segment + every library row in one atomic operation. No contradiction
between the two behaviors.
Also extends the compliance whitepaper with a section explaining the
Local Library integration so Franck's team can see that the wipe
contract isn't worked around by the UX shortcut.
cc
Matches Qobuz's own mobile app posture. The previous 3-day window was
both user-hostile (punishes anyone on a flaky network) and a compliance
red flag (shorter windows read as 'we're hiding something', longer
windows read as 'we're lenient for a reason'). 30 days is the exact
parity answer.
The useful protection against bulk-download-and-ghost attacks comes
from the CMAF-at-rest offline cache (v2 format), not from aggressive
revalidation. This grace window is a belt over the suspenders.
Changes:
- GRACE_PERIOD_SECS: 3 → 30 days in config/subscription_state.rs, with
a comment explaining the reasoning for future readers.
- Log message in session_lifecycle no longer says "3 days" (it quoted
a constant, now says "grace window").
- Disclaimer string in all 5 locales (en/es/de/fr/pt) updated from
"3 days" to "30 days" so the Offline Playback settings screen
reflects the actual behavior.
No behavior changes for users with an active subscription. Users who
were within the old 3-day window don't lose cache — the window
extended, not contracted.
cc
Closes the playback side of the offline hardening. v2_play_track's
offline-cache-hit branch now queries the new CMAF bundle columns via
get_cmaf_bundle(), branches on cache_format:
- cache_format = 2 (new): read init.mp4 + segments.bin + manifest.json,
unwrap the content_key through qbz-secrets, decrypt frames via the
shared qbz_qobuz::cmaf::decrypt_segments_into, assemble into a
plain-FLAC Vec<u8>, and feed it to player.play_data — exactly the
same interface the player has always seen for cache hits.
- cache_format = 1 (legacy): unchanged — read the plain FLAC file at
segments_path (the old file_path column) and play directly.
Any failure on the v2 path (missing init, wrong-size unwrap, decrypt
error, vault init failure) logs a warning and falls through to the
next cache tier (memory, disk playback cache) or the network — same
degradation model as a stale legacy entry.
load_cmaf_offline_bundle() is isolated in playback.rs so the hot
v2_play_track body stays readable; it owns the "convert a CmafBundleRow
from the DB into audio_data for the player" pipeline.
LoadedBundle in offline_cache/cmaf_store gets a decrypt_to_flac method
so the caller doesn't have to duplicate the "parse init + concat header
+ decrypt segments" dance the streaming path already does.
End-to-end for v2:
download → cmaf::download_raw → persist_bundle + wrap key → DB
play → get_cmaf_bundle → read_bundle → unwrap key → decrypt
cc
Closes the last legacy /track/getFileUrl user-facing hole flagged by
the CMAF audit. spawn_track_cache_download now tries the CMAF path
first; only falls through to /track/getFileUrl if any of the CMAF
steps fail (no CoreBridge yet, /file/url returns a non-CMAF response,
network hiccup, SecretBox init failure, etc.).
On CMAF success the on-disk layout is:
<offline_root>/tracks-cmaf/<track_id>/
init.mp4 — unencrypted container with FLAC header
segments.bin — concatenated encrypted audio segments
manifest.json — segment offsets (belt-and-suspenders recovery)
The per-track AES content key and session infos are wrapped via
qbz-secrets::SecretBox before they touch the SQLite row
(content_key_wrapped, infos_wrapped columns from the previous commit).
cache_format flips to 2 on the row; the library-index entry lands
with the same title/artist/album the legacy path used, so the UI is
unchanged.
What is deliberately NOT done on the CMAF path:
- No write_flac_tags / embed_artwork: the bundle on disk is encrypted,
writing FLAC tags would corrupt it. The library row carries the
metadata the UI actually reads.
- No organize_cached_file: v2 bundles live under tracks-cmaf/<id>/
by design, no per-artist/album tree (the files aren't standalone
playable FLACs anyway).
Two new modules in src-tauri/src/offline_cache/:
- cmaf_store: persist/load/remove the on-disk bundle layout + the
recovery manifest. I/O only, no crypto, no network.
- secret_vault: lazy SecretBox singleton scoped to the offline-root
directory. The SecretBox handle is cached in OnceLock so every
download shares the same keyring entry (or KDF master key).
Existing offline entries keep working — they're cache_format=1, so
they read from the plain-FLAC file_path unchanged. Playback-from-v2
comes in the next commit (task #20).
Legacy fallback still writes tags + organizes files exactly like
before. This keeps users whose v1 cache is still useful unblocked
while the v2 path takes over fresh downloads.
cc
Adds columns to cached_tracks for the v2 format that stores Qobuz's raw
CMAF segments bit-identical on disk, with the per-track AES content key
wrapped via qbz-secrets (OS keyring or KDF fallback).
New columns (added via idempotent ALTER TABLE, safe to re-run):
- cache_format INTEGER DEFAULT 1 — 1 = legacy plain FLAC (existing),
2 = raw CMAF bundle (new)
- init_path TEXT — path to init.mp4 (FLAC header +
segment table)
- content_key_wrapped BLOB — wrapped 16-byte AES content key
- infos_wrapped BLOB — wrapped session infos salt
- format_id INTEGER — Qobuz format id (5/6/7/27)
- n_segments INTEGER — number of audio segments
Existing rows keep cache_format=1 and continue to play from the plain
FLAC at file_path — zero regression for users with populated caches
when the upgrade ships. New downloads will land as cache_format=2. The
two formats coexist until v1 rows age out naturally (user re-download
or subscription-lapse cache wipe).
Adds set_cmaf_bundle() / get_cmaf_bundle() helpers + a CmafBundleRow
struct so the download path and the playback path have one authoritative
DB surface to talk to.
Also adds qbz-secrets as a direct src-tauri dep so the next commit
(rewiring spawn_track_cache_download) can wrap keys right at the
download site.
cc
Foundation for the offline-cache hardening story. The offline cache
needs to persist per-track AES content keys to disk, but storing them
plaintext would make copying the SQLite DB enough to decrypt the
cached audio on another machine.
qbz-secrets provides a uniform wrap/unwrap API backed by:
1. **OS keyring** (preferred): libsecret/gnome-keyring on Linux,
Keychain on macOS, DPAPI on Windows. A 256-bit master AES key
lives inside the OS secure store; all wraps go through it. This
is the gold-standard device binding used by commercial music
apps (Spotify, Apple Music, Tidal) for the same class of data.
2. **HKDF fallback**: when the OS keyring is not reachable (headless
setups — Raspberry Pi, Docker, the future qbzd daemon on a
server), the master key is derived on demand via HKDF-SHA256
over service_name + machine_id + a persistent per-install UUID.
Weaker than keyring (reversible by anyone with filesystem access
to both sources) but still device-bound against cross-machine
copy attacks, and lets daemon/headless variants work at all.
Every wrap uses AES-256-GCM with a fresh random 12-byte nonce. The
on-disk envelope carries a version byte + backend marker + nonce +
ciphertext+tag, so (a) we detect tampering via GCM, (b) we refuse to
silently unwrap a blob produced by a backend we can't reach, and (c)
we have a forward-compat path for future key rotation.
4 unit tests cover: small-secret round-trip, 16-byte content-key
round-trip (the exact CMAF use case), GCM tamper detection, and
nonce-randomness (two wraps of the same input differ).
This crate intentionally has zero QBZ dependencies — it's a generic
primitive. Next commits wire it into the offline cache schema + the
DB migration.
cc
Prep work for offline-cache CMAF hardening. The full CMAF pipeline
(init-segment setup, full-download, decrypt) used to live in
src-tauri/src/commands_v2/helpers.rs — fine for playback but unreachable
from the offline-cache code without dragging Tauri deps around.
Moves:
- try_cmaf_full_download → qbz_qobuz::cmaf::download_full
- try_cmaf_streaming_setup → qbz_qobuz::cmaf::setup_streaming
- CmafStreamingInfo struct → qbz_qobuz::cmaf
Adds:
- qbz_qobuz::cmaf::download_raw + CmafRawBundle — fetches the same track
but returns the ENCRYPTED segments + init bytes + the unwrapped
content_key + the session infos, ready to be persisted to disk as-is.
The offline cache will use this so that cached files are bit-identical
to what Qobuz delivered (no decrypt-to-disk), with the content key
stored separately under an OS-keyring-wrapped blob. Coming in next
commits.
- qbz_qobuz::cmaf::decrypt_segments_into — shared decrypt helper used by
download_full and (in the next commits) by the offline-playback path
that reads encrypted segments from disk instead of CDN.
In-tree behaviour is unchanged: try_cmaf_full_download /
try_cmaf_streaming_setup in helpers.rs are now thin wrappers that hand
the CoreBridge's QobuzClient to the crate functions. Same API surface
for playback.rs callers, same log tags, same on-wire behaviour.
v2_cmaf_stream stays in src-tauri because it binds to qbz-player's
BufferWriter + qbz-cache's AudioCache — those are playback-only deps
that don't belong in qbz-qobuz.
Net: -100 LOC out of src-tauri, +390 LOC in a properly-layered crate
module with docs explaining the two variants and why the raw one exists.
cc
Sweep of remaining <QualityBadge compact> usages in row/list contexts.
Same fix as the label popular-tracks one: switch to the formatQuality
text representation so every row lines up visually.
Replaced in:
- SearchView.svelte — track rows in track tab & album tab
- PurchasesView.svelte — album list rows
- PurchaseAlbumDetailView.svelte — album metadata header (matches the
text-only treatment already used by AlbumDetailView)
- VirtualizedFavoritesAlbumGrid.svelte — favorites album list rows
Kept as-is (the badge is a first-class visual element, not a text
indicator in a list):
- Player widgets — NowPlayingBar, ExpandedPlayer, ImmersiveControls,
ImmersivePlayer
- Immersive visualizer panels (all 13)
- SearchView "Most Popular" promoted card
- AlbumReactivePanel
cc
LabelView's popular tracks section was rendering the <QualityBadge>
component with compact mode — same one we dropped elsewhere. Switch
to the formatQuality() text representation used by ArtistDetailView's
popular tracks so both views look identical.
Also align .track-quality CSS (font-size / color / min-width) with
ArtistDetailView's rules.
cc
/label/get is gone from the Qobuz v9.7.0.3 Android app (source:
c30/b.java doesn't declare it anymore). With the Qobuz beta rollout
the server-side deprecation timer is probably running, so we yank our
dependency now.
Removed:
- LABEL_GET path constant (qbz-qobuz + src-tauri/api)
- get_label() client method (qbz-qobuz + src-tauri/api)
- get_label() wrapper in QbzCore + CoreBridge
- v2_get_label tauri command + its lib.rs registration
- LabelDetail backend type (qbz-models + src-tauri/api/models)
- commands::search::get_label (dead, was never registered)
- Unused LabelDetail import in src/routes/+page.svelte
Preserved:
- Frontend LabelDetail interface (it's a UI view-model shaped by
LabelReleasesView, not a backend contract)
- /api/labels/{id} HTTP route on qbzd — now composes /label/page +
/label/getAlbums internally so external HTTP clients still see the
same { id, name, description, image, albums: { items, total, ... } }
shape
cc
LabelReleasesView now fetches /label/page (metadata) + /label/getAlbums
(paginated catalog) in parallel instead of hitting the legacy
/label/get one-shot. loadMore() paginates through /label/getAlbums.
LabelView's loadLabelAlbumsAndDescription() now only fetches the album
list via /label/getAlbums; the description comes exclusively from the
already-in-flight /label/page call (loadLabelPage).
Both views still present the same LabelDetail-shaped view-model;
nothing UI-visible should change. Prepares for deletion of the legacy
/label/get stack in the next commit.
cc
Closes the gap between our client and the Qobuz Android app's current
label API (source: c30/b.java). Qobuz is rolling out a web beta so the
legacy /label/get is likely on borrowed time — adding the v9.7.0.3
endpoints now so the migration can happen in follow-up commits.
New endpoints (paths + client + core + bridge + v2 command + registered):
- /label/getAlbums → v2_get_label_albums
paginated catalog with sort/order/genre_ids/from_date/to_date
- /label/getNextReleases → v2_get_label_next_releases
- /label/getAwardedReleases → v2_get_label_awarded_releases
- /label/getPlaylists → v2_get_label_playlists
- /label/getTopArtists → v2_get_label_top_artists
- /label/story → v2_get_label_story
- /label/getList → v2_get_label_list (POST, mirrors
track/getList signing)
New response types in qbz-models:
- LabelListPage<T> — generic { has_more, items: [T], total?, offset?,
limit? } envelope, tolerant to either V2 list or SearchResultsPage
shapes until samples land
- LabelStoryResponse, LabelGetListResponse — best-effort with optional
fields so a shape mismatch is non-fatal
The legacy /label/get + get_label() + v2_get_label + LabelDetail are
retained untouched for now; frontend migration and deletion come next.
cc
Fix#326 — multi-track selection in Local Library. Works on the tracks
tab and inside the album detail view (the more useful context per user
feedback). Bulk play next / play later / add to playlist.
Fix#327 — clicking a track in the queue panel now plays that exact
track even under shuffle. Adds play_upcoming_at with shuffle-aware
index resolution, plus dead From-impl cleanup.
The reset `$effect` was tracking its own writes. When the select-mode
button set `trackSelectMode = true`, the effect re-ran (because
`resetMultiSelect()` reads both `trackSelectMode` and `selectedTrackIds`
inside the effect body) and immediately cleared the state again — so
the button visibly did nothing.
Wrap the reset call in `untrack()` so the effect only rebinds on tab /
album changes, not on its own output.
cc
Extends the tracks-tab multi-select to the album detail view. User
requested this because it's actually more useful there (picking a
subset of an album's tracks for a playlist is the common case).
- Select toggle button added to the album-actions row (next to play /
shuffle), using the same `action-btn-circle` style so it sits with
the existing circular actions.
- TrackRow inside `albumSections` now receives `selectable`,
`selected`, `onToggleSelect` — TrackRow already supports these, they
were just not wired here.
- Same BulkActionBar rendered below the track list; the existing bulk
handlers (`handleBulkPlayNext` / `handleBulkPlayLater` /
`handleBulkAddToPlaylist`) were updated to look up selected ids from
both `tracks` and `albumTracks`, so it works in either context.
- $effect watches `activeTab` and `selectedAlbum?.id`, clearing
selection whenever the user switches tab or enters/leaves an album.
Prevents stale selection bleeding across views.
cc
Mirrors the pattern already used in FavoritesView so users can select
multiple local tracks and bulk-add them to the queue (play next / play
later) or to a playlist — the same way it works for Qobuz favorites
and playlists.
- New `trackSelectMode` + `selectedTrackIds` state + handlers (toggle
mode, toggle row, bulk play next/later, bulk add to playlist).
- New `SquareCheckBig` toolbar button on the tracks tab (matches the
one in FavoritesView).
- VirtualizedTrackList wired with `selectable`, `selectedIds`,
`onToggleSelect` props (already supported, just unused here).
- `<BulkActionBar>` rendered below the list when selection is active.
- New `onBulkAddToPlaylist` prop, wired in +page.svelte to
`openAddToPlaylist(trackIds, true)` so the existing playlist picker
modal handles the rest.
- Bulk play next/later go through `cmdAddTracksToQueue` /
`cmdAddTracksToQueueNext` (route to qbzd when remote, otherwise local
bulk command). Plex tracks are filtered out only for "add to
playlist" (per existing per-row guard); they're fine in the queue.
cc
The frontend was resolving queue-panel clicks via
`actualIndex = current_index + trackIndex`, mixing the unshuffled
canonical position with the shuffle-aware display position. On shuffle
mode, the resulting index pointed at a different track than the one
the user clicked, which is exactly what issue #327 reports.
Solution:
- New `QueueManager::play_upcoming_at(upcoming_index)` resolves the
click position through `shuffle_order` + `shuffle_position` when
shuffle is on, and falls back to `current_index + upcoming_index + 1`
otherwise.
- Exposed through `QbzCore::play_upcoming_at` (emits QueueUpdated) and
`CoreBridge::play_upcoming_at`.
- New `v2_play_queue_upcoming_at` tauri command.
- `QueuePanel.onPlayTrack` now carries the `originalIndex` so the
caller knows the exact upcoming-list position the user clicked.
- `handleQueueTrackPlay` calls the new command directly — no more
client-side index arithmetic.
Also deletes the two dead `From<crate::queue::QueueTrack>` impls in
commands_v2/queue.rs (canonical queue lives in qbz-player now), per
the zero-legacy V2 policy.
Tests: two new unit tests cover the linear and shuffle-aware paths.
Session persistence is untouched — the new method only consults
existing state.
cc
AirPlay was scaffolded in both crates/qbz-cast/src/airplay and
src-tauri/src/cast/airplay but never worked at runtime: the RAOP
sender required an Apple MFi-licensed stack with no free/open
alternative, and the backend state was already disabled via the
commented `.manage(airplay_state)` line in src-tauri/src/lib.rs.
The CastPicker UI already hid the AirPlay tab pending streaming
support that was never going to ship.
Delete:
- crates/qbz-cast/src/airplay/ (entire directory)
- src-tauri/src/cast/airplay/ (entire directory)
- 10x v2_airplay_* commands from commands_v2/library.rs + their
tauri::generate_handler entries
- AirPlayError from qbz-cast errors
- 'airplay' from CastProtocol + every case arm in castStore.ts,
CastPicker.svelte, AudioOutputBadges.svelte
- Corresponding i18n keys if present
Zero behavior change for Chromecast / DLNA / QConnect / MPRIS. If
AirPlay ever becomes feasible we'll revisit from scratch with a
real streaming backend.
cc
Split the monolithic v2_search_all command (44 cognitive complexity,
critical on Sonar) into four small single-purpose helpers:
- parse_results_page<T>(response, key, limit) — generic DeserializeOwned
accessor that replaces four copy-pasted .get().and_then().unwrap_or
blocks returning an empty SearchResultsPage.
- filter_page<T, F>(page, keep) — closure-based retain-with-total-
adjustment that replaces three near-identical post-filter blocks.
- most_popular_from_item(item, blacklist) — per-item match over the
three supported types; each arm is a flat parse + single blacklist
check, no nested continues.
- pick_most_popular(response, blacklist) — traverses the items array
via find_map, replacing the deeply-nested and_then/for/match/return
stack that tripped the cognitive-complexity threshold.
Semantics are preserved: same filter criteria (including the track
"no performer" edge case), same skip-on-blacklist behaviour, same
return shape. v2_search_all itself is now ~30 lines, each helper is
<15 complexity.
cc
Bugs (3, all same pattern): Promise-typed variables were used as
boolean conditions, which is always truthy regardless of the resolved
value. Make the nullness check explicit:
- src/lib/services/imageCacheService.ts:36 (Map.get result)
- src/lib/stores/awardCatalogStore.ts:108 (inflight Promise|null)
- src/lib/stores/windowControlsStore.ts:228 (detectInFlight)
Hotspots:
- playerStore.test.ts, queueStore.test.ts: http -> https in test
fixtures (harmless in-memory fixtures, but keeps the linter quiet)
- playbackTargetStore.ts:30: replaced the trailing-slash trim regex
with a bounded while-endsWith loop to drop the ReDoS warning
- playlistSuggestionsService.ts:181 & trackActions.ts:551: kept
Math.random for shuffle/seed (non-cryptographic by design); added
explanatory comments and marked the Sonar hotspots as SAFE.
Closes Reliability delta from 3.0 (C) to 1.0 (A) on next scan.
cc
Per the original instruction: single line for 1.2.7 + the full 1.2.6
body (which already carries the 1.2.5 content below it). The previous
version over-expanded the 1.2.7 section into three paragraphs.
cc
Resolved via two `nix build` iterations against the v1.2.7 tag.
Users tracking main get a zero-friction build; users pinning to the
v1.2.7 git tag still need to substitute the hashes themselves since
the hashes were unknown at tag time (same as every prior release).
cc
The v1.2.6 regenerated tray glyphs were monochrome outlines of the Q:
the selection logic (prefer_dark_tray() -> dark-variant) picks
tray-dark.png on dark panels, which rendered as a black Q on dark
bg (issue visible in Plasma on emerge qbz-bin install).
Switch to a full-colour render of the final icon.svg (matte-vinyl
disc + blue rim + inner highlight). Full-colour rim gives definition
on both light and dark panels, so one PNG works for every variant:
the three tray files (tray.png, tray-light.png, tray-dark.png) now
point to the same render and the selection logic becomes a no-op.
cc
CodeQL rust/cleartext-logging (alert #69) flagged the info-level log
that prints the radio session id on creation. The value is only
useful for local troubleshooting; demote to debug! so it stays out
of default-level logs (same treatment as the qbzd user_id logs).
cc
The 0.10.x advisory was fixed in v1.2.7 by bumping 0.10.0 -> 0.10.1.
The same advisory also applies to 0.9.x with a separate patched
version (0.9.3). Applying the bump to both lockfiles so the alerts
for the transitive 0.9.x deps close too.
cc
Settings menu > Report Issue now opens a modal instead of jumping
straight to the GitHub new-issue page. The modal explains that
sharing the (manually masked) logs speeds up triage and offers two
actions:
- Go to logs → navigates to Settings > Developer Mode and
auto-opens the Logs modal so the user can review and upload.
- Create issue report → opens the GitHub issues page.
A persistent "Do not show this again" checkbox stores the preference
in localStorage (qbz-hide-report-issue-modal). When the flag is set,
the menu item skips the modal and goes straight to GitHub, matching
the previous behaviour.
Wiring: new settingsIntentStore lets UserCard cue SettingsView to
open at the `developer` section with showLogsModal=true, consumed and
cleared on mount so a plain Settings navigation afterwards uses the
normal default section.
i18n: new reportIssue block added to all 5 locales (en/es/de/fr/pt).
cc
New resting state (= previous hover):
fill --accent-hover
glyph --text-primary
ring --text-primary (2px)
New hover state (= previous resting):
fill --accent-primary
glyph --accent-hover
ring --text-primary (2px)
Ring colour/thickness stays constant across both states; only fill
and glyph flip.
cc
Glyph colour in normal/inactive state is now var(--accent-hover) —
i.e. the same colour the button fills to on hover. Explicit color:
var(--text-primary) on the hover rule to keep the hover path intact
after inverting the resting glyph colour.
cc
Per design direction: normal/inactive state of .action-btn-circle.primary
now uses the exact same stroke as the hover state (2px inset
--text-primary). The sole visual difference between resting and hover
is now the background fill (--accent-primary vs --accent-hover).
cc
Revert the four commits that touched .action-btn-circle since 1.2.6:
- d673dc20 thicken stroke 1->2px (3px primary)
- a9eaf646 thicken only resting stroke of primary
- eb9f82ea bump primary resting stroke to 5px
- 5a52ef55 switch primary to real border
All rules back to their pre-1.2.6-release state. Awaiting a new
direction from the user.
cc
Inset box-shadow renders the circular stroke as a stair-stepped /
hairline edge on WebKitGTK — no matter how thick we set it, sub-pixel
AA eats most of it and on HiDPI it disappears entirely. Switch the
primary .action-btn-circle to an actual 5px border with
box-sizing: border-box so the outer dimensions stay 44x44 but the
stroke is rasterised through border AA (which respects border-radius
cleanly).
Also swap --border-subtle for --alpha-40 so the ring has guaranteed
contrast against the accent colour in every theme.
Secondary buttons and is-active stay on inset box-shadow — they're
thinner and the background contrast is higher there, so the shadow
path still reads fine.
cc
Settings > Developer Mode > View Logs now has a toggle (default ON,
persisted to localStorage as qbz-paste-bundle-diagnostics) that
prepends the full System Diagnostics snapshot plus a 10-second cast
scan to the terminal paste upload, so bug reporters share one link
instead of two. Console-tab uploads are unaffected.
- New service module diagnosticsSnapshot.ts centralises the snapshot
payload (runtime + system + playback + qconnect + optional cast
scan) so the panel and the paste flow don't drift apart.
- LogsModal shows "Collecting diagnostics..." while the scan is
running, then "Uploading..." once it hands off to the paste server.
Also revert the auto-run cast scan on the diagnostics panel: bundling
into the paste covers the "one-shot bug report" use case, and the
panel opens instantly again.
cc
New v2_get_system_info command and matching UI section in the
System Diagnostics panel. What it reports:
- os (linux/macos/windows)
- arch (x86_64, aarch64)
- kernel_version from /proc/sys/kernel/osrelease
- Linux distro: id, version_id, pretty_name from /etc/os-release
(falls back to /run/host/os-release so it works inside Flatpak)
- install_method: flatpak / snap / appimage / dev / native, detected
via FLATPAK_ID + /.flatpak-info, SNAP, APPIMAGE env vars, and
debug_assertions as the last fallback
- flatpak_runtime + version: parsed from /.flatpak-info
- loaded library versions (from /proc/self/maps, symlink-resolved):
webkit2gtk-4.1, gtk-3 (or 4), glibc, alsa, pipewire, pulseaudio
All info is derived from local files/env; no sensitive data, no IDs,
no hashes. Included in the clipboard export.
cc
- Volume: playerStore.getVolume() already returns 0-100, the extra *100
was reporting "10000%". Just Math.round() the stored value.
- Cast scan: run automatically the first time the panel is opened so
the user doesn't have to press the button. Button now doubles as
"re-scan" while disabled during an in-flight scan. A spinner
placeholder shows while the initial scan is in progress.
- Track info: capture a single snapshot on open/refresh instead of
live-subscribing to the player store — live updates were unnecessary
for a diagnostic dump and slowed the settings page. Use "Refresh"
to take a fresh snapshot.
cc
Extend the System Diagnostics panel with three new sections aimed at
what debug tickets usually ask for, and include them in the clipboard
export:
- Playback: is-playing, volume, position/duration, current track
(title, artist, album, source, local flag, quality/format/bit-depth/
sample-rate). No track IDs or UUIDs — defensive regex redacts any
hex/UUID-shaped strings before export so paste sites and CodeQL
don't flag them as secrets.
- Qobuz Connect: running/transport_connected, role (controller /
local-renderer / observer / none), active renderer friendly
name/brand/model (no UUIDs or IPs), visible renderer count, last
error (id-redacted).
- Cast Discovery: on-demand 10-second multicast scan for Chromecast
and DLNA; reports per-protocol count and the friendly names that
were discovered. No hosts, no ports, no UUIDs.
Playback rows stay live via a player-store subscription while the
panel is open.
cc
3px was still not enough against a low-contrast --border-subtle ring.
Push it to 5px so the stroke is unmistakable at default resolution
and survives HiDPI scaling.
cc
Previous commit bumped every stroke state to the same thickness. The
hover and secondary-button states were fine; only the primary's
resting stroke (using --border-subtle, a low-contrast colour) read as
jagged from sub-pixel AA and disappeared on HiDPI.
Revert secondary buttons, is-active, and primary-hover to their
original 1-2px. Keep the primary resting state at 3px so it survives
AA at the default resolution and stays visible on HiDPI.
cc
The 1px inset stroke on .action-btn-circle read as jagged at standard
resolution (sub-pixel antialiasing artifacts) and effectively invisible
on HiDPI displays. Bump the resting stroke to 2px (secondary) and 3px
(primary play button) so it survives both; hover states scale with it
to keep the visual hierarchy. The extra pixels eat slightly into the
concentric fill, per the requested trade-off.
Applies to all reuse sites: Album/Artist/Playlist/Label/FavQ detail
headers, DynamicSuggest, ForYouTab, LocalLibrary, etc.
cc
The previous CSS only disabled user-select while .dragging was active,
but the drag class only gets applied after crossing the 5px threshold
in onPointerMove. During those first few pixels the browser's default
selection behaviour would highlight card titles and artist names,
which the user then has to click away to clear.
Disable user-select on the scroll-container permanently. Text is
still selectable in the album/artist/playlist detail views — only the
carousel rows themselves are locked.
cc
Includes:
- feat(window): optional track metadata in window title (#324)
- fix(window,login): grant set-title capability + shrink login logo 20%
- fix(cast): keep scanning spinner visible for the full discovery window
Users whose favorites tab_order was persisted before 'labels' became
a favorites tab see the sidebar render without the Labels entry,
while the TitleBar nav (which uses a fresh default) shows it fine.
When loading the persisted tab_order, diff against the canonical
default and splice back any tab the user is missing at its default
position. Preserves any reordering the user applied.
cc
Advisory: rand is unsound with a custom logger using rand::rng().
Affects 0.10.x only; 0.10.1 fixes the issue. The older rand versions
still present in the lockfiles (0.7.3, 0.8.5, 0.9.2) are transitive
dependencies that do not use the rand::rng() API surface introduced
in 0.10 and are not exploitable via this advisory.
The lru 0.12.5 advisory (GHSA-rhfx-m35p-ff5j) is a transitive dep of
ratatui 0.29.0 (used by qbzd). Can't be bumped without upstream
ratatui dropping the old lru; tracked separately.
cc
Multicast discovery (DLNA / Chromecast) typically needs 5-15s before
devices announce themselves. The previous code set loading=false
after the first pollDevices() call, so users saw an empty "No devices
found" state just a second or two after opening the picker — even
though discovery was still in progress.
Add a separate `scanning` flag that stays true for 15 seconds after
startDiscovery (cleared explicitly on stopDiscovery and on error).
The empty state now shows the spinner + "Loading devices" while
(loading || scanning), so users get visual feedback during the full
multicast window instead of a misleading "no devices found".
cc
- Add core:window:allow-set-title to capabilities/default.json. Tauri 2
rejects setTitle() from the frontend unless the capability is
explicitly granted; without this the window-title feature silently
fell back to "QBZ" in every case.
- Login logo: 175px -> 140px (-20%) per feedback.
- Drop the debug console logging on the title effect now that the
wiring is confirmed working; keep the warn-on-failure.
cc
Add an opt-in setting under Appearance that lets the OS window title
reflect the currently playing track. Template supports {artist},
{track}, {album} placeholders; defaults to "{artist} — {track}".
Falls back to "QBZ" when disabled or with no track.
Persisted to localStorage (pure UX preference — no backend state).
cc
HorizontalScrollRow.setPointerCapture() was called on every pointerdown
inside the scroll container. Per the Pointer Events spec, once a
pointer is captured, subsequent events — including the click that
follows pointerup — are retargeted to the capture element. For cards
rendered inside the carousel that meant clicks never reached the card
button, so nothing happened when users tried to open an album, artist,
or playlist from any row on Home / Discover / Editor's Picks / For You.
Don't capture the pointer up front. Only call setPointerCapture once
the move threshold (5px) is crossed, i.e. when we know this is a real
drag and not a click. Plain clicks take their normal path to the card
and navigation works; drags still get capture so the scroll keeps
tracking the cursor if it leaves the container.
Also wrap both capture/release in try/catch (some WebKit versions
throw when the pointer is no longer valid) and reset dragDistance in
onClickCapture so a swallowed click doesn't poison the next one.
cc