85 Commits

Author	SHA1	Message	Date
cucadmuh	fc34a0ec59	feat(offline): local-bytes browse when server is unreachable (#1017) ... * feat(offline): local-bytes browse for artists and albums Make Artists, All Albums, and artist/album detail pages work offline from the library index limited to on-disk library and favorite-auto tracks. Add a DEV header toggle to simulate offline browse for testing. * feat(offline): reactive DEV offline toggle with full disconnect simulation Subscribe nav and browse/detail hooks to useOfflineBrowseActive so UI refreshes on toggle. DEV force-offline now blocks server probes, reports disconnected status, and gates Subsonic like real offline for player parity. * feat(offline): bytes-first favorites when offline browse is active Load Favorites from local playback bytes, filter starred tracks client-side, and restrict album-level star queries to local album ids. Drop interim perf attempts (lean SQL, progressive load, connection singleton, prefetch UX). * feat(offline): tracks, help, player stats; suspend library picker offline - Offline browse for Tracks hub from local bytes; sidebar nav for tracks/help/statistics - Statistics redirects to player-stats offline; server/Last.fm tabs skip network fetches - Hide music-library picker offline; save filter and restore on reconnect (all libraries while disconnected) - Unified isOfflineSidebarNavAllowed for library + system entries * feat(offline): fork disconnect navigation by offline browse capability When the server drops: stay on the page if nothing is browsable offline; reload in place on offline-capable routes; otherwise redirect to All Albums instead of the old /offline or /favorites bounce. * feat(offline): browse cached playlists when the server is down List and open manually pinned regular playlists from local library-tier bytes offline, with sidebar/nav routing and read-only playlist UI. * feat(offline): read-only artist detail and local play-all paths Hide favorites and discography offline actions when browse is offline; load Play All, Shuffle, and top-track continuation from local album bytes. * feat(offline): read-only album detail and enqueue from local bytes Hide favorites, download, and cache-offline actions on album pages when offline browse is active. Favorites album cards enqueue via the same resolveAlbumForServer path as play, including local playback bytes. * chore: remove unused import in AlbumCard after enqueue refactor * feat(offline): unify browse integration contract across the app Add useOfflineBrowseContext, offlineMediaResolve, and offlineActionPolicy; wire shell nav to a single capability source; migrate play/enqueue and context-menu paths off raw getAlbum; replace readOnly with action policy on detail surfaces. Tests updated for the media-resolve facade. * feat(offline): close browse contract gaps and fix offline Home feed Split offline browse modules, align favorites capability across servers, wire action policy on context menus, migrate hooks to useOfflineBrowseContext, and preserve stale Home feed cache when offline so the UI does not empty. * fix(offline): block playbar stars, close audit gaps, trim dead exports Hide star rating and favorite in PlayerBar when offline browse is active via offlineActionPolicy playerBar surface. Wire stay-reload token into browse hooks, migrate hooks to context.active, guard rating prefetch network calls, and route playlist load through resolvePlaylist. * docs: add CHANGELOG and credits for offline browse PR #1017 * fix(offline): stop DEV connection probe regression in tests React to devForceOffline transitions only in useConnectionStatus so mount does not double-fire check() or ignore disableBackgroundPolling. Add pingWithCredentials to PlayerBar test mock and DEV-toggle unit tests.	2026-06-07 15:59:41 +03:00
cucadmuh	2d3c723a6e	feat(offline): unify local playback, offline library, and favorites sync (#1008) ... * feat(local-playback): LP-1 media layout and download_track_local Add library-index-backed path builder in psysonic-core and a unified Tauri download command that writes under media/{cache|library}/ with layout fingerprints; legacy hot/offline commands unchanged for now. * feat(local-playback): LP-2 localPlaybackStore and media tier Rust helpers Add unified Zustand index with legacy offline/hot-cache import, media_layout TS mirror, and Rust commands for tier size/purge/delete/promote. * feat(local-playback): LP-3 wire prefetch and playback to unified index Route downloads through download_track_local, delegate hot/offline shims to localPlaybackStore, and update resolve/promote/prefetch plus key rewrite. * feat(local-playback): LP-4–LP-6 offline UI, invalidation, and mediaDir Offline Library loads pinned groups via library index; sync-idle invalidates stale paths; Settings uses a single mediaDir with cache/library tier sizes. * feat(local-playback): migrate legacy offline files to media/library layout Move flat psysonic-offline downloads into nested media/library paths using library index metadata, with retry on sync-idle when tracks are not yet indexed. * feat(local-playback): simplify offline disk migration and restore Offline Library UI Scan psysonic-offline on disk and relocate by library track id; restore pinSource and cover art for migrated pins; add find_live_by_id for segment/key resolution. * feat(local-playback): disk-first offline reconcile and fast library tier discovery Reconcile library-tier index against on-disk files using candidate track IDs instead of scanning the full catalog. Refresh Offline Library from disk on open and focus so deleted folders drop out of the UI. Add Rust discover/prune helpers and wire album/server reconcile through the unified path. * fix(offline): resolve local playback URLs across server index-key variants Offline Library play failed when library-tier files were indexed under a host key while playback looked up only the active profile UUID. Use findLocalPlaybackEntry for URL resolution, pin queueServerId to the card server, and build play queues from tracks that still have on-disk bytes. * fix(offline): playlist cards, playback from Offline Library, and local URL routing Show playlists with name and quad/custom cover instead of the first track's album artist. Build play queues with library-batch fallback and offline-only server switch. Prefer library-tier URLs in playTrack; add playback-unavailable toast and missing trackToSong import. * fix(cache): ephemeral disk reconcile, empty-dir prune, and Storage UI Sweep media/cache after eviction (orphan files, stale index, empty folders). Settings: split media folder from cover cache; in-browser image cache lives under Cover art cache with aligned columns; clear only IndexedDB images. * feat(offline): show library disk usage in Offline Library header Query media/library tier size on reconcile and display it in a right-aligned stat block beside the page title and album count. * fix(cache): defer unindexed hot-cache eviction; drop legacy offline size cap Reconcile ephemeral cache without deleting files from other app instances; evict unindexed hot-cache files oldest-first only when over hotCacheMaxMb. Remove the hidden maxCacheMb gate and offline-full banner on album pages. * feat(offline): play-all cache card and stable Offline Library grid rows Add a shuffle-and-play card for all on-disk library pins plus hot-cache tracks when buffering is enabled. Fix virtual row height for offline cards and reserve the year line so grid rows no longer overlap. * feat(offline): queue-cache grid card limited to media/cache Replace the full-width play-all banner with a playlist-style grid tile. Shuffle/enqueue only ephemeral hot-cache tracks when buffering is enabled, not offline library pins. * chore(licenses): regenerate bundled OSS list for 1.48.0-dev Set GPL-3.0-or-later on workspace crates and extend cargo-about accepted licenses so generate-licenses.mjs runs; refresh src/data/licenses.json. * feat(favorites): auto-sync starred tracks into separate media/favorites tier Keep manual Offline Library in media/library/ and favorites offline in favorite-auto/index + media/favorites/ so toggling sync cannot purge user-pinned bytes; playback resolves library before favorites. * feat(favorites): compact offline toggle with disk icon and sync semaphore Move control to the page header (disk + switch, tooltips); show red/yellow/green LED when enabled instead of the full-width save-offline card. * fix(favorites): trigger offline sync on star/unstar from anywhere Hook star/unstar API so favorites offline reconcile runs globally (songs, albums, artists); optimistic unstar removes local bytes; drop Favorites-page-only sync. * fix(cache): skip hot-cache prefetch when favorites or library bytes exist Treat favorite-auto tier like offline library for prefetch, stream promote, and same-track replay so synced favorites are not duplicated in media/cache. * fix(favorites): reconcile offline files on merged track union only Dedupe artist/album/song stars into one target set per track id; drop eager unstar deletes so overlapping favorites do not remove bytes still needed. * feat(offline): add Favorites card to Offline Library Mirror queue-cache card for favorite-auto tier with play, enqueue, and navigation to Favorites on card click. * feat(offline): show library+favorites disk total with icon breakdown Sum media/library and media/favorites in the On disk widget and open an icon popover on hover with per-tier sizes for screen readers and sighted users. * feat(favorites): enable offline Favorites tab when auto-save is on Keep Favorites in the sidebar when disconnected, land on /favorites without manual pins, and load starred rows from the local library index. * feat(favorites): cross-server offline browse with per-server covers When auto-save is on, Favorites merges starred items from every indexed server and syncs each server independently. Detail links carry ?server= for offline album/artist pages; cover art resolves disk cache by entity serverId instead of the active server only. * feat(playback): mixed-server queue scope and cross-server favorites sync Per-ref server identity for playback (URL index key in queue refs, profile UUID for API): trackServerScope, playbackServer helpers, gapless/scrobble/covers by playing ref. Remove cross-server enqueue block; remap queueItems on URL remigration. Favorites: star/unstar and favorite-auto sync target the owning serverId (not only active); queueSongStar passes server through pending sync. * fix(offline): suppress Subsonic calls during favorites and local playback Add reachability guards so offline favorites browse, album detail, queue sync, scrobble, and Now Playing metadata skip network when the server is down or the track plays from psysonic-local. Load starred albums/tracks from the library index only (not the full artist table), refresh favorites from index first, and pass server scope in favorites navigation. * fix(queue): export share and playlist save for active server only Mixed-server queues now filter queue refs by the browsed server profile before copying a share link or saving/updating a playlist from the toolbar. * fix(offline): complete album pins and resume interrupted downloads Prefer full getAlbum track lists when online so partial library index does not truncate offline pins; refresh songs before pin from album detail. Resume incomplete persisted pins after reconcile and reconnect, cancel in-flight work on delete, and chunk library batch fetches past 100 refs. * fix(offline): pin queue, queued UI, and re-pin after remove Serialize album and playlist offline pins so parallel enqueue no longer drops in-flight work. Show an explicit queued state on album and playlist actions with dequeue on repeat click, sidebar tooltips for long labels, and clear stale cancel flags so Make available offline works after remove. * fix(offline): remove Offline Library cards without full page reload Optimistically drop the deleted card from local grid state, show the loading spinner only on first visit, and ignore stale disk refreshes so pin updates no longer flash the whole library view. * fix(offline): artist discography pin state and queue handling Detect cached/queued/downloading from persisted album pins instead of ephemeral bulkProgress, skip already offline or in-flight albums when enqueueing discography, and show the correct hero button after revisit. * fix(local-playback): address LP-1 review handoff (B1, M1–M7) Harden media path sanitization and tier containment, align Rust/TS layout fingerprints, serialize per-track downloads, and fix favorites re-enable, multi-server debounce, prev-track promote key, now-playing reachability, and ephemeral prefetch soft-skip for unindexed tracks. * fix(offline): cancel in-flight favorites downloads on unstar Abort Rust streams with the real favorites downloadId when sync is rescheduled or disabled, and drop completed bytes that no longer belong in the starred set so unstar does not leave orphan files on disk. * fix(build): resolve TypeScript errors blocking prod nix build Align mediaLayout with LibraryTrackDto camelCase, extend analysis-sync reasons, fix OfflineLibrary grid cover typing, and tighten vitest mocks so `tsc && vite build` passes under the flake beforeBuildCommand. * fix(rust): satisfy clippy too_many_arguments for CI Bundle offline-library analysis and local path/migration helpers into parameter structs so `cargo clippy -D warnings` passes on the branch. * fix(settings): show correct hot-cache track count in Buffering section Count ephemeral localPlayback rows instead of prefix-matching index keys, which always missed host:port server segments and showed zero tracks. * fix(media-layout): align truncation threshold on code points (M1) Rust sanitize_and_truncate_segment now uses char count like TS so long non-ASCII metadata does not diverge layout fingerprints; add Cyrillic parity tests and clarify ephemeral cold-miss doc on download_track_local. * fix(test): use numeric cachedAt in hotCacheStore count test Align test fixture with LocalPlaybackEntry type so tsc passes in CI. * docs: add CHANGELOG and credits for offline experience PR #1008 * feat(offline): auto-sync manually cached playlists when track list changes Re-download new tracks and prune removed ones for playlist pins only, triggered from updatePlaylist, playlist detail load, smart-playlist polling, and reconnect. * docs: note cached-playlist sync in CHANGELOG and credits for PR #1008 * fix(offline): exclude smart playlists from manual offline cache and sync Hide cache-offline for psy-smart-* playlists, block download/sync paths, and document the distinction in CHANGELOG. * feat(offline): auto-sync cached albums and artist discographies Generalize pinned playlist reconcile into pinnedOfflineSync so manually pinned albums and artist discographies re-download added tracks and prune removed ones on reopen, reconnect, and catalog changes. * feat(offline): split pinned sync triggers by pin kind Album and artist pins reconcile after library index sync and reconnect; regular playlists reconcile hourly and on in-app playlist edits only. Remove reconcile-on-open for album, artist, and playlist detail views. * fix(offline): address PR #1008 review (N1, tests, pin queue) Scope playlist reconcile to the owning server via getPlaylistForServer. Add artist discography and mixed-server playlist tests; dedupe pending sync jobs; skip pinTasks overwrite during active downloads.	2026-06-06 22:43:03 +03:00
Frank Stellmacher	1de2b0e850	feat(queue): switchable queue display mode (Queue vs Playlist) (#922) ... * feat(queue): add queueDisplayMode setting with rehydrate (default queue) * feat(queue): render upcoming-only or full timeline by mode, with header toggle * feat(settings): add queue display mode toggle to Personalisation * i18n: queue display mode strings across all locales * test(queue): display-mode rendering and absolute index mapping * docs: changelog + credits for queue display mode (#922)	2026-05-30 00:26:07 +02:00
Frank Stellmacher	9fa086c428	feat(server): dual server address (LAN + public) per profile (#880) ... * feat(server): ServerProfile.alternateUrl + shareUsesLocalUrl Additive optional fields on ServerProfile to back the dual-address work. 'alternateUrl' is the optional second endpoint (e.g. LAN counterpart of a public 'url' or vice versa); 'shareUsesLocalUrl' chooses which of the two goes into Orbit / entity / magic-string shares when both are set. Pure schema change — no runtime consumers yet. Single-address profiles keep the same persisted shape; the optional fields are simply absent. * feat(server): serverEndpoint module with LAN classification + IPv6 Introduces a single home for connect-/share-layer URL utilities that the dual-address work will build on: * normalizeServerBaseUrl(raw) — aligned with serverProfileBaseUrl * isLanUrl(url) — IPv4 (unchanged) + IPv6: ::1 loopback, fe80::/10 link-local, fc00::/7 ULA, and IPv4-mapped (both dot-decimal and the URL-API-normalized hex form, since new URL() rewrites ::ffff:1.2.3.4 to ::ffff:HHHH:HHHH) * allNormalizedAddresses(profile) — deduped [url, alternateUrl?] * serverAddressEndpoints(profile) — LAN-first ServerEndpoint[] isLanUrl moves out of useConnectionStatus.ts (the hook now imports + re-exports it for backward compatibility); OrbitStartModal points at the new path directly. 38 unit tests cover the IPv4/IPv6 matrix, dedupe, ordering, and edge cases. * feat(server): pickReachableBaseUrl with in-memory connect cache Adds the runtime connect layer on top of serverEndpoint: * pickReachableBaseUrl(profile) — sequential LAN-first ping via the existing pingWithCredentials; first OK wins. * ensureConnectUrlResolved(profile) — boot / switch / online-event entry point (same mechanism, intent-named). * In-memory cache keyed by profileId; sticky behaviour tries the cached endpoint first, falls back to the natural order on miss. * invalidateReachableEndpointCache(profileId?) — single-profile and whole-cache flushes for profile-edit / credentials-change / online. * getCachedConnectBaseUrl(profileId) — sync getter for getBaseUrl fallback path (next commit). The cache is **session-only**, never persisted. Single-address profiles keep the same shape (one endpoint, one ping). 9 new unit tests cover single + dual address, LAN-first preference, fallthrough, unreachable + stale-cache clear, sticky hit, and the two invalidate flavours. * feat(server): getBaseUrl reads connect cache, falls back to primary url Dual-address profiles need 'getBaseUrl' to return the runtime-probed connect URL (LAN at home, public elsewhere), not the literal primary 'url'. To keep the sync getter shape that ~60 call sites depend on, the store now reads 'getCachedConnectBaseUrl(server.id)' from the serverEndpoint cache. If no probe has run yet (very early boot, before switchActiveServer populates the cache), it falls back to the normalized primary URL — identical to today's behaviour. Single-address profiles see no difference; their cache entry equals serverProfileBaseUrl(url). * feat(server): switch + connection-status probe via ensureConnectUrlResolved Both surfaces that previously called pingWithCredentials(server.url, ...) directly now route through the dual-address connect layer: * switchActiveServer awaits ensureConnectUrlResolved(server), reads the identity (type/serverVersion/openSubsonic) off the returned ping, and hands probe.baseUrl (not server.url) to scheduleInstantMixProbeForServer so the AudioMuse probe also hits the reachable endpoint. * useConnectionStatus.check() does the same on every 120 s tick — sticky cache fast-paths the steady state, and a network change naturally flips the active endpoint without a manual retry. * useConnectionStatus.retry() and the 'online' event flush the cached entry for the active profile first, so the next probe starts from the natural LAN-first order instead of revalidating a stale URL. Single-address profiles behave identically: one endpoint in the list, one ping per check. No behaviour change for them. * feat(server): PickReachableResult.ping + connectBaseUrlForServer helper Two additive extensions to the serverEndpoint surface that the upcoming CONNECT migrations all need: * 'ping: PingWithCredentialsResult' on the OK branch of PickReachableResult so callers (switchActiveServer, useConnectionStatus) can read type/serverVersion/openSubsonic from the same probe instead of issuing a second pingWithCredentials. * connectBaseUrlForServer(server) — sync getter for the connect URL of *any* saved profile (active or not). Reads the cache, falls back to normalized primary url on miss. Becomes the canonical helper for non-active-server HTTP traffic (apiForServer, stream URLs, cover fetches, library bind session). Tests: pingOk() fixture now returns identity fields; the single toEqual-asserting test in pickReachableBaseUrl became a guarded read to keep equality concise while still asserting on the new ping field. * feat(connect): apiForServer + stream URLs route via connectBaseUrlForServer Non-active-server HTTP traffic (the apiForServer entry point, used by QueuePanel cross-server cover fetches and share-paste resolution) and the stream-URL builders previously read 'server.url' directly, bypassing the dual-address connect cache. Both now go through connectBaseUrlForServer, which serves the cached LAN/public endpoint when one exists and falls back to the normalized primary url otherwise. buildStreamUrl(id) now uses the baseUrl it already pulled from getBaseUrl() (which is connect-cache aware as of 2a6d8283) instead of re-normalizing server.url — same value for single-address profiles, correctly dual-address for the rest. Single-address callers see no behaviour change. * feat(connect): cover fetch + cover-cache ensure use connect URL Both cover-fetch surfaces previously read 'scope.url' / 'server.url' straight into HTTP requests, which would freeze the cover pipeline on the primary URL even when a LAN endpoint was reachable: * buildCoverArtFetchUrl(ref, tier) — for the 'server' scope (queue rows cached against a non-active profile) and the 'playback' scope (cross-server playback) now resolves the connect URL via connectBaseUrlForServer before handing off to buildCoverArtUrlForServer. * ensureArgsFromRef in coverCache.ts — restBaseUrl for the Tauri 'cover_cache_ensure' invoke now uses the cached connect URL for both 'server' and 'active'/'playback' scopes. Scope.url itself remains the index-stable primary URL — that's what storageKeys (INDEX) consume. Only the HTTP base shifts to the connect endpoint, exactly the split the spec calls out. * feat(connect): library bind + server-test probe via ensureConnectUrlResolved Two more 'rebind / re-test an existing saved server' paths still pinged the literal primary URL — both go through the dual-address connect layer now: * bindIndexedServer (librarySession.ts): used to ping server.url then pass serverProfileBaseUrl(server) as the bind 'baseUrl' to Rust. Now: one ensureConnectUrlResolved call covers both — probe.baseUrl feeds librarySyncBindSession directly, so Rust's per-server library sync uses whichever endpoint actually answered. Drops the pingWithCredentials and serverProfileBaseUrl imports. * testConnection (ServersTab.tsx): same shape — probe via the connect layer, read identity from probe.ping, hand probe.baseUrl to scheduleInstantMixProbeForServer so the AudioMuse probe also hits the connect endpoint. Single-address profiles still ping once. Add/edit save handlers (handleAddServer / handleEditServer) keep the direct pingWithCredentials against the user-entered data.url — that flow is the dual-address verify hook, which PR 2 extends. * feat(server): serverShareBaseUrl — public-by-default share URL picker Adds the share-layer companion to connectBaseUrlForServer. Different intent: connect picks the reachable endpoint for HTTP, share picks the URL that goes into Orbit invites / entity share payloads / queue share links / magic strings — where a guest opening the link is not on the host's LAN. Logic per spec §5.1: * Single-address profile → that one address (normalized). * Both set, default flag → public. * Both set, shareUsesLocalUrl flag → local. * Edge cases (both LAN, both public, missing one of the two): fall back to the first endpoint in the list so the function is total. Empty profile returns the normalized url (possibly empty) — defensive, never throws. 7 unit tests pin all six branches plus the empty case. Call-site migration (Orbit, copyEntityShareLink, QueuePanel, magic string srv field, findServerIdForShareUrl, Orbit LAN warning) lands in the next commits. * feat(share): Orbit + entity + queue shares use serverShareBaseUrl Four share-encoding surfaces previously read 'getBaseUrl()' (connect) or the raw 'server.url' (primary) when embedding the host into outgoing share links — both wrong for a dual-address profile: * copyEntityShareLink (track / album / artist / composer) — was getBaseUrl(); now reads serverShareBaseUrl(active). Guests opening the link are off-LAN, so public is the right default. * OrbitStartModal — was raw server?.url for both 'buildOrbitShareLink' and the LAN warning. Now goes through serverShareBaseUrl; the LAN warning correspondingly reflects the address the guest will see, not the host's primary. * OrbitSharePopover — same fix on the host-only share popover. * QueuePanel.handleCopyQueueShare — was getBaseUrl(); same migration. Single-address profiles return exactly the same string from serverShareBaseUrl as serverProfileBaseUrl(server.url) did before, so no behaviour change for the common case. shareUsesLocalUrl flips the default to LAN for the rare 'share into a LAN-only group' use; that checkbox lands with the form UI in the next sub-phase. findServerIdForShareUrl + paste-side share matchers are migrated in the next commit (read-side of the same contract). * feat(share): paste-side resolves dual-address profiles + connect URL Read-side counterpart to the encode-side migration: * findServerIdForShareUrl(servers, shareSrv) now matches a profile when shareSrv normalizes to either profile.url OR profile.alternateUrl. Without this, a paste of a link generated against the host's LAN address (shareUsesLocalUrl=true) would fail to find the local saved profile even though it's the same server. * resolveSharedSong / resolveShareSearchAlbum / resolveShareSearchArtist in enqueueShareSearchPayload now hand connectBaseUrlForServer(lookup.server) to the *WithCredentials HTTP calls instead of the raw lookup.server.url. The looked-up profile may be dual-address; this routes the song / album / artist fetch through whichever endpoint is currently reachable. Indirect consumers (shareServerOriginLabel, shareQueueServerContext) read the same findServerIdForShareUrl, so no code change needed there — they now match both addresses transparently. * feat(verify): serverFingerprint + same-server verification Pure-logic core of dual-address verify. Three exports: * fetchServerFingerprint(baseUrl, user, pass) — one ping (envelope 'version' extracted alongside type/serverVersion/openSubsonic) plus four soft-fail optional calls in parallel (getMusicFolders, getUser, getLicense, getIndexes). Optional failures collapse to null fields, not whole-fingerprint failure. Subsonic-generic — never branches on type === 'navidrome'. indexesDigest is a hash of letter-count plus sorted first 20 artist ids, so two probes against the same library see the same digest without comparing full payloads. * compareFingerprints(a, b) — strict on the ping triple (type case-insensitive, serverVersion exact, openSubsonic boolean); envelope apiVersion informational only. Body signals counted only when both sides have a non-null value; empty musicFolders [] on both sides still counts as a matching signal. Result: 'match' (>=1 common signal all agreeing) / 'mismatch' (any common differs) / 'insufficient' (0 common). No 'save anyway' for insufficient in v1. * verifySameServerEndpoints(profile, user, pass) — single-address short-circuits to ok:true (nothing to verify). Otherwise parallel fingerprint probes, then pairwise compare. Ping-fail on any endpoint reports the offending host for the UI. 20 unit tests cover the compare matrix (every body signal in every direction), Navidrome- vs minimal-Subsonic-shape probes, ping-fail, and all four verify outcomes (ok / unreachable / mismatch / insufficient). HTTP mocked via vi.stubGlobal('fetch') + plain-object Response shape (avoiding any Response-polyfill dependency). * feat(boundary): resolve_host_addresses Tauri command + TS wrapper Adds one additive invoke for dual-address form hints. Spec §9.1 + contracts.md §6. Rust side (src-tauri/src/lib_commands/app_api/network.rs): * #[tauri::command] resolve_host_addresses(hostname: String) -> Result<Vec<String>, String> * tokio::net::lookup_host with a port suffix (':0'); discards the port from each SocketAddr, dedupes addresses via HashSet. * strip_port helper handles 'host:port', 'ipv4:port', '[ipv6]:port', '[ipv6]' (no port), and bare 'ipv6' (left as-is for lookup_host to wrap). 7 unit tests cover each shape. * Lookup failure → Ok(vec![]) so a DNS hiccup doesn't surface as an error toast or block the save flow — form-hint only. Frontend wrapper (src/api/network.ts): * resolveHostAddresses(hostname) — trims, invokes, swallows errors to an empty array so consumers get a clean total function. §04 boundary note: additive command, no breaking change. Added to the invoke_handler! generate_handler list in lib.rs at the natural alphabetical-ish slot near migration_run. * feat(form): AddServerForm — second optional address + share flag + DNS hint UI side of dual-address. AddServerForm now carries the four new moving parts spec §6 calls out: * Second address field ('Second address (optional)') under the primary URL. Placeholder flips to suggest the opposite kind of address based on the primary's LAN classification. * Contextual hint under the second field when it's empty — 'add a public address for outside-home use' (primary is LAN) or 'add a local address for faster home access' (primary is public). Hint disappears once the field has content. * Two-LAN client-side check on submit: when both addresses classify as LAN, save is blocked with a toast. Reverse case (both public) intentionally allowed per spec §6.3. * shareUsesLocalUrl checkbox — visibility rule per spec §5.3: hidden until the second address has content; shows with the persisted value on edit; cleared when the user empties the second address before save. DNS hint: on primary-URL blur we call the Tauri resolve_host_addresses command and classify the response by isLanUrl. Literal IPs skip DNS (already classified locally). DNS miss → no hint surfaces (never blocks save). Used only for the hint text — connect still goes through pingWithCredentials. i18n: 9 new keys in en + ru (serverAlternateUrl*, shareUsesLocalUrl*, serverBothLanError). Other locales fall back to English. onSave signature widened to 'void | Promise<void>' — ServersTab / Login both accept that already. The save flow itself still calls the legacy pingWithCredentials path; verify wiring lands in 2e. * feat(verify): wire verifySameServerEndpoints into add + dual-edit flows Save flow now blocks persisting a dual-address profile that fails the same-server check. Spec §6.4 + §7.4. handleAddServer: * When data.alternateUrl is non-empty, runs verifySameServerEndpoints BEFORE the existing ping. mismatch / insufficient / unreachable each surface a localized toast and abort the save (no addServer call). * Single-address adds keep the legacy single-ping path — no extra network round-trip when there's nothing to verify. handleEditServer: * Unconditional save remains the default — but if the edit either introduces / changes alternateUrl OR changes url / username / password while alternateUrl is set, verify runs first and may block. * After persist, invalidates the reachable-endpoint cache for this profile id so any sticky cached connect URL from before the edit is re-probed on the next access (credentials may have changed, alternate may have appeared). i18n: 4 new toast keys in en + ru (dualAddressVerifying placeholder for future progress UI, plus mismatch / insufficient / unreachable). Other locales fall back to English. announceVerifyResult helper keeps the toast routing in one place so handleAddServer and handleEditServer share the same surface. * i18n(settings): dual-address keys across all 9 locales Adds the 13 new dual-address keys to the remaining 7 locales: de · fr · es · nl · nb · ro · zh. * serverAlternateUrl + placeholderPublic / placeholderLocal * serverAlternateUrlHintAddPublic / HintAddLocal (contextual hints under the second-address field) * serverBothLanError (client-side two-LAN validation) * dualAddressVerifying / Mismatch / Insufficient / Unreachable (toast strings; Unreachable carries the {{host}} interpolation) * shareUsesLocalUrl + Desc (checkbox label + short description) Placeholders (example.com URL / 192.168.1.100:4533) kept identical across all locales — same shape the existing serverUrlPlaceholder already uses. Single coordinated sweep so every supported language ships dual- address fully translated rather than falling back to English. * feat(cover): cover_cache_rename_server_bucket Tauri command Adds the disk-side companion to the upcoming URL-change remigration flow (dual-server-address spec §8.3). When a user edits the primary url so the derived index key changes, the SQLite migration already re-tags rows via the existing migration_run command — this command moves the cover-cache bucket on disk so cached WebP tiles stay reachable under the new key. Behaviour: * old_key == new_key → no-op. * Old bucket missing → no-op success (nothing to migrate). * New bucket missing → simple fs::rename (fastest path). * Both exist → recursive merge with 'prefer existing' on file collision (the newer bucket wins; data is never lost). * Emits 'cover:bucket-renamed' with {oldKey, newKey} on success so the frontend disk-src cache can invalidate stale URLs. Sanitization: rejects empty, backslash, and '..' path segments at the FS boundary. Forward slashes are legitimate (a Navidrome mounted at a subpath like 'music.example.com/navidrome' produces an index key with one); they're handled by Path::join. 4 unit tests cover key sanitization (accepts real keys, rejects traversal/backslash) and the merge semantics (unique-file move + prefer-existing on collision). Registered in lib.rs invoke handler. * feat(remap): rewriteFrontendStoreKeysForRemap — explicit oldKey→newKey path Adds the URL-change remigration entry point next to the existing UUID→indexKey migration. Same plumbing (offline store, hot cache, analysis-strategy maps) but driven by explicit { oldKey, newKey }[] mappings instead of being derived from the current servers list. Also folds in the player-side cleanup the existing path didn't have: * queueServerId — if currently bound to a remapped index key, repoint to the new one so playback continues through the rename instead of looking unbound. * analysisStrategyStore — runs the same map-key swap inline (the 'migrateServerOverrides' helper handles UUID→indexKey, not indexKey→indexKey). Same prefer-existing-on-collision semantics as the disk-side cover_cache_rename_server_bucket — if a destination key already carries data, we keep it. 8 unit tests cover no-ops, the four store rewrites, the queue repoint, the 'leave other servers untouched' guarantee, and the collision case. * feat(remap): serverUrlRemigration orchestrator — 4-stage pipeline Single-file orchestrator that runs the full URL-change remigration when a profile edit shifts the primary url's derived index key. Spec §8 + contracts.md §4. Two exports: * indexKeyRemapForUrlChange(prev, next): IndexKeyRemap | null — short-circuits scheme-only edits ('http://x' ↔ 'https://x'), trailing-slash differences, and alternateUrl-only changes by normalizing both sides through serverIndexKeyFromUrl and returning null when they match. Empty urls also return null. * runIndexKeyRemigration(remap): Promise<IndexKeyRemigrationResult> — runs inspect → run → frontend-rewrite → cover-rename in order, aborts on the first failure and reports the offending stage. Failure ordering rationale: * inspect / run failures stop the destructive step — DB is untouched, the caller can retry safely. * frontend rewrite swallows errors (best-effort; zustand persist catches up on rehydrate next session). * cover-rename failure is reported but does NOT roll back the DB rows (that would be even more destructive); covers under the old key recover via the existing cover backfill on next access. 10 tests cover the detect logic (5 cases including the path-suffix case) plus all four pipeline stages with mocked Tauri invoke — including verifying the legacyId/indexKey mapping shape lands on both inspect and run calls. * feat(remap): wire URL-change remigration into ServersTab edit flow handleEditServer now detects a primary-url index-key change BEFORE any other save logic (verify, persist, etc.) and orchestrates the full remigration when one is needed. Flow: * indexKeyRemapForUrlChange(prev, next) — null for scheme-only edits / alternateUrl-only edits / no-op edits, so the common case falls straight through without prompting the user. * On a real remap → confirm modal via useConfirmModalStore.request (danger style, plain-language oldKey → newKey copy, explicit 'cannot be undone'). User cancel → abort save entirely. * On confirm → runIndexKeyRemigration pipeline. Failure surfaces a stage-specific toast (inspect / run / cover-rename — wording per spec §8.4 + the recoverability matrix in serverUrlRemigration.ts). * On success → fall through to the existing dual-address verify, then auth.updateServer + invalidate cache + ping (unchanged). i18n: 7 new keys (urlRemigrationTitle / Message with oldKey + newKey interpolation / Confirm / Progress / FailureInspect / FailureRun / FailureCoverRename) — full sweep across all 9 locales (en, de, ru, fr, es, nl, nb, ro, zh). Test fixup: the offline-store collision test in rewriteFrontendStoreKeys needed an 'as unknown as' cast — the existing OfflineTrackMeta type doesn't carry the test-only marker property, and a one-step cast TS rejected as not overlapping enough. * feat(magic): magic-string v2 encode/decode with dual-address fields Adds the v2 wire format for server invites. Spec §10 + contracts.md §5.2. Encode is opportunistic: payloads with alternateUrl set OR shareUsesLocalUrl=true emit v2; everything else stays v1 byte-identical. This means single-address profiles keep producing exactly the same invite they did before — older receivers can't tell the difference. v2 shape: { v: 2, url, alt?, shareLocal?, u, w, n? } * url — the host's share URL (public by default; LAN if shareLocal), NOT necessarily the host's primary URL. Receiver treats it as the primary of the new profile (their own index key). * alt — the host's alternate address (the other half of the pair). * shareLocal — mirrors the host's shareUsesLocalUrl preference so onward shares from the receiver behave the same way. Decode accepts both v1 and v2. v2-only fields are left undefined when decoding a v1 payload (no '|| undefined' shim — kept absent so zustand persist diffs stay clean). Defensive: an empty alt on a v2 invite decodes as if the field were absent, never as ''. Test updates: 'rejects a payload with the wrong version' now targets v: 3 (v: 2 became valid). 7 new tests cover the v1/v2 wire-format choice, both v2 round-trip shapes, the v1-decode-into-v2-fields- undefined backward-compat case, and the empty-alt edge. * feat(magic): wire magic-string v2 through invite-encode + paste consumers Five surfaces now produce / accept v2 invites with the dual-address fields end-to-end: Encode side (admin → user invite): * MagicStringModal — looks up the saved profile that matches the serverUrl prop (primary OR alternateUrl normalize-match) and encodes through serverShareBaseUrl + alternateUrl + the share flag. Falls back to plain v1 for single-address profiles. * UserForm — same lookup + encode plumbing on the in-form 'Save & get magic string' flow. Decode side (paste invite into form): * AddServerForm useEffect (initialInvite from outer state) + handleMagicStringChange (live paste) both pull alternateUrl and shareUsesLocalUrl off the decoded payload into form state, so the second-address field + checkbox surface immediately on a v2 paste. * Login form state gains hidden alternateUrl + shareUsesLocalUrl fields (not user-editable — Login stays single-address by design); v2 paste / initial-invite both populate them so they persist with the new profile via addServer. handleQuickConnect likewise forwards the existing dual-address shape for already-saved profiles. * attemptConnect signature widened with the two optional fields; addServer / updateServer call sites conditionally include them only when alternateUrl is non-empty so single-address profiles keep their lean persisted shape. Both encode helpers share the same magicPayloadAddressFields lookup (MagicStringModal + UserForm) — the duplication is acceptable for two co-located small files but a single shared helper would be the natural place to consolidate if a third encoder appears. * fix(form): magic-string submit forwards decoded alternateUrl + share flag AddServerForm.submit's magic-string branch was forwarding only name/url/username/password from the decoded payload, silently dropping alternateUrl + shareUsesLocalUrl. A v2 invite pasted into the magic-string field and saved would land in the store as a single- address profile even though handleMagicStringChange had already populated the dual-address fields into form state for display. Now the magic branch picks the dual-address fields off the decoded payload (same conditional spread as the non-magic branch a few lines down) so v2 invites round-trip end-to-end through the form. * fix(verify): extractUserId drops username fallback to avoid false mismatches Spec §7.2 footnote: 'fallback (normalized username) only if no id on either side'. The old extract unconditionally fell back to the authenticated username whenever user.id was empty — but the comparator can't tell username-fallback apart from a server-supplied id. So a server pair where endpoint A returns user.id='42' and endpoint B only returns user.username='frank' would land in compare with userId values '42' vs 'frank' and report mismatch on what is actually the same user on the same server. Now extractUserId returns null when user.id is absent. Both sides returning null means compareFingerprints skips userId as a common signal (correct behaviour per the §7.3 'both sides have a value' rule). One new test pins it; the call site drops the redundant fallbackUsername argument. * fix(remap): rewriteFrontendStoreKeysForRemap migrates coverStrategyStore Spec §8.2 lists 'analysis/cover strategy maps' as targets of the URL-change remigration. The For-Remap path covered analysis but missed cover — a user-set cover strategy override (e.g. 'aggressive' for one server) would silently drop when the user edited that profile's primary URL, because the key tagged under the old index key never made it to the new one. Same shape as the analysis remap inline: prefer-existing on collision (newer key wins), delete the legacy entry afterwards. One new test pins the move; setup adds a fresh useCoverStrategyStore reset between cases. * fix(cover): is_safe_index_key rejects absolute paths + drive letters Defense-in-depth gap in cover_cache_rename_server_bucket. The old sanitizer only rejected backslashes and '..' segments — '/etc/passwd' on Unix and 'C:\Windows' on Windows both passed. Path::join with an absolute argument REPLACES the base path, so root.join('/etc/passwd') on Unix would walk out of cover-cache entirely. Real index keys never reach this state — they come out of serverIndexKeyFromUrl which strips schemes and trailing slashes, so no leading separator and no drive-letter prefix is ever produced. But the comment promises 'defense in depth' and that defense is worth completing. Now rejects: * empty keys (would join to the cover-cache root itself) * leading '/' or '\' * Windows drive-letter prefix 'X:' (case-insensitive ASCII letter) * backslashes anywhere (separators are forward-slash only) * '..' segments after split('/') One new Rust test covers all four cases. * fix(connection): isLan badge reflects active endpoint, not primary url useConnectionStatus.isLan was reading isLanUrl(server.url) — the *primary* address — so a dual-address profile that had fallen over to its public alternate kept advertising 'LAN' in the badge until the user looked at the server URL itself. Spec call-site-checklist line 25: 'active endpoint kind for badge (LAN vs extern)'. Now: ensureConnectUrlResolved returns probe.endpoint.kind on success; the hook tracks the latest kind in local state and surfaces that. Pre-first-probe fall-through keeps the old primary-URL classification so the badge has something to render at mount time. Three tests pin the three states (LAN-active after probe, public- active after fallback, primary-fallback before first probe completes); plus one for the online-event handler that invalidates the cache and re-probes. * fix(server): dedupe concurrent pickReachableBaseUrl calls for same profile Multiple call sites probe on roughly the same beat — useConnectionStatus 120-s tick + online handler + initial mount, switchActiveServer, bindIndexedServer, and ServersTab.testConnection. Two near-simultaneous probes for the same profile both observed an empty cache, both pinged every endpoint, and raced to write the sticky URL with last-write-wins. On a dual-address profile the slower probe could stomp the correct LAN sticky a millisecond after it was set. Now: an in-flight Map<profileId, Promise<PickReachableResult>>; a second call for the same id during an active probe returns the same promise instead of starting a fresh one. The finally-clear keeps the dedup window narrow (one settled probe → next call probes fresh). invalidateReachableEndpointCache deliberately doesn't touch the in-flight map — the racing probe's own finally will clean up. Three tests pin it: two concurrent calls share one ping; a fresh call after the previous settled does ping again; plus the existing shareBaseUrl two-LAN-with-flag-on test + the two-public-default test for completeness. * refactor(magic): extract magicPayloadAddressFields to single shared helper The lookup that turns a serverUrl into the v2-encode-ready { url, alternateUrl?, shareUsesLocalUrl? } shape was duplicated byte-identically between MagicStringModal.tsx and UserForm.tsx — both Navidrome admin user-mgmt encode sites. Workdocs §03 / §1a 'one source of truth for behavior'. Now lives in src/utils/server/serverMagicString.ts as a named export. Both call sites import + pass the current servers list (via useAuthStore.getState().servers) — keeps the helper pure so it's straight to unit-test if a third encoder ever appears. * fix(cover): wire cover:bucket-renamed listener for URL-change remigration cover_cache_rename_server_bucket emits cover:bucket-renamed on successful rename / merge, but no frontend listener was wiring it in. After a URL-change remigration the in-memory disk-src cache still held entries pointing at `{root}/{oldKey}/…/.webp` paths the disk no longer carries — the next read would serve a stale URL until the entry naturally aged out. New: forgetDiskSrcForServer(serverIndexKey) in diskSrcCache drops every cover entry under one server key in one pass (the existing forgetDiskSrcPrefix needs a non-empty coverArtId and can't blanket- clear a server). useCoverArtBridge subscribes to cover:bucket- renamed and calls it with oldKey. Tests: forgetDiskSrcForServer happy path, empty-key defensive no-op, no-match no-op; plus a regression-pin on the existing forgetDiskSrcPrefix so the two helpers don't drift in semantics. * test(dual-server): fill the high-impact coverage gaps from the branch review Adds the tests the review identified as missing on the hot-path UI flows + the partial-fail / alt-only edges: * AddServerForm.test.tsx (new) — five component tests: single-address save / dual-address save / two-LAN block-with- toast / v2 magic-string paste forwarding alt + share flag / edit-flow stripping alt+flag when the field is emptied. * Login.test.tsx (new) — v2 invite paste persists alternateUrl + shareUsesLocalUrl onto the saved profile; v1 invite leaves those fields undefined. * shareLink.test.ts — alternateUrl-only match for findServerIdForShareUrl (the dual-address paste case where the host shared the LAN URL via shareUsesLocalUrl=true); 'first hit wins' across two profiles where both match. * serverFingerprint.test.ts — partial-fail mix (folders+user ok, license+indexes rejected) so a Promise.allSettled regression wouldn't go silent. * cover_cache/mod.rs — rename_bucket_inner extracted as a testable FS-only helper (the Tauri command wrapper now just locks state + calls it + emits the event), plus six tests covering empty/unsafe keys, no-op-when-missing, no-op-when- equal, simple-rename, merge-with-prefer-existing. Also: every test fixture that I authored on this branch using 'frank' / 'frank@example.com' as a stand-in username/email swapped to 'tester' / 'tester@example.com' — keeping personal names out of test data is the codebase convention (see factories.ts) and is now a memory rule. * fix(test): typed mock access for pingWithCredentials in useConnectionStatus vi.mocked(...) returns the mock typed properly — bare .mock fails tsc because the imported function signature isn't a vi.Mock at import time. * docs(changelog): dual server address (PR #880) * fix(test): align diskSrcCache tests with main cover storage key API After rebase onto main, forgetDiskSrcPrefix takes a CoverArtRef-shaped argument and storage keys include cacheKind; merge coverDiskUrl tests from main with dual-address forgetDiskSrcForServer coverage.	2026-05-28 14:36:25 +03:00
cucadmuh	df3533bb5a	fix(cover): Windows thumbnails, tier fallback, PNG decode, coverArt id (#878) ... * fix(cover): tier fallback for sparse surfaces and Windows asset URLs Sparse UI (player bar, queue) now reads disk covers via the same tier ladder as dense grids, so a warm 800.webp satisfies a 128px request. Reject non-asset convertFileSrc results on Windows, widen Tauri asset scope, and seed ladder keys on cover:tier-ready. applyDiskPath uses seedGridDiskSrcCache only to avoid notify/subscriber infinite loops. * fix(artist): top-track thumb uses album coverArt already warm in grid Song coverArt ids often differ from album cover ids (e.g. Octastorium in the grid vs empty track thumb). Prefer the album row's coverArt on artist pages and ensure high priority for 32px dense cells. * fix(cover): albumId for playback/queue; no broken img until disk URL ready Prefer albumId over track-id coverArt (Navidrome). Wire queue to CoverArtImage with playback scope. CoverArtImage renders a placeholder div until asset src exists to avoid the browser broken-image icon. * fix(test): add song id to resolveArtistPageSongCoverArtId fixture Pick<SubsonicSong, …> requires id; fixes tsc in CI/build. * fix(cover): resolve albumId for Now Playing and artist top tracks Prefer albumId when album.coverArt echoes track id; use sparse surface on artist suggestion thumbs; apply resolveSubsonicSongCoverArtId across playback surfaces (Now Playing, fullscreen, mobile, mini). * fix(cover): decode PNG from Subsonic before WebP tier encode Enable `png` in the image crate — some servers return PNG cover art; failed decode left `.fetch-failed` and empty thumbs for those albums. * refactor(cover): consolidate cover id resolution and align tests Move resolveSubsonicSongCoverArtId helpers to src/cover/resolveCoverArtId.ts with resolvePlaybackTrackCoverArtId for player surfaces; co-locate tests; fix FullscreenPlayer expectations for albumId-first resolution. * docs: CHANGELOG and credits for PR #878 * fix(cover): keep per-track coverArt when distinct from song id Address PR #878 review (b): albumId only when coverArt is missing or echoes track id; pin case with unit test; comment isRawFsPath symmetry. * chore(cover): address PR #878 review nits (scope, tests, rename) Narrow asset scope to cover-cache dirs only; add diskSrcCache Windows-path tests; rename ArtistTopTrackCover; CHANGELOG symptom-first wording. * fix(cover): restore asset scope to app data dirs (Windows regression) $APPDATA/cover-cache/** did not match Tauri scope resolution — covers were blocked after load. Use $APPDATA/** and $APPLOCALDATA/** (no $DATA). * fix(cover): Windows asset URLs — restore DATA scope, path normalize Regression after review nits: dropped $DATA/** and strict isAssetProtocolUrl blocked valid http://asset.localhost URLs on Windows. Normalize C:/ paths before convertFileSrc; CoverArtImage/Hero hide broken img on load error. * fix(cover): disk peek fallbacks when cache folder id differs Small surfaces resolve albumId while cover-cache often stores WebP under track id or album.coverArt from the grid. Peek batch now tries legacy ids; playback scope resolves server index key by URL key, not UUID-only lookup. * fix(cover): Navidrome al-* vs mf-* disk id mismatch UI used mf-* coverArtId while library backfill only cached al-* folders. Prefer album id for display/peek when coverArt is mf-*; backfill now queues both distinct album_id and cover_art_id values. * fix(cover): mf→al disk peek when mf folder missing in cache Navidrome Subsonic often returns mf-* coverArtId while backfill only creates al-* folders. Peek mf first, then al-* from hints; load albumId from library when Subsonic omits it; ensure fallback uses al-* id. * feat(cover): CoverArtRef, segment disk layout, library-index backfill Normalize cover caching around stable entity ids from the local library and Navidrome fetch ids. Disk paths live in psysonic_core::cover_cache_layout (album/<entityId>/); UI uses CoverArtRef with cacheEntityId + fetchCoverArtId. - Remove SQLite/mf peek helpers (diskPeekIds, peekCoverOnDisk, mergeDiskIdHints) - Backfill reads album/artist rows from library SQLite (bare Navidrome ids ok) - Use stored cover_art_id for HTTP; per-disc dirs only when discs differ - Migrate call sites to albumCoverRef / albumCoverRefForPlayback * feat(cover): central CoverEntry resolver (artist, album, track) Add resolveEntry.ts and Rust CoverEntry helpers as the single source of truth for cache_entity_id vs fetch_cover_art_id. ref.ts delegates to them; resolveCoverArtId becomes a thin compatibility shim. * feat(cover): resolve cover entries from local library index Add library_resolve_cover_entry IPC and cover_resolve.rs so album, artist, and track covers use SQLite cover_art_id + disc detection. TypeScript helpers in resolveEntryLibrary.ts prefer the index over live API fields when rows exist. * feat(cover): library-first hooks for grids and playback UI Add useAlbumCoverRef, useArtistCoverRef, useTrackCoverRef, and usePlaybackTrackCoverRef — sync fallback then SQLite index upgrade. Wire album/artist cards, album header, song card, and all player surfaces to resolve covers from the local library when indexed. * feat(cover): complete library-first migration across all UI surfaces Add Album/Artist/TrackCoverArtImage, useLibraryCoverPrefetch, and batch resolve helpers. Migrate grids, search, home, playback sidecars, warm peek, playlists, and share flows to hooks that upgrade from SQLite. Backfill normalizes album rows through cover_resolve; document paths in COVER_PATHS.md. Radio remains a deliberate non-library exception. * fix(cover): stop render loop from unstable serverScope in library hooks Default param `{ kind: 'active' }` created a new object every render, so every grid cell re-ran library_resolve IPC and setState in a loop. Use COVER_SCOPE_ACTIVE singleton, coverScopeKey deps, and guarded sync updates. * chore(cover): remove COVER_PATHS.md from app tree (lives in workdocs) Audit doc is team spec — see workdocs 2026-05-cover-art-pipeline/cover-paths-audit.md. * fix(cover): unstick library backfill after route changes (PR #870 regression) useCoverNavigationPriority cleanup called beginNavigation instead of end, leaking navigationHoldDepth so ui_priority_hold never released and backfill never downloaded. Also skip disk check after cover_resolve normalization. * fix(cover): segment progress, cap backfill CPU, include artists in catalog Progress and disk size now scan album/ and artist/ segments (canonical 800.webp). Prune legacy flat server/al-* dirs on startup and backfill pass. Backfill: max 2 concurrent ensures; JPEG decode and WebP encode run on the blocking pool behind a shared 2-permit semaphore so Tokio workers stay cool. Artists were missing because the catalog only read the empty artist table; add distinct artist_id from track and album rows. Paginate with a composite (kind, id) cursor so album and artist rows are not skipped. * fix(cover): drop legacy prune; backfill per-disc and artist catalog Remove prune_legacy_* and cover_cache_catalog_entry — layout is only cover_dir (album|artist segments); stale flat dirs clear on LAYOUT_STAMP change. Backfill: artists from track/album artist_id; expand albums to per-CD mf-* slots when discs differ; fix resolve_album_cover_entry when album row is missing. * fix(cover): reduce library IPC storms and fix multi-disc player art Skip per-row library_resolve on live search and artist album grids; warm grids from API coverArt after mount instead of blocking layout. Dedupe and cap concurrent library_resolve calls. Restore per-disc cache keys in the player and queue when track mf-* art differs from the album bucket. * fix(cover): skip library resolve on advanced and full search rows Use API coverArt for album/artist rails and lazy viewport artwork so result pages do not fire hundreds of library_resolve IPC calls at once. * fix(cover): default libraryResolve off for browse grids and rails Skip per-card library_resolve on album/artist/song browse UI by default; keep it on album/artist headers, playback queue rows, and orbit approval. * fix(cover): split UI/backfill CPU pools and restore mainstage hero carousel Library backfill no longer shares the 2-permit JPEG/WebP semaphore with visible cover ensures. Hero initializes albums from props, re-binds scroll visibility after mount, updates backdrop on slide change, and uses library resolve for correct cover art on the banner. * fix(analysis): resume full-library scan after candidates phase Reset the SQL cursor when entering full-library mode so tracks with partial analysis are not skipped. Tighten TS backfill completion and CPU queue watermarking; align cover-cache key tests with album-scoped storage keys. * fix(library): remove useless map_err in cover_resolve (clippy) CI treats clippy::useless-conversion as error on rusqlite optional() chains. * fix(cover): satisfy clippy on cover_cache_ensure IPC args Pass CoverCacheEnsureArgs as a single Tauri parameter instead of nine positional fields; align frontend invoke payload with { args }.	2026-05-28 03:15:08 +03:00
Frank Stellmacher	45b9229ceb	refactor(queue): thin-state refs as canonical, full Track via resolver (#872) ... * refactor(queue): wire queue UI to the track resolver (thin-state phase 3) cucadmuh's phase-3 steps: - Selectors (useQueueTracks) read resolver-first: getCachedTrack → queue: Track[] fallback (until phase 4), F4 star/rating overrides merged on read. - QueueList rows source their track from the resolver (queue fallback); rows show title/artist/duration only, so no override merge there. - pendingStarSync star/rating success → invalidateQueueResolver so the cache reflects the synced value. - queueResolverBridge re-seeds on queueIndex change too — the prefetch window travels with the playing track. Additive: queue: Track[] stays canonical and behaviour is unchanged (rows resolve to the same data). Phase 4 drops queue: Track[] and the fallbacks. * docs(changelog): queue panel reads through track cache (#860) * fix(queue): stop a render loop that froze the UI on long queues A long virtualized queue + a track change could lock the WebView for ~2 min: - useVirtualizer was handed a fresh `initialRect` object literal every render, so it kept re-initializing in a loop. Hoisted it to a stable module constant. - getCachedTrack did an LRU bump (Map delete+set) during render — a render-time side effect. Made it a pure read; recency is set at write time in cacheSet. * perf(mobile): virtualize the mobile player queue drawer The mobile now-playing queue drawer rendered the full queue with .map; a multi-thousand-track queue meant thousands of DOM nodes. Virtualize it with @tanstack/react-virtual (uniform rows, stable initialRect) so the DOM stays at O(visible rows), matching the desktop QueuePanel. Active track is centred on open via scrollToIndex. * perf(mini): virtualize the mini-player queue list The mini-player queue rendered the full MiniSyncPayload queue with .map. Virtualize it against the OverlayScrollArea viewport (stable initialRect) so the mini window's DOM stays at O(visible rows). Drag-reorder is preserved: rows keep data-mq-idx alongside the virtualizer's measureElement. * refactor(queue): add resolveQueueTrack/getQueueTracksView helper (thin-state phase 4) Render-safe ref→Track view for the phase-4 consumer migration off queue: Track[]. Resolver cache → caller fallback (legacy queue[idx] during dual-write) → placeholder; ref queue-only flags carried, F4 overrides merged. Pure synchronous read, no cache mutation (the freeze landmine), so it is safe in render. * refactor(queue): keep queueItems as the canonical in-memory mirror (thin-state phase 4) Step 1b: dual-write the thin queueItems ref list at every queue write site (the 11 mutations, next/radio top-up, playTrack, undo/redo restore, instant-mix, radio, server-queue init, lucky-mix rollback, and hydrate) so it tracks queue: Track[] in memory, not only at persist time. Identity-preserving maps (star/rating overrides) keep the same refs and are intentionally left untouched. Resolves the restore double-role flagged for 1b: queueItemsIndex is now the restore-pending sentinel that gates hydrateQueueFromIndex, while queueItems stays canonical -- rebuilt from the whole queue after a full hydrate instead of cleared. Normal mutations never set the sentinel, so it only fires on a fresh cold-start restore, not on later server switches. No behaviour change; queue: Track[] stays the source consumers read until phase 3. tsc + full vitest suite (1119 tests) green. * refactor(queue): mobile queue drawer reads through the track resolver (thin-state phase 4) Step 2: the mobile now-playing queue drawer resolves each row's track from the resolver cache (→ queue: Track[] fallback until phase 4), matching the desktop QueueList wired in the phase-3 commit. Subscribes to the resolver version so rows re-render as the cache fills. Structure (count, order, keys, the playTrack arg) still comes from queue: Track[] until it is dropped in the final step. The mobile drawer was the last queue display surface still reading track metadata straight off the fat queue. tsc + full vitest suite green. * refactor(queue): ref-native queue mutations + dual-write bridge (thin-state phase 4) Step 3a: the 11 queueMutationActions now splice/filter/reorder QueueItemRef[] (matching by trackId + the ref's queue-only flags) instead of Track[]. `bridgeQueueFromItems` rebuilds the dual-written queue: Track[] from the new refs by id — purely structural (no resolver/override merge), so behaviour is byte-identical and playerStore.queue.test.ts stays unchanged green. The working ref list comes from `itemsOf(state)` (derived from queue: Track[] for now); the final step swaps that one line to state.queueItems once the fat queue is gone. enqueue / enqueueAt / enqueueRadio seed the resolver cache with incoming tracks (seed-before-splice) so they resolve without a network round-trip after the fat queue is dropped. Adds a DEV-only id-parity guardrail (queue vs queueItems); dev-runtime only, silent in vitest and prod. tsc + full vitest suite (1119) green; contract test unchanged. * refactor(queue): ref-native radio/infinite top-ups (thin-state phase 4) Step 3b: nextAction's proactive infinite-queue and radio top-ups build the new queue as QueueItemRef[] and bridge back to queue: Track[] (same as the queue mutations), and seed the resolver cache with the freshly fetched tracks so they resolve without a network round-trip after the fat queue is dropped. The radio top-up keeps its HISTORY_KEEP front-trim, now expressed on refs. The exhausted-queue refill paths hand their new queue to playTrack, which keeps its fat-queue handling until the final step (its no-arg case needs the resolver- derived queue that lands with the queue: Track[] removal). tsc + full vitest (1119) green; contract test unchanged. * refactor(queue): undo snapshots store thin refs, not Track[] (thin-state phase 4) Step 4: QueueUndoSnapshot.queue: Track[] becomes queueItems: QueueItemRef[], killing the undo "hidden multiplier" — 32 snapshots of a 50k queue now cost refs, not 32×50k full tracks. applyQueueHistorySnapshot rebuilds the display queue from the refs via resolveQueueTrack: resolver cache → the live queue by id (covers tracks the edit didn't remove) → placeholder. currentTrack stays a full track in the snapshot and is restored to the engine unchanged. The snapshot refs derive from queue: Track[] for now (so the undo/redo contract cases, which seed only `queue`, stay green); the final step swaps that to [...s.queueItems]. tsc + full vitest suite (1119) green. * perf(mini): cap the mini-player queue snapshot to ±100 around the current track (thin-state phase 4) Step 5: the mini bridge no longer serializes the full queue over IPC on every push — a 50k Artist-Radio queue would otherwise re-encode in full on every track advance. snapshot() sends a window of 100 tracks before/after the playing song; queueIndex is made slice-relative. The mini component stays unchanged (slice- relative); jump/reorder/remove control events are translated back to absolute queue indices via the window offset captured on the last push. tsc + full vitest suite (1119) green. Mini bridge has no unit tests — needs a quick mini-player smoke (queue shows ±100, jump/reorder/remove land correctly). * refactor(queue): make queueItems a required PlayerState field (thin-state phase 4) Foundation for the final consumer migration off queue: Track[]: queueItems has been written at every queue write site since phase 1b, so promoting it from optional to required is a no-op at runtime (tsc confirms zero new errors) and lets the upcoming reader migrations read state.queueItems without `?? []` noise. * refactor(queue): migrate structural queue readers off queue: Track[] (thin-state phase 4) First reader batch toward dropping queue: Track[]: the queue-length selectors (usePlaybackServerId, usePlaybackCoverArt, useQueuePanelDrag, useMiniQueueDrag) now read state.queueItems.length, and FullscreenPlayer's next-track cover prefetch resolves through useQueueTrackAt instead of indexing the fat queue. All behaviour- identical during dual-write (queueItems is in lockstep with queue). tsc + full vitest suite (1119) green. Note: getPlaybackServerId() (playbackServer.ts) deliberately stays on queue for now — it is called from many partially-mocked test stores, so it migrates with the final field removal where the seedQueue helper covers those tests. * refactor(queue): QueuePanel save/share/playlist read queueItems (thin-state phase 4) The id/length reads (save to playlist, share link, create playlist, empty-queue guards, next-tracks divider) now read state.queueItems instead of the fat queue. Behaviour-identical during dual-write; queue: Track[] stays for the rendered QueueList + auto-scroll until the field is dropped. tsc + full suite (1119) green. * refactor(queue): drop queue: Track[] — thin queueItems is the only queue (thin-state phase 4) The store no longer holds the fat queue. `queueItems: QueueItemRef[]` is the sole canonical queue; full `Track`s resolve on demand via the resolver (index batch → getSong fallback, bounded LRU cache); only `currentTrack` stays a full Track. At 50k tracks the store holds ~hundreds of resolved tracks + the refs, not 50k Track objects. - **Persist:** partialize is refs-only (no windowed slice / PERSIST_QUEUE_HALF). A `merge` migrates every historical blob shape → `queueItems` (existing `queueItems` → legacy `queueRefs` → pre-ref windowed `queue: Track[]`) and drops the obsolete `queue` key, so saved queues survive the upgrade. - **Restore (decision B):** `hydrateQueueFromIndex` eager-resolves the whole ref list into the cache on cold start (index → getSong, so an index-off queue still plays), clears the restore sentinel. - **Resolver bridge:** keeps `[idx-50, idx+200]` warm via `resolveVisibleRange`. - **Mutations / actions / playback:** operate on refs; the playing track is `currentTrack`, the next/neighbour tracks resolve from the cache. Navigation (next/previous/row-jump) keeps `queueItems` and only moves the index — no full resolve or queue rebuild per track change. - **Persist tests** cover the three old-blob migrations; `seedQueue` test helper replaces the `setState({ queue })` seeds. tsc + full vitest suite (1115) green. Behaviour-preserving by the test contract; the gapless track change + cold-start restore + mini cap still want a live smoke before merge. * fix(queue): star/rating keeps the queue row resolved instead of blanking to "…" (thin-state) Rating/starring a queue song flashed the row's title to the "…" placeholder until the next track change. Root cause: on sync success pendingStarSync called invalidateQueueResolver, which DROPPED the cached track — and with queue: Track[] gone there's no fat fallback, so the row resolved to a placeholder until the resolver bridge re-fetched the window. Fix: add patchCachedTrack(trackId, patch) and use it on star/rating success to update the cached entry in place (title kept, synced starred/userRating applied) instead of dropping it. No placeholder flash, no re-fetch. tsc + full vitest suite (1115) green. * fix(player): quota-safe persist so a full localStorage can't kill playback A very large queue (~50k refs) overflows the localStorage quota; the persist write then threw QuotaExceededError from inside set(), which aborted playTrack before audio_play — no audio output at all. Back the player persist with a quota-safe storage wrapper so a failed write degrades to a no-op instead of throwing. Restoring the full ref list at that ceiling (vs a windowed cap) is left as a follow-up. * polish(player): throttle the quota-skip persist warning to once per key The quota-safe persist logs a skip on every failed write; on a huge queue that floods the dev console once per mutation. Warn once per key per quota-exceeded streak, re-armed when a write to that key next succeeds. * fix(queue): port new cover-pipeline readers to thin-state Main's cover pipeline (#870) reads s.queue.length and seeds the player store with queue: [track] in its tests. Under thin-state, queue: Track[] no longer exists — the canonical queue is queueItems: QueueItemRef[]. These four files were brought across in the merge but still spoke the old shape; this commit aligns them with the thin-state contract. - src/cover/usePlaybackCoverArt: queueLength = queueItems.length - src/cover/usePlaybackCoverArt.test: seed via toQueueItemRefs - src/api/coverCache.test: same - src/hooks/useNowPlayingPrewarm.test: same (two test cases) * fix(queue): canonicalize thin-state server identity for mixed-server queues `QueueItemRef.serverId` and `PlayerState.queueServerId` are now written as the URL-derived index key on every writer path, matching the library index direction. Mixed-server queues with duplicate `trackId` across servers stay unambiguous because the resolver cache, persistence, and playback bindings all share one key shape. - new `canonicalQueueServerKey()` helper (idempotent UUID-or-key normalizer) - `toQueueItemRefs`, `bindQueueServerForPlayback`, `seedQueueResolver`, and `hydrateQueueFromIndex` emit canonical keys - `getCachedTrack` falls back to the canonical lookup so refs persisted in the legacy UUID shape still resolve through the migration window - persist `merge` rewrites `queueServerId` and every ref `serverId` on rehydrate, so the live store never holds mixed shapes - `removeServer` compares against the resolved id so a profile delete still clears the matching queue binding - the two `playbackServer.test.ts` asserts that hard-coded the UUID shape are updated to the canonical key (existing reader-tolerance is unchanged) * fix(queue-undo): bind snapshot prepend to snapshot-canonical server identity When `applyQueueHistorySnapshot` has to prepend the still-playing track (the snapshot's queue does not contain it), the new ref must follow the snapshot's playback server, not the live `queueServerId`. A server switch racing the undo would otherwise stamp the prepended ref with the new server, mis-resolving the playing track on the very next render. - `QueueUndoSnapshot` now carries `queueServerId` (captured by `queueUndoSnapshotFromState`); older in-memory entries fall back through the snapshot's own refs and finally the live store value - the prepend in `applyQueueHistorySnapshot` plus the post-restore `seedQueueResolver` both source the server identity from this snapshot context, run through `canonicalQueueServerKey` so cache bucket and ref shape stay in lockstep * test(queue): regression cluster for mixed-server queues with duplicate trackId Covers the four invariants the thin-state review called out: - resolver correctness: same `trackId` on two servers maps to two distinct cache entries via canonical keys, and legacy UUID-shaped refs still read the same entries through the compat lookup path - restore/hydrate: persist `merge` forward-migrates UUID-form blobs in three shapes (canonical `queueItems`, legacy `queueRefs`, mixed-server `queueItems`) to canonical keys - undo snapshot application: prepended ref follows the snapshot's playback server even when the live queue has been rebound to a different one, with fallback to snapshot refs and live state for legacy entries - queue sync id emission: `flushPlayQueuePosition` -> `savePlayQueue` passes plain track ids and the playback server out of band, no per-ref `serverId` ever leaks into the request body Also asserts the write helpers (`toQueueItemRefs`, `bindQueueServerForPlayback`) emit canonical keys directly. * perf(queue-header): coalesce resolver burst updates and aggregate in one pass `QueueHeader` recomputed total and remaining queue durations on every resolver cache version bump via two separate full-queue reduces. A mass resolve burst (queue restore, prefetch window slide) bumps the version dozens of times in one frame, and very long queues turned that into visible main-thread stutter. - one pass: a single for-loop produces both total and future-tracks duration; a 50k-track queue costs one walk per recompute, not two - `useDeferredValue(version)` coalesces the burst into a single low-priority commit so the cache version is only sampled once per React frame instead of once per cache write * fix(queue): use stable artist seed for radio top-up The proactive radio top-up in `runNext` seeded `getSimilarSongs2` and `getTopSongs` from `resolveQueueTrack(nextRef)` metadata. When the next ref is still cold in the resolver cache, the placeholder track has empty artist fields, and the top-up would fire `getSimilarSongs2('')` -- silently returning nothing and leaving the queue dry just before the radio rail would have refilled. - prefer the just-played `currentTrack` (always fully resolved in the player store) and the stored radio seed artist id - fall back to the next-track metadata only when those are missing - skip the top-up entirely when no stable seed is available, instead of emitting a non-deterministic empty request * docs(changelog): queue mixed-server routing and quota-safe persist (#872)	2026-05-27 00:10:34 +02:00
cucadmuh	418b25914a	feat(cover): unify cover pipeline and stabilize mainstage/now-playing (#870) ... * chore(cover): scaffold cover module and rust cover_cache stub Wave 0: src/cover/ skeleton per contracts.md §12, stub IPC commands in cover_cache/mod.rs (no-op returns until phase B). * feat(cover): add unified cover module and tier resolver (phase A) Wave 1A: tiers, storage keys, resolveJs with cold/sibling races, useCoverArt, CoverArtImage, layoutSizes, playback scope helpers, coverSiblings tier ladder, deprecated shims on subsonicStreamUrl. * feat(cover): rust disk cache and tier-ready events (phase B) Wave 1B: cover_cache module with WebP tier encode, HTTP canonical 800 fetch, cover_cache_* commands, cover:tier-ready / cover:evicted events, disk layout tests. * feat(cover): prefetch hook, tier-ready handoff, library backfill IPC (phase B/C) Wave 2: useCoverArtPrefetch, cover:tier-ready/evicted bridge, one-time IDB cover key clear, prefetch registry drain, MainApp wiring. * feat(cover): migrate dense grids to CoverArtImage and prefetch (phase D) Wave 3A: dense surfaces use layout-native displayCssPx, surface=dense, coverPrefetchRegister on Home/Albums/search; AlbumCard cell width from grid. * feat(cover): migrate sparse surfaces and integrations (phase E sparse) Wave 3B: sparse CoverArtImage/useCoverArt, lightbox tier 2000, ArtistHeroCover, MPRIS/Discord/export integrations, playback chrome and detail heroes. * feat(cover): revalidation scheduler and disk pressure gate (phase E+) Wave 4: coverCacheMaxMb settings (en/ru), StorageTab disk usage, cover_cache_configure, useCoverRevalidateScheduler, playbackServer uses cover fetchUrl; pressure watermarks. * docs: CHANGELOG and credits for cover art pipeline PR #869 * fix(cover): stop webview getCoverArt storm on dense grids (429) Dense surfaces no longer put rotating getCoverArt URLs in img src; load disk via Rust ensure + convertFileSrc. Tier-ready notifies listeners instead of invalidating IDB. Throttle background prefetch and cap Home registry. * fix(cover): omit empty img src until cover URL is ready React 19 warns on src=""; CoverArtImage uses undefined until disk/IDB resolves; queue current track shows placeholder when src is still empty. * fix(cover): disk cache by host index key, parallel ensure, asset protocol Bind cover storage to serverIndexKey (library host), rename cover IPC/events, fix REST base URL and Tauri flat args, enable protocol-asset for disk paths, add prioritized ensure queue, and wipe legacy profile-UUID cache once. Limit Vite dep scan to index.html so research/target HTML is ignored. * fix(cover): WebP tiers, disk peek, home cache, asset URLs for mainstage Encode lossy WebP (~82), write only missing tiers, library cover backfill, and cover_cache_peek_batch for fast paint from disk. diskSrcCache + CSP asset protocol; no IDB fallback when server is up. Session Home feed cache with warm peek on return; BecauseYouLike deduped cover hook and high prefetch. * feat(cover): per-server cache strategy and native library backfill Move cover disk cache settings to Offline & cache with Lazy/Aggressive per server, per-server clear, and no size cap. Run full-catalog backfill on the Rust runtime (sync-idle wake, bounded HTTP, bulk 800px writes without flooding the webview). Drop global prefetch limits from auth store and waveform clear from the offline storage block. * fix(build): CSP connect-src for Subsonic API; quieter prod nix build Prod webview blocked axios ping after cover CSP (missing connect-src). Drop cargo tauri -v in flake build, raise Vite chunk limit, ignore tsbuildinfo. * fix(cover): complete WebP ladder in library bulk backfill Aggressive backfill now writes all derived tiers (128–800), skips IDs only when the full ladder exists (not 800 alone), avoids fetch-failed markers on bulk HTTP errors, and stops the pass when the active server changes. * fix(cover,home): navigation-priority backfill and Because You Like UX Pause library cover backfill while navigating; split peek/ensure traffic so grids and rails win over bulk work. Disk src lookup, grid warm hooks, and non-blocking mainstage prime for faster visible covers. Because You Like: session snapshot, staggered horizontal skeleton row, text hidden until cover is ready, and layout aligned with loaded cards. * feat(random-albums,library): local-first album fetch + cover art pipeline Random Albums теперь запрашивает локальный SQLite-индекс (ORDER BY RANDOM() LIMIT N) вместо сетевого запроса к серверу. При готовом индексе спиннер исчезает практически мгновенно; сеть используется только как фолбэк. - advanced_search.rs: добавляет `("random", _) => RANDOM()` в allowlist сортировок - browseTextSearch.ts: runLocalRandomAlbums — SQLite-рандом для Albums - RandomAlbums.tsx: doFetchRandomAlbums local-first для обоих путей (без жанра и с жанром через runLocalAlbumsByGenres + JS-shuffle); speculative reserve прогревает следующий батч в фоне после каждого Refresh Также: обновление пайплайна обложек (coverTraffic, peekQueue, ensureQueue, diskSrcLookup, warmDiskPeek, prefetchRegistry, useCoverArt, useWarmGridCovers, useCoverNavigationPriority, resolveIntersectionScrollRoot и сопутствующие компоненты/хуки). * fix(random-albums): prevent double-load on Zustand rehydration useEffect([selectedGenres, load]) fired twice on every visit: first with default store values, then again ~50 ms later when Zustand rehydrated mixMinRatingFilterEnabled/minAlbum/minArtist from localStorage. Previously this was invisible because the first network fetch took ~1.5 s, so loadingRef.current was still true on the second fire. With the new local-first SQLite path the first load completes in ~50 ms, leaving the guard cleared before rehydration triggers a second random batch. Fix: ref-pattern — keep loadRef.current fresh on every render, effect depends only on selectedGenres. Manual Refresh and genre-filter changes still call the latest closure correctly. * fix(random-albums): stop warmCoverDiskSrcBatch in fillReserve from causing visual flash fillReserve вызывал warmCoverDiskSrcBatch для обложек резервного батча, что вызывало bumpDiskSrcCache() для каждой новой обложки (~30+ вызовов). Это будило всех подписчиков useCoverArt на текущей странице, провоцируя видимую перерисовку примерно через ~1.5 с после загрузки (когда filterAlbumsByMixRatings делает сетевые запросы к рейтингам артистов). - fillReserve: убран warmCoverDiskSrcBatch — обложки прогреваются лениво при consume резерва через primeAlbumCoversForDisplay - reserve-путь в load(): добавлен primeAlbumCoversForDisplay перед setAlbums (аналогично non-reserve пути; при уже прогретом кэше — мгновенно) * feat(because-you-like): reserve-first pattern — instant display on return visits Каждый визит на Mainstage после первого теперь отдаёт готовую заготовку мгновенно, вместо spinner → сетевые запросы → контент. Архитектура: - resolvePicks / fetchBecauseYouLike вынесены на уровень модуля (выход из замыкания useEffect); читают текущий localStorage, возвращают { anchor, recs, nextAnchorHistory, nextPicksHistory } - fillBecauseReserve — fire-and-forget фоновая функция: запускается сразу после отображения результата, кладёт следующий батч в _becauseReserve. Covers намеренно не прогреваются (bumpDiskSrcCache на текущей странице не нужен); они прогреваются через primeAlbumCoversForDisplay при consume. - useLayoutEffect: если reserve готов — не сбрасывает стейт в skeleton (контент появляется без мигания) - useEffect: reserve-first path — consume → primeCovers → setState → fill; full-fetch path сохранён как fallback при первом визите или промахе Поведение: - Визит 1: full fetch (как раньше) → показ → fillReserve R1 - Визит 2+: consume R1 → мгновенный показ → fillReserve R2 - При сетевом сбое: restore из session cache (как раньше) * fix(because-you-like): initialise state from reserve — no skeleton flash on remount При ремаунте компонент стартовал с refreshing=true/anchor=null/recs=[] и показывал skeleton на один тик до того как useEffect отработает. Теперь useState() использует lazy initializers, которые читают _becauseReserve прямо в первом рендере: если reserve валиден — state сразу refreshing=false, anchor=X, recs=[...] и skeleton не показывается вообще. Covers уже в diskSrcCache (из предыдущего показа) и появляются без дополнительных запросов. useLayoutEffect упрощён: вызывает hasValidReserve() и сбрасывает в skeleton только если reserve отсутствует (для случая navigation без ремаунта). * fix(because-you-like): apply reserve in useLayoutEffect to handle async pool arrival Lazy initializers не могли применить reserve при первом рендере, потому что mostPlayed/recentlyPlayed/starred приходят из Home.tsx асинхронно — pool=[] на первом рендере, poolKey не совпадает с reserve. useLayoutEffect теперь активно ставит стейт из reserve (а не просто не сбрасывает): когда pool обновляется до реальных данных, useLayoutEffect срабатывает синхронно до paint, проверяет reserve и сразу применяет anchor/recs/refreshing=false. При отсутствии reserve — сбрасывает в skeleton как прежде. * fix(because-you-like): reserve > cache > skeleton — eliminate skeleton flash on mount Корневая причина: Home.tsx загружает mostPlayed асинхронно через useEffect, поэтому на первом рендере pool=[], poolKey=''. Reserve хранится с реальным poolKey → mismatch → lazy initializers запускали skeleton. Теперь двухуровневый fallback без зависимости от poolKey: 1. reserve (serverId + poolKey совпадают) → мгновенный новый батч 2. becauseYouLikeCache (только serverId) → stale-while-revalidate, контент доступен сразу с mount, обновляется тихо в фоне 3. skeleton → только при полном отсутствии данных (первый визит) Применяется одинаково в lazy useState initializers, useLayoutEffect и full-fetch path useEffect (не сбрасывать в skeleton пока есть cached контент). * fix(because-you-like): key reserve by serverId only; guard useEffect on empty pool Проблема: reserve хранился с poolKey, но на первом рендере pool=[] → poolKey='' → mismatch → показывался кэш (предыдущий набор) ~500ms пока Home.tsx не загружал mostPlayed. Исправления: - BecauseReserve: убран poolKey — reserve валиден для любого pool-состояния на том же сервере. Pool (топ-артисты) меняется медленно; один раз показать reserve с чуть устаревшим anchor лучше чем показывать предыдущий набор 500ms - hasValidReserve: проверяет только serverId - fillBecauseReserve: убран poolKey из сигнатуры и хранилища - useEffect: guard pool.length === 0 → возврат без fetch/consume; effect перезапустится когда pool заполнится (реальные deps изменятся) → reserve применяется из useLayoutEffect ещё до pool, без стале-флэша Итоговый порядок: reserve (instant, serverId) > cache (stale-while-revalidate) > skeleton (только первый визит) * fix(home): remove mix-rating deps from feed useEffect — prevent Zustand rehydration double-fetch Корень: useAuthStore(mixMinRatingFilterEnabled/Album/Artist) были в deps useEffect. Zustand persist реhydrates асинхронно — сначала activeServerId, потом mix-rating значения. Это вызывало двойной запуск эффекта: - Первый запуск: homeFeedCache hit → показывает набор предыдущего просмотра - Второй запуск (после rehydration): cache miss или повторный fetch с реальными mix-настройками → ~500ms → новый набор Итог: Hero, AlbumRow, BecauseYouLikeRail показывали предыдущий набор первые ~500ms при каждом возврате на Mainstage. Fix: убраны mixMinRatingFilterEnabled/Album/Artist из deps. getMixMinRatingsConfigFromAuth() читается внутри эффекта через getState() — всегда актуальные значения без пересоздания замыкания. Mix-настройки по-прежнему применяются при fetch, но не вызывают двойной запуск при rehydration. * feat(home): local-first discover songs via SQLite ORDER BY RANDOM() Добавлена runLocalRandomSongs (аналог runLocalRandomAlbums для треков) в browseTextSearch.ts — использует libraryAdvancedSearch с sort random, field уже поддерживается Rust-кодом через wildcarded ("random", _) ветку. В Home.tsx: discoverSongs теперь сначала пробует локальный индекс, и только при недоступности (индекс не готов, ошибка) падает обратно на getRandomSongs.view. Ускоряет первую загрузку Mainstage — треки берутся из SSD вместо сети. * fix(home): pre-populate state from cache at mount — eliminate empty-state flash on return visits Причина: Home.tsx размонтируется при навигации. При возврате первый рендер всегда с пустыми массивами (heroAlbums=[], mostPlayed=[] и т.д.), потом useEffect читает homeFeedCache и заполняет state. Даже один кадр с пустым состоянием вызывает перерисовку Hero и BecauseYouLikeRail (pool=[]). Решение: getInitialHomeFeed() читает homeFeedCache синхронно через useAuthStore.getState() (не hook) в lazy useState initializers. К моменту повторного визита store уже rehydrated — все state получают кэшированные данные до первого рендера. Дополнительно: wasPrePopulated предотвращает повторный applyFeedSnapshot в useEffect когда state уже заполнен — иначе новые ссылки на массивы вызывали бы ненужные ре-рендеры дочерних компонентов с теми же данными. * fix(mainstage): keep refresh without return flicker Keep Home and Because You Like visually stable during a single visit while still refreshing data for the next re-enter. Improve mainstage cover warmup by ensuring and pre-decoding above-the-fold artwork so hero and top rails appear instantly after navigation. * fix(mainstage): stabilize because rail and hero background framing Measure Because You Like layout before first paint to avoid width snap flicker, and render hero background as centered cover-fit images so the frame no longer jumps from top to middle on mount. * fix(now-playing): prewarm track data and prevent stale carry-over Warm Now Playing fetch caches and playback cover art on track change so entering the page no longer waits on first-load requests. Gate key-based sections (top songs, tour, Last.fm) by the active track/artist keys to avoid briefly rendering values from the previous track. * fix(cover,test): refresh playback scope and default tauri cover mocks Recompute playback cover scope when queue/server context changes so now-playing art resolves against the correct server after handoffs. Add default cover-cache invoke handlers to the shared Tauri test harness to prevent unhandled rejections in suites that mount cover-aware UI. * fix(cover,now-playing,test): align prewarm scopes and tighten tauri mocks Make cover-cache invoke defaults opt-in for tests, align radio prewarm scope with active rendering scope, and add targeted hook tests for prewarm + playback-scope reactivity. Also harden Rust cover URL building to avoid panic on malformed base URLs. * test(cover): hoist mocked useCoverArt and clean EOF whitespace Fix the new playback-scope hook test to use a hoisted vi.mock-safe stub and keep branch-wide diff checks clean by removing an accidental trailing blank line. * fix(cover): align playback ensure auth and harden backfill retry flow Use playback-server credentials for playback-scoped cover ensures, persist fetch-failed markers for bulk library backfill failures, and avoid advancing backfill cursor when UI-priority hold interrupts a batch. * fix(ci): resolve clippy lint and update frontend node runtime Move fetch helper before the test module to satisfy clippy's items-after-test-module rule, and modernize frontend CI to setup-node v6 with lts/* instead of pinned Node 20. * chore(settings): simplify cover and analytics strategy copy Move strategy summaries below tables, simplify Lazy/Aggressive wording, keep analytics warning always visible, and localize Russian texts to plain language without technical jargon.	2026-05-26 19:35:08 +03:00
Frank Stellmacher	06213cb5d8	perf(queue): virtualize the queue list (#857) ... * perf(queue): virtualize the queue list Render the QueuePanel queue through @tanstack/react-virtual so the DOM stays O(visible rows) instead of O(queue length) — a 10k+ Artist Radio queue no longer creates tens of thousands of DOM nodes. Row logic (reorder DnD, radio/ auto dividers, lucky-mix loader, context menu) is unchanged, just wrapped in the virtual rows. Auto-scroll to the next track moves out of useQueueAutoScroll (which relied on every row being in the DOM) to a virtualizer scroll plus an exact scrollIntoView on the real target row. Phase 0 of the queue thin-state plan; no store/persist changes. * docs(changelog): virtualized queue list (#857)	2026-05-22 22:17:32 +02:00
Frank Stellmacher	ccf4d5d8cb	feat(queue): persist queue header duration mode (#724) ... * feat(queue): persist header duration mode (#625) The queue header chip cycles total / remaining / ETA, but the choice lived in QueuePanel `useState` and reset to 'total' on every app launch. Move it into `authStore` (persisted under `psysonic-auth`) so the chosen mode survives restarts like other UI preferences. - `DurationMode` consolidated in `authStoreTypes` (re-exported from `queuePanelHelpers` so existing component imports stay valid). - New `queueDurationDisplayMode` field + `setQueueDurationDisplayMode` setter wired through `createUiAppearanceActions`, default `'total'`. - `computeAuthStoreRehydration` validates the persisted value against the three known modes (pattern matches the existing seekbarStyle block) — garbage, null, undefined, or a missing key map back to `'total'` so the chip never receives an unknown mode. - `QueuePanel` reads / writes via `useAuthStore` selectors instead of local `useState`. - Tests: trivial-setter coverage in `authStore.settings.test.ts` and a new `authStoreRehydrate.test.ts` covering corrupt, missing, and valid rehydration cases. Reuses kveld9's design from PR #625; not merged because the 1.46 refactor split locales and reshuffled queue-helper exports. Credited via Co-Authored-By trailer. Co-Authored-By: Kveld. <kveld912@proton.me> * docs(changelog): queue header duration mode persistence (#724) Adds the CHANGELOG entry + kveld9 credits line referencing the real PR numbers (no #TBD placeholder) — feedback.md §2.7+§2.8 workflow: commit docs as a second push onto the open PR. --------- Co-authored-by: Kveld. <kveld912@proton.me>	2026-05-15 19:14:06 +02:00
cucadmuh	45e0e1206f	fix(playback): pin queue playback to source server when browsing another library (#717) ... * fix(playback): pin queue streams, cover art, and library links to queue server When the active server changes while a queue from another server is playing, keep streams and UI on queueServerId; switch back for artist/album links and queue or player-bar context menus. * fix(playback): switch to queue server when opening Now Playing Ensure active server matches queueServerId before Subsonic fetches on the Now Playing page, mobile player route, and queue info panel; scope caches by server id. * docs(credits): mention Now Playing in PR #717 contribution line * fix(playback): route scrobble and queue sync to queue server Address PR review: apiForServer for scrobble/now-playing/savePlayQueue, clear queueServerId on server removal, mini-player queueServerId sync, block cross-server enqueue with toast, and regression tests.	2026-05-15 16:08:41 +03:00
Frank Stellmacher	5231169a71	refactor(format): consolidate duration formatters into format/formatDuration (Phase L, part 2) (#690) ... The mm:ss track-time formatter was hand-rolled in 11 places and the h:mm:ss total-duration formatter in 4 — extract two tested functions: - formatTrackTime(seconds, fallback='0:00') — m:ss, used for track / playback times. fallback param covers the '–' placeholder rows. - formatLongDuration(seconds) — h:mm:ss when >=1h, else m:ss, used for album / queue totals. Behaviour preserved per call site: the unified guard (!seconds || !isFinite || <0 -> fallback) produces identical output to every prior variant for all real inputs; SongRow keeps its '–' via the fallback arg. Removes the formatter exports from 6 componentHelpers files (playerBarHelpers / fullscreenPlayerHelpers deleted — they only exported the formatter) and 7 inline component copies. + formatDuration.test.ts	2026-05-14 14:50:10 +02:00
Frank Stellmacher	7a7a9f5e6b	refactor(utils): group utils/ files into topic folders (Phase L, part 1) (#689) ... 111 of 122 top-level src/utils/ files move into 16 topic folders (audio, cache, cover, share, server, playback, playlist, deviceSync, waveform, mix, format, export, changelog, ui, perf, componentHelpers). True singletons with no cluster stay at the utils/ root. Pure file-move: a path-aware codemod rewrote 539 relative-import specifiers across 275 files; no logic touched. The hot-path coverage gate list (.github/frontend-hot-path-files.txt) is updated to the new paths for the 11 gated utils files — a mechanical consequence of the move, not a CI change. tsc is green.	2026-05-14 14:27:44 +02:00
Frank Stellmacher	8ff630cb5c	refactor(queue-panel): H4 — split QueuePanel.tsx 1256 → 383 LOC across 11 files (#667) ... * refactor(queue-panel): H4 — extract helpers + Save/LoadPlaylistModal Pure code-move: formatTime, formatQueueReplayGainParts, renderStars and the DurationMode type → utils/queuePanelHelpers.tsx; the two playlist modals → own files under components/queuePanel/. QueuePanel.tsx: 1256 → 1104 LOC. * refactor(queue-panel): H4 — extract QueueHeader Pure code-move: the title/count/duration/collapse-button header → its own component file. No prop or behaviour changes. QueuePanel.tsx: 1104 → 1004 LOC. * refactor(queue-panel): H4 — extract QueueCurrentTrack + QueueLufsTargetMenu The currently-playing track block (cover, info, replay-gain / LUFS badge with its target-listbox portal) moves into two own files. Pure code-move via prop plumbing. setLoudnessTargetLufs is typed as LoudnessLufsPreset throughout the new components. QueuePanel.tsx: 1004 → 812 LOC. * refactor(queue-panel): H4 — extract useQueuePanelDrag hook Moves the psy-drag wiring (hit-test registration, drop-inside dispatch for song/songs/album/queue_reorder payloads, drop-outside removal) into its own hook. Drops the dead isRadioDrag variable since the parsedData.type === 'radio' guard inside onPsyDrop already handles that case. QueuePanel.tsx: 812 → 715 LOC. * refactor(queue-panel): H4 — extract useQueueLufsTgtPopover hook Pulls the LUFS-target popover open-state, button/menu refs, fixed-position recompute on open/resize/scroll, and auto-close-when-RG-collapses out of QueuePanel. QueuePanel.tsx: 715 → 662 LOC. * refactor(queue-panel): H4 — extract QueueToolbar The toolbar-button switch (shuffle/save/load/share/clear/gapless/crossfade/ infinite) and the crossfade popover (with its close-on-outside-click effect) move into one component. crossfadeBtnRef / crossfadePopoverRef and showCrossfadePopover state are now component-local — QueuePanel no longer sees them. QueuePanel.tsx: 662 → 541 LOC. * refactor(queue-panel): H4 — extract QueueList The OverlayScrollArea + queue.map block (with track rows, lucky-mix dice overlay, and radio/auto-added section dividers) moves into its own component. PlayerState['contextMenu'] + PlayerState['playTrack'] are re-used for prop typing, the local StartDrag alias matches the DragDropContext signature. QueuePanel.tsx: 541 → 434 LOC. * refactor(queue-panel): H4 — extract QueueTabBar + useQueueAutoScroll, final cleanup QueueTabBar is the bottom queue/lyrics/info tab switcher. useQueueAutoScroll groups the three list-scroll effects (publish scrollTop reader, restore pending snapshot, scroll next track into view on advance). Drops the dead toggleQueue and replayGainMode selectors plus the now-unused Play, Radio, MicVocal, ListMusic, Info imports and OverlayScrollArea. QueuePanel.tsx: 434 → 383 LOC. Every new file under 400.	2026-05-13 22:33:02 +02:00
Frank Stellmacher	f7b2799d39	refactor(api): F.51 — extract playlists + play queue + radio + statistics (#616) ... Four more domain-eng modules out of `api/subsonic.ts`: - `subsonicPlaylists.ts` — `getPlaylists`/`getPlaylist`/`createPlaylist` /`updatePlaylist`/`updatePlaylistMeta`/`uploadPlaylistCoverArt`/ `uploadArtistImage`/`deletePlaylist`. The two upload helpers use the Tauri-side CORS bypass (`upload_playlist_cover` / `upload_artist_image`). - `subsonicPlayQueue.ts` — `getPlayQueue`/`savePlayQueue`. - `subsonicRadio.ts` — Internet Radio CRUD (4 fns), Tauri-side cover art ops (3 fns), RadioBrowser search/top + `fetchUrlBytes`. - `subsonicStatistics.ts` — `fetchStatisticsLibraryAggregates`/ `fetchStatisticsOverview`/`fetchStatisticsFormatSample` with their three per-server-folder caches and the `statisticsPageCacheKey` helper. `STATS_CACHE_TTL` renamed from the misleadingly-shared `RATING_CACHE_TTL` constant. Also: drop ~20 now-unused type/value imports from `subsonic.ts`, trim three orphan jsdoc comments left behind by earlier slices, fix four `vi.mock` targets (`queueSync`, `playerStore.persistence`) plus the dynamic `await import('../api/subsonic')` calls in `ContextMenu.tsx` to point at the new module paths. Pure code-move. subsonic.ts: 561 → 144 LOC (−417). What's left: ping/pingWithCredentials/probeInstantMix/scheduleInstantMixProbe + internal `apiWithCredentials`/`restBaseFromUrl`.	2026-05-13 01:03:13 +02:00
Frank Stellmacher	9606a99efb	refactor(api): F.50 — extract 7 small domain modules (#615) ... Seven domain-eng splits peel ~200 LOC of read endpoints out of `api/subsonic.ts`: - `subsonicStreamUrl.ts` — `buildStreamUrl`, `coverArtCacheKey`, `buildCoverArtUrl`, `buildDownloadUrl` (token-signed URL builders for the four /rest endpoints we hand to the browser). - `subsonicStarRating.ts` — `getStarred`, `star`, `unstar`, `setRating`, `probeEntityRatingSupport`. `setRating` still triggers the lazy `navidromeBrowse` cache invalidation; the same-folder lazy import path is preserved. - `subsonicSearch.ts` — `search`, `searchSongsPaged`. - `subsonicScrobble.ts` — `scrobbleSong`, `reportNowPlaying`, `getNowPlaying`. - `subsonicAlbumInfo.ts` — `getAlbumInfo2`. - `subsonicLyrics.ts` — `getLyricsBySongId`. - `subsonicGenres.ts` — `getGenres`, `getAlbumsByGenre`. 63 external call sites migrated to direct imports. Four `vi.mock` targets in the store-level tests pointed at `../api/subsonic` and were updated to the new module paths. Pure code-move. subsonic.ts: 762 → 561 LOC (−201).	2026-05-13 00:46:13 +02:00
Frank Stellmacher	006635de4b	refactor(api): F.49 — extract library + artists + ratings (#614) ... Three domain-eng modules peel ~316 LOC of fetch/mapping out of `api/subsonic.ts`: - `subsonicLibrary.ts` — browse + random + per-song fetch (`getMusicDirectory`, `getMusicIndexes`, `getMusicFolders`, `getRandomAlbums`, `getAlbumList`, `getRandomSongs`, `getRandomSongsFiltered`, `getSong`, `getAlbum`, `filterSongsToActiveLibrary`, `similarSongsRequestCount`, plus the private `albumIdsInActiveLibraryScope` cache). - `subsonicArtists.ts` — artist endpoints (`getArtists`, `getArtist`, `getArtistInfo`, `getTopSongs`, `getSimilarSongs2`, `getSimilarSongs`). Uses Library's `filterSongsToActiveLibrary` and `similarSongsRequestCount` for the per-library scoping fallback. - `subsonicRatings.ts` — `parseSubsonicEntityStarRating` parser plus `prefetchArtistUserRatings` and `prefetchAlbumUserRatings` workers with the shared 7-min cache. Calls back into Library/Artists for the per-id fetch. 51 external call sites migrated to direct imports. No re-export shims in `subsonic.ts`. Statistics endpoints still in `subsonic.ts` keep their `RATING_CACHE_TTL` constant locally (same 7-min window). subsonic.ts: 1078 → 762 LOC (−316).	2026-05-13 00:23:53 +02:00
Frank Stellmacher	72030f17fd	refactor(api): F.48 — extract subsonic types + client primitives (#613) ... First Phase F slice. Splits the 1333-LOC `api/subsonic.ts` along its two most obvious axes: - `subsonicTypes.ts` — all ~24 exported interfaces + type aliases (album/song/artist/playlist/directory/genre/now-playing/radio, random-songs filters, three statistics shapes, search + starred results, AlbumInfo, structured-lyrics types, etc.) plus the `RADIO_PAGE_SIZE` constant. - `subsonicClient.ts` — token-auth + `getClient` + `api<T>()` + `libraryFilterParams` + `secureRandomSalt` / `getAuthParams` / `SUBSONIC_CLIENT`. The credential-bearing API helpers (`pingWithCredentials`, `apiWithCredentials`, `restBaseFromUrl`, `probeInstantMixWithCredentials`) stay in `subsonic.ts` for now — they could move into the client module in a follow-up. 66 external call sites migrated to direct imports from the new modules (no re-export shims in `subsonic.ts`). Pure code-move; contract test stays green. subsonic.ts: 1333 → 1078 LOC (−255).	2026-05-13 00:05:58 +02:00
Frank Stellmacher	9fac6eb490	refactor(player): E.42 — migrate playerStore re-exports to direct imports (#607) ... Migrates ~74 call sites away from the playerStore re-export shims that were kept during M0–E.41 to avoid touching 30+ imports per PR. Now that the bigger refactor work is done, each helper goes back to its real home: - `initAudioListeners`, `installQueueUndoHotkey`, `flushPlayQueuePosition` → from their own store modules - `getPlaybackProgressSnapshot`, `subscribePlaybackProgress`, `PlaybackProgressSnapshot` → from `playbackProgress` - `resolveReplayGainDb`, `shuffleArray`, `songToTrack` → from `utils/*` - `_resetQueueUndoStacksForTest`, `consumePendingQueueListScrollTop`, `registerQueueListScrollTopReader` → from `queueUndo` - `PlayerState`, `Track` types → from `playerStoreTypes` Drops the corresponding 13 re-export stubs from `playerStore.ts` and the now-unused imports. Also drops dead section banners + per-wrapper comments above one-line action delegates. Trims one stale "(separate PR)" note in `transportLightActions.ts` since that follow-up landed in E.39. `playerStore.ts`: 180 → 112 LOC (−68). Down from Phase E's starting 3732 LOC. `bootstrap.test.ts` mock target updated from `../store/playerStore` to `../store/queueUndoHotkey` to keep the spy reachable after the import change.	2026-05-12 22:46:13 +02:00
Kveld.	64b33e6941	feat: customizable queue toolbar with drag-and-drop reordering and visibility toggles (#534) ... * Add drag-and-drop reordering and visibility toggles for queue toolbar * docs(changelog): credit PR #534 (queue toolbar customization) Adds the v1.46.0 CHANGELOG entry and a new bullet on kveld9's contributors block in Settings → System. --------- Co-authored-by: Psychotoxical <171614930+Psychotoxical@users.noreply.github.com>	2026-05-11 12:35:38 +02:00
Maxim Isaev	308eb36f05	feat(analysis): re-analyze waveform when clearing loudness cache ... Add analysis_delete_waveform_for_track, invoke it from loudness reseed, clear waveformBins in the UI, and extend queue strings for tooltips/toast.	2026-05-10 01:34:40 +03:00
Frank Stellmacher	726f3f0ff2	fix(radio): queue navigation, dedup, and similar-first variety (#500) (#503) ... * fix(radio): queue navigation, dedup, and similar-first variety (#500) After a Radio session ran a while, three things broke: Queue navigation through duplicates. playTrack re-resolved the active queue index by `findIndex(t.id === track.id)`, returning the *first* matching id, so reaching the second occurrence of a track snapped queueIndex back to the earlier slot — highlight jumped and the next advance played the wrong follow-up. Added an optional `targetQueueIndex` to playTrack, threaded through next(), previous(), the audio:ended repeat-one path, queue-row click, and the queue-item context menu. findIndex stays as the fallback for callers that just have a track and a fresh queue. Queue accumulation. enqueueRadio didn't dedupe incoming tracks; the next() top-up deduped against the live queue but trimmed the played tail down to HISTORY_KEEP=5, so a song heard 8 ago was gone from `existingIds` and a later Last.fm/topSongs response could re-add it; and the `.filter(...)` pass admitted intra-batch repeats (top + similar overlap is common) because it read the dedup set before mutating it. A module-level radioSessionSeenIds set, fed by enqueueRadio and both top-up paths and reset on artist change and clearQueue, closes all three: trimmed ids stay in the set, ids about to be replaced (fresh enqueueRadio wiping the pending radio block) are removed first so callers can re-introduce them, and the dedup pass mutates the set inline. Variety. Starting Radio on a track stacked five top tracks of the seed artist before any similar-artist material played. Switched the seed path and both top-up paths to lead with similar songs (other artists) and only fall back to top tracks when similar comes back empty — preserves the "no Last.fm" graceful degradation but stops the seed artist from monopolising the front of the queue. Not affected: gapless audio:track_switched (already index-based, no findIndex), AudioMuse Instant Mix / Lucky Mix (single-element queues or enqueue-only paths), the artist-radio path (no seedTrack — already picks just one top track and fills the rest from similar). Reported by netherguy4. * docs: changelog entry for PR #503 Logs the radio queue navigation/dedup/similar-first fix in v1.46.0 "## Fixed".	2026-05-07 19:56:57 +02:00
Frank Stellmacher	072bef473f	fix(queue): restore pre-#419 Play-icon prefix on the active row (#469) ... PR #419 replaced the small (10px) Play icon next to the active queue title with an animated 3-bar eq-bars block prefixed before the row. Restore the original Play-icon-in-title behaviour and drop the unused isStorePlaying selector.	2026-05-05 23:40:07 +02:00
Frank Stellmacher	364b29ceee	fix(queue): restore PR #420 QueuePanel.tsx parts lost in #419 squash (#440) ... The drag-row-outside-queue-to-remove feature shipped in #420 (by cucadmuh) had its QueuePanel.tsx wiring wiped when #419 was squash- merged from a branch that pre-dated #420. The DragDropContext and MiniPlayer parts of #420 survived; only QueuePanel.tsx was overwritten. Restored to the state on commit 274ac5b3: - Import `registerQueueDragHitTest` from DragDropContext - Subscribe to `removeTrack` from playerStore - Register the queue rect as a hit-test region on mount - Document-level psy-drop listener that removes the dragged row when the drop coordinates fall outside the queue rect Co-authored-by: cucadmuh <49571317+cucadmuh@users.noreply.github.com>	2026-05-03 14:03:07 +02:00
Kveld.	18b4a982ef	feat: queue-ux-improvements (#419) ... * feat(queue): add ETA display, equalizer indicator and collapsible now playing * deleted endsAt and showDuration strings, changed eta update to 30s * feat(queue): ETA tooltip, persistent Now Playing collapse, EQ bar pause, remove redundant Play icon * feat(queue): fold ETA into existing total/remaining toggle as third mode The standalone ETA span next to the track counter is removed; instead the clickable duration label in the queue header now rotates through three modes per click: total → remaining → eta → total. Counter (N/M) stays where it was. ETA mode keeps the live-feel treatment from the original PR (accent colour while playing, muted at 50% opacity when paused). The other two modes use plain accent. i18n: queue.etaTooltip removed (no longer a separate descriptive label), queue.showEta added as the action tooltip ('Show estimated end time') in all 8 locales — matches the showRemaining / showTotal pattern. * docs(changelog): add #419 queue UX improvements entry Adds the [1.45.0] / Added entry for this PR's queue panel refinements (position counter, tri-state duration toggle including ETA, collapsible Now Playing section, animated EQ indicator). --------- Co-authored-by: Psychotoxical <171614930+Psychotoxical@users.noreply.github.com>	2026-05-02 21:45:55 +02:00
cucadmuh	274ac5b3b4	feat(queue): drag rows outside queue to remove; trash ghost outside bounds (#420) ... * feat(queue): drag rows outside queue to remove; trash ghost outside bounds - Document-level psy-drop when cursor leaves queue rect (main + mini) - DragDropContext: drop coordinates on psy-detail; optional wrapRef on OverlayScrollArea - Trash icon on drag ghost only outside registered queue hit-test regions * docs(changelog): add queue drag-out removal for PR #420	2026-05-02 02:36:35 +03:00
cucadmuh	87373edb17	fix(loudness): target sync, effective pre-analysis trim, and queue/settings copy (#333) ... * fix(loudness): target sync, -14 pre-analysis ref, queue UI, and reseed - Front: coalesce loudness refresh by target LUFS; replay-gain IPC dedupe keys include norm target and effective pre-attenuation so TGT changes apply. - Rust: placeholder gain before integrated LUFS uses pivot at -14 LUFS; UI gain from effective trim; reseed loudness after delete when waveform cache would skip. - Pre-analysis: store attenuation relative to -14 LUFS; engine and UI use an offset for other targets; migrate legacy absolute values on rehydrate. - Queue/Settings: Loudness/TGT labels vs value buttons; styles; i18n for help. * fix(i18n): simplify loudness pre-analysis helper copy Remove reference-target wording from loudness pre-analysis helper text and keep only the effective adjustment shown for the current LUFS target in all locales.	2026-04-27 02:54:58 +03:00
Maxim Isaev	55a49a9fb0	feat(player): restore queue list scroll on queue undo/redo ... Store the main queue panel viewport scrollTop in undo snapshots and reapply it after undo/redo so Ctrl+Z / Ctrl+Shift+Z restores scroll position alongside queue state.	2026-04-27 00:33:47 +03:00
Psychotoxical	185cb8f7cd	Merge branch 'main' into feat/waveform-loudness-cache	2026-04-26 02:05:10 +02:00
Psychotoxical	77b2a5401a	fix(queue): preserve scroll context when user clicks a track in the queue ... Auto-scroll used to fire on every currentTrack change, including manual clicks inside the queue list itself. The clicked track would slide off screen as the list rebased onto the new "next track", which is disorienting — the user just acted on something specific and expects to keep seeing it. Set a one-shot suppression flag from the queue-item onClick handler so the immediately following auto-scroll effect skips its scrollIntoView call. Natural advance (track end, prev/next button, anything that does not originate inside the queue list) leaves the flag untouched and keeps the original "show what's coming next" behavior. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-26 01:41:25 +02:00
Maxim Isaev	53cab7654c	feat(player,queue): loudness strip controls and normalization readout fixes ... - Add Tauri command to delete loudness_cache rows for a track and helpers in AnalysisCache. - Queue tech strip: click dB to reseed loudness; LUFS target picker via body portal; metric styling aligned with strip (no link chrome). - Player store: reseed clears local cache and replays analysis seed; show loudness dB from SQLite cache when live state is still null; allow first numeric normalization-state update through the short duplicate filter. - audio_update_replay_gain: resolve loudness from the requested gain when playback URL is not pinned yet.	2026-04-25 23:38:27 +03:00
Psychotoxical	453151f1fc	Merge branch 'main' into feat/waveform-loudness-cache ... # Conflicts: # src/store/playerStore.ts	2026-04-25 21:47:48 +02:00
Maxim Isaev	e009fd1823	fix(settings): make normalization modes exclusive and refine LUFS UI ... Replace the mixed ReplayGain/Loudness controls with a single exclusive mode selector, hide RG-specific controls when LUFS is active, and align the queue tech badge behavior between RG and LUFS. Also update LUFS targets to -10..-16 ordering and default loudness target to -12.	2026-04-25 22:36:55 +03:00
Maxim Isaev	86704473ed	fix(audio): stabilize loudness normalization and streaming startup behavior ... Improve normalization consistency by separating cache refresh for non-playing tracks, hardening track-id cache lookups, and keeping UI gain state aligned with actual playback. Also reduce startup stalls by preferring non-seekable streaming when format hints are missing and by tuning ALSA/analysis paths to avoid underrun-prone churn.	2026-04-25 22:09:38 +03:00
Psychotoxical	6ca678547b	fix(orbit): attribute bulk-added tracks to host in queue view ... Album and playlist enqueues go through usePlayerStore.enqueue() directly, never through hostEnqueueToOrbit, so the tracks never land in state.queue. Our attribution map only covered state.queue entries, so bulk-added rows rendered with no label at all. Fall back to "Added by you" when a track is in the host's player queue but has no state.queue entry — the host added it themselves by definition (pre-session or bulk-add). The guest-side view already had this fallback via base.host in useOrbitHost.ts. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-25 00:34:00 +02:00
Psychotoxical	a84be98140	feat(orbit): show track attribution in host queue + host label in guest queue ... Before: the guest queue already labelled guest-suggested tracks with "Suggested by {user}", but host picks had no label — and the host's own queue had no attribution at all. The host couldn't tell which upcoming rows came from guests without checking the pending-approvals list. - Guest queue: host-pick rows now show "Added by host" instead of hiding the attribution line. - Host queue: each row (and the current track) shows "Added by you" or "Added by {user}" while an Orbit session is active. Lookup uses the existing OrbitState.queue / currentTrack addedBy field, so no new protocol fields. New i18n keys (en+de+fr+nl+zh+nb+ru+es): orbit.queueAddedByHost · queueAddedByYou · queueAddedByUser Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-25 00:28:46 +02:00
Psychotoxical	17bcac7155	chore(orbit): manual approval flow for guest suggestions ... Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-24 17:36:44 +02:00
Psychotoxical	1a470b51b5	chore(orbit): participant strip at the top of the queue for host and guest ... Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-24 14:29:03 +02:00
Psychotoxical	fe7dc7af54	Merge branch 'main' into exp/orbit ... # Conflicts: # src/components/QueuePanel.tsx	2026-04-24 01:06:51 +02:00
Frank Stellmacher	e86133738d	fix(ui): swap Gapless / Infinite Queue toolbar icons (#284) ... Reported in #274 — the icons for the Gapless and Infinite Queue toggles were the wrong way round. The infinity symbol was on Gapless, but reads much more naturally on Infinite Queue (a queue that never ends), and the arrow-up-to-line on Infinite Queue had no obvious mapping at all. Move infinity to Infinite Queue. Use MoveRight (right-pointing arrow) for Gapless — visualises 'flows straight through to the next track without stopping' and stays distinct from the chain/link family at 13 px in both the QueuePanel and Mini Player toolbars. Closes #274	2026-04-24 00:48:55 +02:00
Psychotoxical	861798ea7a	Merge branch 'main' into exp/orbit	2026-04-24 00:19:14 +02:00
Psychotoxical	e9e61b9a05	refactor(lucky-mix): review follow-ups from Psychotoxical ... - Drop the ~110 lines of dead full-screen overlay CSS that was never referenced in JSX (.lucky-mix-overlay*, .lucky-mix-cube*, full-screen @keyframes). Keep the .lucky-mix-pip* rules since the inline queue variant re-uses them. - Extract availability gate into hooks/useLuckyMixAvailable.ts (pure predicate + hook). Replaces five duplicated inline checks in Sidebar, MobileMoreOverlay, RandomLanding, Settings/SidebarCustomizer, and the internal re-check in buildAndPlayLuckyMix. - Add a cancel mechanic: * luckyMixStore gets a cancelRequested flag + cancel() method * LuckyMixCancelled sentinel is thrown from a bailIfCancelled() helper sprinkled between await boundaries in the build loop * catch-block swallows the sentinel silently (no toast, no error state) * auto-cancel subscription on playerStore detects manual user track changes (anything not in queuedIds) and flips cancelRequested so the finished mix does not later overwrite the user's choice * inline .queue-lucky-loading dice indicator is now a button — click triggers explicit cancel, hover fades the dice to signal the action - Restore the queue snapshot when the build fails before ever starting playback, so the user does not land in an empty player after an error. If playTrack already ran, leave current state alone (their track plus whatever was enqueued is more useful than a stale pre-click queue). - Rework locale labels to consistently carry the "Mix" suffix so the entry reads well next to "Random Mix" / "Random Albums" in the sidebar: DE Glücks-Mix, ES Mezcla Suerte, FR Mix Chance, NB Lykkemiks, NL Geluksmix, ZH 好运混音. EN stays "Lucky Mix", RU stays «Мне повезёт». Toast/settings/randomNavSplit copy aligned to the new names. New luckyMix.cancelTooltip key added in all 8 locales. AudioMuse gating stays — as Cuca confirmed, the feature's quality relies on a correct similar-track selection, so the requirement is intentional. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-23 18:41:46 +02:00
Maxim Isaev	ab5c8e0b48	feat(lucky-mix): instant mix from your preferences ... Lucky Mix targets ~50 tracks in one run: pick seeds from your most-played artists/albums and 4+ rated songs, add similar tracks, then fill the mix with random library picks, skipping anything you rated 1–2. On start it trims the old “upcoming” tail so the queue does not show stale next tracks, starts playback on the first viable seed, routes to Now Playing, and can emit structured steps to the backend debug log.	2026-04-23 18:42:52 +03:00
Psychotoxical	2b97a7b01e	exp(orbit): host merge, guest queue view, settings popover, i18n ... Guest suggestions now auto-merge into the host's play queue at random positions inside the upcoming range, so they actually surface alongside host-picked tracks instead of piling up at the end. Per-item dedupe via addedBy:addedAt:trackId keys survives reshuffles. Guests get a read-only mirror of the session in place of their queue panel — live-card for the host's current track, suggestion list with submitter attribution, and a footer reminding them the host owns playback. Track metadata is resolved lazily and cached locally. New host-only settings popover (gear in the bar) with auto-approve and auto-shuffle toggles plus a "Shuffle now" action. Settings live in the OrbitState blob and push immediately to Navidrome; missing fields on older blobs default to "both on". 15-min shuffle now touches the real playerStore queue via a new shuffleUpcomingQueue action — previous behaviour only reshuffled the guest-facing suggestion history. A manual shuffle is available from the settings popover so the interval can be verified without waiting. Start-modal reworked into a single step: share-link is visible and copy-able from the start, auto-copied on Start if the host hasn't already hit Copy. Link carries a live name-derived slug (parser strips it, SID is authoritative). LAN/remote-server hint above the facts. Random session-name suggester pulls from three pattern pools for ~10k unique combinations. All user-visible Orbit strings moved to a dedicated orbit i18n namespace (en + de); other locales fall back to en via i18next. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-23 02:49:42 +02:00
Psychotoxical	7fe492d233	exp(orbit): start modal, paste-to-join, suggest track from context menu ... Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-23 01:21:19 +02:00
Frank Stellmacher	7c9a300022	feat(share): library deep links (psysonic2) with paste + toolbar actions (#261) ... * feat(share): library deep links (psysonic2) with paste and toolbar actions Add base64url-encoded payloads for track, album, artist, and ordered queue. Handle paste outside inputs to switch server, validate entities, navigate or play. Reuse clipboard helper for context menu, queue panel, album and artist headers. Tests distinguish server invite strings from library shares. * fix(share): play partial queue when some shared tracks are missing Skip unavailable song IDs when pasting a queue share while preserving order. Toast when some tracks are missing; error only if none resolve. Add openedQueuePartial and queueAllUnavailable i18n; remove queueTracksMissing. * feat(settings): paste server invites globally and scroll to add form Handle psysonic1- magic strings outside inputs: navigate to settings or login with prefilled add-server fields. Decode invites embedded in surrounding text. Scroll the add-server block into view when opening from a paste so long server lists stay oriented. --------- Co-authored-by: Maxim Isaev <im@friclub.ru>	2026-04-22 11:21:00 +02:00
cucadmuh	b61c168430	fix(ui): overlay scrollbars, resizer hit-test, and Linux mini wheel (#255) ... Add OverlayScrollArea with shared thumb metrics and drag handling; size the thumb against the rail track height so panel insets cannot push it past the visible rail. Route scroll uses a stable viewport id; Genres restores scroll and infinite-scroll observation against that viewport (merged with upstream virtualized genres list and lazy routes behind Suspense). Suppress queue resizer activation when the pointer targets the main-route overlay scrollbar; disable the resizer while dragging the thumb and use a grabbing cursor on the body. Apply WebKitGTK smooth wheel to the mini webview as well as main; the mini window reapplies the persisted setting after auth store hydration.	2026-04-21 22:44:28 +02:00
Frank Stellmacher	06140a490b	feat(queue): add Now-Playing Info tab with artist bio, song credits and Bandsintown tour dates (#244) ... * feat(queue): add Now-Playing Info tab with artist bio, song credits and Bandsintown tour dates A third tab in the right-side queue panel surfaces context for the currently playing track: - Artist card: image + biography from Subsonic getArtistInfo (Last.fm "Read more on Last.fm" anchor stripped), with read-more toggle that only appears when the bio actually overflows the 4-line clamp. - Song info: contributor credits from OpenSubsonic contributors[] rendered stacked (name prominent, role muted). Section is hidden entirely on servers without contributor support, and rows that just re-state the main artist under role "artist" are filtered out. - On tour: optional Bandsintown integration (opt-in, off by default). HTTP fetch + JSON parsing happen entirely on the Rust side; the frontend wrapper deduplicates concurrent calls and caches results in RAM for the session. Limited to 5 events with a "Show N more" toggle. When the toggle is off, the section becomes an in-place opt-in card with a privacy info-tooltip explaining what data is sent — same tooltip is also exposed on the matching toggle in Settings. Caching: artist info and song detail are memoised by stable IDs across component remounts, so jumping between tracks of the same album/artist does not refire the network calls. Implementation notes: - Bandsintown app_id "js_app_id" — arbitrary strings (e.g. "psysonic") now return HTTP 403 from rest.bandsintown.com; js_app_id is the ID Bandsintown's own embeddable widget uses and is broadly accepted. - Tour items use negative left/right margins so the date badge stays visually aligned with the section title while the hover background extends slightly past the section edges. - New i18n namespace nowPlayingInfo across all 8 locales (en, de, fr, nl, zh, nb, ru, es) including pluralised "Show N more" forms. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(now-playing-info): switch nested flex-columns to block layout to stop content-dependent drift Repeated reports of the Tour and Song-info sections rendering at inconsistent x-positions (sometimes left of the section title, sometimes centred, sometimes correctly aligned) — varying by artist, sidebar width, and even whether "Show more" was clicked. Root cause: nested flex-direction: column containers (.np-info → .np-info-section → .np-info-tour / .np-info-credits) where the cross-axis (horizontal) sizing on WebKitGTK occasionally inherits the intrinsic min-content of the longest child. With one "Naherholungsgebiet/Freizeitgelände Lago Alfredo"-style venue name that overflows the sidebar, the parent ul gets pushed past 100% width and the entire layout drifts. min-width: 0 on every level didn't help because cross-axis stretch in flex-column ignores it for content-driven overflow. Fix: collapse all the section/list containers to display: block. Block layout is content-agnostic — children always render at 100% parent width, left-aligned, deterministically. Spacing between siblings now uses the lobotomy selector (`> * + * { margin-top }`). Only the tour item itself stays flex (badge ↔ meta horizontal layout), and that one still has overflow: hidden + flex: 1 1 0 + min-width: 0 on the meta column to truncate venue/place text with ellipsis. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Psychotoxical <dev@psysonic.app> Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-21 19:13:18 +02:00
Psychotoxical	e07ef0ebf1	feat(queue): collapse ReplayGain into a click-to-expand badge ... Per @cucadmuh's feedback: the presence of ReplayGain matters more than the actual numbers. The tech bar now shows a small 'RG' pill on line 1 whenever the track has any RG metadata; hovering reveals the values via tooltip, clicking persistently expands the second line. - Source icon stays inline before the format string (was getting separated from FLAC by the centred stack layout) - Pill uses --accent-tinted color-mix so it adapts to every theme - ChevronDown rotates on expand for a clear affordance - New persisted state: themeStore.expandReplayGain (default collapsed) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 12:34:52 +02:00
Psychotoxical	a48159d302	feat(queue): split tech bar into two lines when ReplayGain is present ... The tech info strip in the queue header was a single ellipsised line, so ReplayGain values (Track / Album / Peak) got cut off on tracks with a full codec + bitrate + samplerate prefix. Now the strip wraps into two lines whenever RG values exist: - Line 1: codec · bitrate · bit depth/sample rate (unchanged) - Line 2: 'ReplayGain · T … dB · A … dB · Peak …' — slightly smaller and dimmed for hierarchy, ellipsises independently if it still overflows. Tracks without RG metadata stay one line as before. New i18n key `queue.replayGain` ('ReplayGain') added to all 8 locales. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 12:24:46 +02:00
Psychotoxical	cd1c785e43	fix(queue): use data-tooltip instead of title for source badge ... Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-17 15:55:48 +02:00