112 Commits

Include renames

Author	SHA1	Message	Date
topkoa	ab2e68a638	ci: resolve the allowlist baseline against the real base branch ... The allowlist-closed diff hardcoded `origin main`, but ship-ci.yml also runs this workflow for PRs into release/** and for pushes to release/**, where a main baseline diffs against the wrong branch and can fail changes that have nothing to do with the allowlist. It now resolves the base: PR -> github.event.pull_request.base.ref (the branch it merges into) push -> github.ref_name (the branch itself; its tip already contains the change, so the diff is a no-op — enforcement happens at PR time) Also from review, all documentation drift introduced by my own earlier commits: - The layer count said "three" in the module docstring, the workflow comment, the docs, and the changelog. There are four (allowlist-closed was added). - The changelog listed three scanned modules; there are five. - The docs and changelog stated the rule for keys core *reads*, omitting writes — which are equally gated, and land in every pack we emit. - The CI summary line labelled grandfathered keys "pending spec", implying adoption is the only resolution. For original_audio it is not: the fix is removal. Relabelled "grandfathered (tracked debt)". - feedpak-spec-exceptions.yml said an entry clears when core "stops reading" the key; the rule is "no longer reads or writes". - Replaced a bitwise `&` over two bools with two named results and an explicit `and` — both checks must run (a stale READERS list and an undeclared key are separate failures; short-circuiting would hide one), and `&` reads like a typo. Signed-off-by: topkoa <topkoa@gmail.com>	2026-07-13 00:32:24 -04:00
topkoa	32d723b774	ci: close the escape hatches — the FEP process is the only route ... The gate's purpose is to make a non-conforming change *not merge*, so the person merging must stop and decide whether to take it through the format process. The escape hatches defeated exactly that: a developer who did not want to write a FEP could name their key `x-whatever`, or append an entry to feedpak-spec-exceptions.yml with any issue link, and merge. Both were self-serve and in-repo. That is a speed bump with a signed excuse note, not a gate. The relief valve is the FEP process itself, not something in this repo. The spec's governance already says so: "A change is not part of the format until it lands here." Removed the `x-` prefix bypass. It was invented here, not in the spec — the spec reserves no experimental namespace. Its "unknown keys are reserved for forward-compatibility" rule is about *tolerating* other implementations' keys, not a licence for core to mint its own. feedpak-spec-exceptions.yml is now a CLOSED grandfather list. A new check (allowlist-closed) diffs it against the base branch and fails any PR that ADDS an entry; removal stays allowed, so the list can only shrink. Deleting an entry does not by itself pass the gate — key-coverage still fails while core reads the key, so the entry goes when the code goes. Every failure message now points at the FEP process and at bumping .feedpak-spec-ref to the merged spec SHA, which is the one supported way a new manifest key reaches core. CI fetches the base branch to diff the allowlist; the bootstrap flag covers the one case with no baseline — the PR introducing the gate. Signed-off-by: topkoa <topkoa@gmail.com>	2026-07-13 00:14:57 -04:00
topkoa	ceb1e143cd	ci: second review pass — recurse examples, reject duplicate exceptions ... Six more findings from CodeRabbit and Copilot on #934. All valid; four were my own docs lagging the write-checking change in d0626f5. check_forward() now discovers example packs recursively, so a pack nested under examples/<group>/ can't slip past the "every example pack" contract. Taken WITHOUT the suggested is_file() filter, which would have broken it: a feedpak is dual-form — a zip (foo.feedpak) or a directory (foo.feedpak/) — and the spec's own examples ship as directories, so is_file() would have matched zero packs. Suffix matching covers both forms. load_exceptions() rejects duplicate keys instead of silently keeping the last one, which would quietly retarget the tracking issue for a piece of debt this file exists to track. The sloppak import is wrapped so a missing dependency produces a CI-legible ::error:: rather than a bare traceback. Docs caught up with the code: the exceptions file header, its stale-entry rule, and the changelog all said "reads" when the gate checks reads AND writes. Signed-off-by: topkoa <topkoa@gmail.com>	2026-07-12 23:54:07 -04:00
topkoa	0dc9fd7ba8	docs: the fix for original_audio is removal, not adoption ... The spec already carries the pre-separation mixdown as a stem ({id: full, file: stems/full.ogg}), so the key added a second, redundant location for audio to a format that already had one. Adopting it into the spec would make that permanent; the resolution in #933 is to remove it. No behaviour change — the gate is agnostic about which way a violation resolves, and only insists that one of the two happens deliberately and in the open before the code merges. This just stops the exception entry, the changelog, and the docs from presupposing adoption. Signed-off-by: topkoa <topkoa@gmail.com>	2026-07-12 23:35:49 -04:00
topkoa	22332bef22	ci: gate core against the feedpak spec ... feedpak is published as an open format with its own repo, normative spec, JSON Schemas, and reference validator. That makes the spec a contract with everyone outside this repo: third-party packers, converters, and players build against it, and it is meant to be the complete description of a pack. Nothing enforced that. #583 added a manifest key (`original_audio`) that core, lib/enrichment.py, and the stems plugin all now depend on, but which was never added to the spec — so a spec-compliant pack stopped being a fully-working pack, the reference validator could not warn authors about a key it had never heard of, and third-party tooling began emitting an `original/` directory reverse-engineered from an example in a code comment. See #933. We cannot mechanically prove core interprets a key the way the spec means. We can prove three surface properties, and they cover the drift that actually happens: 1. key-coverage — every manifest key core reads is declared in the spec's manifest.schema.json (AST scan of lib/sloppak.py, lib/enrichment.py, lib/songmeta.py). 2. forward — core's load_song() ingests every example pack the spec ships. 3. reverse — every pack committed here passes the spec's own tools/validate.py (7/7 pass today). The spec is pinned by SHA in .feedpak-spec-ref rather than tracked from its default branch, so a change over there cannot redden an unrelated PR here; bump it in its own PR, where a red result is precisely the signal that core does not satisfy the new spec. A gate with no legitimate way to say "yes, deliberately, not yet" gets switched off the first time it blocks a release, so there are two escape hatches: the reserved `x-` key prefix (always permitted, and it tells every third-party packer the key is not stable surface), and feedpak-spec-exceptions.yml, which requires a tracking issue per entry. An exception that goes stale — the spec caught up, or core stopped reading the key — fails the build, so the allowlist cannot become somewhere drift quietly accumulates. `original_audio` is seeded there against #933 so the gate lands green and starts blocking the next instance immediately, rather than requiring #933 to be resolved first. Dev/CI tooling only; never on the serve or Docker path (constitution Principle I). jsonschema is installed in the CI job, not added to requirements.txt. Signed-off-by: topkoa <topkoa@gmail.com>	2026-07-12 23:30:45 -04:00
3 people	9d0bf95716	refactor(ui)!: remove the classic v2 shell — v3 is the only UI (R3a) (#871) ... * refactor(ui)!: remove the classic v2 shell — v3 is the only UI (R3a) Deletes `static/index.html`, the `/v2` route, and the `FEEDBACK_UI` v2/legacy opt-out. `/` and `/v3` both serve `static/v3/index.html`, which has been the default since 0.3.0. This is step 0 of the core-frontend ES-module migration (R3a). Both shells load the same `static/app.js`, so every later step of that migration — exposing the window contract, the `defer` ordering fix, the `type="module"` flips — would otherwise have to be made and verified twice. Removing the fallback now halves that surface before any of it is touched. Incidentally fixes a latent bug in `index()`: its guard read `if getenv_compat("FEEDBACK_UI") or getenv_compat("FEEDBACK_UI") in ("v2", "legacy")`, whose left operand is truthy for *any* non-empty value — so `FEEDBACK_UI=v3` actually served the **v2** shell. - `static/tailwind.min.css` regenerated: the content globs scanned the deleted file, so v2-only utility classes are now purged (CI's tailwind-fresh job rebuilds and diffs it). - Constitution amended to 1.3.0 — Principle II's frontend file list now names `static/v3/index.html`. - Tests: 4 suites read the v2 shell (3 via a constructed `path.join` that a literal grep misses). Their v2 halves are paired duplicates of v3 tests that stay, so they are dropped; `alpha_warning_banner` and the capability-registry script-order test retarget to `static/v3/index.html`. BREAKING CHANGE: `FEEDBACK_UI=v2` / `=legacy` and the `/v2` route are gone. Unset the variable and use `/`. No chart, settings, or plugin data changes, and no plugin API changes — v3 reuses the same engine. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs: drop the stale '/ is v2' plugin-verification guidance (CodeRabbit) The v3-only rewrite updated the intro paragraphs but left three lines that still instructed plugin authors to verify in 'both / (v2) and /v3' — now the same shell. Historical 'in v2 it was X' contrasts are kept: they still orient authors whose plugins also ship to users on older cores. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 16:33:03 +02:00
3 people	5e30138c87	refactor(server): extract the artist routes into routers/artist.py (R3) (#870) ... The artist page + external-links payload (/api/artist/{name}/page, /links, /links/refresh) plus their exclusive helpers (_artist_links_payload, _artist_links_from_mb, the URL-slot table) move to lib/routers/artist.py. Bodies verbatim except @app->@router and the seam reads (meta_db->appstate.meta_db, CONFIG_DIR->appstate.config_dir, _default_settings->appstate.default_settings). MB link enrichment is reached as enrichment.X; the URL-safety validator is imported from lib/library_registry.py. No new seams. server.py: 2,507 -> 2,413 (-94). Verified: pyflakes clean; route set unchanged (143); full pytest 2395 passed. eslint 0. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 15:49:37 +02:00
3 people	0547f55844	refactor(server): extract the media/file-serving routes into routers/media.py (R3) (#869) ... Song audio (/audio/{f}), the local-audio-path resolver (/api/audio-local-path), and raw sloppak-member serving (/api/sloppak/{f}/file/{rel}) — plus the shared _resolve_sloppak_local_file helper — move to lib/routers/media.py. Bodies verbatim except @app->@router and the cache/static path seams (AUDIO_CACHE_DIR-> appstate.audio_cache_dir, STATIC_DIR->appstate.static_dir, SLOPPAK_CACHE_DIR-> appstate.sloppak_cache_dir — all already in the seam). No new slots. The two test fixtures that redirect STATIC_DIR to a temp dir now also patch appstate.static_dir (the moved routes read the seam, not server's global). server.py: 2,638 -> 2,507 (-131). Verified: pyflakes clean; route set identical (143), all unique-path (no catch-all, no shadowing); full pytest 2395 passed (the audio-local-path + sloppak-file-traversal cases). eslint 0. Boot smoke: /audio, /api/sloppak/{}/file serve 404 for unknown, 0 tracebacks. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 15:36:22 +02:00
3 people	b7624b7e65	refactor(server): extract the enrichment route handlers into routers/enrichment.py (R3) (#868) ... The 14 /api/enrichment/* routes — status, kick/cancel, per-song state, the Match-Review queue (accept/reject/pick/search/rematch/refresh/states), and the AcoustID fingerprint identify endpoints — plus the route-exclusive candidate sanitizer move to lib/routers/enrichment.py. Bodies verbatim except @app->@router and the seam reads (meta_db->appstate.meta_db, CONFIG_DIR->appstate.config_dir). The enrichment engine (transport, matcher, worker, upload caps) already lives in lib/enrichment.py from the earlier subsystem move and is reached as enrichment.X. No new seams. server.py: 2,925 -> 2,638 (-287). Verified: pyflakes clean; route set identical (143); full pytest 2396 passed (the enrichment route + Match-Review + identify cases, which fake the network on the enrichment module). eslint 0. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 15:19:34 +02:00
3 people	f09c4a217f	refactor(server): extract library + collections routes + the provider registry (R3) (#866) ... The library query surface (songs/albums/artists/stats/genres/tuning-names/ practice-suggestions), the provider list/art/sync endpoints, and collection CRUD move to lib/routers/library.py. The registry itself — LibraryProviderRegistry, LocalLibraryProvider, SmartCollectionProvider, the collection-provider lifecycle (_sync/_unregister_collection_provider), and the shared query/collection helpers (_library_filter_args, _split_csv, _sanitize_collection_rules, _safe_art_redirect_url, the filter-key sets) — moves to lib/library_registry.py. The PLUGIN CONTRACT is untouched: server.py still constructs the singleton (LocalLibraryProvider needs meta_db), still exposes register_library_provider / unregister_library_provider to plugins via plugin_context (with the per-plugin ownership scoping in plugins/__init__.py), and injects the registry + local provider into appstate. The router reads appstate.library_providers / appstate.local_library_provider at call time; the provider classes are duck-typed so no plugin imports a base class. Acyclic: library_registry imports routers.art (for LocalLibraryProvider.get_art) + appstate, never server. server.py: 3,692 -> 2,925 (-767). Verified: pyflakes clean; ORDERED route table identical set (library block mounts at one site — all exact/specific-path, no catch-all, no shadowing); full pytest 2397 passed (incl the plugin register/unregister + collection-as-provider tests). eslint 0. Boot smoke: /api/library + providers list "local"; a created collection surfaces as a `collection:N` provider through the seam; collection CRUD clean. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 14:56:12 +02:00
3 people	bbdff4e10f	refactor(server): extract the song routes into routers/song.py (R3) (#864) ... Upload/delete, the catalog-metadata write-back, user-meta, overrides, gap-fill, and the per-song info payload (11 routes) move to lib/routers/song.py with their exclusive helpers (the atomic upload commit + the song-IO lock, the upload caps, the gap-fill proposal builders). Bodies verbatim except @app->@router and the seam reads: meta_db->appstate.meta_db, art_override_paths->appstate.art_override_paths, and the scan/ingest helpers that stay in server.py (the scan lifecycle owns them) -> new appstate seam callables: kick_scan, invalidate_song_caches, stat_for_cache, and scan_status() (a getter — the underlying dict is reassigned). The gap-fill MBID/ISRC regexes are reached as enrichment.X; _MULTIPART_OVERHEAD_SLACK (shared with the staying AcoustID-identify route) moves to lib/enrichment.py beside _ACOUSTID_MAX_UPLOAD_BYTES. ROUTE ORDER: song_router mounts AFTER art_router — get_song_info's catch-all `/api/song/{filename:path}` would otherwise shadow `/api/song/{path}/art*` (Starlette matches first-registered; the :path converter is greedy). server.py: 4,478 -> 3,692 (-786). Verified: pyflakes clean; ORDERED route table preserves the specific-before-catch-all invariant; full pytest 2397 passed (incl the art/cover 304 + CAA-fetch tests that caught the shadowing before it was fixed). eslint 0. BEHAVIORAL — needs an on-device pass (upload a sloppak, edit metadata write-back, delete a song) before merge. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 13:14:52 +02:00
3 people	7258e1066a	refactor(server): extract the settings routes into routers/settings.py (R3) (#863) ... GET/POST /api/settings, /api/settings/reset, and the two-phase atomic export/import bundle (/api/settings/export|import) move to lib/routers/settings.py with their exclusive helpers (the relpath allowlist validator, the atomic writer, the library-DB snapshot + sqlite integrity gate, the config-type validator, the bundle schema). Bodies verbatim except @app->@router and the seam reads: meta_db->appstate.meta_db, CONFIG_DIR->appstate.config_dir, _running_version->appstate.running_version(), and _default_settings-> appstate.default_settings (the canonical defaults builder stays in server.py — the scan + artist-links code share it — and is injected as a new seam callable). server.py: 5,539 -> 4,478 (-1,061). Verified: pyflakes clean (bar the pre-existing File/safe_join/tuning_name/ET); route table IDENTICAL (143); full pytest 2397 passed (154 settings cases incl the export→import round-trip + library-DB snapshot/restore + relpath-allowlist SSRF/ traversal guards, retargeted onto the settings module). eslint 0. BEHAVIORAL — needs an on-device settings export→import round-trip sign-off before merge (do not merge on green CI alone). Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 12:35:05 +02:00
3 people	73127d5416	refactor(server): extract the album-art routes into routers/art.py (R3) (#862) ... The six song-art routes — GET /api/song/{f}/art, .../art/cover-search, .../art/candidates, POST .../art/upload, .../art/url, DELETE /api/art/{f}/override — plus their exclusive helpers (the ETag/304 response machinery, _save_art_override, _url_host_is_internal, _fetch_art_url + the art size/redirect caps) move to lib/routers/art.py. Bodies verbatim except @app->@router and the seam reads: meta_db->appstate.meta_db, ART_CACHE_DIR->appstate.art_cache_dir, and the three shared art helpers that stay in server.py (used by the song/delete routes too) -> appstate.<callable> (_song_pack_art_exists, _art_override_paths — already seam-injected for the enrichment worker — plus a new art_safe_name slot). The CAA / release-search transport lives in lib/enrichment.py and is reached as enrichment.X. LocalLibraryProvider.get_art now calls art_router.get_song_art. server.py: 5,988 -> 5,540 (-448). Verified: pyflakes clean (bar the pre-existing File/safe_join/tuning_name/ET); route table IDENTICAL (143); full pytest 2399 passed (33 art serve/candidates/ override/url cases incl the SSRF-guard _url_host_is_internal + _fetch_art_url size-cap tests, retargeted onto the art module); test_packaging 43; eslint 0. Boot smoke: /art 404, /art/candidates 404, DELETE /override 200 from the router. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 11:56:53 +02:00
3 people	165475d115	refactor(server): move the metadata-enrichment subsystem into lib/enrichment.py (R3) (#861) ... * refactor(server): move the metadata-enrichment subsystem into lib/enrichment.py (R3) MusicBrainz / Cover-Art-Archive / AcoustID transport, the match-scorer glue, and the background enrichment worker (~930 lines, 61 defs) leave server.py as one cohesive unit. Bodies are verbatim; the only changes are seam reads: meta_db / config_dir / sloppak_cache_dir / art_cache_dir -> appstate.<slot> _song_pack_art_exists / _art_override_paths (stay in server.py for the art + delete routes) -> appstate.<callable> (new seam slots, injected by reference) _env_flag -> env_compat.env_flag_compat (the existing identical helper) _artist_title_from_filename -> imported from metadata_db (its home) the User-Agent VERSION lookup: Path(__file__).parent -> Path(__file__).resolve().parents[1] (lib/enrichment.py -> app root) server.py drives the worker through the module (import enrichment; the routes + scan lifecycle call enrichment.X). Tests that faked the network on `server` (_mb_http_get, _enrich_network_enabled, _caa_http_get, ...) now patch the same names on `enrichment` — the module attribute is resolved at call time, so one setattr reaches both the routes and the worker's internal callers. Acyclic: enrichment imports appstate/appconfig/dlc_paths/metadata_db/mb_match/ acoustid_match/sloppak/loosefolder, never server. server.py: 6,917 -> 5,988 (-929). Verified: pyflakes clean (bar the pre-existing File/safe_join/tuning_name/ET); route table IDENTICAL (143); full pytest 2400 passed (140 enrichment/art cases incl the offline-safety + transport-error-pauses-pass contracts that fake the network); test_packaging 44 passed (enrichment.py resolves under lib/); eslint 0. Boot smoke: /api/enrichment/status + POST /kick serve from the new module. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test: reset enrichment worker state between tests (CodeRabbit) lib/enrichment.py now owns the worker, and it stays imported for the whole session while the `server` fixtures pop-and-reimport `server` — so the cancel Event / status dict / caches would leak across tests, and a stale `_enrich_cancel` could short-circuit a later direct `_background_enrich()`. An autouse conftest fixture clears that process-global state before each test. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test: tighten the enrichment-reset fixture (CodeRabbit) Narrow the import guard to ImportError (not blind Exception, BLE001), and stop clearing _caa_index_locks — it's guarded by _caa_index_locks_guard, so an unlocked clear() would race a still-alive worker, and its per-release mutexes carry no test state. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 11:32:21 +02:00
3 people	508829c012	refactor(server): extract /api/tunings into routers/tunings.py + lib/appconfig.py (R3) (#858) ... The merged-tuning-catalog route moves to lib/routers/tunings.py, verbatim except @app->@router, CONFIG_DIR->appstate.config_dir, and the two seam substrates it needed: - lib/appconfig.py — the pure config.json reader `_load_config` (used by ~11 server sites + future config-reading routers). server.py re-imports it, so those call sites and any `server._load_config` test reference are unchanged. - appstate.tuning_providers — the TuningProviderRegistry instance injected by reference (a stable object mutated in place via register()/unregister()), so the router reads the same registry plugins populate through plugin_context. The instance stays defined in server.py, so `server.tuning_providers` still resolves — zero test retargets. The tuning constants (DEFAULT_REFERENCE_PITCH, TUNING_PRESET_MIDIS, freqs_to_midis) already live in lib/tunings.py and are imported directly. server.py: 6,960 -> 6,917. Verified: pyflakes clean (bar the pre-existing unused `tuning_name` import); route table IDENTICAL (143); full pytest 2400 passed (110 tuning/config cases); eslint 0. Boot smoke: /api/tunings serves referencePitch + tunings + tuningMidis. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 01:43:19 +02:00
3 people	cce95cbd1e	refactor(server): extract the diagnostics routes into routers/diagnostics.py (R3) (#857) ... The three /api/diagnostics/* routes (export, preview, hardware) plus their exclusive payload-cap helpers and the `_diag_*` normalisers. Bodies verbatim except @app->@router, CONFIG_DIR->appstate.config_dir, _running_version()-> appstate.running_version() (a new seam slot; the impl stays in server.py where the settings region also calls it), and the builtin-plugins lookup in _diag_plugins_roots: Path(__file__).parent -> Path(__file__).resolve().parents[2] (routers -> lib -> app root; plugins/ ships at the app root in every packaging path). The pure caps/normalisers (_diag_cap_console/_dict/_contributions, _diag_coerce_bool, _diag_normalize_include, _DIAG_MAX_*) are re-exported from server.py so the existing `server._diag_*` / `server._DIAG_*` tests keep resolving — none of them monkeypatch these, so no test retargets. server.py: 7,216 -> 6,960. Verified: pyflakes clean (bar the intentional re-export lines); route table IDENTICAL (143); full pytest 2399 passed (77 diag/packaging + 122 diagnostic- matched cases incl the cap/coerce/normalize suites); eslint 0; Codex pending. Boot smoke: /hardware, /preview, and POST /export (200 application/zip) all serve from the new router location. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-11 01:27:52 +02:00
3 people	b6098e3695	perf(harness): add 2D-highway frame-time measurement + capture the R3c gate (H0) (#848) ... * perf(harness): add 2D-highway frame-time measurement + capture the R3c gate (H0) scripts/perf-baseline.mjs gains a `--song` mode: it wraps requestAnimationFrame before any page script, TAGS the frames the highway actually painted (via highway.addDrawHook), starts playback, and reports draw-frame p50/p95/p99 over `--frames` seconds across `--runs` runs. Tagging is the point — ~half the rAF callbacks are other cheap loops (~0.1 ms); averaging them in would hide a renderer regression, so only draw frames are counted. This is the metric the plan says gates the highway.js split (R3c) but the harness never measured (it did server latency + boot + heap only, and the R0 numbers were against an empty library). docs/perf-baseline.md now records the pre-lift baseline on the Arcturus feedpak: p50 ~2.2 ms, p95 spread 2.7-3.2 ms across 3 runs. The H-container lift (next) re-runs this on the same box and must stay within noise. Maintainer/CI-only tooling; the existing no-`--song` run is unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * perf(harness): close page on error + MD040 fence + CHANGELOG (CodeRabbit) - frameTimeOnce now closes its page in a finally, so a failing run doesn't leak the page until the final browser.close() (CodeRabbit). - fenced code block gets a bash language hint (MD040). - CHANGELOG mentions the new --song frame-time mode. --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 23:15:07 +02:00
3 people	7c87538d6b	refactor(server): extract the chart routes into routers/chart.py (R3) (#846) ... Unblocked by the DLC-path substrate (#843): chart's only server-module deps are now app + meta_db (both seam); _get_dlc_dir/_resolve_dlc_path come from dlc_paths, sloppak/loose detection from the shared lib modules. 4 routes (split/unsplit/ work/fileinfo), meta_db-only otherwise. 0 setattr targets, 0 helpers to relocate. Bodies verbatim; @app -> @router, meta_db -> appstate.meta_db. include_router at the original site; 143-route table identical to origin/main. No test retargeting. server.py: 8,003 -> 7,909. Verified: pyflakes clean on the router; no new undefined/dead in server.py; route table identical; pytest 2401 passed (74 across work_charts/context_menu/ group_filter/packaging); eslint 0. Boot smoke: chart/work 200, chart/fileinfo resolves the real pack path through _resolve_dlc_path. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 22:15:25 +02:00
3 people	514461167e	refactor(server): extract the highway WebSocket into routers/ws_highway.py (R3) (#844) ... The single largest handler in server.py — the 902-line /ws/highway/{filename} chart streamer — plus its 3 exclusive helpers (_pick_smart_arrangement, _sanitize_authors, _sanitized_song_offset). server.py: 9,008 -> 8,003 (-1,005, the biggest single R3 cut). Clean move despite the size: the handler's only server-module deps are the 4 path constants + 3 exclusive helpers + app + log. Everything else it uses is either NESTED inside the handler (_evict_audio_cache, _fill_scale_degree, _manifest_entries, _tone_names, _xml_rank, _send_keepalives) or imported from the shared lib modules (song/audio/sloppak/drums/notation/dlc_paths/metadata_db). - Path constants read through the appstate seam: added static_dir / sloppak_cache_dir / audio_cache_dir slots (config_dir already there); server.py configures them. Bodies otherwise verbatim (@app.websocket -> @router.websocket, PATHS -> appstate.*, log -> module logger). - sloppak_cache_dir IS setattr-patched, so the 3 test_highway_ws_* suites now also `setattr(appstate, "sloppak_cache_dir", ...)` next to their existing server patch. _sanitize_authors unit tests import it from routers.ws_highway (it moved). No other test churn. - Removed 23 now-dead imports from server.py (song/audio/drums/notation/ bisect/contextvars/structlog/WebSocket*/_arr_smart_sort_key) — diffed against the origin/main unused-import baseline so only NEWLY-dead ones went. owns_tmp (assigned, never read) moved verbatim — it's pre-existing dead on origin/main too; left as-is to keep the move faithful. Verified: route table identical to origin/main (143, paths/methods/order); handler body verbatim spot-checked; pyflakes clean (server has no new undefined/dead); pytest 2400 passed; packaging guard 53; eslint 0. Boot smoke: the highway WS streams the full chart (song_info/beats/sections/notes/chords/ notation/anchors/drum_tab -> ready) BYTE-for-byte the same message sequence as origin/main across arrangements 0/1/2, zero tracebacks. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 21:12:54 +02:00
3 people	0dcc9136b6	refactor(server): move DLC path resolution to lib/dlc_paths.py (R3 substrate) (#843) ... The keystone for the path-dependent routers (ws_highway, song, audio-local-path, sloppak): the "where do the song files live + safe containment" layer leaves server.py so a router can reach it. - `_resolve_dlc_path` (pure — args only) moves verbatim. - `_get_dlc_dir` reads the env-derived paths through the appstate seam (appstate.dlc_dir/dlc_dir_env/config_dir) instead of module globals, so lib/dlc_paths.py does no import-time IO. - appstate gains `dlc_dir`/`dlc_dir_env` slots (config_dir already there); server.py configures them. All three are env-derived, so a setenv+reimport fixture reconfigures them for free — ZERO setattr retargeting. - server.py RE-EXPORTS both (`from dlc_paths import _get_dlc_dir, _resolve_dlc_path`), so its 24+16 call sites AND the tests that reach `server._get_dlc_dir()` / `server._resolve_dlc_path()` directly (test_dlc_junction, test_highway_ws_*) resolve unchanged — no test edits. server.py: 9,085 -> 9,008. Verified: _resolve_dlc_path byte-identical to origin/main; _get_dlc_dir's only change is the three path identifiers -> appstate.*; pyflakes clean; route table identical (143); pytest 2407 passed (test_dlc_junction + both highway_ws suites green via re-export); packaging guard 52; eslint 0. Boot smoke: library scans (8 songs, _get_dlc_dir), a real song resolves + serves art (_resolve_dlc_path), and the highway WS reaches `ready` with notes. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 20:41:42 +02:00
3 people	a883f9213f	refactor(server): extract the playlists routes into routers/playlists.py (R3) (#841) ... The biggest router yet — 12 playlist routes + custom covers — and the first that needs the config-path seam. server.py: 9,302 -> 9,085 (-217). Three causally-linked pieces, all required for playlists: - `config_dir` joins the appstate seam (the plan always put the path constants there; deferred in S3, needed now). It's env-derived, so the ~49 pop-and-reimport fixtures reconfigure it for free — ZERO setattr retargeting. STATIC_DIR/SLOPPAK_CACHE_DIR (patched via setattr) stay in server.py until a router that reads them is extracted, and get retargeted then. - `_clean_str` (pure request-field sanitizer, 14 callers) -> lib/reqfields.py; server.py imports it back. Unblocks wanted/saved/collections/profile/... later. - routers/playlists.py: bodies verbatim, `@app`->`@router`, `meta_db`-> `appstate.meta_db`, `CONFIG_DIR`->`appstate.config_dir`, `_clean_str` from reqfields, `_ART_CACHE_HEADERS` as a local const (art keeps server.py's). The two exclusive cover helpers (_playlist_cover_path/_url) move with it. include_router at the original site; full 143-route table identical to origin/main. One test retarget: test_playlists_api called `server._playlist_cover_path` directly -> now imports it from routers.playlists (reads appstate.config_dir, which the `server` fixture configures). Verified: pyflakes clean; route table identical; pytest 2401 passed (28 in playlists+collections+appstate); packaging guard 51 (auto-picked up reqfields); eslint 0; boot smoke drives create/rename/add-song/cover-upload/serve/delete — the cover writes 1.png under CONFIG_DIR THROUGH appstate.config_dir and serves 200 with an mtime cache-bust token; a wrong-typed name field still 400s via _clean_str; demo untouched. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 19:58:09 +02:00
3 people	b41361eb1b	refactor(server): extract the loops routes into routers/loops.py (R3) (#839) ... Third router. Practice loops (saved A/B regions per song): GET/POST/DELETE /api/loops, meta_db-only (0 setattr targets, 0 helpers to relocate per router_scan.py). Bodies verbatim; @app -> @router, meta_db -> appstate.meta_db. include_router at the original site; 143-route table identical to origin/main. server.py: 9,337 -> 9,301. No test retargeting (test_demo_mode only names the paths in middleware regexes). Verified: pyflakes clean; route table identical; pytest 2398 passed; packaging guard green; eslint 0; boot smoke drives POST (auto-names "Loop N") / GET / DELETE / missing-fields error, and demo mode 403s both writes while allowing the read. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 19:05:01 +02:00
3 people	6c98aba433	refactor(server): extract the artist-alias routes into routers/artist_aliases.py (R3) (#838) ... * refactor(server): extract the artist-alias routes into routers/artist_aliases.py (R3) Second router, picked by router_scan.py: the artist-aliases / Tidy-up (P4) group ranks at 0 monkeypatch.setattr targets and 0 helpers to relocate. 5 routes (list/set/merge/delete aliases + raw-artist picker), all meta_db-only. Bodies verbatim; only @app.<m> -> @router.<m> and meta_db -> appstate.meta_db. include_router mounts at the original site; full 143-route table identical to origin/main (paths, methods, order). No test retargets: test_artist_alias drives via TestClient(server.app) + server.meta_db, neither of which moved. Verified: pyflakes clean on the router; no new undefined in server.py; JSONResponse still used in server.py (not dead); pytest 2398 passed (18 in test_artist_alias); packaging guard green; eslint 0; boot smoke drives all 5 routes end-to-end (set ACDC->AC/DC, read back, 400 on missing fields, delete). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs: credit both router extractions in the size-exemptions rationale (CodeRabbit) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 18:55:03 +02:00
3 people	b3215694e7	fix(build): move appstate.py + routers/ under lib/ so the desktop app ships them (#836) ... The packaged desktop app died at startup: File ".../Resources/slopsmith/server.py", line 71, in <module> import appstate ModuleNotFoundError: No module named 'appstate' feedback-desktop's scripts/bundle-slopsmith.sh copies a HARDCODED list of core files into the bundle -- server.py, VERSION, lib/, data/, static/, plugins/__init__.py. The root-level appstate.py (#833) and routers/ (#834) shipped fine in Docker, passed every test, and were silently dropped from the packaged app. Both now live under lib/, the one core directory every packaging path already copies wholesale -- Dockerfile `COPY lib/`, docker-compose.yml, and the desktop bundler's `cp -r lib` -- and that all three put on sys.path (on Windows via the embeddable-Python ._pth, where PYTHONPATH is ignored: build-windows.sh writes `../slopsmith` and `../slopsmith/lib`). No feedback-desktop change and no new release are needed for this to take effect. lib/ is also the CORRECT home under Principle V, and always was once the design settled: with the injection seam, appstate.py constructs nothing and does no import-time IO, and a route module only builds an APIRouter. The premise that forced root placement -- "appstate opens sqlite at import" -- stopped being true when configure() replaced ownership. The Dockerfile / .dockerignore / docker-compose.yml entries added for the root layout are reverted; nothing else in core changes (git mv, so --follow survives). tests/test_packaging.py is the guard: it walks server.py's module-level imports, keeps the ones resolving inside this repo, and fails if any lives outside a directory the packagers copy -- with the ModuleNotFoundError spelled out. So the next root-level core module can't ship broken. Negative-checked: restoring appstate.py to the root fails it; the message names the file and the four packaging files a root module would have to teach. (It also has to skip `origin in {"built-in","frozen"}` -- on 3.14 the frozen stdlib reports origin="frozen", and Path("frozen").resolve() lands inside the repo, which flagged `os` and `stat` as first-party.) Verified: the bundler's copy replicated exactly into a temp dir and booted with PYTHONPATH=<bundle>:<bundle>/lib -- `import server`, `import appstate`, `import routers.audio_effects` all resolve, appstate.meta_db is server.meta_db, 143 routes. The same simulation against origin/main reproduces the production ModuleNotFoundError. pytest 2398 passed (2348 + 50 new); route table still identical to origin/main (paths, methods, order); docker build context reaches lib/appstate.py and lib/routers/ with no __pycache__; native uvicorn boot smoke serves /api/version, /api/library, the moved audio-effects router, and all three migrated plugins' src/ graphs; eslint 0 errors. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 17:16:34 +02:00
3 people	ebe59d3f97	refactor(server): extract the audio-effects routes into routers/audio_effects.py (R3) (#834) ... The first route module through the appstate seam (#833). Picked BY MEASUREMENT, not by the plan's guess: a transitive dep-closure scan over every route group ranked audio-effects at 0 monkeypatch.setattr targets and exactly one exclusive helper. (The same scan disproved the plan's assumption that artists/aliases was free -- api_artist_links reaches _mb_http_get and _enrich_network_enabled, both setattr targets.) Bodies are verbatim. The only edits are mechanical: @app.get(...) -> @router.get(...) audio_effect_mappings.x -> appstate.audio_effect_mappings.x The singleton read must stay a module attribute resolved at call time, so a re-imported server re-publishes a fresh DB into the seam and monkeypatch reaches this module. `routers/` never imports `server`: server -> routers -> appstate. `app.include_router(...)` sits exactly where the routes used to be defined -- FastAPI matches in registration order, so the mount site preserves it. Verified by diffing the FULL route table against origin/main: 143 routes, identical paths, methods AND order. server.py: 9,445 -> 9,386 lines. `fastapi.Query` went dead with the move and was removed (the other four unused imports are pre-existing on main). Packaging: COPY routers/ /app/routers/ plus `!routers/` + `!routers/**` in .dockerignore (that file opens with a blanket `*`). Verified against the real docker daemon: routers/ reaches the build context, __pycache__ does not. Verified: pyflakes clean on routers/; no new undefined name in server.py; pytest 2348 passed (75 in the audio-effects + demo-mode suites); eslint 0 errors; boot smoke drives all five routes end-to-end (create -> read back -> activate -> clear -> delete -> 404 on missing -> 400 on bad body), Query(...) still 422s on a missing required param, and demo mode still 403s all four moved write routes while allowing the read. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 15:24:31 +02:00
3 people	d6f2df14f7	feat(server): add appstate.py, the router seam (R3) (#833) ... * feat(server): add appstate.py, the router seam (R3) Routes moving out of server.py need `meta_db` and friends, but must not `import server` -- that goes circular the moment server imports them back. server.py keeps CONSTRUCTING its singletons and now injects them once via `appstate.configure(...)`; routers read them back as module attributes at call time (`import appstate; appstate.meta_db`). The Python analogue of the frontend refactor's `configureX({...})` seams and of the plugin `setup(app, context)` contract: dependencies flow one way, server -> routers -> appstate. Two properties are load-bearing, both pinned by tests/test_appstate.py: 1. `import appstate` constructs nothing and touches no disk. This is why the ~49 test fixtures that `sys.modules.pop("server")` + re-import (to rebuild meta_db under a patched CONFIG_DIR) keep working UNTOUCHED. A singleton owned by appstate would survive that pop and go stale -- verified. 2. Reads must be late-bound. `from appstate import meta_db` freezes the binding and defeats both a later configure() and monkeypatch.setattr -- the same read-only-binding trap as ES imports. configure() raises on an unknown slot instead of silently creating a global nothing reads, and the suite asserts server ACTUALLY calls it. Negative-checked: dropping the configure() call fails exactly the two wiring tests while the other five stay green -- those five are the false-green a seam test must not be. The new suite imports server through an `isolated_server` fixture that patches CONFIG_DIR to tmp_path and closes both DB connections on teardown. An unguarded `import server` constructs MetadataDB + AudioEffectsMappingDB under the real `~/.local/share/feedback` (reproduced: running the file alone created web_library.db + audio_effects.db there). The full suite now leaves the real config dir untouched. Packaging: `COPY appstate.py /app/` plus a .dockerignore allowlist entry. That file opens with a blanket `*` exclusion, so root-level Python must be re-allowed explicitly -- without it the image build fails on the COPY. Verified against the real docker daemon (build context reaches /app/appstate.py). docker-compose.yml gains the dev bind-mount; docker-compose.nas.yml runs the baked image, so the COPY covers it. `routers/` will need the same two entries when it lands. Verified: pyflakes clean; pytest 2348 passed (2341 + 7 new); eslint 0 errors; boot smoke serves /api/version, /api/library, /api/audio-effects/mappings, and all three migrated plugins' src/ graphs, with `appstate.meta_db is server.meta_db` asserted against the live import. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test(appstate): address CodeRabbit — restore slots on teardown, really re-import Two real findings on #833, both fixed: (1) `isolated_server` closed server's DB connections but left `appstate.meta_db` and `appstate.audio_effect_mappings` published and pointing at the closed handles -- a live-looking, dead singleton for any later test. Teardown now snapshots and restores both slots. (2) `test_reimporting_server_republishes_the_fresh_singletons` never performed a second import: it only re-asserted what `test_server_wires_the_seam` already covers, so it could not detect the very staleness it names. (I introduced that regression while fixing Codex's CONFIG_DIR isolation finding.) It now pops `server`, re-imports under a SECOND CONFIG_DIR, and asserts the seam republishes -- `second_server.meta_db is not first_db` and `appstate.meta_db is second_server.meta_db`. Negative-checked both directions: simulating an appstate-OWNED singleton (configure() only-first-wins) now fails the re-import test, and dropping server's configure() call still fails exactly the two wiring tests. NB CodeRabbit's committable suggestion inserted the snapshot above the fixture docstring, which would have demoted it from __doc__; written by hand instead. pytest 2348 passed; the full suite leaves the real ~/.local/share/feedback untouched. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 15:06:22 +02:00
3 people	94a58b7a42	refactor(server): extract AudioEffectsMappingDB into lib/audio_effects_db.py (R3) (#831) ... Move-only, same shape as the MetadataDB extraction. The core-owned song/tone -> audio-effect-provider routing index leaves server.py for a flat lib/ module. The class body is byte-identical; server.py reconstructs exactly from origin/main minus the cut range plus the import-back and the call site. server.py: 9,705 -> 9,433 lines. The only non-verbatim change is the constructor seam: `__init__` takes `config_dir` instead of reading the module-level CONFIG_DIR, so the module does no IO at import (Principle V). The `audio_effect_mappings` singleton stays in server.py -- no route, no test, and none of the `monkeypatch.setattr(server, ...)` targets move. No import went dead. Verified: pyflakes clean on the new module; no new undefined name in server.py; pytest 2341 passed; eslint 0 errors; boot smoke drives the extracted DB end-to-end (POST a mapping -> GET reads it back -> audio_effects.db lands in CONFIG_DIR, proving the config_dir seam) and all three migrated plugins still serve their src/ module graphs. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 14:30:05 +02:00
3 people	58120745bc	refactor(server): extract MetadataDB into lib/metadata_db.py (R3) (#830) ... Move-only. The library metadata cache -- the `MetadataDB` class (4,018 lines) plus the query helpers it owns (keyset paging cursors, the tuning grouping key, smart-arrangement naming, tag normalisation, the startup DB-restore swap) -- moves out of server.py into a flat `lib/` module. Every moved block is byte-identical to its server.py original; server.py is exactly origin/main minus the six cut ranges, minus the now-dead `import contextlib`, plus the import-back block and the constructor call site. server.py: 14,037 -> 9,705 lines. The one non-verbatim change is the seam that lets the class leave server.py: `MetadataDB.__init__` now takes `config_dir` explicitly instead of reading the module-level CONFIG_DIR, so `lib/metadata_db.py` does no IO at import (Principle V). The `meta_db` singleton stays in server.py, so `server.meta_db` (282 refs) and `server.app` (67 refs) resolve unchanged and no route moves. None of the 114 `monkeypatch.setattr(server, ...)` targets moved. Logging still goes through the `feedBack.server` logger, so log filters and caplog assertions resolve to the same logger object. `tests/test_settings_export_library_db.py` imports `_apply_pending_db_restore` from metadata_db (the test moves with its subject); no other test changed. Verified: pyflakes clean on the new module (zero undefined names, zero unused imports) and no new undefined name in server.py; pytest 2341 passed; node --test 1030 passed; eslint 0 errors; uvicorn boot smoke serves /api/version, /api/library, and all three migrated plugins' src/ module graphs (stems, studio, editor -> 200). Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-10 14:18:59 +02:00
Byron GamatosandGitHub	950e348357	R0: module-migration rails (src/ serving, live-edit cache, scriptType loading, governance) (#812) ... Host enablement for the plugin ES-module migration: sandboxed /api/plugins/{id}/src/ serving, no-cache+weak-ETag/304 live-edit caching on src/+screen.js+assets, scriptType:module loader injection + scriptType/minHost manifest passthrough; constitution v1.2.0 + module playbook + signed size-exemptions register + maintainer/CI-only ESLint gate; rerunnable perf-baseline harness. Reviewed by Codex (local), Copilot, and CodeRabbit.	2026-07-08 10:14:40 +02:00
3 people	a18a818e8b	fix(playback): throttle legacy bridge-hit recording; emit loop-set for manual A/B (#811) ... * fix(playback): throttle legacy bridge-hit recording; emit loop-set for manual A/B window.feedBack.getLoop() is a read surface plugins legitimately poll (note_detect HUD ticked it at ~30 Hz), but every call recorded a playback.loop-api bridge hit: compat-shim bookkeeping, a playback:bridge-hit event, and a diagnostics snapshot rebuild + stringify per call — real main-thread cost and a saturated hitCount in the capability inspector, even with no song playing. - _recordPlaybackBridge now throttles per bridgeId|surface (5 s window). Bridge hits are a 'surface still in use' signal, not a call counter. - setLoopEnd() (manual A/B buttons) now emits the same loop-set transport event as setLoop(), so event-driven consumers no longer need to poll getLoop() to see button-armed loops. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(changelog): note loop-api bridge throttle fix Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-08 00:00:58 +02:00
5 people	5cb4ea0623	feat(drums): capture velocities alongside times in unmapped-percussion reporting (#808) ... * feat(drums): capture velocities alongside times in unmapped-percussion reporting Both drum converters opt-in out_unmapped capture (convert_drum_track_from_midi, convert_drum_track_to_drumtab) gain an index-aligned `velocities` list next to `times`, carrying each dropped note real dynamics — MIDI velocity verbatim; GP velocity with the same 1-127 gate as mapped hits, falling back to the 100 import default. A hand-mapping UI (the editor unmapped-notes dialog) can then restore mapped notes at their source dynamics instead of flattening to v:100 (editor-side consumer: feedBack-plugin-editor#111). The GP path chronological sort now reorders times and velocities in LOCKSTEP so multi-voice measures cannot silently reassign dynamics. Additive: callers that ignore the new key are unaffected. Tests: extended tests/test_midi_import_drums.py + tests/test_gp2rs_drums.py (alignment, lockstep sort, out-of-range fallback) — 26 passing. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JEoFeTPSnz4NpwwCG52hnu * docs(gp2rs): clarify velocity-default comment, mark dead-path fallback - The mapped-GP velocity comment conflated GP's authoring default (95, Velocities.default) with the drumtab render default (100, DEFAULT_VELOCITY in lib/drums.py) used when `v` is omitted. Clarify both defaults and that only the latter applies to omitted hits. - Mark the `else: times.sort()` fallback in the unmapped-percussion time/velocity sort as belt-and-suspenders — times and velocities are always appended together under the same len<100 guard, so lengths can't actually diverge. No behavior change; comment-only maintainability nits from PR review. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: ChrisBeWithYou <chris@rifflarr.local> Co-authored-by: Claude Fable 5 <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-07 23:58:49 +02:00
4 people	fadaa154e9	feat(library): sort and badge by personal difficulty rating (#810) ... * feat(library): sort and badge by personal difficulty rating Adds sort=difficulty/difficulty-desc to the library API (correlated subquery over song_user_meta.user_difficulty, unrated songs pushed to the bottom either direction, same pattern as the existing mastery sort) and surfaces the rating as a badge on library cards in both the v2 grid/tree views and the v3 grid. The rating itself already existed (song_user_meta) — this just makes it sortable and visible, so it's no longer only readable in the per-song edit drawer. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * fix(library): escape difficulty badge, wire tree view, add changelog+tests - Wrap song.user_difficulty in esc() at both badge call sites (static/app.js ~2082 and ~2283) for XSS-consistency with the sibling tuning badge, which already uses esc(). - server.py: query_artists (the classic tree view's data source, used by /api/library/artists) never batch-attached user_difficulty the way query_page does for the grid, so the tree-view difficulty badge added in 75673c3 was unreachable dead code (song.user_difficulty was always undefined there). Now attaches it via the existing user_meta_map() helper, same pattern as query_page. - Add an [Unreleased] CHANGELOG.md entry for the difficulty sort + badge feature, matching the repo's existing entry format. - Add tests/test_library_filters.py::test_difficulty_sort_pushes_unrated_to_bottom asserting unrated songs sort to the bottom in both sort=difficulty and sort=difficulty-desc directions, and ::test_tree_view_songs_carry_user_difficulty covering the query_artists fix above. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(library): chunk user_meta_map + rebuild stale tailwind css Address review-bot findings on the difficulty sort/badge: - user_meta_map now chunks filenames into 400-row batches (like overrides_map) before the IN (...) query. query_artists (tree view) passes every song across up to 50 artists, which could push the placeholder count past SQLite's older variable limit; query_page's small pages are unaffected. (CodeRabbit: Stability & Availability) - Rebuild static/tailwind.min.css: the ◆N difficulty badge introduced bg-blue-900/30 + text-blue-300, which were never compiled into the committed stylesheet, failing the tailwind-fresh CI gate. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-07 23:57:20 +02:00
5 people	e446b05a99	feat(keys_highway_3d): key layout modes, lane-color opacity & octave lines (#803) ... * feat(keys_highway_3d): sharp-layout modes, lane-color opacity, octave lines Add a Highway layout section to the settings with a rebuilt way to draw sharps/flats and lanes on the 3D piano highway: - Sharps & flats layout (keys3d_bg_sharpMode): floating (original raised plane), flat (one plane, zero-overlap piano-shaped tiled lanes with the naturals evened out), and realistic (one plane, bars sized like the physical keys). All geometry lives in pure laneSpanFlat()/laneSpanReal() helpers. Default: realistic. - Lane color opacity (keys3d_bg_laneOpacity, 0-1): fades the pitch-class lane tint; at 0 it is a dark floor with guide lines only at the key-block boundaries (E-F and each octave), toward 1 full vivid colored lanes. The strips, per-lane separators and block lines crossfade with the value. Default: 0. - Octave separators (keys3d_bg_octaveGaps, default on) and Octave line contrast (keys3d_bg_octaveContrast, 0-1): the B->C octave line is a dark layer scaled by lane opacity plus a bright layer scaled by its inverse, so it auto-shifts dark->bright as the lanes fade. Settings re-read on init() so they apply on the next chart build. All other behavior (MIDI scoring, palettes, camera, themes, hit feedback) is unchanged. Unit tests cover the new defaults, the sharp-mode setting, and the lane geometry (tiling/evening for flat, uniform/overlap for realistic). Signed-off-by: LegionaryLeader <legionaryleader@gmail.com> Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * Update plugins/keys_highway_3d/settings.html Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * Update plugins/keys_highway_3d/screen.js Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * fix(keys_highway_3d): don't trim active-range boundary lane when neighbor sharp is out of range laneSpanFlat() trimmed a white key's edge for its neighboring black key's lane even when that neighbor midi fell outside range.activeLow..range.activeHigh — the neighbor's lane is never drawn (see the activeLow/activeHigh skip around the lane-strip loop), so the trim left a dark, unfilled sliver at the active-range boundary with no sharp lane to fill it. Gate the trim on the neighbor being in-range; callers that don't pass a range (e.g. the raw-tiling unit tests) keep the prior unconditional-trim behavior. Also add the CHANGELOG entry for this PR's feature set, following the existing keys_highway_3d wording convention (no plugin-local CHANGELOG exists; plugin.json was already bumped 0.1.2 -> 0.2.0 by the original commits). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Signed-off-by: LegionaryLeader <legionaryleader@gmail.com> Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com> Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-07 23:57:14 +02:00
5 people	1bccb8a9e8	feat(midi): convert_midi_tempo_map — extract tempos, time signatures, beat grid (#796) ... * feat(midi): convert_midi_tempo_map — extract tempos, time signatures, beat grid The keys/drums MIDI converters always built a tempo-aware tick->seconds map internally (to bake note times) and then discarded it — and never read time_signature meta at all — so every MIDI import landed with no bars, no measures, and an implied 4/4 no matter what the file said. New lib/midi_import.py helper convert_midi_tempo_map(midi_path, track_index) extracts the grid a .mid actually carries: - tempos: {time, bpm} per tempo event (deduped per tick, 120 default) - time_signatures: {time, ts: [num, den]} — the song-timeline shape - beats: one row per beat on the editor grid shape — numbered downbeats with a den hint, measure:-1 interior beats; the beat unit follows the active signature (6/8 = six eighth-note rows per bar) Event scope mirrors _build_tick_to_seconds: SMF type 0/1 merge meta from all tracks, type 2 reads ONLY the chosen track (independent timelines — callers must never share one grid across type-2 tracks). Mid-bar signature events (ill-formed but seen in the wild) apply at the next bar boundary. All times compute from absolute ticks through the cumulative tempo table and round once at emit — rounding error never accumulates with song length. A bar-count safety valve guards malformed files. Consumer: the editor's multitrack MIDI import (tempo-seed dialog, feedBack-plugin-editor roadmap Phase 3). Tests: tests/test_midi_tempo_map.py — 10 cases driving the REAL function against real .mid files built with mido (no stubs): default grid, tempo bends, 500-bar rounding-drift check, 4/4->3/4 and 6/8 signatures, mid-bar signature deferral, duplicate-tick last-wins, type-2 meta isolation from a bogus sibling track, empty files, grid coverage bounds. Full MIDI-adjacent suite green: 55 passed (test_midi_tempo_map + test_midi_import + test_midi_import_drums + test_gp2midi) under the project venv. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JEoFeTPSnz4NpwwCG52hnu * fix(midi): make convert_midi_tempo_map robust — real division guard, symmetric tempo default, single-pass meta - Push the ticks-per-beat fallback into _build_tick_to_seconds (the single place ticks route through), guarding on `> 0` so a division==0 (malformed) or negative SMPTE-division header no longer raises ZeroDivisionError or walks the beat grid into negative times. Mirror the guard at the convert_midi_tempo_map beat_ticks site. The local `or 480` was cosmetic before — the closure still divided by the raw division. - Seed tempos_out with a 120 BPM row at time 0 when the first set_tempo lands after tick 0, symmetric with the (0, 4, 4) time-signature default, so the sidecar matches the grid the head of the song actually used. - Collapse the duplicated meta_source/note_source lists into one source_tracks walked in a single pass (meta collection + end_tick). - Fix a weak assert in test_mid_bar_signature_applies_at_the_next_boundary (operator-precedence `(A and B) or C`) to assert den == 4 outright. - Add tests: non-positive division (0 + negative SMPTE), first tempo after start seeds 120@0, explicit SMF type-0 file, and the _TEMPO_MAP_MAX_BARS safety valve. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: ChrisBeWithYou <chris@rifflarr.local> Co-authored-by: Claude Fable 5 <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-07 10:27:17 +02:00
byrongamatosandClaude Opus 4.8	9fb63fd3b5	fix(tuner): anchor injectPlayerButton to a direct-child button (feedBack#800) ... `injectPlayerButton()` anchored the injected Tuner button with `controls.querySelector('button:last-child')`, which can match a NESTED button that is not a direct child of `#player-controls`. `insertBefore(btn, nestedButton)` then throws `NotFoundError` (the reference node must be a direct child); since injection runs from the tuner's `screen:changed` handler, the throw propagated out of the player-screen transition and stalled its render. The v3 path was already safe (plugin-control slot); only the classic anchor was bad. Use `:scope > button:last-of-type` (direct child only) with a `parentNode === controls` guard before insertBefore, falling back to appendChild. Bump plugins/tuner 1.3.3 → 1.3.4. Test: tests/plugins/tuner/js/inject_player_button.test.js — extracts the real function and runs it over a faithful DOM model whose insertBefore enforces the direct-child invariant; the nested-last-button case reproduces the throw on the old anchor and passes on the new one (5 tests). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Signed-off-by: byrongamatos <xasiklas@gmail.com>	2026-07-07 09:54:06 +02:00
4 people	612b1f2e0d	feat(v3): choose handedness in the instrument selector + onboarding (give lefties a break) (#793) ... * feat(v3): add a handedness (left-handed) choice to the instrument selector + onboarding Left-handed players could already mirror the highway, but only via a buried Settings toggle they had to find AFTER setup -- so a lefty went through the tour, the tuner and calibration all right-handed first (community callout). Add a "Handedness: Right / Left" row to the v3 instrument badge popover, alongside Instrument / Strings / Tuning (all player-orientation choices). It writes the same lefty preference -- highway.setLefty when a live highway exists (flips it immediately + persists), else the 'lefty' localStorage key the highway reads on init -- and keeps the Settings "Left-handed" checkbox in sync. The first-run tour's "Choose your instrument" step, which runs before the tuner/audio- calibration steps, now calls it out so lefties flip it up front. Frontend-only, additive. Full core JS suite green (938). Tests: tests/js/badges_handedness.test.js. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UR2Cr7GEu3yMY7SrfxH6c1 * docs: split the spliced Handedness/Colorblind CHANGELOG entries A rebase pasted the Handedness bullet over the Colorblind preset entry's bold lead, merging two unrelated Added entries into one run-on bullet. Restore them as two separate bullets. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-05 23:50:30 +02:00
3 people	1a8540935b	fix(gp_autosync): slope-constrained DTW steps — stop path collapse on riff-based songs (#791) ... librosa.sequence.dtw's default step sizes permit pure horizontal/vertical moves; on songs whose chroma is self-similar for long stretches the flat cost surface let the path collapse (minutes of score onto one audio frame), so auto-sync produced monotonic-but-garbage sync points and the per-bar warp imported charts badly out of sync while reporting success. Use the standard music-sync step pattern [[1,1],[1,2],[2,1]] (local tempo ratio bounded to 0.5x-2x), falling back to unconstrained steps if the global length ratio makes it infeasible. Validated on the reported song (138 BPM tab, YouTube audio): coarse points now track 1:1, refine holds slopes 0.77-1.04, warped downbeats hit onset peaks at 3.3x background energy. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-05 23:12:31 +02:00
3 people	b914612f9d	fix(highway_3d): recover from WebGL context loss instead of crashing on alt-tab (#790) ... Switching the active window / alt-tabbing away (most often on Windows) can trigger a GPU context reset. The 3D highway's WebGL renderer had no webglcontextlost handler, so a lost context was left to escalate into a render-process crash -- matching the intermittent "randomly crashes when I change windows" desktop reports. The renderer now binds webglcontextlost/webglcontextrestored on its own WebGL canvas (ren.domElement): the loss is preventDefault()'d so the browser keeps the context restorable, draw() bails while the context is down so no GL work runs on a dead context, and on restore the viewport is re-applied and rendering resumes (Three re-uploads scene resources on the next frame). Listeners are removed in teardown. Root cause is a strong hypothesis -- the crash is intermittent and unreproducible -- but the fix is low-risk and additive and closes a real gap: there was no context-loss handling anywhere in the renderer. plugins/highway_3d 3.31.2 -> 3.31.3. Tests: tests/js/highway_3d_context_loss.test.js (source-contract, like the other highway_* tests). The sibling keys_highway_3d / drum_highway_3d renderers share the same gap -- follow-up in their repos. Claude-Session: https://claude.ai/code/session_01UR2Cr7GEu3yMY7SrfxH6c1 Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-05 22:20:32 +02:00
3 people	de002cdc24	feat(highway): add "Colorblind (deuteranope)" string-color preset (#788) ... Adds a one-click preset to the shared "Highway String Colors" picker, next to the existing Okabe-Ito "Colorblind-friendly" preset. Contributed by a deuteranopic player who found the Okabe-Ito set still hard to separate: it retunes the six main strings and keeps that set's 7/8-string colors. Applies to both the 2D and 3D highways via the shared picker, which writes the slot->hex map the renderers already consume. Additive frontend-only change to HWC_PRESETS in static/app.js; the picker UI and both highways pick it up automatically (the preset list is generated from HWC_PRESETS and applied by id). All 20 highway string-color JS tests pass; app.js syntax-checks clean. Claude-Session: https://claude.ai/code/session_01UR2Cr7GEu3yMY7SrfxH6c1 Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-05 21:13:13 +02:00
3 people	92dc321fdf	feat(gp_autosync): piecewise time-warp helpers + refine_sync onset pass (#787) ... * feat(gp_autosync): piecewise time-warp helpers + refine_sync onset pass auto_sync computes per-bar sync points but consumers only ever applied the scalar bar-1 audio_offset, so any tempo drift between the recording and the tab's authored tempo accumulated over the song. Add the librosa-free helpers needed to apply the full piecewise mapping: - bar_start_times(gp_path): per-bar score times sharing auto_sync's axis (GPIF bar-resolution map, GP3/4/5 per-tick integration) - build_warp_anchors(points, bar_starts): monotonic (score, audio) anchors - warp_time(t, anchors): piecewise-linear map with edge-slope extrapolation - warp_song_times(song, warp): retime a lib.song.Song in place (notes, sustains, chords, beats, sections, anchors, handshapes, phrase levels, tone changes, tempo overrides) - gp_has_expandable_repeats(gp_path): detects GP3/4/5 repeat/volta/direction markup whose playback expansion auto_sync's as-written points cannot map Also implement refine_sync() — the editor's refine-sync endpoint has imported it since the snapshot but it never existed in lib, so the Refine button 500'd. It densifies the DTW points to every Nth bar and re-times each with a local onset phase sweep (radius clamped under half a beat to avoid one-beat locks, short scoring grid + median residual snap against the first beats). Synthetic click-track validation: ~13ms mean / ~40ms max error from ±180ms coarse input across 117-123 BPM recordings of a 120 BPM tab. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * review: Copilot round 1 — normalize bar_start_times GP3/4/5 parse failures to ValueError, document ImportError Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-05 20:08:19 +02:00
4 people	bde25c0bc8	fix(gpx): clamp partial final BCFS sector so GP6 .gpx import works (#749) ... Every real Guitar Pro 6 (.gpx) file failed to import with "GPX BCFS sector pointer out of range (malformed file)". A real .gpx's BCFZ-declared decompressed size isn't 0x1000-aligned, so its last (small) container file lands in a partial trailing sector. _parse_bcfs raised whenever a sector read would run past the buffer end, rejecting the whole container before score.gpif could be extracted -- so no GP6 file could be charted in the song editor. (GP7/GP8 .gp files take the ZIP path, not BCFS, which is why this wasn't caught earlier.) Clamp the final sector read to the buffer end (the per-file size field trims the padding anyway), matching canonical GPX readers (alphaTab / PyGuitarPro). A sector whose start is past the end still raises, so the malformed-file guard is preserved. Verified against two real GP6 files -- both now unpack to valid GPIF with all tracks. Adds the previously-missing positive BCFS round-trip coverage: partial-final-sector, multi-file, sector-aligned baseline, and the preserved out-of-range guard. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-05 00:20:31 +02:00
4 people	c7aa5a10b0	fix(v3): recycle library grid cards on scroll instead of rebuilding the window (#742) ... The virtualized v3 Songs grid rebuilt its entire visible window (grid.innerHTML = _renderCardsRange(...) + a full wireCards pass) every time it slid by one row. Each row-boundary crossing was therefore a heavy synchronous frame — reparse ~60 cards, re-attach hundreds of listeners, reflow — that stalled the main thread and buffered held-arrow key-repeats, flushing them in a burst. Testers saw the library "go super fast for a second then slow down," skipping "every so many scrolls," up or down, at the same spots each time. It hitched scrolling back up over already-loaded songs too, because the cost was DOM teardown, not fetching. renderWindow() now reconciles the window in place: it reuses the card nodes that stay on-screen and builds only the row that enters/leaves (~6 nodes per slide instead of ~60). Nodes are keyed by absolute index (data-idx) with a real-vs-skeleton + select-mode signature (data-sig) so hole-fills after a page fetch and select-mode toggles still rebuild exactly the nodes that changed. wireCards()'s existing data-wired guard then wires only the freshly-built nodes, so per-slide listener churn drops with it. Everything keyed off data-fn (favorites, ⋮ menu, right-click, selection, accuracy badges, A–Z rail) is unaffected. Follow-up to the stage-2 virtualized grid (#636 item 3). Frontend-only. Tests: tests/js/v3_songs_window_recycle.test.js — window stays [start,end) contiguous and in-window node identity is reused across a down-then-up scroll; select-mode toggle and a rail-seek jump rebuild correctly. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-05 00:19:46 +02:00
3 people	2c1c6f7eac	fix(starter): sync _BUILTIN_STARTER_SOURCES with content/starter on disk (#775) ... Two commits (delete beethoven-ode_to_joy, re-add The Adicts' Ode to Joy) never updated _BUILTIN_STARTER_SOURCES: it still listed the deleted pack and omitted the added one. The listed-but-missing file made the all-present gate never fire, so NO starter content seeded on first run — and the on-disk-but-unlisted pack would bundle as dead weight. Both starter-seed guard tests were red on main, reddening ci/test on every core PR. Sync the manifest to disk. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-05 00:15:29 +02:00
OmikronApexandClaude Fable 5	425f72b33f	feat(v3): playlist shuffle toggle ... Crossing-arrows toggle next to Play all / Play album on the playlist detail page. When on, playQueue.start Fisher-Yates-shuffles the queue once at start — on a copy, so the stored playlist order is untouched — swapping per-slot album arrangements in lockstep so each slot keeps its pinned arrangement (#685 contract preserved). Prev-less queue semantics are unchanged: auto-advance simply walks the shuffled order. Preference is global, persisted as localStorage v3PlaylistShuffle. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-03 13:07:47 +02:00
3 people	7ef52cdd66	fix: Edit Metadata persists into .feedpak files (suffix gate predated the rename) (#725) ... write_song_metadata dispatched zip-form packages on `suffix == ".sloppak"` only, while core reads both suffixes everywhere else (sloppak.SONG_EXTS, .feedpak being the current write extension). Editing a zip-form .feedpak's title/artist/album/year therefore silently fell back to a DB-only update, which looked fine until the next full library rescan re-derived metadata from the file and reverted the edit — the exact failure this module exists to prevent. Directory-form packages were unaffected (manifest-presence dispatch, not suffix). Gate on SONG_EXTS, add TestWriteSongMetadata regression coverage (both zip suffixes, mixed-case suffix, directory form, unknown-suffix fallback), and correct the stale scan_worker comment claiming .sloppak-suffix-only detection (the code already accepts both via is_sloppak). Claude-Session: https://claude.ai/code/session_01H1ZBEcZoJinde9ms5fAjwc Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 20:51:57 +02:00
3 people	4b6cbe8b11	Fix 3D drum/keys highways not resizing on fullscreen under splitscreen (#723) ... The guitar/bass highway_3d renderer self-detects panel-canvas size changes in its draw() loop and re-runs applySize() every frame, because the splitscreen host overrides hw.resize and never calls renderer.resize(). The drum and keys highways lacked that fallback — they only re-framed when the host explicitly called resize(w, h) — so their panels stayed framed for the pre-fullscreen size while the guitar/bass panels adapted. Symptom: a too-small, off-center highway in the drum/keys panels after maximizing a split-screen session. Port highway_3d's per-frame drift check into both draw() loops: re-apply on backing-store change (canvas.width/height) AND on CSS-box drift (clientWidth/clientHeight vs the last applied logical size, throttled to every 10th frame). Track _lastHwW/_lastHwH + _appliedW/_appliedH per instance and reset them in destroy() so a reused instance re-frames on the next song. plugins/drum_highway_3d -> 0.3.1, plugins/keys_highway_3d -> 0.1.1. Tests: tests/js/drum_keys_highway_3d_resize_reframe.test.js. Signed-off-by: Kris Anderson <topkoa@gmail.com> Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-02 18:42:26 +02:00
4 people	15fabb62aa	Fix v3 Songs A–Z rail: reliable taps, precise drag, hittable size (#653) ... * Fix v3 Songs A–Z rail: reliable taps, precise drag, hittable size Follow-up to #634. Three rail bugs reported on macOS + Windows (0.3.0, 2026-06-29 — =Scr4tch=, MajorMokoto): - Taps often did nothing ("clicked O, nothing happened"). pointerdown calls setPointerCapture, after which the browser retargets the follow-up click to the rail container, so the click handler's closest('.v3-azrail-letter') resolved null and a plain tap (no pointermove) had no other path. Drive the jump from pointerdown itself; reduce the click handler to keyboard activation only (e.detail === 0, Enter/Space). - A drag landed short of the release ("where you release isn't where you get sent"). Every letter crossed fired jumpToLetter with behavior:'smooth'; stacked smooth-scroll animations over the virtualized grid lagged and settled imprecisely. jumpToLetter now takes a smooth flag and scrolls instantly ('auto') while scrubbing, animating only discrete taps/keyboard jumps, so the grid tracks the finger and the release lands on the let-go letter. - The rail was too small at 1440p and didn't scale. Letters were a fixed .62rem glued at right:2px (~13px-tall target). They now scale with the viewport (clamp(.72rem, 1.4vh, 1.05rem)), sit off the edge with taller/wider equal-width hit targets and a hover/active highlight so the scrub target is visible. Keyboard arrow-nav and present-letter gating are unchanged. Tests: tests/js/v3_az_rail.test.js gains pointerdown-seek, keyboard-only click guard, and instant-vs-smooth assertions (809 JS tests; the 13 pre-existing unrelated failures are unchanged). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QbexxfTt8q2tAn436MqGWF * fix(v3): ignore non-primary buttons on A–Z rail pointerdown (PR #653 review) Right- or middle-clicking the A–Z rail (or a secondary multi-touch pointer) no longer triggers a seek; only the primary tap/drag scrubs. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>	2026-07-02 13:59:10 +02:00
3 people	0d28886d46	Fix v3 Songs List View favorite heart staying dim until re-search (#654) ... Favoriting from the tree / "List View" flipped the glyph ♡→♥ but the heart stayed grey until a re-search — reported macOS+Windows, open since 0.3.0 / 2026-06-25. One shared wireCards() [data-fav] handler serves both the grid card and the List-View row, but they render with different idle colours (grid text-white, List View text-fb-textDim) and the handler only ever removed the grid's text-white. So in List View text-fb-textDim lingered next to the freshly-added text-fb-accent and won by CSS source order — the glyph changed but the colour didn't, until a re-search re-rendered the row. Each heart now declares its idle colour via a data-fav-idle attribute; the handler swaps exactly that class (so only one colour class is ever present) and writes the new state back onto the in-memory song model so a re-render / virtualized-grid recycle agrees instead of reverting. Tests: tests/js/v3_favorites_toggle.test.js. Full JS suite 810 tests; the 13 pre-existing unrelated failures are unchanged. Claude-Session: https://claude.ai/code/session_01QbexxfTt8q2tAn436MqGWF Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-02 13:58:21 +02:00
3 people	d20b33348b	feat(v3): host theme read surface — window.feedBack.theme + always-present --fbv-* tokens (#646) ... First slice of the host theme contract (#644): give plugins a host-owned way to read the active theme + its device affordances, so a feature renders correctly under any theme instead of binding to whichever one the dev saw. theme-core.js previously only APPLIED themes and emitted --fbv-* vars only while a theme was equipped (nothing to read in the default state), with no read API. Now, all additive + feature-detected: - Always-present default `fb` palette as `--fbv-*` on :root (the un-themed look is unchanged — fb-* utilities still use their compiled defaults; this only hands plugins a stable host token to read + derive surfaces from). Adds two keystone ROLES the palette lacked: `on-accent` (legible fg on the accent fill) and `focus-ring`. - window.feedBack.theme.get() -> {id, isThemed, tokens}; .capabilities() -> {glow, gradients, motion} (the device-affordance signal; recolor-only themes report defaults, a theme may opt out via `capabilities` in its payload, motion is reduced-motion-gated); .prefersReducedMotion(). - Normalized `theme:changed` event from the single apply() chokepoint. The apply side stays on window.v3Theme; the read surface is attached defensively so it survives the feedBack bus being (re)built by capabilities.js regardless of load order. Verified via a headless render (apply/unequip intact, defaults present + restored, capability opt-out honored, event payload correct) + tests/js/v3_theme_read_api.test.js. See docs/host-theme-contract.md. Claude-Session: https://claude.ai/code/session_01QbexxfTt8q2tAn436MqGWF Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-02 13:57:58 +02:00
3 people	5e78f2f7f7	fix(tuner): remove unused settings + fix sidebar panel position (#661) ... Removes the Floating Button and Tuning Visibility settings sections and finishes retiring their still-live config: drops the disabledTunings menu filter and showFloatingButton gate from screen.js/ui.js and their persistence in routes.py (retired keys are stripped on write). Repositions the tuner panel opened from the v3 sidebar Plugins popover to anchor beside it via the host's stable plugin-control slot API (falling back to the popover id), clamped to the viewport so it can't open off-screen, and re-anchored on resize. Updates tuner config tests to the retired-key behavior; plugins/tuner 1.3.2 -> 1.3.3. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-02 09:35:18 +02:00