9 Commits

Author	SHA1	Message	Date
Psychotoxical	1a82376f8c	feat(music-network): unified scrobble & enrichment framework (replaces hard-wired Last.fm) (#1066) ... * feat(music-network): core domain types and wire contracts Foundation for the Music Network framework: provider-agnostic domain types, capability model, typed errors, and account shapes under src/music-network/core, plus the ScrobbleWire / EnrichmentWire / PresetManifest / AuthStrategy contracts. No runtime wiring yet. * feat(music-network): generic audioscrobbler/listenbrainz/maloja transports Generalize the Rust remote layer for the Music Network framework. Add provider-agnostic transports parameterized by base_url: - audioscrobbler_request: Audioscrobbler v2 with caller-supplied endpoint (Last.fm, Libre.fm, Rocksky, custom GNU FM, Maloja compat share it) - listenbrainz_request: Token-header JSON (direct + Maloja LB compat) - maloja_request: native /apis/mlj_1 JSON lastfm_request stays as a thin transition delegate against the fixed host; it is removed once the framework owns all call sites. Wiremock tests cover audioscrobbler_request with a custom base_url and API-error mapping. * feat(music-network): audioscrobbler wire with last.fm + libre.fm presets Add the Audioscrobbler v2 wire, the behavioural successor to the legacy src/api/lastfm.ts, implementing the full EnrichmentWire surface (scrobble, now playing, love/unlove, loved sync, similar artists, track/artist stats, top lists, recent tracks, user profile, urls). - client.ts: transport wrapper over audioscrobbler_request, classifying failures into MusicNetworkError without touching any store - sign.ts: TS mirror of the api_sig base-string ordering rule (unit-tested) - auth/tokenPoll.ts: browser token-poll connect flow as a reusable strategy - presets/lastfm.ts, presets/librefm.ts: bundled, enrichment-capable, token-poll presets (both endpoints verified live) Extends WireContext with profileBase and ConnectContext with authBase so URL builders and connect flows need no preset lookup. * feat(music-network): listenbrainz + maloja-native wires, paste-auth presets Add the scrobble-destination wires and presets: - ListenBrainz wire (scrobble + now playing via playing_now), backing both the direct api.listenbrainz.org preset and the Maloja /apis/listenbrainz compat preset (one wire, two presets, differing only by base URL) - Maloja native wire (/apis/mlj_1/newscrobble, scrobble only — Maloja has no now-playing endpoint) - Shared api_key_only paste-auth strategy (token/key/session-key paste); the Audioscrobbler wire now dispatches token-poll vs paste by preset - Presets: listenbrainz, maloja_listenbrainz, maloja_native, rocksky (scrobble-only, session-key paste, bundled keys — verified live), and custom_gnufm (token-poll, user-supplied url/key/secret) - Contracts: ConnectContext.authStrategy, PresetManifest.selfHostedApiSuffix maloja_compat (the {url}/apis/audioscrobbler mode) is intentionally omitted: its protocol cannot be verified and is almost certainly the legacy handshake, not the 2.0 web API; Maloja is covered by the native and ListenBrainz modes. * feat(music-network): registry, orchestrator, enrichment router + runtime facade Wire the framework together behind a single facade: - registry: wireRegistry (WireId -> wire), presetRegistry (the 7 built-in presets), registerBuiltinWires (one-time side-effect registration) - CapabilityProbe: wire probe overlaid by manifest staticCapabilities as the final authority (lets two presets on one wire diverge, e.g. Rocksky's nowPlaying:false over the Audioscrobbler wire's optimistic yes) - ScrobbleOrchestrator: best-effort fan-out; flips the per-account session-error flag on AUTH_SESSION_INVALID and clears it on next success - EnrichmentRouter: resolves the single primary to its EnrichmentWire; the type guard rejects non-enrichment wires (Maloja/ListenBrainz) - MusicNetworkRuntime: the only app entry point — accounts, roles, fan-out, enrichment, urls, probe. Reads/writes state through the MusicNetworkStore port (Phase 5 backs it with the auth store) and a RuntimeHost for side effects - getMusicNetworkRuntime singleton + index.ts public barrel Tests cover fan-out, master toggle, capability gating, session-error flip/clear, primary eligibility, and enrichment routing. * feat(music-network): auth-store state + lossless legacy migration + runtime bridge Add the persisted Music Network state to the auth store and wire the runtime, all additively — nothing existing breaks yet. - authStoreTypes: musicNetworkAccounts / enrichmentPrimaryId / scrobblingMasterEnabled + actions; legacy lastfm* fields kept until Phase 6 - authMusicNetworkActions + defaults/wiring (synchronous localStorage) - accountPersistence: migrateLegacyLastfm (lossless — preserves session key, username and scrobbling preference; fills bundled Last.fm key from the preset; sets the migrated account as enrichment primary) + sanitizeAccounts - authStoreRehydrate: one-shot migration guarded by a sentinel so a later disconnect cannot resurrect the account from still-present legacy fields - musicNetworkBridge: backs the MusicNetworkStore port with the auth store and the RuntimeHost with the Tauri shell; initialized in pre-React bootstrap nowPlayingEnabled stays a global toggle (not a lastfm* field); the Phase 6 playback call-site will gate dispatchNowPlaying on it, preserving behaviour. * feat(music-network): route playback, enrichment and love through the runtime Migrate every Last.fm call-site onto the Music Network runtime, preserving behaviour: - playback (audioEventHandlers, playTrackAction): scrobble@50% and now-playing via dispatchScrobble/dispatchNowPlaying; loved-fetch via isTrackLoved. Now- playing follows scrobbling (as Last.fm did), Navidrome now-playing keeps the nowPlayingEnabled gate - enrichment: useArtistSimilarArtists, useNowPlayingFetchers, Statistics, and the ArtistDetail similar-artists gate now use the runtime, gated on an enrichment primary - love: PlayerBar, PlayerTrackInfo, all context menus, useNowPlayingStarLove and the startup loved-sync route through setTrackLoved / toggleNetworkLove - player store: lastfmLoved/lastfmLovedCache -> networkLoved/networkLovedCache; lastfmActions -> networkLoveActions; loved cache storage renamed with a lossless legacy-key fallback - getMusicNetworkRuntimeOrNull() for best-effort callers so they no-op (not throw) before the runtime is initialized src/api/lastfm.ts and the Integrations UI still use the legacy path; they are migrated and removed in the next phase. * feat(music-network): manifest-driven Integrations UI + scrobble batch format Replace the Last.fm Integrations card with a manifest-driven Music Network section, and fix Audioscrobbler scrobbling to the batch/array shape. - settings/musicNetwork/: MusicNetworkSection (master toggle, destination cards, enrichment-primary picker, Maloja proxy warning, add-a-service list) driven entirely off the preset registry; icon map from PresetManifest.icon - IntegrationsTab delegates to MusicNetworkSection (Discord/Bandsintown/ Navidrome now-playing unchanged) - i18n: musicNetwork.* across all 9 locales, incl. a per-field help hint for Rocksky's CLI session-key flow (rocksky login) - scrobble now uses the documented array form (artist[0]/track[0]/…); the bare single form is only tolerated by Last.fm, Rocksky requires the indexed form - auth-error detection keys off the response message (not the ambiguous numeric code) so a Rocksky server-500 no longer flips the account to a reconnect state - PresetManifest.PresetField gains an optional helpKey Rocksky's server rejects some non-ASCII track metadata with a 500 — a Rocksky backend bug; the client call is correct (verified). * fix(music-network): clearer Integrations layout + scrobble batch fix Address UI feedback on the Music Network section: - per-account scrobble toggle moves inside its account block (was a loose row between cards — unclear which account it belonged to) - master toggle and the primary-service picker are now boxed blocks at the top, not bare rows - primary-service copy reworked: 'Primary service' + a line spelling out that liked tracks/similar artists/stats come from it while scrobbling still goes to all enabled services - distinct zones separated by dividers (master/primary · connected · add) Also folds in the verified scrobble fixes: documented array form (artist[0]/track[0]/…) so Rocksky accepts scrobbles, and auth-error detection by message rather than the ambiguous numeric code (a Rocksky server-500 no longer flips the account to a reconnect state). Rocksky session-key field gains a CLI help hint (rocksky login), all 9 locales. * feat(music-network): indicator + remove legacy lastfm path Phase 7b/7c — finish the cutover and delete the old Last.fm path. - LastfmIndicator -> MusicNetworkIndicator (shows the enrichment primary's status, click -> Integrations) - delete src/api/lastfm.ts; remove Rust lastfm_request (remote.rs + lib.rs) - remove legacy authStore lastfm* fields, actions and types; delete authLastfmActions.ts; rehydrate migration reads the legacy blob via a cast - migrate the remaining NowPlaying call-sites (NowPlaying.tsx + the now-playing fetchers/prewarm/star-love hooks) off lastfmSessionKey/lastfmUsername onto the enrichment primary (gate + cache key) - type imports LastfmTrackInfo/LastfmArtistStats -> music-network TrackStats/ ArtistStats; drop 8 stale api/lastfm test mocks and the obsolete Last.fm auth tests; update settingsTabs + src/CLAUDE.md No lastfm imports remain outside src/music-network/; lastfm_request removed (acceptance §12). tsc clean, 1947 frontend tests + remote rust tests green. * test(music-network): cover scrobble shape + error classification, drop dead i18n keys Remove the 14 unused legacy scrobble/connection i18n keys across all 9 locales (settings.lfm*/scrobble*, connection.lastfm*); the live love, profile-link and now-playing keys stay. Add regression tests for the parity-critical transport logic: the indexed batch/array scrobble body, the auth-vs-network error classification (numeric codes collide across providers), and the manifest-overrides-probe capability merge. * feat(music-network): provider-agnostic UI + Maloja Audioscrobbler & Koito presets - de-hardcode the single provider name across every enrichment surface (love labels, now-playing badge, stats title); derive it from the enrichment primary and interpolate via {{provider}} i18n params - surface a toast when a paste-auth connect probe fails — a static 'supported' capability flag no longer masks a runtime probe error - add the Maloja Audioscrobbler (GNU FM) preset (the third Maloja wire mode) and a Koito preset (ListenBrainz-compatible), both data-only - generalise PRIVACY.md and the scrobbling help entry to the framework - rename residual lfm* identifiers to network*; strip legacy flat lastfm* fields from the persisted blob; neutral transport error prefix - tests: error classification, scrobble body, capability probe, registry * fix(music-network): validate paste-auth keys on connect + UI polish - AudioscrobblerWire.probe now validates an api_key_only session with a signed call and reports scrobble:'error' only on a genuine auth failure (a scrobble-only service that rejects user.getInfo is not a bad key), so an invalid Maloja Audioscrobbler / Rocksky key surfaces a connect toast instead of failing silently; WireContext carries the preset authStrategy - drop the unreachable Statistics empty-state branch and its dead lfmNotConnected i18n key; use the useEnrichmentPrimaryLabel hook there - drive the love-button glyph from the enrichment primary's manifest icon; neutral Music Network section icon; remove a dead LastfmIcon import - tests: paste-auth vs token-poll probe behaviour * chore(music-network): rename showLastfmSimilar → showNetworkSimilar, refresh stale comments Post-parity polish: the similar-artists toggle now sources from the generic enrichment runtime, so rename the lingering lastfm-flavoured identifier; drop stale 'Mirrors today's LastfmX' doc comments referencing the removed legacy types, and generalise the scrobble-point comment. * docs(changelog): Music Network entry (PR #1066) Co-Authored-By: cucadmuh <49571317+cucadmuh@users.noreply.github.com> * fix(music-network): bound request timeout on the provider transports audioscrobbler_request / listenbrainz_request / maloja_request built a reqwest client with no timeout, so a hung provider left scrobble / probe / loved-sync promises unresolved. Add a shared provider_http_client() with a 15s timeout, matching the sibling fetch_* commands. Addresses review C3. * refactor(music-network): dedupe wire transport + no-enrichment helpers The three provider clients repeated the same invoke -> classify-error -> MusicNetworkError boilerplate, and the three probe() bodies repeated the "mark every enrichment capability no" loop. Extract wires/shared/invokeTransport() (each wire keeps its own arg shape + auth rule) and markNoEnrichment() in core/capabilities.ts. Addresses review C4. * refactor(music-network): drop write-only malojaWireMode dead state malojaWireMode was written on connect but never read — the wire is resolved by wireId and the Maloja base URL by the preset's selfHostedApiSuffix. Remove the field, the MalojaWireMode type, the malojaWireModeFor helper, the AccountPatch entry, the PresetField union member, and the export. Addresses review C1. * refactor(music-network): one useEnrichmentPrimary hook, drop lastfm fallback The enrichment-primary lookup (accounts.find by enrichmentPrimaryId) was duplicated across two hooks and inlined in the indicator and both context-menu builders, two of them with a hardcoded 'lastfm' icon fallback. Add one music-network/ui/useEnrichmentPrimary() returning {account,label,icon}|null; useEnrichmentPrimaryLabel/Icon delegate to it and the indicator + context menus consume it directly. Icon fallback is the neutral 'custom' glyph, never a provider (provider-agnostic, §7.3). Addresses review C2. --------- Co-authored-by: cucadmuh <49571317+cucadmuh@users.noreply.github.com>	2026-06-11 22:56:30 +02: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	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
Frank Stellmacher	d15e270499	refactor(queue): persist thin QueueItemRef list (thin-state phase 1) (#858) ... * refactor(queue): persist thin QueueItemRef list (thin-state phase 1) Introduce QueueItemRef ({ serverId, trackId, autoAdded?, radioAdded?, playNextAdded? }) and persist the whole queue as a thin queueItems list, superseding the queueRefs id list. Dual-write: the windowed queue: Track[] stays as the index-off fallback; the in-memory store is unchanged. hydrateQueueFromIndex now prefers queueItems (per-item serverId) and carries the queue-only flags onto the hydrated tracks (the index doesn't store them), with a queueRefs fallback for stores persisted before this change. Phase 1 of the queue thin-state plan; no store/consumer changes yet. * test(queue): cover legacy queueRefs-only upgrade in hydrate * docs(changelog): queue section dividers kept on index restore (#858)	2026-05-22 22:43:41 +02:00
‮Artem	be9722149b	fix(player): cap persisted queue window (#756) ... Playing/shuffling a big playlist set `queue` to ~10k `Track` objects. zustand `persist` then `JSON.stringify`'d the whole queue into `localStorage` on every persisted `set` → `QuotaExceededError` storm: playback never started and the main thread stalled on each write. `partialize` now persists only a ±250-track window around `queueIndex` (remapping the index into the slice) instead of the entire queue. The authoritative full queue lives server-side — synced via Subsonic `savePlayQueue` and restored through `getPlayQueue`. localStorage is only a fast local cache, so bounding it doesn't lose the queue; it just restores a ±250 window instantly while the full queue rehydrates from the server. Controlled before/after on a 10,509-track playlist: - before: QuotaExceededError ×9, play/shuffle dead - after: QuotaExceeded = 0, playback works	2026-05-17 22:06:41 +03: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	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	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
Frank Stellmacher	8569a17797	test(playerStore): progress snapshot + persistence flush (Phase F1 / PR 2c) (#542) ... progress.test.ts: getPlaybackProgressSnapshot shape + post-emit reflection, subscribePlaybackProgress (notify, (next, prev) pair, near-duplicate epsilon coalesce at 0.005 s, unsub stops notifications, multiple subscribers independent), live-emit throttling guard (drops within 1500 ms + < 0.9 s delta; large delta passes; time threshold passes). persistence.test.ts: flushPlayQueuePosition forwards (ids, currentId, posMs) to savePlayQueue, caps song-id list at 1000, no-ops on radio / no-track / empty queue, swallows backend errors, floors position to whole ms. playerStore.ts coverage 39.55% -> 40.48%. F1 50% floor not met -- remaining ~10pp lives in playTrack's async hot-cache/replay-gain body, shuffleQueue, stop, enqueueRadio, initializeFromServerQueue and the orbit auto-merge paths. Either a follow-up PR 2d or a revised F1 floor; flagged in the PR body. Gate unchanged -- playerStore.ts stays out until the floor is met. Discovered + fixed during this PR: the spread ...await vi.importActual() mock pattern lets the real savePlayQueue leak through to playerStore.ts's relative import (../api/subsonic) even when the alias-form is mocked. Switched persistence.test.ts to an explicit non-spread mock map listing every export the store uses.	2026-05-11 22:14:57 +02:00