1328 Commits

This Branch

This Branch

All Branches

Author	SHA1	Message	Date
Frank Stellmacher	42e3fdb976	test(playerStore): characterize pure helpers + queue mutations (Phase F1 / PR 2a) (#540) ... trackShape.test.ts: songToTrack mapping (required, optional, replayGain flattening, missing-block fallback, no invented flags); resolveReplayGainDb precedence (disabled, track, album, auto with prev/next neighbour match, missing albumId fallback, both gains missing); shuffleArray (non-mutating, preserves multiset, copies, empty/single, deterministic under mocked RNG). queue.test.ts: enqueue / enqueueAt (auto-added separator placement, queueIndex shift, index clamping), playNext (playNextAdded tag, position, empty input), clearQueue (state reset, audio_stop call), reorderQueue (splice, currentTrack-id-following queueIndex), removeTrack (clamp on shrink, keep when after cursor), undo / redo (empty stacks return false, rollback, replay, new edit drops pending redo). Adds a 5-line test-only export _resetQueueUndoStacksForTest in playerStore.ts because the undo/redo arrays live at module scope outside the Zustand state graph; storeReset.ts now calls it so resetPlayerStore is fully complete. playerStore.ts coverage 4.76% -> 18.1% lines. PR 2b + 2c push further toward the F1 floor of 50%.	2026-05-11 21:40:47 +02:00
Frank Stellmacher	4f9ad07d65	test(frontend): harness expansion + utility coverage push (F0 + F6) (#539) ... * test(frontend): expand harness for store/component/contract tests - factories: makeSubsonicSong, makeServer, makeAuthState, makeQueueState - storeReset.ts: per-test reset for player/auth/preview/orbit stores - mocks/subsonic.ts: realistic fixtures + stream/cover URL helpers - mocks/browser.ts: ResizeObserver/IntersectionObserver/matchMedia/clipboard/object URLs - mocks/tauri.ts: tauriMockListenerCount for listener-lifecycle regression tests - renderWithProviders: pin i18n language to 'en' by default; { language } opt-out - vitest.config: pool 'forks' + isolate to avoid module-mock + Zustand-global flake - README: documented patterns, store-reset policy, i18n rule, isolation rationale * test(frontend): bump utility coverage + expand hot-path gate serverMagicString: 71→100% (encode/decode rejection branches, clipboard fallback paths). shareLink: 69→97% (all entity kinds, queue trim, orbit decoder, findServerIdForShareUrl). dynamicColors: 44→100% (extractCoverColors DOM paths via Image / canvas / fetch mocks). Gate adds shareLink.ts and dynamicColors.ts — both stable above 95%. Comments updated for the new floor and the M4 hard-gate handoff.	2026-05-11 21:11:23 +02:00
Frank Stellmacher	a228ce1c91	chore: fix stale doc references (#538) ... - src/test/README.md: layout listed wrong filename for the readme itself - miniPlayerBridge.ts: comment pointed at a doc that lives outside the repo	2026-05-11 16:57:54 +02:00
Frank Stellmacher	123fbcc802	fix(orbit): event-driven host push + guest seekbar lock (#537) ... * fix(orbit): event-driven host push on play/pause flips Without this, the worst-case delay between "host hits pause" and "guest stops" is two full polling windows (host's 2.5 s push tick + guest's 2.5 s read tick, plus network) — long enough for the guest to noticeably run past the host. Subscribing to playerStore.isPlaying changes adds at most one extra remote write per flip; non-flip state ticks still ride the existing 2.5 s timer. The listener filters on isPlaying so the per-second currentTime ticks don't trigger spurious pushes. * fix(orbit): lock seekbar for guests — sync follows the host Guests could drag/click/wheel the seekbar, which would jump the local player and then snap back at the next host poll (2.5 s of inconsistent UX) — or push the guest into a diverged state where Catch Up was the only way back. The seekbar is host-controlled in Orbit; the guest input path now reflects that. - App.tsx exposes `data-orbit-role="host"|"guest"` on the root element alongside the existing `data-orbit-active` marker. - WaveformSeek's container gains a `.waveform-seek-container` class so CSS can target it. - Guest rule: `pointer-events: none` on children blocks click / drag / wheel / hover; the parent keeps `cursor: not-allowed` + reduced opacity so the disabled state is visually unambiguous. Hosts and non-orbit users see no change. * docs(changelog): credit PR #537 (orbit sync latency + guest seekbar)	2026-05-11 13:34:02 +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
Frank Stellmacher	02d533e949	test(frontend): vitest framework bootstrap + hot-path coverage gate (#536) ... * test(frontend): vitest framework bootstrap + hot-path file coverage gate Adds the harness for component, hook and store tests on top of the existing util tests in src/utils/. Mirrors the backend rust-tests rollout: jsdom env, v8 coverage, soft hot-path file gate, dedicated CI workflow. What's in: - vitest.config.ts: jsdom environment, v8 coverage, alias @ -> src - src/test/setup.ts: jest-dom, @testing-library cleanup, vi.mock for @tauri-apps/api/{core,event} + plugin-shell, Map-backed Storage polyfill for Node 25 + jsdom 26 (both ship a broken native localStorage) - src/test/mocks/tauri.ts: programmable onInvoke() / emitTauriEvent() helpers, auto-reset between tests - src/test/helpers/factories.ts: makeTrack / makeTracks - src/test/helpers/renderWithProviders.tsx: render() wrapped with MemoryRouter + I18nextProvider - src/test/README.md: conventions doc (where tests go, how to mock Tauri, what to never mock) Sample tests showing the patterns: - src/components/CoverLightbox.test.tsx: component, queries by role - src/store/previewStore.test.ts: store characterization, event handlers + stopPreview (startPreview deferred until the cross-store provider strategy is decided) CI: - .github/workflows/frontend-tests.yml: jobs for vitest, tsc, coverage + hot-path gate. coverage job carries continue-on-error: true (soft). - .github/frontend-hot-path-files.txt: initial list (3 utils at >=70%). playerStore + the unfinished half of previewStore are deferred until Phase 1 coverage work lands. - scripts/check-frontend-hot-path-coverage.sh: mirror of the rust gate. npm scripts: - test: one-shot run (unchanged) - test⌚ vitest in watch mode - test:coverage: v8 coverage + html / lcov / json-summary reports 57 / 57 tests pass; tsc --noEmit clean. * chore(nix): sync npmDepsHash with package-lock.json --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-05-11 12:25:48 +02:00
cucadmuh	1cc43dc669	fix(dev): support local Rust coverage checks (#535) ... Add the coverage and lint tools to the Nix dev shell so local pre-PR checks can match CI, and make the hot-path coverage gate locale-stable.	2026-05-11 00:50:46 +03:00
Frank Stellmacher	7c32172d5d	test: cargo-test workspace bootstrap + hot-path file coverage gate (#533) ... * test(workspace): bootstrap cargo test infrastructure - Add [workspace.dependencies] for shared test deps (tempfile, wiremock, mockall, proptest). - Wire psysonic-syncfs dev-dependency on tempfile. - Add proof-of-life unit tests in psysonic-core::user_agent (2) and psysonic-syncfs::cache::fs_utils (5). - Add dedicated rust-tests.yml workflow: cargo test --workspace, cargo clippy --workspace --all-targets -- -D warnings, and a cargo-llvm-cov coverage artifact (no fail threshold yet). Phase A of the 3-sprint test rollout. cargo test --workspace runs 7/7 green. * chore(clippy): satisfy `cargo clippy --workspace --all-targets -- -D warnings` Pre-existing lints exposed by the new CI gate. All mechanical, no behavior changes: - `is_multiple_of` replacements (5) - `abs_diff` for u8 manual centering (1) - `while let Ok(p) = next_packet()` for symphonia decode loops (2) - collapse `else { if … }` blocks (3) - factor very-complex types into `type` aliases: `BuiltSourceStack`, `StreamReopenRequest`/`StreamReopenReply`, `LoudnessSeedHold`, `SeedDoneSender`/`RunningSeedJob` - `#[derive(Default)]` instead of manual `impl Default` (3) - `#[allow(clippy::enum_variant_names)]` on `IcyState` — descriptive `Reading*` prefixes are intentional - `#[allow(clippy::needless_range_loop)]` on the EQ band loops — `band` indexes multiple parallel arrays - `#[allow(clippy::too_many_arguments)]` on Tauri command signatures and stream-task entry points (refactoring would change the JS-side invoke contract or touch hot decode/streaming paths) - struct-literal initializers in taskbar_win.rs (windows-only) - `strip_prefix`, useless `format!`, redundant closure, redundant borrow, casting-to-same-type, unnecessary cast, doc-list overindent * test(syncfs): cover sanitize_path_component / sanitize_or / build_track_path Sprint 1.1 of the Rust test rollout. 22 unit tests in `psysonic-syncfs::sync::device` covering the path layer the device-sync manifest depends on: - sanitize_path_component (6): invalid char → `_`, AC/DC vs ACDC stays distinguishable, control chars, leading/trailing dot+space trim, inner dots/spaces preserved, Unicode preserved. - sanitize_or (3): empty / collapse-to-empty fallbacks, sanitized passthrough. - build_track_path album tree (7): full metadata, track-num zero-pad, missing track-num → "00", album_artist/album/title fallbacks, per-component sanitization. - build_track_path playlist tree (5): track-artist (not album-artist) used in filename, index zero-pad, name/artist fallbacks, both name AND index required (otherwise falls through to the album tree). - Cross-OS separator (1): `\` on Windows, `/` elsewhere. Workspace test count: 7 → 29. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(analysis): cover analysis_cache::store with in-memory SQLite roundtrips Sprint 1.2 of the Rust test rollout. 20 unit tests in `psysonic-analysis::analysis_cache::store` exercising the cache that gates analysis seeding, waveform rendering, and loudness normalization. To avoid a `tauri::AppHandle` dependency in tests, added a test-only `AnalysisCache::open_in_memory()` constructor that opens `Connection::open_in_memory()` and runs the production `migrate_schema`. The WAL pragma is skipped because in-memory databases don't support journal-mode changes; the test surface doesn't need durability. - track_id_cache_variants (3): bare → stream:, stream: → bare, empty-bare drops the extra entry. - waveform_cache_blob_len_ok (2): rejects non-positive bin_count and any blob whose length isn't exactly 2 * bin_count. - schema (1): all three tables created by migrate_schema. - Waveform roundtrip (4): JOIN against analysis_track is required, full field preservation, upsert overwrites the existing row, inconsistent blob length is filtered out by get_waveform. - Loudness roundtrip (2): existence flips on upsert; PK includes target_lufs so two rows per track can coexist. - Id-variant lookup (2): get_latest_*_for_track searches both bare and stream: forms. - cpu_seed_redundant_for_track (1): only true when both waveform AND loudness are cached. - Deletes (4): per-track deletes clear both id variants, empty/whitespace track_id is a no-op, delete_all_waveforms wipes all rows. - Status upsert (1): touch_track_status overwrites status on conflict. Workspace test count: 29 -> 49. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(audio): cover pure helpers in psysonic-audio::helpers Sprint 1.3 of the Rust test rollout. 58 unit tests across 13 pure helper functions in `psysonic-audio::helpers` — format detection, URL identity, loudness placeholders, gain math. Notable invariant caught by the test suite: `compute_gain` in loudness mode forces peak=1.0, so the `gain_linear.min(1.0 / peak)` step caps positive loudness gain at unity. This prevents above-0-dBFS clipping and is now an explicit assertion (`compute_gain_loudness_mode_caps_positive_gain_at_unity`). A naive expectation that loudness mode just applies 10^(db/20) would miss this — the first draft of that test failed for exactly that reason. Coverage: - provisional_loudness_gain_from_progress (5): zero-total / zero-downloaded short-circuits, start_db clamping, full-progress reaches end_db, end_db floored at -3 dB. - content_type_to_hint (3): common MIMEs, case-insensitive, unknown. - format_hint_from_content_disposition (5): quoted, RFC-5987 filename*=, unknown ext, no ext, no filename. - normalize_stream_suffix_for_hint (3): lowercased known, empty/whitespace, unknown. - sniff_stream_format_extension (9): fLaC / OggS / RIFF+WAVE / ftyp (m4a) / EBML (mka) / ADTS (aac) / MP3 sync / MP3 after ID3v2 / empty + random. - playback_identity (4): local URL, Subsonic stream URL, non-stream URL, stream URL without id param. - analysis_cache_track_id (4): logical-id preference, fallback, whitespace-as-missing, both-missing. - same_playback_target (3): different salts equivalent, different ids differ, fallback string compare. - loudness_gain_placeholder_until_cache (3): pre-analysis clamped to <=0, target lift, ±24 dB clamp. - loudness_gain_db_after_resolve (4): cache > JS hint, JS used when uncached + allowed, non-finite JS rejected, placeholder when JS off. - compute_gain (9): off-mode unity, volume clamp, replaygain pre-gain, fallback, peak cap, loudness unity cap, loudness ignores peak, loudness without db. - normalization_engine_name (2): mapping + fallback. - gain_linear_to_db (4): unity, half, zero/negative, non-finite. Workspace test count: 49 -> 107. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-1): top up to gate B with pure helpers + queue states Sprint 1 top-up after the gate-B coverage check showed psysonic-analysis at 36.2% and psysonic-syncfs at 17.7%. Targeting pure surface only — no HTTP mocking, no AppHandle deps — to defer Sprint 2's wiremock work. psysonic-analysis::analysis_cache::compute (10 tests): - recommended_gain_for_target: target - integrated baseline, true-peak cap (-1 - 20*log10(peak)), ±24 dB clamp. - md5_first_16kb: empty bytes match the canonical empty-md5 digest, sub-16-KB inputs use full data, larger inputs truncate at 16 KB. - derive_waveform_bins: zero bin_count / empty bytes return empty; silence at u8 midpoint (128) yields all-zero bins; output is the peak buffer concatenated with itself; extreme amplitude (0 or 255) saturates to 255. - normalize_peak_bins: empty input returns empty; uniform input collapses to the +8 base offset; monotonic input yields non- decreasing output bounded in [8, 255]. psysonic-analysis::analysis_runtime (17 tests, both queue states): AnalysisBackfillQueueState — default-empty; is_reserved checks both deque and in_progress; try_pop_next promotes head to in_progress; finish_job only clears when id matches; all five enqueue outcomes (NewBack/NewFront/DuplicateSkipped/RunningSkipped/ReorderedFront); prune_queued_not_in drops unkept entries. AnalysisCpuSeedQueueState — all five enqueue outcomes (NewBack/NewFront/MergedQueued/ReorderedFront/RunningFollower); prune_queued_not_in returns (removed_jobs, removed_waiters); dropped waiters receive Err on the oneshot channel. Two backfill tests use struct-literal initialisers with ..Default::default() to satisfy clippy::field_reassign_with_default. psysonic-syncfs::sync::batch (7 tests, FS helpers): prune_empty_parents — single-level, multi-level walk, stops at non-empty, levels=0 is a no-op. delete_device_files — counts only existing paths, prunes two levels of empty parents, returns 0 for empty input. psysonic-syncfs::file_transfer (3 tests): subsonic_http_client builds successfully for short, long, and zero timeouts. Added `tokio = { ..., features = ["macros", "fs"] }` to psysonic-syncfs/Cargo.toml [dev-dependencies] so tests can use #[tokio::test]. Coverage after this commit (cargo llvm-cov --workspace): psysonic-analysis: 36.2% -> 54.2% (gate B >=40% ✓) psysonic-syncfs: 17.7% -> 25.8% (gate B deferred to Sprint 2 — remaining uncovered surface is HTTP-driven Tauri commands) psysonic-audio: 11.4% -> 11.4% (Sprint 2 territory) Workspace test count: 107 -> 149. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-2.1): RangedHttpSource Read/Seek + wiremock for syncfs Sprint 2.1 of the Rust test rollout — split into pure-struct coverage of the ranged-HTTP source and wiremock infrastructure for syncfs Subsonic roundtrips. psysonic-audio::stream::ranged_http (16 tests): Direct unit tests on RangedHttpSource — the consumer side that Symphonia drives. Read (7): zero at EOF, zero for empty output buffer, copies full buffer when downloaded, advances pos across multiple calls, zero when superseded by gen_arc change, partial read when done with only some data, zero when done with no data ahead of cursor. Seek (7): from-Start, from-Start clamps to total_size, from-Current positive + negative, from-End negative, InvalidInput error before start, beyond-end clamps. MediaSource (2): is_seekable returns true, byte_len returns total_size. Why not ranged_download_task end-to-end: ranged_download_task takes AppHandle (= AppHandle<Wry>), but tauri::test::mock_app() returns AppHandle<MockRuntime>. Going E2E needs either a runtime-generic refactor cascading through submit_analysis_cpu_seed and analysis_seed_high_priority_for_track, or extracting a pure ranged_http_download_loop helper. Both fit the cucadmuh §14 "extract pure functions" pattern and land in Sprint 2.2. psysonic-syncfs::sync::batch — wiremock infrastructure (9 tests): Extracted parse_subsonic_songs as a pure helper out of fetch_subsonic_songs so the response-shape parsing is testable without a roundtrip. Pure parse (6): missing subsonic-response field, unknown endpoint returns empty, album song-array, single-song-as-object normalised to a 1-element vec, playlist entry-array, empty album. Wiremock roundtrips (3): happy-path album fetch, 404 surfaces an Err, single-entry playlist also normalises to a 1-element vec. Cargo.toml dev-dep adjustments: psysonic-audio: tauri = { features = ["test"] }, wiremock, tokio with macros + rt-multi-thread. psysonic-syncfs: wiremock, tokio with rt-multi-thread. Coverage delta: psysonic-audio: 11.4% -> 15.4% psysonic-syncfs: 25.8% -> 33.5% psysonic-core: 20.9% -> 27.0% Workspace test count: 149 -> 174. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-2.2): extract ranged_http_download_loop + wiremock coverage Sprint 2.2a/b of the Rust test rollout — split the HTTP loop body out of ranged_download_task into a pure async helper that no longer needs an AppHandle, then exercise it against wiremock. The new helper: pub(crate) async fn ranged_http_download_loop<F>( http_client: reqwest::Client, url: &str, initial_response: reqwest::Response, buf: &Arc<Mutex<Vec<u8>>>, downloaded_to: &Arc<AtomicUsize>, gen: u64, gen_arc: &Arc<AtomicU64>, mut on_partial: F, ) -> (usize, RangedHttpLoopOutcome) Returns (downloaded_bytes, Completed|Superseded|Aborted). Caller owns the AppHandle-dependent post-loop work — setting `done`, promoting buf to stream_completed_cache, kicking off cpu-seed submission. ranged_download_task is now a thin wrapper that: 1. Sets up the loudness_seed_hold drop guard. 2. Builds an `on_partial` closure capturing AppHandle + normalization atomics + a local `last_partial_loudness_emit` Instant for rate limiting (matches the previous inline behaviour exactly: rate gate fires regardless of normalization mode; mode check is inside). 3. Calls `ranged_http_download_loop`. 4. Stores `done`, returns early on Superseded, otherwise runs the post-loop seed + cache-promote pipeline. Wiremock tests (6) on the pure helper: - loop_completes_full_download_on_200: happy path, buf + downloaded_to. - loop_invokes_partial_callback_per_chunk: callback fires, last call has correct (downloaded, total). - loop_aborts_on_initial_404: non-success returns Aborted, 0 bytes. - loop_returns_superseded_when_gen_arc_changes_before_first_chunk: uses ResponseTemplate::set_delay so the gen flip wins the race. - loop_reconnects_with_range_header_after_short_first_response: custom Respond impl returns 200 (first half) then 206 (second half) on a request carrying Range:. Tolerant — wiremock doesn't always trigger the second call for short bodies; accepts Completed or Aborted. - loop_aborts_when_reconnect_returns_non_206: second hit returns 200 instead of 206 → loop aborts after the first half. #[allow(clippy::too_many_arguments)] on the helper because the param set mirrors the existing wrapper's signature (8 args vs the 7 default cap). Coverage delta: psysonic-audio: 15.4% -> 19.8% (+4.4) psysonic-core: 27.0% -> 55.7% (incidental — wiremock body bytes hit shared logging paths) Sprint 2.2c (progress_task EventSink trait) is deferred — a ~2-hour refactor with smaller coverage value-per-minute than continuing into Sprint 2.3 (syncfs Tauri-command wiremock work that retroactively closes gate B). Workspace test count: 174 -> 180. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-2.3): wiremock for file_transfer + offline cache helper Sprint 2.3 of the Rust test rollout. Closes deferred gate B — psysonic-syncfs goes from 33.5% to 44.3% line coverage (target ≥40%). file_transfer.rs (5 wiremock + tempdir tests): - stream_to_file writes the full response body to the dest path. - stream_to_file creates an empty file for an empty 200 body. - stream_to_file returns Err when the dest directory is missing. - finalize_streamed_download renames .part → dest on success, removes .part. - finalize_streamed_download cleans up the .part file when the rename fails (verified by pre-creating dest as a directory so rename hits the "is a directory" error on every supported OS). cache/offline.rs: Extracted `download_track_to_cache_dir` from `download_track_offline` — AppHandle-free primitive that takes a resolved cache_dir + reqwest::Client + url. The Tauri command is now a thin wrapper that derives cache_dir (custom_dir branch unchanged; default branch reads app.path()), holds the semaphore permit, and calls the helper. After the helper returns it kicks off `enqueue_analysis_seed_from_file`. Helper tests (4): - 200 response writes the file with the expected name. - Pre-existing file is returned without hitting the network (mock configured with no expectations — would error on contact). - 404 surfaces "HTTP 404" Err and leaves no file behind. - Three nested missing directories are created automatically. Extracted `delete_offline_track_with_boundary` from `delete_offline_track` — pure FS primitive. The AppHandle was only used to derive the boundary path when base_dir was None; the inner function now takes the boundary directly. Helper tests (4): - Removes the file and prunes empty parents up to the boundary. - No-op (Ok(())) when the file path doesn't exist. - Boundary directory itself stays even when emptied. - Pruning halts at a non-empty parent. Coverage delta: psysonic-syncfs: 33.5% -> 44.3% (+10.8pp, gate B closed ✓) Workspace test count: 180 -> 193. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-3.1+3.2): cover psysonic-integration discord + navidrome client Sprint 3.1+3.2 of the Rust test rollout. psysonic-integration goes from 0.0% to 31.2% line coverage on the back of pure-helper tests + wiremock roundtrips for the Subsonic/Native API client primitives. discord.rs (16 tests): Pure helpers: - normalize: lowercases, collapses whitespace, returns empty for pure-whitespace, preserves Unicode letters. - words_overlap: empty inputs → false, full match → true, exactly 50% threshold meets, below 50% → false, asymmetric lengths handled. - apply_template: replaces all placeholders, substitutes empty for None album, leaves unknown placeholders untouched, handles repeated placeholders. - cache_and_return: inserts entry with the given URL + recent fetched_at. search_with_url against wiremock (4 tests): - returns 600x600 URL when artist + album match (the 100x100 → 600x600 hardcoded transform). - returns None when no result matches. - returns None for empty results array. - exercises the words_overlap fuzzy-match branch via spawn_blocking around the sync reqwest::blocking::Client. navidrome/client.rs (10 tests): Pure / construction: - nd_http_client builds without panicking. - nd_err flattens a real reqwest connect error chain into a single string (chain joiner appears 0+ times depending on OS — we just verify it doesn't panic and returns something readable). nd_retry behavior: - First-try success: 1 attempt total, no retries. - Status-level error (404): 1 attempt — retries are reserved for transport failures. - All-attempts-fail with synthetic transport errors (connect to 127.0.0.1:1): 4 attempts (initial + 3 backoffs), final Err. - Non-transient builder error (malformed URL): 1 attempt, no retry. navidrome_token via wiremock: - Roundtrip: 200 with {"token": "..."} → returns token string. - 200 without token field → "no token" Err. navidrome/queries.rs (4 tests): nd_build_filters (private pure helper): - None library_id → seed unchanged. - Numeric library_id stored as JSON Number. - Non-numeric library_id falls back to JSON String. - Existing seed keys preserved alongside library_id. Cargo.toml: Added [dev-dependencies] block to psysonic-integration: - tokio with macros + rt-multi-thread + test-util - wiremock = { workspace = true } Coverage delta: psysonic-integration: 0.0% -> 31.2% (+31.2pp) Workspace test count: 193 -> 222. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-3.3): cover remote.rs PLS/M3U parsing + playlist resolution Sprint 3.3 of the Rust test rollout. Adds 14 tests for the radio / playlist URL resolution layer in psysonic-integration::remote, lifting the crate from 31.2% to 39.1% line coverage. parse_pls_stream_url (5 tests): - Returns first File1= entry for a multi-entry playlist. - Case-insensitive on the File1= key (Subsonic radio servers vary). - Returns None for non-http(s) URLs (e.g. ftp://). - Returns None when no File1 entry exists. - Tolerates leading whitespace on lines. parse_m3u_stream_url (4 tests): - Skips #EXTM3U header and #EXTINF comment lines. - Returns the first URL in stream order. - Returns None when no URL line is present. - Returns None for relative paths (Symphonia has no base URL). resolve_playlist_url against wiremock (5 tests): - Direct stream URLs (no .pls/.m3u/.m3u8 ext) skip the HTTP step → None. - URLs with query strings strip the query before extension matching. - PLS URL: extracts first stream from a [playlist] body. - M3U8 URL: extracts first stream skipping comment lines. - Content-Type override: .m3u extension + audio/x-scpls Content-Type routes through the PLS parser. set_body_raw is required here — set_body_string forces text/plain regardless of insert_header. Coverage delta: psysonic-integration: 31.2% -> 39.1% (+7.9pp) Workspace test count: 222 -> 236. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-3.4): cover icy state machine + ipc dedup + alsa device fingerprint Sprint 3.4 of the Rust test rollout. Three pure-helper batches that together push workspace-wide coverage to 30.0% (gate D long-term target met) and lift psysonic-audio from 19.8% to 25.0%. psysonic-audio::stream::icy (12 tests, ICY metadata state machine): parse_icy_meta: - Canonical block extracts title, marks is_ad=false. - StreamUrl='0' (CDN ad marker) sets is_ad=true. - Missing StreamTitle tag → None. - Unterminated title → None. - Empty title → None. - Tolerates trailing null padding. - Tolerates non-UTF-8 bytes (lossy conversion). - Uses first `';` after the title — does NOT skip past StreamUrl (the implementation comments call this out explicitly). IcyInterceptor: - Pass-through when no metadata block reached yet. - Zero-length metadata block (length byte = 0) produces no IcyMeta and audio bytes flow uninterrupted. - Length=1 (16 bytes meta) is stripped from the audio stream and parsed into an IcyMeta. - State preserved across multiple process() calls — same block fed in 1-byte chunks still yields the IcyMeta. - Two metaint cycles in a single input emit titles independently (verified by re-feeding split at the boundary). psysonic-audio::ipc (13 tests, normalization-state dedup + partial- loudness suppression): norm_state_changed: - Identical payloads → unchanged. - Engine difference is significant. - target_lufs drift < 0.02 dB suppressed; >= 0.02 dB triggers. - current_gain_db drift < 0.05 dB suppressed; >= 0.05 dB triggers. - None ↔ Some gain transition is significant. - Both None gains → unchanged. partial_loudness_should_emit (uses unique track keys per test to avoid sharing the process-global suppression map): - Emits on first call for a fresh key. - Suppresses delta < 0.1 dB on same key. - Re-emits when delta >= 0.1 dB threshold is crossed. - Different keys are independent. psysonic-audio::dev_io (11 tests, ALSA sink fingerprint + dedup): output_devices_logically_same / output_enumeration_includes_pinned: - Identical names match; different non-ALSA names don't. - includes_pinned exact-matches and returns false for absent / empty. linux_alsa_sink_fingerprint (Linux-only, stub on others): - Extracts (iface, card, dev) from "hdmi:CARD=NVidia,DEV=3". - Defaults DEV to 0 when missing. - Returns None for unknown ifaces (e.g. "pulse:"). - Returns None when no colon. - Lowercases iface name. - Different ALSA ifaces (hw vs plughw) on same card/dev are NOT logically the same — the fingerprint includes iface. - Non-Linux stub always returns None for any input. Coverage delta: psysonic-audio: 19.8% -> 25.0% (+5.2pp) WORKSPACE: 28.1% -> 30.0% (+1.9pp, gate D met ✓) Workspace test count: 236 -> 267. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-4): close gate C — synthetic WAV fixtures for compute + decode Sprint 4 of the Rust test rollout. Closes the last open coverage gate: psysonic-audio jumps from 25.0% to 35.1% (target >=35%) by feeding a runtime-generated mono PCM-16 WAV through the real Symphonia decode pipeline. No binary fixture committed — the WAV is synthesized on demand from a 440 Hz sine at -6 dBFS. psysonic-analysis::analysis_cache::compute (refactor + 9 tests): Extracted `seed_from_bytes_into_cache(cache, track_id, bytes)` from `seed_from_bytes_execute(app, ...)`. The new entry point takes a `&AnalysisCache` directly so tests can use `AnalysisCache::open_in_memory()` without an AppHandle. The Tauri command remains a one-line shim that resolves the cache from `app.try_state` and delegates. - count_mono_frames returns ~44100 frames for a 1s WAV. - count_mono_frames returns None for garbage or empty input. - analyze_loudness_and_waveform produces sane LUFS/peak/gain for a -6 dBFS sine: integrated_lufs in (-30, 0), true_peak in [0.4, 0.6], bins layout = peak_u8 + mean_u8 = 2 * bin_count. - analyze_loudness_and_waveform returns None for zero bin_count and empty bytes. - seed_from_bytes_into_cache E2E: WAV → upserts both waveform AND loudness rows; second call returns SkippedWaveformCacheHit; garbage bytes fall back to derive_waveform_bins (no loudness row). psysonic-audio::decode (15 tests): - find_subsequence (5): start/middle/missing/oversize/first-of-repeat. - parse_gapless_info (4): default when iTunSMPB absent, decodes delay/total from a synthesized blob, zero-total filters out, no-value falls through to default. - SizedDecoder::new (3): constructs from synthetic WAV, errors on garbage, hi-res hint passes through. - log_codec_resolution (2): doesn't panic for valid PCM_S16LE params or for the unknown CODEC_TYPE_NULL fallback. build_source_tests (4 — uses build_source's full DSP-wrapper stack): - Synthetic WAV produces a BuiltSource with correct output_channels and a positive duration_secs. - Garbage bytes return Err. - build_streaming_source from a SizedDecoder also succeeds. - Resampling 44.1 → 48 kHz wraps a UniformSourceIterator and reports output_rate=48_000. Local helpers (synthetic_wav_bytes_local, build_mono_pcm16_wav_local) duplicated into the build_source_tests submodule because the parent `tests` module's helpers are private — duplication is two ~20-line fns and avoids a #[cfg(test)] visibility bump on the helpers. Coverage delta: psysonic-analysis: 54.2% -> 69.5% (+15.3pp from compute.rs WAV E2E) psysonic-audio: 25.0% -> 35.1% (+10.1pp, gate C ✓) WORKSPACE: 30.0% -> 36.3% (+6.3pp) All four coverage gates now closed: A ✓ (bootstrap) B ✓ (syncfs 44.3% + analysis 69.5%, target ≥40%) C ✓ (audio 35.1%, target ≥35%) D ✓ (workspace 36.3%, target ≥30%) Workspace test count: 267 -> 294. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-2.2c): extract ProgressEmitter trait + spawn_progress_task tests Sprint 2.2c of the Rust test rollout — the deferred follow-up after gate C closed. Pulls the three event sinks out of `spawn_progress_task` behind a `pub trait ProgressEmitter`, with a blanket impl for any `AppHandle<R>`. Production call sites at `commands.rs:392` and `radio_commands.rs:176` are unchanged because `AppHandle<Wry>` now satisfies the trait via the blanket impl. `spawn_progress_task` is now generic over the emitter type: pub(super) fn spawn_progress_task<E: ProgressEmitter>( ... emitter: E, ... ) Three call sites in the loop body (`audio:progress`, `audio:track_switched`, `audio:ended`) now route through `emitter.emit_*` instead of `app.emit(...)`. Tests added (4 in `progress_task::tests`): MockEmitter: Arc<MockEmitter> implements ProgressEmitter; records every payload + counts ended fires. TaskHarness: bundles all 13 Arc<…> the spawn function needs with sane defaults (44.1 kHz, stereo, 120 s duration_secs). - task_breaks_immediately_when_generation_already_changed: bumping gen_counter before spawn → first 100 ms tick exits without emitting. - radio_with_dur_zero_emits_ended_when_done_flag_flips: dur=0 + done=true → audio:ended fires once + gen_counter bumps. - task_emits_progress_payload_with_duration_after_first_tick: samples_played=5s of audio → first tick emits ProgressPayload with duration=120.0 and current_time in [0, 120]. - done_with_chained_info_swaps_to_chain_and_emits_track_switched: full gapless transition path — track_switched fires with chained duration, current_playback_url updates, gapless_switch_at timestamp is recorded, audio:ended does NOT fire. Tokio runtime choice: multi_thread + worker_threads=1 with real 200 ms sleeps. The start_paused/advance pattern under current_thread didn't reliably drive the spawned task's loop body even with repeated yield_now() (the task hits multiple awaits per iteration and tokio's auto-advance-when-parked doesn't always park at the right moment). Real time + 200 ms waits are tolerable for tests that observe a single 100 ms tick — total runtime overhead < 1 s. Cargo.toml: added "test-util" to psysonic-audio dev-dep tokio features even though we ultimately didn't need pause/advance — keeping it for future progress_task tests that might exercise the throttle window. Coverage delta: psysonic-audio: 35.1% -> 38.6% (+3.5pp; comfortable margin on gate C) WORKSPACE: 36.3% -> 37.7% All four gates remain green. Workspace test count: 294 -> 298. cargo clippy --workspace --all-targets -- -D warnings clean. * test(sprint-5a): extract pure helpers from 4 small Tauri-command wrappers Sprint 5a — first quick-wins batch toward cuca's per-function ≥80% hot-path coverage requirement. Four pure-helper extractions, each accompanied by direct tests against the helper. Wrappers shrink to 2-5 line shims that resolve State + delegate. psysonic-syncfs::cache::offline: Extracted `read_seed_bytes_if_needed(cache: Option<&AnalysisCache>, track_id, file_path)` from `enqueue_analysis_seed_from_file`. The AppHandle-bound `enqueue_analysis_seed` call stays in the wrapper. 5 tests: bytes returned when no cache attached, bytes returned for fresh-cache miss, None when cache says redundant, None for missing file, None for empty file. psysonic-analysis::analysis_cache::store: Promoted `AnalysisCache::open_in_memory()` from `#[cfg(test)] pub(crate)` to plain `pub` so cross-crate test harnesses can call it without a test-support Cargo feature dance. Production never calls it. Re-exports added at `analysis_cache` module level: `WaveformEntry`, `LoudnessEntry`. psysonic-analysis::commands: Extracted three pure helpers from the four read-side Tauri commands: - `get_waveform_payload(cache, track_id, md5_16kb)` — exact-key lookup. - `get_waveform_payload_for_track(cache, track_id)` — id-variant lookup. - `get_loudness_payload_for_track(cache, track_id, target_lufs)` — with recommended-gain recompute against the optional requested target. Plus `impl From<WaveformEntry> for WaveformCachePayload`. Wrappers log + delegate. 10 tests covering all three helpers + the From impl: missing keys, existing rows, md5 distinguishability, id-variant matching, recommended-gain recomputation against requested target, target_lufs clamping into [-30, -8], None-target falls back to cached row's own target. psysonic-audio::helpers: Extracted `resolve_loudness_gain_with_cache(cache, track_id, target_lufs, opts)` from `resolve_loudness_gain_from_cache_impl`. The latter now resolves track_id + cache via AppHandle, then delegates. 5 tests: missing row → None, existing row → finite gain in expected range, id-variant lookup, higher target_lufs yields higher gain, touch_waveform=false smoke. (NaN-roundtrip through SQLite is platform- dependent — the .is_finite() guard in the helper is defensive code not directly testable via the cache API.) psysonic-integration::discord: Parameterised `search_itunes_artwork(client, cache, artist, album, title)` via a new `search_itunes_artwork_with_base(..., base_url)` that the wrapper calls with the new `ITUNES_SEARCH_URL` constant. Lets tests redirect at a wiremock instance. 4 tests against wiremock: cached entry returns without network, strategy-1 exact match returns + caches, no-result case returns None, successful lookup populates the in-memory cache for next call. Coverage delta: psysonic-analysis: 69.5% -> 73.4% psysonic-syncfs: 44.3% -> 47.1% psysonic-audio: 38.6% -> 39.9% psysonic-integration: 39.1% -> 46.2% WORKSPACE: 37.7% -> 40.6% Workspace test count: 298 -> 322. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-5b): extract sync_download_one_track + offline cache resolver + Discord text fields Sprint 5b — three of four planned medium-difficulty extractions land. audio_chain_preload skipped: its body is State<AudioEngine>-tight through-and-through (chained_info / preloaded / generation atomics + gapless_enabled gating + bytes-fetch with multiple HTTP/local branches). Splitting it cleanly needs a deeper engine-level refactor than the extract-pure-helper pattern handles. Flag for cuca: skipped here, can revisit in a separate engine-API-extraction pass if per-function coverage on it is needed. psysonic-syncfs::cache::offline: Extracted `resolve_offline_cache_dir(custom_dir, server_id, default_root)` from `download_track_offline`'s cache-dir resolution. Pure function — no AppHandle, no I/O beyond a single path-exists check on the optional custom-volume root. 4 tests: None custom_dir → default_root/server_id; empty-string custom_dir treated like None; existing custom volume → custom/server_id; missing custom volume → "VOLUME_NOT_FOUND" Err. psysonic-syncfs::sync::device: Extracted `sync_download_one_track(dest_path, suffix, url, &client)` from `sync_track_to_device`. Returns Ok(false) for pre-existing files (skipped), Ok(true) for fresh downloads, Err on transport / status / finalize failures. The Tauri command wraps it with the device:sync:progress emit calls per outcome. 4 tests via wiremock + tempdir: 200 → file written + Ok(true); pre-existing file → Ok(false), no network call; 403 → "HTTP 403" Err, no file created; missing parent dirs auto-created. psysonic-integration::discord: Two pure helpers extracted from `discord_update_presence`'s body: - `compute_discord_text_fields(title, artist, album, details_template, state_template, large_text_template) -> DiscordTextFields { details, state, large_text }` — applies the three configurable templates with documented defaults. - `compute_discord_start_timestamp(elapsed_secs, now_unix_secs) -> i64` — the Unix-timestamp `start` field for Discord's elapsed-time display. 7 tests: defaults vs custom templates, missing album yields empty substitution, Unicode handling; timestamp floor + zero-elapsed + fractional handling. Coverage delta: psysonic-syncfs: 47.1% -> 50.8% psysonic-integration: 46.2% -> 48.3% WORKSPACE: 40.6% -> 41.6% Workspace test count: 322 -> 337. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-5c-part1): extract calculate_sync_payload track-JSON helpers Sprint 5c part 1 — extract the three pure helpers that calculate_sync_payload inlined for size estimation, TrackSyncInfo construction, and playlist context injection. audio_play deferred: its 14-arg body is State<AudioEngine> orchestration through-and-through (gapless_enabled load + ghost-command guard via gapless_switch_at + chained_info take + preloaded.lock + generation fetch + sink + samples_played + ...). The pure compute_gain / resolve_loudness_gain / build_source / ranged_http_download_loop helpers it composes are all already at ≥80%. The wrapper itself is the integration point, not pure logic — flag for cuca: the extract-pure-helper pattern doesn't reach inside it cleanly. psysonic-syncfs::sync::batch: - estimate_track_size_bytes(track) — prefer explicit size, fall back to duration*320kbps/8, return 0 when both missing. - track_sync_info_from_subsonic_json(track, track_id, playlist_name, playlist_index) — build TrackSyncInfo from a Subsonic song JSON. albumArtist falls back to artist when missing or whitespace-only. Default suffix = "mp3". - inject_playlist_context(track, name, idx) — attach _playlistName / _playlistIndex keys to a track JSON in place. No-op when both args are None or the value isn't an object. calculate_sync_payload's add-source loop now uses these three helpers instead of inline JSON parsing. Behaviour preserved: same dedup-by-(source_id, track_id), same fallback chains, same context-key names. Tests (13): estimate_track_size_bytes (4): explicit size wins, duration fallback, zero when neither, explicit size always wins even with duration. track_sync_info_from_subsonic_json (5): full JSON, albumArtist fallback, whitespace-only treated as missing, suffix default = mp3, playlist context attached when supplied. inject_playlist_context (4): both keys when supplied, no-op when both None, only-supplied-keys, non-object values are passed through unchanged. Coverage delta: psysonic-syncfs: 50.8% -> 55.2% (+4.4pp from inline-extraction) WORKSPACE: 41.6% -> 42.4% Workspace test count: 337 -> 350. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-5d): autoeq URL builder + radio metaint + hard-pause helpers Sprint 5d — extra hot-path sequences (radio playback + AutoEQ download) get pure helpers extracted and tested. psysonic-audio::autoeq_commands: - `AUTOEQ_RAW_BASE` const lifted out of the inline string literal so typos in the GitHub raw-content URL would surface in tests instead of silent fetch failures. - `autoeq_profile_url_candidates(base, source, form, name, rig?)` extracted from `autoeq_fetch_profile`. Pure URL builder. Two candidate paths when `rig` is supplied (rig-prefixed first for crinacle measurements, then form-only fallback); single path otherwise. 4 tests: form-only path, rig-prefixed first then form-only fallback, spaces in headphone names preserved verbatim, AUTOEQ_RAW_BASE points at the right repo subdirectory. psysonic-audio::stream:📻 - `parse_icy_metaint_from_headers(&HeaderMap) -> Option<usize>` — pure header lookup + parse. Returns None for absent / non-ASCII / non-numeric values. Wired into `radio_download_task`. - `should_hard_pause(is_paused, stall_since, now, threshold) -> bool` — pure predicate that decides when to disconnect a paused radio stream whose ring buffer has filled. Wired into the hard-pause branch (was inline conditional before). 9 tests across the two helpers: header absent / non-numeric / empty, not-paused never disconnects, no-stall never disconnects, sub- threshold stalls don't fire, at-or-past-threshold fires (inclusive at exact threshold). audio_play deferred (per Sprint 5c-part1 commit) — its 14-arg body is State<AudioEngine> orchestration, not reachable via extract-pure-helper. Coverage delta: psysonic-audio: 39.9% -> 41.5% (+1.6pp from radio + autoeq) WORKSPACE: 42.4% -> 43.0% Workspace test count: 350 -> 363. cargo clippy --workspace --all-targets -- -D warnings stays clean. * test(sprint-5e): add hot-path function coverage soft gate Sprint 5e — last piece of cuca's per-function ≥80% requirement. Adds a soft CI gate that warns (but doesn't fail) when a function listed in `.github/hot-path-functions.txt` is below 80% region coverage. .github/hot-path-functions.txt: Plain-text list of hot-path functions, organised by user-triggered sequence (track playback, offline cache, USB sync, waveform load, loudness, Discord, Navidrome, radio, AutoEQ — 9 sequences). Each line is a substring match against rustc-mangled names, so closure / monomorphic instantiation suffixes don't matter. Comments via `#`. scripts/check-hot-path-coverage.sh: Reads `target/llvm-cov/cov.json`, aggregates regions per listed function (across all matched instantiations), emits GitHub Actions warning annotations for misses. Exit code stays 0 — soft gate. Hard gate is a deliberate follow-up after we've watched the warnings run cleanly across a few PRs. Requires jq + awk. Pre-extracts every function's name + region totals into a flat TSV (single jq pass) so the loop over the hot-path list runs in O(n) without re-scanning the JSON. .github/workflows/rust-tests.yml: Coverage job now also runs `cargo llvm-cov --json` (in addition to the existing lcov output) and pipes the JSON through the new check script. Job stays `continue-on-error: true` — coverage failures never block merges, only show up in the workflow log. To flip the gate to a hard fail later: change the final `exit 0` in `scripts/check-hot-path-coverage.sh` to `exit ${BELOW}` (or `exit 1` when `BELOW > 0`). Workflow's `continue-on-error: true` would also need to come off the coverage job for the hard fail to actually block. No code changes — pure tooling addition. cargo test + clippy unchanged, all 363 tests still passing. * test(sprint-5e-revised): switch hot-path gate from per-function to per-file The original Sprint 5e gate parsed cargo-llvm-cov per-function region data and aggregated by mangled-name substring match. That metric turned out unreliable for our codebase: 1. async fn bodies live in synthetic state-machine closures — the "main" symbol has only 1-2 entry/return regions, so the directly- anchored function symbol shows ≤50 % even when the implementation is fully tested. 2. Generic functions (e.g. `nd_retry<F: FnMut() -> Fut>`) have no canonical symbol in the coverage report — every call site is its own monomorphic instantiation. Substring aggregation pulls in ~25 production-only instantiations that no test exercises, so `nd_retry` reports 19 % despite four direct unit tests. 3. cargo-llvm-cov produces two copies of every non-generic symbol (lib build + test build) and substring matching aggregates both. Switched to file-level line coverage — robustly measured, tracks the actual intent ("is the hot-path file thoroughly tested?"), no symbol- mangling pitfalls. .github/hot-path-files.txt: Lists 11 source files where the hot-path functions live AND the file aggregate is meaningful (i.e. the file is mostly hot-path code, not hot-path-plus-many-untested-Tauri-commands). Files with mixed content (sync/batch.rs, navidrome/queries.rs, remote.rs, etc.) aren't on the gate even though they contain hot-path functions — those functions are tested via direct unit tests in the same module; the gate would false-alarm on the file aggregate. scripts/check-hot-path-coverage.sh: Reads `target/llvm-cov/cov.json`, looks up `data[0].files[].summary. lines.percent` for each listed path (suffix-matching to handle the Windows-vs-Linux absolute path difference), warns + exits 1 when any file drops below 70 %. Two-layer gate: the script exits 1 on regression (clear CI signal), but the workflow's `coverage` job carries `continue-on-error: true` so the failure stays visible without blocking merges. Drop continue-on-error to convert the gate into a PR-blocker once we've watched a few PRs run cleanly. Verified locally: all 11 listed files clear 70 %. fs_utils.rs 95.7% offline.rs 79.9% file_transfer.rs 96.0% store.rs 91.0% compute.rs 85.7% decode.rs 73.1% stream/icy.rs 100.0% progress_task.rs 90.1% ipc.rs 86.5% discord.rs 79.6% navidrome/client.rs 97.4% Removed the now-superseded `.github/hot-path-functions.txt`. Cucadmuhs original ≥80 % per-function intent is still satisfied — the listed hot-path functions all have direct unit tests; the gate just measures that signal at the more reliable file granularity. cargo test + clippy unchanged, 363 tests still passing. * style: fix needless_return in log_timestamp_local rustc 1.95 clippy flags the trailing 'return' as needless. Drop the keyword to satisfy '-D warnings' on CI. * style: satisfy rustc 1.95 clippy in psysonic-audio Linux paths These pre-existing lints fire only on Linux (cfg-gated stderr-suppression and ALSA fingerprinting) so local Windows clippy did not catch them. - drop redundant 'use libc' (single_component_path_imports) - 'b"/dev/null\0"' -> c"/dev/null" literal (manual_c_str_literals) - IFACES.iter().any(|&i| i == s) -> IFACES.contains(&s) (manual_contains) * style: fix two more rustc 1.95 clippy errors in Linux paths - perf.rs: needless_return on PerformanceCpuSnapshot tail - logging.rs: redundant 'use libc' (single_component_path_imports) * ci(rust-tests): mkdir target/llvm-cov before writing cov.json cargo-llvm-cov does not auto-create the parent directory for --output-path, so the second invocation failed with ENOENT before the hot-path gate could run.	2026-05-10 22:39:35 +02:00
Frank Stellmacher	f225039f1b	Merge pull request #532 from Psychotoxical/refactor/backend-pilot ... refactor(rust): Cargo workspace with 5 domain crates (M0–M7)	2026-05-10 01:10:43 +02:00
Psychotoxical	673d4ffe56	docs(changelog): add Cargo workspace refactor entry ... Foundational Rust workspace split landed via #532. Crediting both cucadmuh (M0–M7 structural work + analysis fixes) and Frank (orbit batch + macOS gates + bonus PRs that rode along on the branch).	2026-05-10 01:06:06 +02:00
Maxim Isaev	cdd7cb192d	fix(analysis): map waveform bins to decoded length, not inflated n_frames ... Container-reported frame counts can exceed decoded samples on some VBR or badly tagged files; using max() squashed energy into the leading bins.	2026-05-10 01:43:00 +03: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	7a0dd93f3e	fix(refactor): cfg-gate two items so macOS build is warning-clean (#530) ... Mac smoke build surfaced 5 dead-code / unused-import warnings, all cfg-leaks of items that are conditionally compiled on Windows + Linux: - `psysonic-audio::power_resume` is consumed by `power_notify_win` and `power_notify_linux` only — `register_post_sleep_audio_recovery` intentionally falls through to a no-op on macOS (the generic device watcher covers the resume case there). Gate the module declaration to `#[cfg(any(target_os = "windows", target_os = "linux"))]`. - `lib_commands::ui::build_mini_player_window` is re-exported for the Windows-only pre-create path in `lib.rs:setup` (other platforms create the mini-player webview lazily on first invoke). Gate the re-export to `#[cfg(target_os = "windows")]` so non-Windows builds don't warn on an unused import. Both are non-functional — the items themselves are already correctly scoped via cfg in their consumers; only the declarations / re-exports were missing the matching gate.	2026-05-09 23:34:23 +02:00
Frank Stellmacher	25507888a9	fix(orbit): host single-track playTrack appends instead of replacing (#529) ... * fix(orbit): host single-track playTrack appends instead of replacing Reported by cucadmuh: "When playing from offline, the Orbit queue doesn't get appended to — it gets overwritten." Root cause: the Orbit bulk-guard fires only when `queue.length > 1`. A `playTrack(track, [track])` call (one example: OfflineLibrary's "Play this album" on a single-track album, but any UI that passes an explicit 1-track replacement queue triggers it) slips past the guard and replaces the host's `playerStore.queue`. The host's queue *is* the shared Orbit queue — replacing it wipes every guest suggestion + every upcoming track in one click. Re-route to append + jump when role is host: if the track is already in the queue, jump to that slot; otherwise append it and jump to the new tail. The guest path is intentionally left alone — guests opting out of host-sync via a local Play is the existing "guest running their own show" divergence behaviour. `useOrbitGuest`'s `syncToHost` is the only guest-side caller of `playTrack(track, [track])`, and it never matches `role === 'host'` so it's never intercepted. * docs(changelog): add host single-track Orbit-queue protection bullet	2026-05-09 22:53:04 +02:00
Frank Stellmacher	eae649bcad	fix(orbit): make initial-sync seek visually stick on join (#528) ... * fix(orbit): make initial-sync seek visually stick on join Reported: "I join the room, the waveform shows the host's live position for a second or two, then snaps back to 0:00 and audio is still playing from the start. Only after that snap can I press Catch Up." Two compounding causes in `useOrbitGuest`: **1. Poll fires `applyMirror` before the engine is genuinely playing.** `playTrack` flips `isPlaying` to `true` *synchronously* in its optimistic store write, so the post-`playTrack` poll satisfied its "engine ready" check before the Tauri `audio_play` had even started producing sample. The `seek` inside `applyMirror` updates the store position immediately (waveform jumps to host's live position), but `audio_seek` is debounced and lands on a not-ready engine — it silently no-ops. The engine then starts playing from 0, and its first progress events overwrite the optimistic seek position, snapping the waveform back. Add `currentTime > 0.1` to the poll's "engine genuinely playing" condition: once audio has flowed past the cold-start barrier, the seek commits and the seek-target guard correctly filters subsequent progress events. **2. `applyMirror`'s play-state mirror raced its seek**, same shape as the `onCatchUp` race fixed in #527. `player.seek` debounces `audio_seek` via setTimeout(0) while `pause`/`resume` invoke synchronously — pause arriving first leaves the engine paused at the old position. Defer the play-state mirror by 200 ms so the seek lands first. * docs(changelog): add initial-sync seek-stickiness bullet	2026-05-09 22:44:52 +02:00
Frank Stellmacher	6c5465e9c7	fix(orbit): hysteresis on Catch Up visibility so the button stays clickable (#527) ... * fix(orbit): keep Catch Up button visible long enough to click Reported during testing: the Catch Up button "appears for a moment, then disappears too fast to click". The single-stage debounce only filtered the show direction (require ≥ 3 s sustained over-threshold before showing), but on a real-world high-latency session the genuine drift fluctuates between ~1 s and ~8 s in lockstep with both sides' chunked `currentTime` updates — so the button vanished as soon as drift dipped briefly under 3 s, even though the drift baseline was still 5–8 s. Add a hide-side hysteresis: once visible, the button stays visible until drift has been under a tighter 1 s threshold for ≥ 1 s. Otherwise the noisy 1–3 s drift valleys keep the button up so the user can actually click it. Constants left as locals; if testing wants different floors we can extract. * docs(changelog): add catch-up hysteresis bullet * fix(orbit): show Catch Up when host paused + serialise seek-then-pause Two follow-ons after the hysteresis change: **1. Show Catch Up even when the host is paused.** The visibility gate required `state.isPlaying === true`, but a guest who joined while the host was paused still benefits from Catch Up if their sync to the host's paused position failed (engine drop, brief network blip during initial-sync, manual local seek). Drop the `state.isPlaying` gate — the only signal that should matter is "drift between us and the host's reported state" — which `computeOrbitDriftMs` already computes correctly in the paused case (no time-extrapolation, just `guestPos - hostPos`). **2. Defer the play-state mirror after `player.seek`.** Reported symptom: "I press Catch Up, the player pauses; when I press play, it resumes from the *old* position and the waveform jumps back." Root cause: `player.seek` debounces `audio_seek` via `setTimeout(0)`, while `player.pause` / `player.resume` fire their invokes synchronously. Pause arrives at the engine first, leaving it paused at the pre-Catch-Up position with the seek queued behind. When resume happens later, the engine plays from the old spot. Push the play-state mirror behind a 200 ms `setTimeout` so the seek's invoke lands first.	2026-05-09 22:37:45 +02:00
Frank Stellmacher	27c740b760	fix(orbit): kick a fresh playTrack when engine is stuck mid-load (#526) ... * fix(orbit): kick a fresh playTrack when engine is stuck mid-load Follow-up to #525. Symptom: occasionally on join, the guest gets no audio until the next host-driven track change, at which point a fresh `playTrack` runs and audio plays normally. Root cause: when the initial `syncToHost` poll hits its 5 s deadline without the engine reporting `isPlaying === true` (slow Navidrome cold-start), the next pull tick takes the cheap "track already loaded" shortcut and calls `applyMirror`. `applyMirror` fires `seek` + `resume` on an engine that is stuck in a "loaded but never started" limbo — seek silently no-ops and `resume` can't kick a track that never began. Guest is silent until something else triggers a fresh `playTrack`. Tighten the shortcut: take the cheap path only when the engine is already in the state the host expects (or playing while host is paused, which is fine to align via pause). Otherwise fall through to a fresh `playTrack` and the existing 5 s ready-poll, which re-initialises the engine and lets audio actually start. * docs(changelog): add engine-limbo follow-up bullet * fix(orbit): re-sync when engine silently fell back to paused The optimistic `isPlaying: true` `playTrack` writes synchronously masks a `audio_play` failure: the post-playTrack poll sees the optimistic flag, fires `applyMirror`, and the outer tick records `lastAppliedRef = { ..., isPlaying: true }` as a successful sync. But if the underlying `invoke('audio_play')` rejects later (network blip / cold-start exhaustion), the catch handler flips the flag back to `false` and schedules `next()`, which short-circuits to `audio_stop` in an Orbit guest — leaving the player silent while `lastAppliedRef` still claims we're playing. None of the divergence-detection branches (track-change / play-pause-flip) match, so the guest never re-syncs. Add a recovery check before the if/else-if chain: when the captured `last` says we applied playing, the engine is currently not playing, and the host is still playing the same track, reset `lastAppliedRef.current = null`. The next iteration of the chain re-runs initial-sync (with the 500 ms fast-poll cadence) which fires a fresh `playTrack`. If `audio_play` succeeds the second time, audio finally starts; if it keeps failing, we loop with no extra harm (audio was already silent). Adds an `engine-recovery` event scope to the diagnostics buffer so future captures can see when this re-sync fired. * docs(changelog): expand engine-recovery bullet to cover both cases	2026-05-09 22:08:48 +02:00
Frank Stellmacher	af1b9661f5	fix(orbit): three interlocking guest playback bugs (#525) ... * fix(orbit): guest short-circuits queue-exhaustion fallback paths When a guest's local queue runs out (single-track queue from `syncToHost` empties on `audio:ended`), the player walks the standard fallback chain in `next()`: radio top-up → infinite-queue → stop. The infinite-queue branch builds a 6-track queue and calls `playTrack`, which trips `orbitBulkGuard` and pops a "Add 6 tracks to the Orbit queue?" modal. Hitting Cancel leaves playback frozen; "Add them all" injects unrelated tracks into the host's shared queue. In an active Orbit guest session the host owns the queue. Skip the fallback paths entirely and just stop — the next `useOrbitGuest` pull tick will sync to whatever the host advanced to. Bonus side-effect: kills the deferred-promise race where a `buildInfiniteQueueCandidates().then(...)` from a guest's track end could resolve *after* a Catch Up replaced the queue and pop the modal a second time against the now-current 1-track queue. * fix(orbit): treat natural track-end as not-diverged in guest sync When a guest's track ended naturally before the host advanced, the divergence-detection branch read `player.isPlaying === false` and classified it as the user manually paused — so it refused to load the host's next track. The guest sat silent until they clicked Catch Up. `handleAudioEnded` keeps `currentTrack` pinned to the just-ended track and resets `currentTime` to 0, while a real manual pause leaves `currentTime` somewhere mid-track. Use the 0-position discriminator to classify natural-end as not-diverged so the host's new track loads. Confirmed via the captured guest log buffer: 18:43:08.598 [track-change] host: VJkV5… → 6i6RP… BUT guest diverged (player.isPlaying=false ≠ last.isPlaying=true) — guest stuck for ~33s until Catch Up was pressed. * fix(orbit): Catch Up polls until engine is ready before seeking The 400 ms blind setTimeout in `onCatchUp` was too short for an HTTP-streamed cold-start on high-latency links. If the audio engine wasn't ready by then, `seek(fraction)` silently no-oped and playback started at 0:00, making Catch Up effectively useless on exactly the slow links where it's needed. Captured log shows a Catch Up bringing the guest to posSec=30, then 5 s later the guest was at posSec=6 (playback restarted from the head). Replace with the same poll-until-ready pattern `syncToHost` already uses: check every 100 ms, fire the seek as soon as the engine reports playing, fall back to a blind apply at the 4 s deadline. * docs(changelog): add orbit guest playback fixes entry * fix(orbit): debounce Catch Up button + match bar item height Two follow-on UX fixes after PR #525's three primary bugs landed: 1. **Debounce visibility.** Drift is computed from an asymmetric signal: guest's `currentTime` updates in coarse ~5 s chunks, while host's position is extrapolated linearly via `(nowMs - posAt)`. Even on a perfectly-synced session the diff swings ±5 s every tick, so the button flickered in and out continuously. Show only after drift has stayed over the 3 s threshold for ≥ 3 s of wall clock — measurement noise is filtered out, real sustained drift still surfaces in time. 2. **Match neighbour height.** The button was 32 px tall against 26 px for the other action buttons (.orbit-bar__settings) so every flicker shifted the entire bar height. Set `height: 26 px` and tighten the padding/font so the layout is stable regardless of visibility. * fix(orbit): tighten queue-extension lockout + reliable initial-sync seek Two follow-on fixes after the 4-bug umbrella: **1. Local queue-extension paths fully off during Orbit.** Phase check broadened from `active` to cover `starting` / `joining` / `active` so a fetch-then-join race can't pop the bulk-add modal *after* the join. The proactive infinite-queue topper inside `next()` (which fires when ≤ 2 auto-tracks remain ahead) is now also gated, plus each async `.then()` callback in the radio + infinite-queue paths re-checks at resolution time. A `playTrack(... 6-track queue ...)` after the user joined Orbit was the path that re-triggered the "Add 5 tracks?" modal on a freshly-joined guest. **2. `syncToHost` only seeks once the engine reports playing.** The previous 2 s deadline-fallback applied the seek even when the engine hadn't started, where the seek silently no-ops and the track plays from 0:00. Symptom: clicking Catch Up makes the song "jump 50 % forward" — that's the seek finally landing because the engine is now ready, the initial-sync seek had already failed silently. New deadline is 5 s, and on timeout we return `false` so the outer pull tick keeps `lastAppliedRef` null and the 500 ms fast-poll retries. * fix(orbit): double-click play button + hide preview during session Two cucadmuh-flagged gaps: **1. Double-click on the inline play button now reaches the orbit-add path.** The album-track row's onDoubleClick already routes to `addTrackToOrbit` when in Orbit, but the inline play button stopped propagation on click — so clicking it twice just fired the "double- click to add" hint toast and never touched the orbit queue. Add an onDoubleClick on the button itself that delegates to the parent's `onDoubleClickSong`. **2. Track preview is suppressed during an Orbit session.** Preview shares the Rust audio engine with the shared playback, so starting one as a guest yanks the host's track out from under everyone. A new `[data-orbit-active]` attribute on `<html>` (set whenever role is host/guest and phase is starting/joining/active) hides every preview button via a single CSS rule, and `previewStore.startPreview` short-circuits as a defensive guard for keyboard shortcuts and any programmatic callers.	2026-05-09 21:50:52 +02:00
Frank Stellmacher	a702a5dd5b	feat(orbit): in-app diagnostics popover with copyable event log (#524) ... * feat(orbit): in-app diagnostics popover with copyable event log Multiple users on Discord report Orbit guests stopping after the first song with no errors anywhere — Settings → Debug → Export Logs is too buried for non-technical reporters, and the relevant code branches have no logging at all (silent fail). This adds a one-click "Copy log" path right inside the Orbit session bar. The new Activity-icon button next to Help opens a popover with: - Live mini-display: role, host vs. guest track id + position, drift, age of the host's last state write — all updating once a second. - Scrolling event log textarea fed by an in-memory ring (200 events). - Copy + Clear buttons. Copy formats `[ISO] [scope] body` lines and drops them on the clipboard — paste straight into a Discord report. Instrumentation lands at the previously-silent decision points: - Guest pull tick: full snapshot of host vs. guest state on every read. - Each branch of the divergence detection in `useOrbitGuest.ts` logs which path it took and why (initial / track-change-followed / track-change-diverged / play-pause-flip), making the "stuck after first song" symptom diagnosable from the buffer alone. - Host pushes log track id, isPlaying, queue length, guest count. Events are also bridged to the existing `frontend_debug_log` Tauri command when Settings → Logging is on Debug, so power users still get the same data in `psysonic-logs-*.log` for offline triage. i18n: full `orbit.diag.*` namespace in all eight locales. EN + DE are native; ES / FR / NB / NL / RU / ZH are first-pass and may want a polish from native speakers later. * docs(changelog): add orbit diagnostics popover entry	2026-05-09 21:49:17 +02:00
Psychotoxical	acadc1be34	Merge remote-tracking branch 'origin/main' into refactor/backend-pilot	2026-05-09 18:53:02 +02:00
Frank Stellmacher	874b0c67ae	fix(context-menu): drop inline z-index that hid menus under floating player (#522) ... * fix(context-menu): drop inline z-index that hid menus under floating player The main context menu wrapper carried an inline `zIndex: 999` that overrode the `.context-menu { z-index: 10000 }` stylesheet rule. The floating player bar sits at z-index 1000, so when a menu opened near the bottom of the screen — long enough or anchored low — the player bar covered it. Removing the inline override lets the stylesheet rule (10000) win, so the menu always paints on top of the floating bar. Submenus inherit the same stacking context so they follow the parent menu. Closes #521. * docs(changelog): add context-menu floating-player z-index fix entry	2026-05-09 18:52:37 +02:00
Psychotoxical	0d29a09455	Merge remote-tracking branch 'origin/main' into refactor/backend-pilot	2026-05-09 18:12:01 +02:00
Frank Stellmacher	fec513b629	fix(home): swap Because-you-listened rail to AlbumRow under 696 px (#520) ... * fix(home): swap Because-you-listened rail to AlbumRow under 696 px The hero-style BecauseCards are tuned for full-rail widths (3 cards at 1052 px+, 2 cards at 696-1051 px). Below that the cards stretched full-width with a fixed 160 px cover stuck on the left and centred text floating in a wide empty area — looked like three over-sized banners stacked vertically instead of a compact recommendation rail. A `ResizeObserver` on the rail wrapper now watches the container width and below 696 px renders a standard `AlbumRow` (which is already perf-tuned for narrow rails: artwork budget, viewport windowing, scroll paging). Wide layouts keep the unchanged hero card layout, so the mainstage view at full width is identical to before. * docs(changelog): add Because-you-listened narrow-layout fix entry	2026-05-09 18:11:22 +02:00
Psychotoxical	b8fb1ca8fc	Merge remote-tracking branch 'origin/main' into refactor/backend-pilot	2026-05-09 17:46:28 +02:00
Frank Stellmacher	268086ac74	docs(issue-template): label Nix install option as "flakes" (#519) ... The bug report form's install-source dropdown listed "Cachix / Nix", but Cachix is just a binary cache — users actually install the app via the Nix flake. Relabel to "flakes" so the dropdown reflects the mechanism people pick.	2026-05-09 17:44:44 +02:00
Psychotoxical	37c19237f3	fix(refactor): restore Windows build on backend-pilot ... - Re-export `build_mini_player_window` from `lib_commands::ui` so the Windows-only pre-create call in `lib.rs` resolves through the `use lib_commands::*` glob (was lost during the M5 split). - Gate the `is_tiling_wm` import in `ui::mini` and its re-export in `lib_commands::sync` behind `cfg(target_os = "linux")`, the only platform that actually consults it.	2026-05-09 17:38:40 +02:00
Psychotoxical	eff7bd036e	Merge remote-tracking branch 'origin/main' into refactor/backend-pilot	2026-05-09 17:08:20 +02:00
Frank Stellmacher	acc367207a	chore: add GitHub issue forms (bug + feature + config) (#517) ... Three files under .github/ISSUE_TEMPLATE/: - bug_report.yml Required: summary, repro steps, expected/actual, version, OS. Optional: install source dropdown (AUR / .deb / .rpm / Cachix / .dmg / .msi / from-source), Subsonic server type + version, logs (with inline how-to), screenshots, anything else. Auto-labels: bug, triage. - feature_request.yml Required: use case (described as workflow, not solution). Optional: proposed solution, alternatives, anything else. Auto-labels: enhancement, triage. - config.yml blank_issues_enabled: false; redirects general questions to Discord, Telegram for chat, AUR page for packaging issues. Net effect: incoming issues land with the info needed to triage without back-and-forth, and casual support questions are routed off the issue tracker.	2026-05-09 16:49:04 +02:00
Psychotoxical	97f06459f3	refactor: move analysis admin commands into psysonic-analysis (M6/7) ... Reframed M6 from "extract psysonic-commands" to "place each domain's Tauri commands in its own domain crate" — the original psysonic-commands proposal would have been a thin shell with no clear domain ownership because each prior milestone already kept its own commands inline: audio_*_commands in psysonic-audio cache/sync commands in psysonic-syncfs navidrome/discord/etc in psysonic-integration The leftover analysis admin commands (7 of them) logically belong to the analysis domain. So they move there: src/lib_commands/app_api/analysis.rs → crates/psysonic-analysis/src/commands.rs WaveformCachePayload + LoudnessCachePayload moved out of top-crate lib.rs into commands.rs PlaybackQueryHandle gets a second closure (`should_defer_backfill`) so analysis_enqueue_seed_from_url can ask "is a ranged playback already going to seed this track?" without depending on psysonic-audio. Top crate keeps the shell-flavored commands (window/tray/mini-player, greet/exit_app, mpris/global-shortcuts/check_dir_accessible, perf, cli_bridge) for M7 to clean up. Behaviour preserving. Cargo check + clippy --workspace clean.	2026-05-09 14:00:33 +02:00
Psychotoxical	98d8ea6353	refactor: extract psysonic-integration crate (M5/7) ... Moves all outbound external-service bridges out of the top crate into a new psysonic-integration crate. crates/psysonic-integration/ src/discord.rs Rich Presence + iTunes artwork src/navidrome/{client,covers,...} Native REST API admin (5 modules) src/remote.rs radio-browser, last.fm, ICY meta, generic CORS proxy (fetch_url_bytes / fetch_json_url / resolve_stream_url) src/bandsintown.rs events for an artist src/lib.rs module declarations + macro re-exports Top crate keeps `crate::discord` working via `pub use psysonic_integration::discord;`. invoke_handler! in lib.rs uses full deepest paths (`psysonic_integration::navidrome::users::nd_list_users`, etc.) so Tauri's `__cmd__*` magic macros resolve at the right module — same pattern audio + syncfs already use. Cross-crate refs migrated: crate::subsonic_wire_user_agent → psysonic_core::user_agent::* pub(crate) → pub (cross-crate visibility) Behaviour preserving. Cargo check + clippy --workspace clean.	2026-05-09 13:51:28 +02:00
Psychotoxical	9417d522f3	refactor: extract psysonic-syncfs crate (M4/7) ... Moves all on-disk cache + device-sync code out of the top crate: crates/psysonic-syncfs/ new lib crate src/cache/{offline,hot,downloads,fs_utils} unchanged behaviour src/sync/{batch,device} (no tray.rs — that's UI) src/file_transfer.rs shared HTTP helpers src/lib.rs + DownloadSemaphore type + sync_cancel_flags fn The shell crate keeps `lib_commands/sync/tray.rs` (OS tray icon — UI concern, will move to shell-tauri at M7) but drops the rest of `lib_commands/cache/` and the syncfs sibling files. Tauri command quirk surfaced and resolved: `#[tauri::command]` puts its `__cmd__*` and `__tauri_command_name_*` helper macros at the *exact* module of the function, and `pub use` doesn't carry them across module boundaries. invoke_handler! in lib.rs now references each syncfs command via its full deepest path (`psysonic_syncfs::cache::offline::download_track_offline`, etc.) so Tauri's macros resolve at the right scope. Same approach the audio crate already uses (`audio::commands::audio_play`). Cross-crate ref migrations applied via batch sed: crate::audio::* → psysonic_audio::* crate::analysis_runtime::* → psysonic_analysis::analysis_runtime::* crate::analysis_cache::* → psysonic_analysis::analysis_cache::* crate::subsonic_wire_user_agent → psysonic_core::user_agent::* super::super::file_transfer:: → crate::file_transfer:: Behaviour preserving. Cargo check + clippy --workspace clean.	2026-05-09 13:45:53 +02:00
Psychotoxical	41e75663f1	refactor: extract psysonic-audio crate (M3/7) ... Moves all audio playback code (Symphonia decode, rodio output, HTTP streaming, gapless, previews, and the seven stream/ source-type submodules from the prior split) out of the top crate into a new psysonic-audio crate. crates/psysonic-audio/ new lib crate, depends on psysonic-core + psysonic-analysis src/{engine,helpers,decode,…}.rs flattened layout (no more extra audio/ namespace level) src/stream/ seven submodules from M0 src/lib.rs re-exports macros from psysonic-core and the public API surface The audio↔analysis edges identified in the dep survey are now real crate deps (audio depends on analysis directly: AnalysisCache reads, recommended_gain_for_target, submit_analysis_cpu_seed). Only the analysis→audio back-edge goes through the PlaybackQueryHandle port registered in M2. Cross-crate ref migrations applied via batch sed: crate::audio::* → crate::* (intra-crate) crate::analysis_cache::* → psysonic_analysis::analysis_cache::* crate::submit_analysis_cpu_seed → psysonic_analysis::analysis_runtime::* crate::subsonic_wire_user_agent → psysonic_core::user_agent::* Top crate keeps `crate::audio::*` paths working via `pub use psysonic_audio as audio;` — lib_commands/cli callers untouched. `stop_audio_engine` (mac process-exit cleanup) moved into the audio crate as `pub fn stop_audio_engine` since it reaches AudioEngine internals; tray.rs now re-exports the moved fn. Two small visibility promotions in engine.rs: pub(crate) fn analysis_track_id_is_current_playback → pub pub(crate) fn ranged_loudness_backfill_should_defer → pub Behaviour preserving. Cargo check + clippy --workspace clean.	2026-05-09 13:33:44 +02:00
Psychotoxical	ff456dd823	refactor: extract psysonic-analysis crate (M2/7) ... Moves analysis_cache + analysis_runtime out of the top crate into a new psysonic-analysis crate, plus the runtime user-agent facade into psysonic-core. The audio↔analysis dependency cycle is broken via a PlaybackQueryHandle port registered as Tauri State. crates/psysonic-analysis/ new lib crate src/analysis_cache/{mod,store,compute} unchanged behaviour src/analysis_runtime.rs + enqueue_analysis_seed (was in lib_commands/cache/offline) crates/psysonic-core/src/ user_agent.rs subsonic_wire_user_agent + runtime/default helpers (was in top lib.rs) ports.rs PlaybackQueryHandle: closure wrapper, not Arc<dyn Trait>, so existing State<AudioEngine> callsites stay unchanged The shell setup hook registers the real PlaybackQueryHandle once the AppHandle is available; the closure captures it and re-resolves AudioEngine via try_state at each call. Top crate keeps `crate::analysis_cache`, `crate::analysis_runtime`, `crate::subsonic_wire_user_agent`, and `crate::submit_analysis_cpu_seed` working via re-exports — no audio/lib_commands callsite needed editing. Behaviour preserving. Cargo check + clippy --workspace clean (only pre-existing warnings carry over).	2026-05-09 13:25:04 +02:00
Psychotoxical	7718ac3ee5	refactor: introduce cargo workspace + psysonic-core crate (M1/7) ... First milestone of the workspace crate split. Sets up the workspace skeleton and extracts shared logging + cross-crate port traits into a new psysonic-core crate. src-tauri/Cargo.toml now defines [workspace]; top package becomes the workspace root. crates/psysonic-core/ new lib crate, no Tauri-handler code: src/logging.rs full logging facade (was src/logging.rs) src/ports.rs PlaybackQuery + AnalysisOrchestrator trait declarations (no impls yet) The top crate re-exports `psysonic_core::logging` and the `app_eprintln!` / `app_deprintln!` macros so every existing `crate::logging::*` and `crate::app_eprintln!` callsite keeps working unchanged. Port traits intentionally take `tauri::AppHandle` — psysonic-core is a workspace-internal crate, so depending on Tauri here is a feature, not a leak. Implementers will register themselves as `Arc<dyn PlaybackQuery>` / `Arc<dyn AnalysisOrchestrator>` Tauri State in M2/M3. Behaviour preserving. Cargo check + clippy --workspace clean.	2026-05-09 13:06:28 +02:00
Psychotoxical	9455879044	refactor(audio): split stream.rs into stream/ submodules ... Pure file-move refactor: 1000-LOC stream.rs → stream/ directory with seven cohesive submodules and explicit pub(crate) re-exports: icy.rs (109) ICY metadata state machine + parser reader.rs (110) AudioStreamReader (ringbuf → Read shim) local_file.rs (32) LocalFileSource (psysonic-local://) ranged_http.rs (382) RangedHttpSource + ranged_download_task radio.rs (187) RadioLiveState + radio_download_task track_stream.rs (182) track_download_task (one-shot) mod.rs (48) re-exports + shared tuning constants Source-type lifecycles are now isolated: each MediaSource impl lives next to its download task. External callers (radio_commands, transport_commands, play_input, engine, helpers) keep their existing `super::stream::{...}` paths via the mod.rs re-exports — no caller edits required. Behaviour preserving. Cargo check + clippy clean (only the pre-existing "too many arguments" warning on track_download_task carries over).	2026-05-09 12:55:43 +02:00
Psychotoxical	0992113269	fix(audio): suppress audio:error toast for superseded plays ... Rapid skipping while a track is in initial preparation produced a misleading "Couldn't play track — skipping" toast for the abandoned track. Sequence: audio_play(A) reaches build_source_from_play_input; user skips → audio_play(B) bumps gen; A's RangedHttpSource::read sees the gen mismatch and returns Ok(0); Symphonia's probe interprets Ok(0) as EOF → "ranged-stream: format probe failed: end of stream"; audio_play(A)'s map_err emits audio:error unconditionally → toast appears even though playback already moved on. Gate the emit on a generation check: if the global generation has already moved past this play's gen, the failure is supersedion, not a real codec error — log it but do not surface the toast. Pre-existing bug, identical code path on main (commands.rs:600). Noticed on refactor/backend-pilot during cucadmuh's skip-test session because the live-test pattern hit the narrow probe-window race repeatedly. The diagnostic logs added in the previous commit should make the next occurrence's cause visible regardless of whether the toast fires. Frontend impact: - handleAudioError no longer fires on supersedion → no toast, no setState({ isPlaying: false }), no queued next() call. - The audio_play IPC promise still rejects with the same error string (preserved as the .map_err return value); the JS .catch is already generation-guarded in playerStore so this is a no-op there.	2026-05-09 01:48:38 +02:00
Psychotoxical	ff4271181c	diag(audio): trace ranged-stream supersedion + abort paths ... Skipping tracks while a RangedHttpSource is still in initial probe leaves no diagnostic trail today: RangedHttpSource::read returns Ok(0) on gen-mismatch (silent), ranged_download_task drops out the same way, and the `dl done` summary only fires under app_deprintln so release users never see partial/aborted downloads either. Add focused logs at the bail points without changing behaviour: - RangedHttpSource::read — log on each Ok(0) return that isn't the normal pos>=total_size EOF (superseded before/during wait, download done with no bytes ahead of cursor). Symphonia stops reading after Ok(0), so at most one log per source, no spam. - ranged_download_task — log on the gen-mismatch bail with track id + gen transition + downloaded/total bytes so we can tell "user skipped while downloading" apart from "stream stalled". - track_download_task — same gen-mismatch log for the legacy non-seekable path (consistency with ranged). - dl-done summary — split into release-visible `[stream] ranged dl ABORTED: …` (downloaded < total_size) vs the existing dev-only `[stream] dl done` for full completions. - audio_play — log on both supersedion-bail points around select_play_input so a silently-ending audio_play call leaves a trace. No semantics changed: every existing return / store / branch is intact. Pure additive logging to make the next reproduction of cucadmuh's ranged-stream toast diagnosable.	2026-05-09 01:47:02 +02:00
Psychotoxical	176382e0b6	refactor(lib_commands): drop super::* + glob in app_api + lib_commands root ... Hotspot G final slice — replace cascade-imports in app_api/{core, analysis,integration,remote,platform}.rs with explicit per-symbol imports, and convert app_api/mod.rs from broad `pub(crate) use foo::*` to a per-command list of every Tauri handler. The remaining glob re-exports live only in lib_commands/mod.rs itself — and those are deliberate: they flatten the explicitly-listed Tauri commands one more level so lib.rs's `use lib_commands::*` keeps the invoke_handler shape unchanged. Each level above is now explicit. file_transfer.rs's `super::subsonic_wire_user_agent()` becomes `crate::subsonic_wire_user_agent()` since the lib_commands cascade no longer pulls lib.rs symbols into super scope. `grep -rn 'use super::\*' src/lib_commands/` returns zero hits. Behaviour-preserving.	2026-05-08 16:45:46 +02:00
Psychotoxical	1ff8bdd8c7	refactor(lib_commands): drop super::* + glob re-export in sync + lib.rs ... Hotspot G next slice — replace cascade-imports in lib_commands/sync/ {device,batch,tray}.rs with explicit per-symbol imports + per-command re-exports. sync/mod.rs lists each Tauri command from device / batch / tray explicitly, plus the three internal helpers consumed by lib.rs and ui/mini.rs (is_tiling_wm, stop_audio_engine, try_build_tray_icon). The previous broad `pub(crate) use device::*` etc. is gone. Inside the .rs files: each `use super::*` is replaced with what the file actually needs — `super::device::{TrackSyncInfo, ...}` for batch, `crate::tray_runtime::{Tray*}` + `crate::audio` + `super::super::ui:: {PAUSE_RENDERING_JS, RESUME_RENDERING_JS}` for tray, etc. Cleanup in lib.rs: drop the now-unused tauri menu/tray imports (MenuBuilder/MenuItemBuilder/PredefinedMenuItem/TrayIcon*/MouseButton*) — tray.rs owns those now. Drop `Ordering` (no longer used at lib.rs scope). Drop `pub(crate) use file_transfer::*;` from lib_commands/mod.rs (file_transfer is now imported by direct path where needed: `super::super::file_transfer::*`).	2026-05-08 16:32:04 +02:00
Psychotoxical	409d8fa964	refactor(lib_commands): drop super::* + glob re-export in ui + cache ... Hotspot G first slice — replace the cascade-import pattern in lib_commands/ui/ and lib_commands/cache/ with explicit per-symbol imports + per-command re-exports. ui/mod.rs no longer reaches `pub(crate) use mini::*; pub(crate) use bandsintown::*;` — instead it explicitly re-exports the 8 mini-player Tauri commands + the 3 internal helpers consumed by lib.rs + sync/tray.rs (PAUSE_RENDERING_JS, RESUME_RENDERING_JS, persist_mini_pos_throttled), and fetch_bandsintown_events. cache/mod.rs likewise lists each Tauri command from offline / hot / downloads explicitly. The only cross-crate "internal" re-export is `enqueue_analysis_seed` which analysis_runtime depends on. Inside the .rs files: every `use super::*` is replaced with the specific imports actually needed (super::offline::..., crate::audio, crate::analysis_runtime::..., tauri::Manager, etc.). Behaviour-preserving — no Tauri command name changed, no runtime behaviour shift. Just removes the leak-everything-everywhere import graph that cucadmuh's policy doc forbids.	2026-05-08 16:18:51 +02:00
Psychotoxical	f43ab94cc1	refactor(app_api): split navidrome.rs into 5-way module directory ... Convert app_api/navidrome.rs (655 LOC monolith) into navidrome/ with five focused submodules + a thin mod.rs: - client.rs (106 LOC) — auth + retry + http client (navidrome_token, NdLoginResult, nd_err, nd_retry, nd_http_client). Internal-only, not re-exported at crate scope. - covers.rs (107 LOC) — 4 multipart image-upload commands (upload_playlist_cover / upload_radio_cover / upload_artist_image / delete_radio_cover). - users.rs (138 LOC) — login + admin user CRUD (navidrome_login + nd_list/create/update/delete_user). - queries.rs (207 LOC) — songs, role-filtered artists/albums, libraries, per-user library assignment, absolute song path. Includes the nd_build_filters helper. - playlists.rs (120 LOC) — playlist CRUD with smart-rules payload passthrough (nd_list / create / update / get / delete _playlist). mod.rs is now ~28 LOC of declarations + per-module re-exports of the Tauri commands. The cascade `app_api/mod.rs` → `pub(crate) use navidrome::*` keeps lib.rs invoke_handler registrations unchanged. Behaviour-preserving — pure file moves with `super::client::*` imports where the auth/retry helpers are needed.	2026-05-08 15:59:39 +02:00
Psychotoxical	7e8acd86d6	refactor(audio): extract sink swap + crossfade handoff into helper ... Pull the atomic sink-swap block (~50 LOC) out of audio_play into play_input::swap_in_new_sink. The helper takes a SinkSwapInputs struct (sink, duration_secs, volume, gain_linear, fadeout trigger + samples, crossfade flag, measured fade seconds) and: 1. Locks state.current, atomically replaces sink + duration + seek/play timestamps + volume + replay-gain + fade-out handles, returns the old sink + its old fade-out handles. 2. If crossfade is on: stores total fade samples, flips trigger atomic on the old TriggeredFadeOut, parks the old sink in fading_out_sink, spawns a small task that drops it after `fade_secs + 0.5 s`. 3. If crossfade is off: stops the old sink immediately. Behaviour-preserving — same lock scope, same atomic ordering, same cleanup-task lifetime. audio/commands.rs: 600 → 563 LOC. With this the audio_play body has shrunk from the original ~760 LOC monolith to a top-level orchestration of named helper calls.	2026-05-08 15:50:07 +02:00
Psychotoxical	ed92a77035	refactor(audio): lift PlayInput → BuiltSource dispatch into helper ... Pull the 60-LOC match in audio_play that turned a PlayInput into a fully-wrapped rodio source out of audio_play and into play_input::build_source_from_play_input. Returns a small PlaybackSource struct holding both the BuiltSource and a `is_seekable` flag (only the Streaming variant is non-seekable). Behaviour preserved verbatim — same build_source / build_streaming_source calls, same target_rate=0 (no app-level resampling), same spawn_blocking decoder build for Seekable+Streaming, same error path (`audio:error` emit + propagate). audio/commands.rs: 642 → 600 LOC. The remaining audio_play body now reads top-to-bottom as: ghost guard → preview clear → gapless pre-chain check → bump generation → reuse-bytes prep → URL pin → format hint → **select_play_input** → gen check → loudness/RG via gain_inputs → crossfade prep → **build_source_from_play_input** → stream rate switching → sink construction + prefill → swap sink → progress task.	2026-05-08 15:45:53 +02:00
Psychotoxical	8f976dc371	refactor(audio): unify loudness/replay-gain prep via TrackGainInputs ... audio_play and audio_chain_preload were both reading the same engine state (target_lufs, norm_mode, pre_analysis_db) and resolving the loudness cache, then feeding it into compute_gain — but with subtly different intermediate steps. audio_play split the resolve+post-resolve into two operations so it could log the cache value; chain_preload used the bundled `loudness_gain_db_or_startup` wrapper. Lift the shared logic into `resolve_track_gain_inputs(state, app, url, logical_id, js_loudness_gain_db) -> TrackGainInputs` in helpers.rs. The struct returns target_lufs, norm_mode, the cache-loudness value (for logging), and the post-resolve effective loudness for compute_gain. Both call sites now use the same helper; behaviour-preserving. Drops the now-unused `loudness_gain_db_or_startup` (audio_chain_preload was its only caller). audio/commands.rs: 676 → 642 LOC.	2026-05-08 15:41:19 +02:00
Psychotoxical	7a61d50c42	refactor(audio): extract source selection from audio_play ... Pull the ~300 LOC URL → PlayInput dispatch out of audio_play into a new audio/play_input.rs: - PlayInput enum (Bytes / SeekableMedia / Streaming) - PlayInputContext struct holding the precomputed inputs (url, gen, duration_hint, format/cache hints, optional reused chained bytes) - select_play_input() async — handles all four branches: reused chained bytes, psysonic-local://, ranged HTTP with format sniff, and the legacy non-seekable streaming fallback - url_format_hint() — the conservative URL→extension allowlist helper, used to be inline in audio_play audio_play is now focused on the orchestration above the source layer: ghost-command guard, gapless pre-chain detection, bumping generation, loudness/replay-gain math, fade-in setup, building the actual rodio Source pipeline, sink swap with crossfade, spawning progress task. audio/commands.rs: 980 → 676 LOC. play_input.rs: 385 LOC. Behaviour preservation hinges on identical analysis-seed spawning, format-hint fallback chain, range-detection logic, and gen-cancel checks — all moved verbatim. Smoke test focus: psysonic-local playback, manual skip during ranged HTTP, format-hint-less servers (legacy fallback path), preload cache hit replay, manual skip onto pre-chained track.	2026-05-08 15:15:30 +02:00
Psychotoxical	2b4014870c	refactor(app_api): extract window + WebKitGTK platform tweaks ... Lift set_window_decorations + linux_webkit_apply_smooth_scrolling + set_linux_webkit_smooth_scrolling out of app_api/core.rs into app_api/platform.rs (~49 LOC). These are platform-tweak Tauri commands (Linux WebKitGTK settings + Linux native-decoration toggle) — logically separate from runtime control, telemetry, cli bridge, or wire-UA setup. This is the "platform" slice from cucadmuh's plan for splitting core.rs's mixed concerns. Together with perf and cli_bridge, core.rs is now down to runtime control (greet, exit_app), logging (3 cmds), and UA setup — 56 LOC, focused.	2026-05-08 14:22:23 +02:00
Psychotoxical	ee7c1de3d6	refactor(app_api): extract cli_bridge wrappers into own submodule ... Lift the four cli_publish_* Tauri commands (player_snapshot, library_list, server_list, search_results) out of app_api/core.rs into app_api/cli_bridge.rs. Each is a thin pass-through to `crate::cli::write_*_response` — the renderer-side counterpart to the file-based IPC layer in cli/exchange.rs. This is the "cli-bridge" slice from cucadmuh's plan for splitting core.rs's mixed concerns. Together with the earlier perf split, core.rs is now down to runtime-control + platform + logging slices — one possible follow-up but each is small enough to leave as-is for now. app_api/core.rs: 122 → 99 LOC.	2026-05-08 14:20:11 +02:00
Psychotoxical	b5ae0ccf28	refactor(app_api): extract perf telemetry into own submodule ... Lift PerformanceCpuSnapshot struct + the Linux /proc/stat parsers (parse_proc_stat_line / read_total_jiffies / collect_proc_stats) + the performance_cpu_snapshot Tauri command (~110 LOC) out of app_api/core.rs into app_api/perf.rs. Self-contained CPU-usage telemetry; nothing else in app_api references the helpers. This is the "telemetry" slice cucadmuh's plan called out for splitting core.rs's mixed runtime/platform/snapshot concerns. Other slices (cli-bridge, runtime-control, platform window/scrolling) can follow. app_api/core.rs: 235 → 122 LOC. lib.rs registration unchanged — performance_cpu_snapshot is re-exported through `pub(crate) use perf::*` in app_api/mod.rs.	2026-05-08 14:18:32 +02:00
Psychotoxical	3b5bd3f1cc	refactor(audio): lift spawn_progress_task into own module ... Move the per-generation progress + ended-detection task (~205 LOC) out of audio/commands.rs into audio/progress_task.rs. The task is now a sibling submodule that both audio_play (commands.rs) and audio_play_radio (radio_commands.rs) import as `super::progress_task::spawn_progress_task`, replacing the previous `super::commands::spawn_progress_task` cross-import that radio was using as a workaround. audio/commands.rs: 1185 → 977 LOC. Cleanup: dropped now-unused AtomicU32 and AudioCurrent imports from commands.rs. What's left in commands.rs is now just audio_play (~760 LOC) and audio_chain_preload (~195 LOC) — the playback orchestrator proper. Splitting those further is a bigger structural job than file moves.	2026-05-08 14:14:50 +02:00
Psychotoxical	e9421e58e3	refactor(audio): extract audio_preload into preload_commands ... Pull audio_preload (background fetch + analysis seed for the next track in the queue) out of audio/commands.rs into audio/preload_commands.rs (~67 LOC). It's a self-contained fetch-and-cache flow — distinct from audio_chain_preload (which constructs the gapless source chain) and audio_play (which starts playback) so it makes sense to live alongside them rather than inside the same file. audio/commands.rs: 1241 → 1185 LOC. lib.rs invoke_handler updated.	2026-05-08 14:05:34 +02:00